diff --git a/CHANGELOG.md b/CHANGELOG.md index 25797895..7ee35d95 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,8 +1,8 @@ # Changelog -## [v1.0.4](https://github.com/NVIDIA/fsi-samples/tree/v1.0.4) (2021-05-13) +## [v1.0.5](https://github.com/NVIDIA/fsi-samples/tree/v1.0.5) (2021-09-26) -[Full Changelog](https://github.com/NVIDIA/fsi-samples/compare/v1.0.3...v1.0.4) +[Full Changelog](https://github.com/NVIDIA/fsi-samples/compare/v1.0.3...v1.0.5) **Closed issues:** @@ -11,6 +11,14 @@ **Merged pull requests:** +- \[REVIEW\] A tiny fix of the readme [\#145](https://github.com/NVIDIA/fsi-samples/pull/145) ([yidong72](https://github.com/yidong72)) +- \[REVIEW\]NLP demo with RIVA backend [\#144](https://github.com/NVIDIA/fsi-samples/pull/144) ([yidong72](https://github.com/yidong72)) +- \[REVIEW\] release HRP greenflow plugin [\#143](https://github.com/NVIDIA/fsi-samples/pull/143) ([yidong72](https://github.com/yidong72)) +- Bump jupyterlab from 1.2.1 to 1.2.21 in /gtc21-s32407-backtestingequityinvestmentstrats/docker [\#142](https://github.com/NVIDIA/fsi-samples/pull/142) ([dependabot[bot]](https://github.com/apps/dependabot)) +- Cusignal nodes for Greenflow. [\#141](https://github.com/NVIDIA/fsi-samples/pull/141) ([avolkov1](https://github.com/avolkov1)) +- \[REVIEW\]add the dynamic input port meta check [\#139](https://github.com/NVIDIA/fsi-samples/pull/139) ([yidong72](https://github.com/yidong72)) +- Update README.md [\#138](https://github.com/NVIDIA/fsi-samples/pull/138) ([MarkJosephBennett](https://github.com/MarkJosephBennett)) +- \[review\]release 1.0.4 candidate [\#137](https://github.com/NVIDIA/fsi-samples/pull/137) ([yidong72](https://github.com/yidong72)) - \[REVIEW\] Update build script. [\#136](https://github.com/NVIDIA/fsi-samples/pull/136) ([avolkov1](https://github.com/avolkov1)) - add nvidia headers [\#135](https://github.com/NVIDIA/fsi-samples/pull/135) ([MarkJosephBennett](https://github.com/MarkJosephBennett)) - \[Review\]Sync up main branch back to develop [\#134](https://github.com/NVIDIA/fsi-samples/pull/134) ([yidong72](https://github.com/yidong72)) @@ -156,7 +164,6 @@ - \[REVIEW\] change the text for notebook 05 [\#55](https://github.com/NVIDIA/fsi-samples/pull/55) ([yidong72](https://github.com/yidong72)) - Fix \#50b - Rename notebook folder to notebooks [\#52](https://github.com/NVIDIA/fsi-samples/pull/52) ([miguelusque](https://github.com/miguelusque)) - Fix \#50 - Rename notebook folder to notebooks [\#51](https://github.com/NVIDIA/fsi-samples/pull/51) ([miguelusque](https://github.com/miguelusque)) -- Fix \#39 - Refactor 04\_portfolio\_trade.ipynb notebook [\#44](https://github.com/NVIDIA/fsi-samples/pull/44) ([miguelusque](https://github.com/miguelusque)) ## [v0.2](https://github.com/NVIDIA/fsi-samples/tree/v0.2) (2019-08-16) @@ -178,6 +185,7 @@ **Merged pull requests:** - Fix \#17 - cuIndicator notebook plot widget is too complicated \(WIP\) [\#45](https://github.com/NVIDIA/fsi-samples/pull/45) ([miguelusque](https://github.com/miguelusque)) +- Fix \#39 - Refactor 04\_portfolio\_trade.ipynb notebook [\#44](https://github.com/NVIDIA/fsi-samples/pull/44) ([miguelusque](https://github.com/miguelusque)) - Merge develop to master [\#43](https://github.com/NVIDIA/fsi-samples/pull/43) ([yidong72](https://github.com/yidong72)) - Fix \#40 - Remove debug info [\#41](https://github.com/NVIDIA/fsi-samples/pull/41) ([miguelusque](https://github.com/miguelusque)) - Update mortgage example using TaskGraph API. [\#38](https://github.com/NVIDIA/fsi-samples/pull/38) ([avolkov1](https://github.com/avolkov1)) diff --git a/gQuant/docker/build.sh b/gQuant/docker/build.sh index 6057953b..2bbbdb8a 100755 --- a/gQuant/docker/build.sh +++ b/gQuant/docker/build.sh @@ -19,19 +19,14 @@ D_FILE=${D_FILE:='Dockerfile.dev'} echo "Building greenflow container..." echo -e "\nPlease, select your operating system:\n" \ - "- '1' for Ubuntu 16.04\n" \ - "- '2' for Ubuntu 18.04\n" \ - "- '3' for Ubuntu 20.04\n" + "- '1' for Ubuntu 18.04\n" \ + "- '2' for Ubuntu 20.04\n" -read -p "Enter your option and hit return [1]-3: " OPERATING_SYSTEM +read -p "Enter your option and hit return [1]-2: " OPERATING_SYSTEM OPERATING_SYSTEM=${OPERATING_SYSTEM:-1} case $OPERATING_SYSTEM in 1) - echo "Ubuntu 16.04 selected." - OS_STR="ubuntu16.04" - ;; - 2) echo "Ubuntu 18.04 selected." OS_STR="ubuntu18.04" ;; @@ -42,35 +37,27 @@ case $OPERATING_SYSTEM in esac echo -e "\nPlease, select your CUDA version:\n" \ - "- '1' for cuda 10.0\n" \ - "- '2' for cuda 10.1\n" \ - "- '3' for cuda 10.2\n" \ - "- '4' for cuda 11.0 (minimum requirement for Ubuntu 20.04)\n" + "- '1' for cuda 11.0\n" \ + "- '2' for cuda 11.2.2\n" -read -p "Enter your option and hit return [1]-3: " CUDA_VERSION - -RAPIDS_VERSION="0.19.0" +read -p "Enter your option and hit return [1]-2: " CUDA_VERSION CUDA_VERSION=${CUDA_VERSION:-1} case $CUDA_VERSION in 2) - echo "CUDA 10.1 is selected" - CUDA_STR="10.1" - ;; - 3) - echo "CUDA 10.2 is selected" - CUDA_STR="10.2" + echo "CUDA 11.2.2 is selected" + CUDA_STR="11.2.2" ;; - 4) + *) echo "CUDA 11.0 is selected" CUDA_STR="11.0" ;; - *) - echo "CUDA 10.0 is selected" - CUDA_STR="10.0" - ;; esac +RAPIDS_CUDA_VER=$(echo ${CUDA_STR} | sed -E 's/([0-9]+\.[0-9]{1,1})[^ ]*/\1/g') + +RAPIDS_VERSION="21.06" + mkdir -p ${BUILDDIR} cp -r ${GREENFLOWDIR} ${BUILDDIR} rsync -av --progress ${GREENFLOWLABDIR} ${BUILDDIR} --exclude node_modules @@ -95,6 +82,22 @@ rsync -av --progress "${PLUGINSDIR}/dask_plugin" "${BUILDDIR}/plugins" \ --exclude dask-worker-space \ --exclude __pycache__ +rsync -av --progress "${PLUGINSDIR}/hrp_plugin" "${BUILDDIR}/plugins" \ + --exclude data \ + --exclude .cache \ + --exclude many-small \ + --exclude storage \ + --exclude dask-worker-space \ + --exclude __pycache__ + +rsync -av --progress "${PLUGINSDIR}/cusignal_plugin" "${BUILDDIR}/plugins" \ + --exclude data \ + --exclude .cache \ + --exclude many-small \ + --exclude storage \ + --exclude dask-worker-space \ + --exclude __pycache__ + rsync -av --progress "${PLUGINSDIR}/simple_example" "${BUILDDIR}/plugins" \ --exclude data \ --exclude .cache \ @@ -136,7 +139,8 @@ RUN cd /home/quant/greenflow && pip install . ## install greenflowlab extension ADD --chown=$USERID:$USERGID ./build/greenflowlab /home/quant/greenflowlab -RUN cd /home/quant/greenflowlab && pip install . +RUN cd /home/quant/greenflowlab && pip install . && \ + jlpm cache clean && jupyter lab clean RUN jupyter lab build @@ -144,11 +148,14 @@ RUN jupyter lab build ADD --chown=$USERID:$USERGID ./build/plugins /home/quant/plugins RUN cd /home/quant/plugins/gquant_plugin && pip install . RUN cd /home/quant/plugins/dask_plugin && pip install . +RUN cd /home/quant/plugins/hrp_plugin && pip install . +RUN cd /home/quant/plugins/cusignal_plugin && pip install . WORKDIR /home/quant/plugins/gquant_plugin ENTRYPOINT MODULEPATH=\$HOME/plugins/gquant_plugin/modules jupyter-lab \ --allow-root --ip=0.0.0.0 --no-browser --NotebookApp.token='' \ - --ContentsManager.allow_hidden=True + --ContentsManager.allow_hidden=True \ + --ResourceUseDisplay.track_cpu_percent=True \ EOM MODE_STR="prod" @@ -157,22 +164,26 @@ esac greenflow_ver=$(grep version "${GREENFLOWDIR}/setup.py" | sed "s/^.*version='\([^;]*\)'.*/\1/") CONTAINER="nvidia/cuda:${CUDA_STR}-runtime-${OS_STR}" -D_CONT=${D_CONT:="greenflow/greenflow:${greenflow_ver}-Cuda${CUDA_STR}_${OS_STR}_Rapids${RAPIDS_VERSION}_${MODE_STR}"} +D_CONT=${D_CONT:="greenflow/greenflow:${greenflow_ver}-Cuda${RAPIDS_CUDA_VER}_${OS_STR}_Rapids${RAPIDS_VERSION}_${MODE_STR}"} pushd ${_basedir} cat > $D_FILE <=3.0.0' jupyter-packaging'>=0.9.2' \ +RUN mamba install -y -c conda-forge -c defaults \ + jupyterlab'>=3.0.0' jupyter-packaging'>=0.9.2' jupyterlab-system-monitor \ nodejs=12.4.0 python-graphviz pydot ruamel.yaml && \ conda clean --all -y && \ jlpm cache clean && \ @@ -221,9 +233,9 @@ RUN pip install bqplot==0.12.21 && \ jupyter lab clean ## install the nvdashboard -# RUN pip install jupyterlab-nvdashboard +# pip install git+https://github.com/rapidsai/jupyterlab-nvdashboard.git@branch-0.6 RUN pip install --upgrade pip && \ - pip install git+https://github.com/rapidsai/jupyterlab-nvdashboard.git@branch-0.6 && \ + pip install jupyterlab-nvdashboard && \ jlpm cache clean && \ jupyter lab clean diff --git a/gQuant/plugins/cusignal_plugin/README.md b/gQuant/plugins/cusignal_plugin/README.md new file mode 100644 index 00000000..06767d2c --- /dev/null +++ b/gQuant/plugins/cusignal_plugin/README.md @@ -0,0 +1,37 @@ +## Greenflow Cusignal Plugin + +Greenflow plugin that includes a set of nodes for Cusignal library. + + +### Install the greenflowlab JupyterLab plugin + +First create a Python enviroment or use one with RAPIDS cuSignal library. Tip, +use mamba to resolve dependencies quicker. +```bash +conda create -n rapids_cusignal -c conda-forge mamba python=3.8 + +conda activate rapids_cusignal + +mamba install -c rapidsai -c nvidia -c conda-forge \ + cusignal=21.06 python=3.8 cudatoolkit=11.2 +``` + +Then install `greenflowlab` JupyterLab plugin, make sure `nodejs` of version +[12^14^15] is installed. E.g: +```bash +mamba install -c conda-forge python-graphviz nodejs=12.4.0 pydot +``` +Then install the `greenflowlab`: +```bash +pip install greenflowlab +``` +Or install `greenflowlab` at the greenflowlab directory: +```bash +pip install . +``` + +### Install the cusignal plugin +Install the plugin directly from the plugin diretory. +```bash +pip install . +``` diff --git a/gQuant/plugins/cusignal_plugin/greenflow_cusignal_plugin/__init__.py b/gQuant/plugins/cusignal_plugin/greenflow_cusignal_plugin/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/gQuant/plugins/cusignal_plugin/greenflow_cusignal_plugin/convolution/__init__.py b/gQuant/plugins/cusignal_plugin/greenflow_cusignal_plugin/convolution/__init__.py new file mode 100644 index 00000000..0efbc698 --- /dev/null +++ b/gQuant/plugins/cusignal_plugin/greenflow_cusignal_plugin/convolution/__init__.py @@ -0,0 +1,5 @@ +from .convolve import * +from .correlate import * +from .fftconvolve import * +from .convolve2d import * +from .correlate2d import * diff --git a/gQuant/plugins/cusignal_plugin/greenflow_cusignal_plugin/convolution/convolve.py b/gQuant/plugins/cusignal_plugin/greenflow_cusignal_plugin/convolution/convolve.py new file mode 100644 index 00000000..5dcb5ff0 --- /dev/null +++ b/gQuant/plugins/cusignal_plugin/greenflow_cusignal_plugin/convolution/convolve.py @@ -0,0 +1,129 @@ +import numpy as np +import cupy as cp + +from cusignal.convolution import convolve as cuconv +from scipy.signal import convolve as siconv + +from greenflow.dataframe_flow import (Node, PortsSpecSchema, ConfSchema) +from greenflow.dataframe_flow.template_node_mixin import TemplateNodeMixin + +__all__ = ['CusignalConvolveNode'] + +_CONV_DESC = '''Convolve two N-dimensional arrays. + +Convolve `in1` and `in2`, with the output size determined by the +`mode` argument. + +Returns: +convolve : array + An N-dimensional array containing a subset of the discrete linear + convolution of `in1` with `in2`. +''' + +_CONV_MODE_DESC = '''mode : str {'full', 'valid', 'same'}, optional +A string indicating the size of the output: + + ``full`` + The output is the full discrete linear convolution + of the inputs. (Default) + ``valid`` + The output consists only of those elements that do not + rely on the zero-padding. In 'valid' mode, either `in1` or `in2` + must be at least as large as the other in every dimension. + ``same`` + The output is the same size as `in1`, centered + with respect to the 'full' output. +''' + +_CONV_METHOD_DESC = '''method : str {'auto', 'direct', 'fft'}, optional +A string indicating which method to use to calculate the convolution. + + ``direct`` + The convolution is determined directly from sums, the definition of + convolution. + ``fft`` + The Fourier Transform is used to perform the convolution by calling + `fftconvolve`. + ``auto`` + Automatically chooses direct or Fourier method based on an estimate + of which is faster (default). +''' + + +class CusignalConvolveNode(TemplateNodeMixin, Node): + def init(self): + TemplateNodeMixin.init(self) + + port_type = PortsSpecSchema.port_type + inports = { + 'in1': {port_type: [cp.ndarray, np.ndarray]}, + 'in2': {port_type: [cp.ndarray, np.ndarray]} + } + outports = { + 'convolve': {port_type: [cp.ndarray, np.ndarray]}, + } + self.template_ports_setup(in_ports=inports, out_ports=outports) + + meta_outports = {'convolve': {}} + self.template_meta_setup(out_ports=meta_outports) + + def conf_schema(self): + mode_enum = ['full', 'valid', 'same'] + method_enum = ['direct', 'fft', 'auto'] + json = { + 'title': 'Cusignal Convolution Node', + 'type': 'object', + 'description': _CONV_DESC, + 'properties': { + 'mode': { + 'type': 'string', + 'description': _CONV_MODE_DESC, + 'enum': mode_enum, + 'default': 'full' + }, + 'method': { + 'type': 'string', + 'description': _CONV_METHOD_DESC, + 'enum': method_enum, + 'default': 'auto' + }, + 'normalize': { + 'type': 'boolean', + 'description': 'Scale convolutioni by in2 (typically a ' + 'window) i.e. convolve(in1, in2) / sum(in2). ' + 'Default False.', + 'default': False + }, + 'use_cpu': { + 'type': 'boolean', + 'description': 'Use CPU for computation via ' + 'scipy::signal.convolve. Default is False and runs on ' + 'GPU via cusignal.', + 'default': False + }, + }, + } + return ConfSchema(json=json) + + def process(self, inputs): + mode = self.conf.get('mode', 'full') + method = self.conf.get('method', 'auto') + normalize = self.conf.get('normalize', False) + use_cpu = self.conf.get('use_cpu', False) + + in1 = inputs['in1'] + in2 = inputs['in2'] + + if use_cpu: + conv = siconv(in1, in2, mode=mode, method=method) + if normalize: + scale = np.sum(in2) + else: + conv = cuconv(in1, in2, mode=mode, method=method) + if normalize: + scale = cp.sum(in2) + + if normalize: + conv = conv if scale == 1 else conv / scale + + return {'convolve': conv} diff --git a/gQuant/plugins/cusignal_plugin/greenflow_cusignal_plugin/convolution/convolve2d.py b/gQuant/plugins/cusignal_plugin/greenflow_cusignal_plugin/convolution/convolve2d.py new file mode 100644 index 00000000..407f441f --- /dev/null +++ b/gQuant/plugins/cusignal_plugin/greenflow_cusignal_plugin/convolution/convolve2d.py @@ -0,0 +1,121 @@ +import numpy as np +import cupy as cp + +from cusignal.convolution import convolve2d as cuconv2d +from scipy.signal import convolve2d as siconv2d + +from greenflow.dataframe_flow import (Node, PortsSpecSchema, ConfSchema) +from greenflow.dataframe_flow.template_node_mixin import TemplateNodeMixin + +__all__ = ['CusignalConvolve2dNode'] + +_CONV2_DESC = '''Convolve two 2-dimensional arrays. +Convolve `in1` and `in2` with output size determined by `mode`, and +boundary conditions determined by `boundary` and `fillvalue`. + +Returns: +out : ndarray + A 2-dimensional array containing a subset of the discrete linear + convolution of `in1` with `in2`. +''' + +_CONV2_MODE_DESC = '''mode : str {'full', 'valid', 'same'}, optional + +A string indicating the size of the output: +``full`` + The output is the full discrete linear convolution + of the inputs. (Default) +``valid`` + The output consists only of those elements that do not + rely on the zero-padding. In 'valid' mode, either `in1` or `in2` + must be at least as large as the other in every dimension. +``same`` + The output is the same size as `in1`, centered + with respect to the 'full' output. +''' + +_CONV2_BOUNDARY_DESC = '''boundary : str {'fill', 'wrap', 'symm'}, optional + +A flag indicating how to handle boundaries: +``fill`` + pad input arrays with fillvalue. (default) +``wrap`` + circular boundary conditions. +``symm`` + symmetrical boundary conditions. +''' + +_CONV2_FILLVAL_DESC = '''fillvalue : scalar, optional +Value to fill pad input arrays with. Default is 0. +''' + + +class CusignalConvolve2dNode(TemplateNodeMixin, Node): + def init(self): + TemplateNodeMixin.init(self) + port_type = PortsSpecSchema.port_type + inports = { + 'in1': {port_type: [cp.ndarray, np.ndarray]}, + 'in2': {port_type: [cp.ndarray, np.ndarray]} + } + outports = { + 'convolve2d': {port_type: [cp.ndarray, np.ndarray]}, + } + self.template_ports_setup(in_ports=inports, out_ports=outports) + + meta_outports = {'convolve2d': {}} + self.template_meta_setup(out_ports=meta_outports) + + def conf_schema(self): + mode_enum = ['full', 'valid', 'same'] + boundary_enum = ['fill', 'wrap', 'symm'] + json = { + 'title': 'Cusignal Convolution2D Node', + 'type': 'object', + 'description': _CONV2_DESC, + 'properties': { + 'mode': { + 'type': 'string', + 'description': _CONV2_MODE_DESC, + 'enum': mode_enum, + 'default': 'full' + }, + 'boundary': { + 'type': 'string', + 'description': _CONV2_BOUNDARY_DESC, + 'enum': boundary_enum, + 'default': 'fill' + }, + 'fillvalue': { + 'type': 'number', + 'description': _CONV2_FILLVAL_DESC, + 'default': 0 + }, + 'use_cpu': { + 'type': 'boolean', + 'description': 'Use CPU for computation via ' + 'scipy::signal.convolve2d. Default is False and runs on ' + 'GPU via cusignal.', + 'default': False + }, + }, + } + return ConfSchema(json=json) + + def process(self, inputs): + mode = self.conf.get('mode', 'full') + boundary = self.conf.get('boundary', 'fill') + fillvalue = self.conf.get('fillvalue', 0) + use_cpu = self.conf.get('use_cpu', False) + + in1 = inputs['in1'] + in2 = inputs['in2'] + + if use_cpu: + conv2d = siconv2d( + in1, in2, mode=mode, boundary=boundary, fillvalue=fillvalue) + else: + conv2d = cuconv2d( + in1, in2, mode=mode, boundary=boundary, fillvalue=fillvalue) + + return {'convolve2d': conv2d} diff --git a/gQuant/plugins/cusignal_plugin/greenflow_cusignal_plugin/convolution/correlate.py b/gQuant/plugins/cusignal_plugin/greenflow_cusignal_plugin/convolution/correlate.py new file mode 100644 index 00000000..5087090e --- /dev/null +++ b/gQuant/plugins/cusignal_plugin/greenflow_cusignal_plugin/convolution/correlate.py @@ -0,0 +1,119 @@ +import numpy as np +import cupy as cp + +from cusignal.convolution import correlate as cucorr +from scipy.signal import correlate as sicorr + +from greenflow.dataframe_flow import (Node, PortsSpecSchema, ConfSchema) +from greenflow.dataframe_flow.template_node_mixin import TemplateNodeMixin + +__all__ = ['CusignalCorrelationNode'] + +_CORR_DESC = '''Cross-correlate two N-dimensional arrays. + +Cross-correlate `in1` and `in2`, with the output size determined by the +`mode` argument. + +Returns: +correlate : array + An N-dimensional array containing a subset of the discrete linear + cross-correlation of `in1` with `in2`. +''' + +_CORR_MODE_DESC = '''The size of the output. + + ``full`` + The output is the full discrete linear cross-correlation + of the inputs. (Default) + ``valid`` + The output consists only of those elements that do not + rely on the zero-padding. In 'valid' mode, either `in1` or `in2` + must be at least as large as the other in every dimension. + ``same`` + The output is the same size as `in1`, centered + with respect to the 'full' output. +''' + +_CORR_METHOD_DESC = '''Method to use to calculate the correlation. + + ``direct`` + The correlation is determined directly from sums, the definition of + correlation. + ``fft`` + The Fast Fourier Transform is used to perform the correlation more + quickly (only available for numerical arrays.) + ``auto`` + Automatically chooses direct or Fourier method based on an estimate + of which is faster (default). See `convolve` Notes for more detail. +''' + + +class CusignalCorrelationNode(TemplateNodeMixin, Node): + def init(self): + TemplateNodeMixin.init(self) + port_type = PortsSpecSchema.port_type + inports = { + 'in1': {port_type: [cp.ndarray, np.ndarray]}, + 'in2': {port_type: [cp.ndarray, np.ndarray]} + } + outports = { + 'correlate': {port_type: "${port:in1}"}, + } + self.template_ports_setup(in_ports=inports, out_ports=outports) + + meta_outports = {'correlate': {}} + self.template_meta_setup(out_ports=meta_outports) + + def conf_schema(self): + mode_enum = ['full', 'valid', 'same'] + method_enum = ['direct', 'fft', 'auto'] + json = { + 'title': 'Cusignal Correlation Node', + 'type': 'object', + 'description': _CORR_DESC, + 'properties': { + 'mode': { + 'type': 'string', + 'description': _CORR_MODE_DESC, + 'enum': mode_enum, + 'default': 'full' + }, + 'method': { + 'type': 'string', + 'description': _CORR_METHOD_DESC, + 'enum': method_enum, + 'default': 'auto' + }, + 'scale': { + 'type': 'number', + 'description': 'Scale output array i.e. out / scale', + 'default': 1 + }, + 'use_cpu': { + 'type': 'boolean', + 'description': 'Use CPU for computation via ' + 'scipy::signal.correlate. Default is False and runs ' # noqa: E131,E501 + 'on GPU via cusignal.', + 'default': False + }, + }, + } + return ConfSchema(json=json) + + def process(self, inputs): + mode = self.conf.get('mode', 'full') + method = self.conf.get('method', 'auto') + scale = self.conf.get('scale', 1) + use_cpu = self.conf.get('use_cpu', False) + + in1 = inputs['in1'] + in2 = inputs['in2'] + + if use_cpu: + corr = sicorr(in1, in2, mode=mode, method=method) + else: + corr = cucorr(in1, in2, mode=mode, method=method) + + corr = corr if scale == 1 else corr / scale + + return {'correlate': corr} diff --git a/gQuant/plugins/cusignal_plugin/greenflow_cusignal_plugin/convolution/correlate2d.py b/gQuant/plugins/cusignal_plugin/greenflow_cusignal_plugin/convolution/correlate2d.py new file mode 100644 index 00000000..9dd9df58 --- /dev/null +++ b/gQuant/plugins/cusignal_plugin/greenflow_cusignal_plugin/convolution/correlate2d.py @@ -0,0 +1,122 @@ +import numpy as np +import cupy as cp + +from cusignal.convolution import correlate2d as cucorr2d +from scipy.signal import correlate2d as sicorr2d + +from greenflow.dataframe_flow import (Node, PortsSpecSchema, ConfSchema) +from greenflow.dataframe_flow.template_node_mixin import TemplateNodeMixin + +__all__ = ['CusignalCorrelate2dNode'] + +_CORR2_DESC = '''Cross-correlate two 2-dimensional arrays. + +Cross correlate `in1` and `in2` with output size determined by `mode`, and +boundary conditions determined by `boundary` and `fillvalue` + +Returns: +correlate2d : ndarray + A 2-dimensional array containing a subset of the discrete linear + cross-correlation of `in1` with `in2` +''' + +_CORR2_MODE_DESC = '''mode : str {'full', 'valid', 'same'}, optional + +A string indicating the size of the output: +``full`` + The output is the full discrete linear cross-correlation + of the inputs. (Default) +``valid`` + The output consists only of those elements that do not + rely on the zero-padding. In 'valid' mode, either `in1` or `in2` + must be at least as large as the other in every dimension. +``same`` + The output is the same size as `in1`, centered + with respect to the 'full' output. +''' + +_CORR2_BOUNDARY_DESC = '''boundary : str {'fill', 'wrap', 'symm'}, optional + +A flag indicating how to handle boundaries: +``fill`` + pad input arrays with fillvalue. (default) +``wrap`` + circular boundary conditions. +``symm`` + symmetrical boundary conditions. +''' + +_CORR2_FILLVAL_DESC = '''fillvalue : scalar, optional +Value to fill pad input arrays with. Default is 0. +''' + + +class CusignalCorrelate2dNode(TemplateNodeMixin, Node): + def init(self): + TemplateNodeMixin.init(self) + port_type = PortsSpecSchema.port_type + inports = { + 'in1': {port_type: [cp.ndarray, np.ndarray]}, + 'in2': {port_type: [cp.ndarray, np.ndarray]} + } + outports = { + 'correlate2d': {port_type: [cp.ndarray, np.ndarray]}, + } + self.template_ports_setup(in_ports=inports, out_ports=outports) + + meta_outports = {'correlate2d': {}} + self.template_meta_setup(out_ports=meta_outports) + + def conf_schema(self): + mode_enum = ['full', 'valid', 'same'] + boundary_enum = ['fill', 'wrap', 'symm'] + json = { + 'title': 'Cusignal Convolution2D Node', + 'type': 'object', + 'description': _CORR2_DESC, + 'properties': { + 'mode': { + 'type': 'string', + 'description': _CORR2_MODE_DESC, + 'enum': mode_enum, + 'default': 'full' + }, + 'boundary': { + 'type': 'string', + 'description': _CORR2_BOUNDARY_DESC, + 'enum': boundary_enum, + 'default': 'fill' + }, + 'fillvalue': { + 'type': 'number', + 'description': _CORR2_FILLVAL_DESC, + 'default': 0 + }, + 'use_cpu': { + 'type': 'boolean', + 'description': 'Use CPU for computation via ' + 'scipy::signal.correlate2d. Default is False and runs on ' + 'GPU via cusignal.', + 'default': False + }, + }, + } + return ConfSchema(json=json) + + def process(self, inputs): + mode = self.conf.get('mode', 'full') + boundary = self.conf.get('boundary', 'fill') + fillvalue = self.conf.get('fillvalue', 0) + use_cpu = self.conf.get('use_cpu', False) + + in1 = inputs['in1'] + in2 = inputs['in2'] + + if use_cpu: + corr2d = sicorr2d( + in1, in2, mode=mode, boundary=boundary, fillvalue=fillvalue) + else: + corr2d = cucorr2d( + in1, in2, mode=mode, boundary=boundary, fillvalue=fillvalue) + + return {'correlate2d': corr2d} diff --git a/gQuant/plugins/cusignal_plugin/greenflow_cusignal_plugin/convolution/fftconvolve.py b/gQuant/plugins/cusignal_plugin/greenflow_cusignal_plugin/convolution/fftconvolve.py new file mode 100644 index 00000000..cbb1e578 --- /dev/null +++ b/gQuant/plugins/cusignal_plugin/greenflow_cusignal_plugin/convolution/fftconvolve.py @@ -0,0 +1,127 @@ +import numpy as np +import cupy as cp + +from cusignal.convolution import fftconvolve as cufftconv +from scipy.signal import fftconvolve as sifftconv + +from greenflow.dataframe_flow import (Node, PortsSpecSchema, ConfSchema) +from greenflow.dataframe_flow.template_node_mixin import TemplateNodeMixin + +__all__ = ['CusignalFFTConvolveNode'] + +_FFTCONV_DESC = '''Convolve two N-dimensional arrays using FFT. + +Convolve `in1` and `in2` using the fast Fourier transform method, with +the output size determined by the `mode` argument. + +This is generally much faster than `convolve` for large arrays (n > ~500), +but can be slower when only a few output values are needed, and can only +output float arrays (int or object array inputs will be cast to float). + +As of v0.19, `convolve` automatically chooses this method or the direct +method based on an estimation of which is faster. + +Returns: +out : array + An N-dimensional array containing a subset of the discrete linear + convolution of `in1` with `in2`. +''' + +_FFTCONV_MODE_DESC = '''mode : str {'full', 'valid', 'same'}, optional +A string indicating the size of the output: +``full`` + The output is the full discrete linear convolution + of the inputs. (Default) +``valid`` + The output consists only of those elements that do not + rely on the zero-padding. In 'valid' mode, either `in1` or `in2` + must be at least as large as the other in every dimension. +``same`` + The output is the same size as `in1`, centered + with respect to the 'full' output. + axis : tuple, optional +''' + +_FFTCONV_AXES_DESC = '''axes : int or array_like of ints or None, optional +Axes over which to compute the convolution. +The default is over all axes. +''' + + +class CusignalFFTConvolveNode(TemplateNodeMixin, Node): + def init(self): + TemplateNodeMixin.init(self) + port_type = PortsSpecSchema.port_type + inports = { + 'in1': {port_type: [cp.ndarray, np.ndarray]}, + 'in2': {port_type: [cp.ndarray, np.ndarray]} + } + outports = { + 'fftconvolve': {port_type: [cp.ndarray, np.ndarray]}, + } + self.template_ports_setup(in_ports=inports, out_ports=outports) + + meta_outports = {'fftconvolve': {}} + self.template_meta_setup(out_ports=meta_outports) + + def conf_schema(self): + mode_enum = ['full', 'valid', 'same'] + json = { + 'title': 'Cusignal Convolution Node', + 'type': 'object', + 'description': _FFTCONV_DESC, + 'properties': { + 'mode': { + 'type': 'string', + 'description': _FFTCONV_MODE_DESC, + 'enum': mode_enum, + 'default': 'full' + }, + 'axes': { + 'type': 'array', + 'items': { + 'type': 'integer' + }, + 'description': _FFTCONV_AXES_DESC, + }, + 'use_cpu': { + 'type': 'boolean', + 'description': 'Use CPU for computation via ' + 'scipy::signal.fftconvolve. Default is False and ' # noqa: E131,E501 + 'runs on GPU via cusignal.', + 'default': False + }, + }, + } + return ConfSchema(json=json) + + def process(self, inputs): + mode = self.conf.get('mode', 'full') + axes = self.conf.get('axes', []) + use_cpu = self.conf.get('use_cpu', False) + + in1 = inputs['in1'] + in2 = inputs['in2'] + + if len(axes) == 0: + axes = None + elif len(axes) == 1: + axes = axes[0] + + if use_cpu: + fftconv = sifftconv(in1, in2, mode=mode, axes=axes) + else: + cache = cp.fft.config.get_plan_cache() + cache.clear() + mempool = cp.get_default_memory_pool() + mempool.free_all_blocks() + + if cache.get_size() > 0: + cache.set_size(0) + + # if cache.get_memsize() != 0: + # cache.set_memsize(0) + + fftconv = cufftconv(in1, in2, mode=mode, axes=axes) + + return {'fftconvolve': fftconv} diff --git a/gQuant/plugins/cusignal_plugin/greenflow_cusignal_plugin/filtering/__init__.py b/gQuant/plugins/cusignal_plugin/greenflow_cusignal_plugin/filtering/__init__.py new file mode 100644 index 00000000..9b7c2fa2 --- /dev/null +++ b/gQuant/plugins/cusignal_plugin/greenflow_cusignal_plugin/filtering/__init__.py @@ -0,0 +1,2 @@ +from .custom_filter_block import * +from .resample_poly import * diff --git a/gQuant/plugins/cusignal_plugin/greenflow_cusignal_plugin/filtering/custom_filter_block.py b/gQuant/plugins/cusignal_plugin/greenflow_cusignal_plugin/filtering/custom_filter_block.py new file mode 100644 index 00000000..f47bca1f --- /dev/null +++ b/gQuant/plugins/cusignal_plugin/greenflow_cusignal_plugin/filtering/custom_filter_block.py @@ -0,0 +1,88 @@ +import ast +from types import ModuleType + +import numpy as np +import cupy as cp + +from greenflow.dataframe_flow import (Node, PortsSpecSchema, ConfSchema) +from greenflow.dataframe_flow.template_node_mixin import TemplateNodeMixin + +__all__ = ['CustomFilterNode'] + + +def compile_user_module(code): + ''' + Usage: + # code is some text/string of code to be compiled dynamically. + code = '\ndef somefn(in1, in2):\n return in1 + in2\n' + module_ = compile_user_module(code) + module_.somefn(5, 6) # returns 11 per def of somefn + ''' + # https://stackoverflow.com/questions/19850143/how-to-compile-a-string-of-python-code-into-a-module-whose-functions-can-be-call + # https://stackoverflow.com/questions/39379331/python-exec-a-code-block-and-eval-the-last-line + block = ast.parse(code, mode='exec') + + module_ = ModuleType('user_module') + exec(compile(block, '', mode='exec'), module_.__dict__) + + return module_ + + +class CustomFilterNode(TemplateNodeMixin, Node): + def init(self): + TemplateNodeMixin.init(self) + + port_type = PortsSpecSchema.port_type + inports = {'signal': {port_type: [cp.ndarray, np.ndarray]}} + outports = {'signal_out': {port_type: '${port:signal}'}} + self.template_ports_setup(in_ports=inports, out_ports=outports) + + meta_outports = {'signal_out': {}} + self.template_meta_setup(out_ports=meta_outports) + + def conf_schema(self): + json = { + 'title': 'Custom Filter Node.', + 'type': 'object', + 'description': 'Custom filter logic. CAUTION: Only run trusted ' + 'code.', # noqa: E131,E501 + 'properties': { + 'pycode': { + 'type': 'string', + 'title': 'Signal Code - pycode', + 'description': 'Enter python code to filter a signal. ' + 'The code must have a function with the following ' # noqa: E131,E501 + 'name and signature: def custom_filter(signal, conf). ' + 'The ``signal`` is a cp or np array. The ``conf`` ' + 'is the node\'s configuration dictionary. Besides ' + '"pycode" custom conf fields are not not exposed via ' + 'UI. If anything needs to be set do it ' + 'programmatically via TaskSpecSchema. The ' + '`custom_filter` function must return a processed ' + 'signal of same type as input signal.' + }, + }, + # 'required': ['pycode'], + } + ui = {'pycode': {'ui:widget': 'textarea'}} + return ConfSchema(json=json, ui=ui) + + def process(self, inputs): + pycode = self.conf.get('pycode') + + if not pycode: + raise RuntimeError('Task id: {}; Node type: {}\n' + 'No code provided. Nothing to output.' + .format(self.uid, 'CustomFilterNode')) + + signal = inputs['signal'] + module_ = compile_user_module(pycode) + if not hasattr(module_, 'custom_filter'): + raise RuntimeError( + 'Task id: {}; Node type: {}\n' + 'Pycode does not define "custom_filter" function.\n' + 'Pycode provided:\n{}' + .format(self.uid, 'CustomFilterNode', pycode)) + + out = module_.custom_filter(signal, self.conf) + return {'signal_out': out} diff --git a/gQuant/plugins/cusignal_plugin/greenflow_cusignal_plugin/filtering/resample_poly.py b/gQuant/plugins/cusignal_plugin/greenflow_cusignal_plugin/filtering/resample_poly.py new file mode 100644 index 00000000..9fe6273a --- /dev/null +++ b/gQuant/plugins/cusignal_plugin/greenflow_cusignal_plugin/filtering/resample_poly.py @@ -0,0 +1,186 @@ +from ast import literal_eval +from fractions import Fraction +import numpy as np +import cupy as cp + +from cusignal.filtering.resample import resample_poly as curesamp +from scipy.signal import resample_poly as siresamp + +from greenflow.dataframe_flow import (Node, PortsSpecSchema, ConfSchema) +from greenflow.dataframe_flow.template_node_mixin import TemplateNodeMixin + +from ..windows import _WINS_CONFIG + +__all__ = ['CusignalResamplePolyNode'] + +_RESAMPLEPOLY_DESC = '''Resample `signal` along the given axis using polyphase +filtering. The signal is upsampled by the factor `up`, a zero-phase low-pass +FIR filter is applied, and then it is downsampled by the factor `down`. +The resulting sample rate is ``up / down`` times the original sample +rate. Values beyond the boundary of the signal are assumed to be zero +during the filtering step. Returns resampled array and new sample rate. +''' + + +class CusignalResamplePolyNode(TemplateNodeMixin, Node): + def init(self): + TemplateNodeMixin.init(self) + inports = { + 'signal': {PortsSpecSchema.port_type: [cp.ndarray, np.ndarray]}, + 'samplerate': { + PortsSpecSchema.port_type: [int, float, np.float32, + np.float64], + PortsSpecSchema.optional: True + }, + 'window': { + PortsSpecSchema.port_type: [cp.ndarray, np.ndarray], + PortsSpecSchema.optional: True + }, + } + outports = { + 'signal_out': {PortsSpecSchema.port_type: '${port:signal}'}, + 'samplerate_out': { + PortsSpecSchema.port_type: [int, float, np.float32, + np.float64], + PortsSpecSchema.optional: True + } + } + self.template_ports_setup(in_ports=inports, out_ports=outports) + + meta_outports = {'signal_out': {}, 'samplerate_out': {}} + self.template_meta_setup(out_ports=meta_outports) + + def conf_schema(self): + padtype_enum = ['constant', 'line', 'mean', 'median', 'maximum', + 'minimum'] + json = { + 'title': 'Polyphase Filter Resample Node', + 'type': 'object', + 'description': _RESAMPLEPOLY_DESC, + 'properties': { + 'new_samplerate': { + 'type': 'number', + 'description': 'Desired sample rate. Specify this or the ' + 'up/down parameters. This is used when `samplerate` ' # noqa: E131,E501 + 'is passed in via ports, otherwise up/down is used. ' + 'If both are set then this takes precedence over ' + 'up/down.' + }, + 'up': { + 'type': 'integer', + 'description': 'The upsampling factor.' + }, + 'down': { + 'type': 'integer', + 'description': 'The downsampling factor.' + }, + 'axis': { + 'type': 'integer', + 'description': 'The axis of `x` that is resampled. ' + 'Default is 0.', # noqa: E131,E501 + 'default': 0, + 'minimum': 0, + }, + 'window': { + 'type': 'string', + 'description': 'Desired window to use to design the ' + 'low-pass filter, or the FIR filter coefficients to ' # noqa: E131,E501 + 'employ. Window can be specified as a string, a ' + 'tuple, or a list. If a string choose one of ' + 'available windows. If a tuple refer to ' + '`cusignal.windows.get_window`. The tuple format ' + 'specifies the first argument as the string name of ' + 'the window, and the next arguments the needed ' + 'parameters. If `window` is a list it is assumed to ' + 'be the FIR filter coefficients. Note that the FIR ' + 'filter is applied after the upsampling step, so it ' + 'should be designed to operate on a signal at a ' + 'sampling frequency higher than the original by a ' + 'factor of `up//gcd(up, down)`. If the port window ' + 'is connected it takes precedence. Default ' + '("kaiser", 5.0)', + 'default': '("kaiser", 5.0)' + }, + 'gpupath': { + 'type': 'boolean', + 'description': 'gpupath - Optional path for filter design.' + ' gpupath == False may be desirable if filter sizes ' # noqa: E131,E501 + 'are small.', + 'default': True + }, + 'use_cpu': { + 'type': 'boolean', + 'description': 'use_cpu - Use CPU for computation via ' + 'scipy::signal.resample_poly. Default is False and ' # noqa: E131,E501 + 'runs on GPU via cusignal.', + 'default': False + }, + 'padtype': { + 'type': 'string', + 'description': 'Only used when `use_cpu` is set. Scipy ' + 'padtype parameter of `resample_poly`. This is not ' # noqa: E131,E501 + 'currently exposed in cusignal.', + 'enum': padtype_enum, + 'default': 'constant' + }, + 'cval': { + 'type': 'number', + 'description': 'Only used when `use_cpu` is set. Value ' + 'to use if `padtype="constant"`. Default is zero.' # noqa: E131,E501 + } + } + } + return ConfSchema(json=json) + + def process(self, inputs): + signal_in = inputs['signal'] + samplerate = inputs.get('samplerate', None) + + new_samplerate = self.conf.get('new_samplerate', None) + if new_samplerate and samplerate: + ud = Fraction(new_samplerate / samplerate).limit_denominator() + up = ud.numerator + down = ud.denominator + else: + up = self.conf['up'] + down = self.conf['down'] + + if samplerate: + samplerate = inputs['samplerate'] + new_samplerate = samplerate * up / down + else: + new_samplerate = up / down + + axis = self.conf.get('axis', 0) + + if 'window' in inputs: + window = input['window'] + else: + window = self.conf.get('window', ("kaiser", 5.0)) + if isinstance(window, str): + windows_enum = list(_WINS_CONFIG.keys()) + # window could be a simple string or python code for tuple + if window not in windows_enum: + # window should be a string that is python code + # evaluated to a tuple. + try: + window = literal_eval(window) + except Exception: + raise RuntimeError('Uknown window: {}'.format(window)) + + gpupath = self.conf.get('gpupath', True) + + use_cpu = self.conf.get('use_cpu', False) + + if use_cpu: + padtype = self.conf.get('padtype', 'constant') + cval = self.conf.get('cval') + signal_out = siresamp( + signal_in, up, down, axis=axis, window=window, + padtype=padtype, cval=cval) + else: + signal_out = curesamp( + signal_in, up, down, axis=axis, window=window, gpupath=gpupath) + + return {'signal_out': signal_out, + 'samplerate_out': new_samplerate} diff --git a/gQuant/plugins/cusignal_plugin/greenflow_cusignal_plugin/gensig/__init__.py b/gQuant/plugins/cusignal_plugin/greenflow_cusignal_plugin/gensig/__init__.py new file mode 100644 index 00000000..69c7e5ca --- /dev/null +++ b/gQuant/plugins/cusignal_plugin/greenflow_cusignal_plugin/gensig/__init__.py @@ -0,0 +1,2 @@ +from .gensig import * +from .wavefilereader import * diff --git a/gQuant/plugins/cusignal_plugin/greenflow_cusignal_plugin/gensig/gensig.py b/gQuant/plugins/cusignal_plugin/greenflow_cusignal_plugin/gensig/gensig.py new file mode 100644 index 00000000..e96e2d8d --- /dev/null +++ b/gQuant/plugins/cusignal_plugin/greenflow_cusignal_plugin/gensig/gensig.py @@ -0,0 +1,72 @@ +import numpy as np +import cupy as cp +import ast + +from greenflow.dataframe_flow import ( + Node, NodePorts, PortsSpecSchema, ConfSchema, MetaData) +from greenflow.dataframe_flow.template_node_mixin import TemplateNodeMixin + +__all__ = ['SignalGeneratorNode'] + + +def exec_then_eval(code): + # https://stackoverflow.com/questions/39379331/python-exec-a-code-block-and-eval-the-last-line + block = ast.parse(code, mode='exec') + + # assumes last node is an expression + last = ast.Expression(block.body.pop().value) + + _globals, _locals = {}, {} + exec(compile(block, '', mode='exec'), _globals, _locals) + return eval(compile(last, '', mode='eval'), _globals, _locals) + + +class SignalGeneratorNode(TemplateNodeMixin, Node): + def init(self): + TemplateNodeMixin.init(self) + outports = { + 'out1': {PortsSpecSchema.port_type: [cp.ndarray, np.ndarray]}, + 'out2': { + PortsSpecSchema.port_type: [cp.ndarray, np.ndarray], + PortsSpecSchema.optional: True + }, + } + self.template_ports_setup(out_ports=outports) + + meta_outports = {'out1': {}, 'out2': {}} + self.template_meta_setup(out_ports=meta_outports) + + def conf_schema(self): + json = { + 'title': 'Custom Signal Generator Node.', + 'type': 'object', + 'description': 'Inject signals into greenflow taskgraphs. Use ' + 'CAUTION. Only run trusted code.', + 'properties': { + 'pycode': { + 'type': 'string', + 'title': 'Signal Code', + 'description': 'Enter python code to generate signal. ' + 'The code must have a dictionary ``myout`` variable ' + 'with keys: out1 and out2. The out2 port is optional. ' + 'The ``myout`` must be the last line. Keep it simple ' + 'please.' + }, + }, + # 'required': ['pycode'], + } + ui = {'pycode': {'ui:widget': 'textarea'}} + return ConfSchema(json=json, ui=ui) + + def process(self, inputs): + pycode = self.conf.get('pycode') + # print('Task id: {}; Node type: {}\nPYCODE:\n{}'.format( + # self.uid, 'SignalGeneratorNode', pycode)) + + if pycode: + myout = exec_then_eval(pycode) + return myout + + raise RuntimeError('Task id: {}; Node type: {}\n' + 'No pycode provided. Nothing to output.' + .format(self.uid, 'SignalGeneratorNode')) diff --git a/gQuant/plugins/cusignal_plugin/greenflow_cusignal_plugin/gensig/wavefilereader.py b/gQuant/plugins/cusignal_plugin/greenflow_cusignal_plugin/gensig/wavefilereader.py new file mode 100644 index 00000000..cc824524 --- /dev/null +++ b/gQuant/plugins/cusignal_plugin/greenflow_cusignal_plugin/gensig/wavefilereader.py @@ -0,0 +1,137 @@ +import wave # Python standard lib. +import struct +try: + # conda install -c conda-forge pysoundfile + import soundfile as sf +except ModuleNotFoundError: + sf = None + +import numpy as np +import cupy as cp +import cusignal + +from greenflow.dataframe_flow import ( + Node, NodePorts, PortsSpecSchema, ConfSchema, MetaData) +from greenflow.dataframe_flow.template_node_mixin import TemplateNodeMixin + +__all__ = ['IQwavefileNode'] + + +def wave_reader(wavefile, nframes): + '''Read an IQ wavefile. Not thoroughly tested.''' + # https://stackoverflow.com/questions/19709018/convert-3-byte-stereo-wav-file-to-numpy-array + with wave.open(wavefile, 'rb') as wf: + chans = wf.getnchannels() + # nframes = wf.getnframes() + sampwidth = wf.getsampwidth() + if sampwidth == 3: # have to read this one sample at a time + buf = '' + for _ in range(nframes): + fr = wf.readframes(1) + for c in range(0, 3 * chans, 3): + # put TRAILING 0 to make 32-bit (file is little-endian) + buf += '\0' + fr[c:(c + 3)] + else: + buf = wf.readframes(nframes) + + unpstr = '<{0}{1}'.format(nframes * chans, + {1:'b', 2:'h', 3:'i', 4:'i', 8:'q'}[sampwidth]) + # x = list(struct.unpack(unpstr, buf)) + wdata = np.array(struct.unpack(unpstr, buf)) + if sampwidth == 3: + # downshift to get +/- 2^24 with sign extension + # x = [k >> 8 for k in x] + wdata = np.right_shift(wdata, 8) + + int2float = 2 ** (sampwidth * 8 - 1) - 1 + # wdata = np.array(x) + wdata_float = wdata.astype(np.float64) / int2float + # iq_data = wdata_float.view(dtype=np.complex128) + + return wdata_float + + +class IQwavefileNode(TemplateNodeMixin, Node): + def init(self): + TemplateNodeMixin.init(self) + + outports = { + 'signal': {PortsSpecSchema.port_type: [cp.ndarray, np.ndarray]}, + 'framerate': {PortsSpecSchema.port_type: float}, + } + self.template_ports_setup(out_ports=outports) + + meta_outports = {'signal': {}, 'framerate': {}} + self.template_meta_setup(out_ports=meta_outports) + + def conf_schema(self): + json = { + 'title': 'IQ Wavefile Node', + 'type': 'object', + 'description': 'Load IQ data from a *.wav file. Preferably ' + 'install "pysoundfile" to do this. Otherwise uses "wave", ' # noqa: E131,E501 + 'but it has not been well tested for variety of ways data ' + 'has been stored in *.wav files.', + 'properties': { + 'wavefile': { + 'type': 'string', + 'description': 'IQ Wavefile *.wav. Typically ' + 'recorded snippets of SDR IQ.' # noqa: E131,E501 + }, + 'duration': { + 'type': 'number', + 'description': 'Number of seconds to load. Number of ' + 'frames loaded is dependent on framerate. Default ' # noqa: E131,E501 + '1 second. Limited to max frames in file. Will ' + 'fail if exceeds GPU memory size.', + 'default': 1.0 + }, + 'use_cpu': { + 'type': 'boolean', + 'description': 'use_cpu - Returns numpy array if True. ' + 'Default is False and returns Cupy array.', # noqa: E131,E501 + 'default': False + }, + }, + } + ui = {'wavefile': {'ui:widget': 'FileSelector'}} + return ConfSchema(json=json, ui=ui) + + def process(self, inputs): + infile = self.conf.get('wavefile') + nsecs = self.conf.get('duration', 1) + + with wave.open(infile) as wf: + wparams = wf.getparams() + # buf = wf.readframes(nframes) + + # int2float = (2**15 - 1) + # wdata = np.frombuffer(buf, dtype=np.int16) + # wdata_float = wdata.astype(np.float64)/int2float + # iq_data = wdata_float.view(dtype=np.complex128) + + nframes = min(int(wparams.framerate * nsecs), wparams.nframes) + if sf is None: + data = wave_reader(infile, nframes) + framerate = wparams.framerate + else: + data, framerate = sf.read(infile, frames=nframes) + + # IQ data + cpu_signal = data.view(dtype=np.complex128).reshape(nframes) + if self.conf.get('use_cpu', False): + out = {'signal': cpu_signal} + else: + # Create mapped, pinned memory for zero copy between CPU and GPU + gpu_signal_buf = cusignal.get_shared_mem( + nframes, dtype=np.complex128) + gpu_signal_buf[:] = cpu_signal + + # zero-copy conversion from Numba CUDA array to CuPy array + gpu_signal = cp.asarray(gpu_signal_buf) + + out = {'signal': gpu_signal} + + out['framerate'] = float(framerate) + + return out diff --git a/gQuant/plugins/cusignal_plugin/greenflow_cusignal_plugin/spectral_analysis/__init__.py b/gQuant/plugins/cusignal_plugin/greenflow_cusignal_plugin/spectral_analysis/__init__.py new file mode 100644 index 00000000..9b4f061b --- /dev/null +++ b/gQuant/plugins/cusignal_plugin/greenflow_cusignal_plugin/spectral_analysis/__init__.py @@ -0,0 +1 @@ +from .welchpsd import * diff --git a/gQuant/plugins/cusignal_plugin/greenflow_cusignal_plugin/spectral_analysis/welchpsd.py b/gQuant/plugins/cusignal_plugin/greenflow_cusignal_plugin/spectral_analysis/welchpsd.py new file mode 100644 index 00000000..4b9cffdd --- /dev/null +++ b/gQuant/plugins/cusignal_plugin/greenflow_cusignal_plugin/spectral_analysis/welchpsd.py @@ -0,0 +1,198 @@ +import numpy as np +import cupy as cp + +from cusignal.spectral_analysis import welch as cuwelch +from scipy.signal.spectral import welch as siwelch + +from greenflow.dataframe_flow import ( + Node, NodePorts, PortsSpecSchema, ConfSchema, MetaData) + +from greenflow.dataframe_flow.template_node_mixin import TemplateNodeMixin + +from ..windows import _WINS_CONFIG + +__all__ = ['WelchPSD_Node'] + +_WELCH_DESC = '''Estimate power spectral density using Welch's method. Welch's +method computes an estimate of the power spectral density by dividing the data +into overlapping segments, computing a modified periodogram for each segment +and averaging the periodograms. +Returns - freqs:ndarray Array of frequencies; +Pxx:ndarray Power spectral density or power spectrum of signal. +''' + + +class WelchPSD_Node(TemplateNodeMixin, Node): + def init(self): + TemplateNodeMixin.init(self) + + inports = { + 'signal': {PortsSpecSchema.port_type: [cp.ndarray, np.ndarray]}, + 'samplerate': { + PortsSpecSchema.port_type: [int, float, np.float32, + np.float64], + PortsSpecSchema.optional: True + }, + 'window': { + PortsSpecSchema.port_type: [cp.ndarray, np.ndarray], + PortsSpecSchema.optional: True + }, + } + outports = { + 'psd': {PortsSpecSchema.port_type: '${port:signal}'}, + 'freqs': {PortsSpecSchema.port_type: '${port:signal}'}, + } + self.template_ports_setup(in_ports=inports, out_ports=outports) + + meta_outports = {'psd': {}, 'freqs': {}} + self.template_meta_setup(out_ports=meta_outports) + + def conf_schema(self): + windows_enum = list(_WINS_CONFIG.keys()) + detrend_enum = ['constant', 'linear', 'false'] + scaling_enum = ['density', 'spectrum'] + average_enum = ['mean', 'median'] + json = { + 'title': 'Welch Power Spectral Density Node', + 'type': 'object', + 'description': _WELCH_DESC, + 'properties': { + 'samplerate': { + 'type': 'number', + 'description': 'fs : float, optional; Sampling frequency ' + 'of the `x` (input signal) time series. Defaults to ' # noqa: E131,E501 + '1.0. This can also be passed at input port ' + '`samplerate`. Port takes precedence over conf.', + 'default': 1.0 + }, + 'window': { + 'type': 'string', + 'description': 'Desired window to use. Alternatively ' + 'pass window via port `window`. In that case its ' # noqa: E131,E501 + 'length must be nperseg. Defaults to a Hann window.', + 'enum': windows_enum, + 'default': 'hann' + }, + 'nperseg': { + 'type': 'integer', + 'description': 'Length of each segment. Defaults to None, ' + 'but if window is str, is set to 256, and if window ' # noqa: E131,E501 + 'is array_like (passed via port `window`), is set to ' + 'the lesser of this setting or length of the window.', + }, + 'noverlap': { + 'type': 'integer', + 'description': 'Number of points to overlap between ' + 'segments. If `None`, ``noverlap = nperseg // 2``. ' # noqa: E131,E501 + 'Defaults to `None`.', + }, + 'nfft': { + 'type': 'integer', + 'description': 'Length of the FFT used, if a zero padded ' + 'FFT is desired. If `None`, the FFT length is ' # noqa: E131,E501 + '`nperseg`. Defaults to `None`.', + }, + 'detrend': { + 'type': 'string', + 'description': 'Specifies how to detrend each segment. If ' + '"constant", only the mean of `data` is subtracted. ' # noqa: E131,E501 + 'If "linear", the result of a linear least-squares ' + 'fit to `data` is subtracted from `data`. If ' + '`detrend` is `False`, no detrending is done. ' + 'Default is "constant".', + 'enum': detrend_enum, + 'default': 'constant' + }, + 'return_onesided': { + 'type': 'boolean', + 'description': 'return_onesided - If `True`, return a ' + 'one-sided spectrum for real data. If `False` return ' # noqa: E131,E501 + 'a two-sided spectrum. Defaults to `True`, but for ' + 'complex data, a two-sided spectrum is always ' + 'returned.', + 'default': True + }, + 'scaling': { + 'type': 'string', + 'description': 'Selects between computing the power ' + 'spectral density ("density") where `Pxx` has units ' # noqa: E131,E501 + 'of V**2/Hz and computing the power spectrum ' + '("spectrum") where `Pxx` has units of V**2, if `x` ' + 'is measured in V and `fs` is measured in Hz. ' + 'Defaults to density', + 'enum': scaling_enum, + 'default': 'constant' + }, + 'axis': { + 'type': 'integer', + 'description': 'Axis along which the periodogram is ' + 'computed; the default is over the last axis (i.e. ' # noqa: E131,E501 + '``axis=-1``).', + 'default': -1 + }, + 'average': { + 'type': 'string', + 'description': '{"mean", "median"}, optional. Method to ' + 'use when averaging periodograms. Defaults to "mean".', # noqa: E131,E501 + 'enum': average_enum, + 'default': 'mean' + }, + 'use_cpu': { + 'type': 'boolean', + 'description': 'Use CPU for computation via ' + 'scipy::signal.spectral.welch. Default is False and ' # noqa: E131,E501 + 'runs on GPU via cusignal.', + 'default': False + }, + }, + } + return ConfSchema(json=json) + + def process(self, inputs): + use_cpu = self.conf.get('use_cpu', False) + + signal = inputs['signal'] + + samplerate = self.conf.get('samplerate', 1.0) + samplerate = inputs.get('samplerate', samplerate) + + window = self.conf.get('window', 'hann') + window = inputs.get('window', window) + + nperseg = self.conf.get('nperseg', None) + try: + nperseg = window.shape[0] + except Exception: + pass + + noverlap = self.conf.get('noverlap', None) + nfft = self.conf.get('nfft', None) + + detrend = self.conf.get('detrend', 'constant') + if isinstance(detrend, str): + detrend = False if detrend.lower() in ('false',) else detrend + + return_onesided = self.conf.get('return_onesided', True) + scaling = self.conf.get('scaling', 'density') + axis = self.conf.get('axis', -1) + average = self.conf.get('average', 'mean') + + welch_params = { + 'fs': samplerate, + 'window': window, + 'nperseg': nperseg, + 'noverlap': noverlap, + 'nfft': nfft, + 'detrend': detrend, + 'return_onesided': return_onesided, + 'scaling': scaling, + 'axis': axis, + 'average': average, + } + + if use_cpu: + freqs, psd = siwelch(signal, **welch_params) + else: + freqs, psd = cuwelch(signal, **welch_params) + + return {'psd': psd, 'freqs': freqs} diff --git a/gQuant/plugins/cusignal_plugin/greenflow_cusignal_plugin/windows.py b/gQuant/plugins/cusignal_plugin/greenflow_cusignal_plugin/windows.py new file mode 100644 index 00000000..40d7724a --- /dev/null +++ b/gQuant/plugins/cusignal_plugin/greenflow_cusignal_plugin/windows.py @@ -0,0 +1,315 @@ +import inspect +import numpy as np +import cupy as cp + +import cusignal.windows as cuwin +import scipy.signal.windows as siwin + +from greenflow.dataframe_flow import ( + Node, NodePorts, PortsSpecSchema, ConfSchema, MetaData) + +from greenflow.dataframe_flow.template_node_mixin import TemplateNodeMixin + +__all__ = ['CusignalWindowNode'] + + +_DEFAULT_WIN_JSON_CONF = { + 'M': { + 'type': 'integer', + 'title': 'M', + 'description': 'Number of points in the output window. If ' + 'zero or less, an empty array is returned.' # noqa: E131,E501 + }, + 'sym': { + 'type': 'boolean', + 'title': 'sym', + 'description': 'When True (default), generates a symmetric ' + 'window, for use in filter design. When False, generates a ' # noqa: E131,E501 + 'periodic window, for use in spectral analysis.', + 'default': True + } +} + +_DEFAULT_WIN_RETDESC = 'Returns - window : ndarray; The window, with the '\ +'maximum value normalized to 1 (though the value 1 does not appear if `M` '\ +'is even and `sym` is True)' + +_WINS_CONFIG = { + 'general_cosine': { + 'json_conf': { + 'a': { + 'type': 'array', + 'items': {'type': 'number'}, + 'description': 'Sequence of weighting coefficients. This ' + 'uses the convention of being centered on the origin, ' + 'so these will typically all be positive numbers, not ' + 'alternating sign.' + }, + }, + 'description': 'Generic weighted sum of cosine terms window.', + 'desc-return': '' + }, + 'boxcar': { + 'description': 'Return a boxcar or rectangular window. ' + 'Also known as a rectangular window or Dirichlet window, this is ' + 'equivalent to no window at all.', + 'desc-return': 'window: ndarray; The window, with the maximum value ' + 'normalized to 1.' + }, + 'triang': { + 'description': 'Return a triangular window.' + }, + 'parzen': { + 'description': 'Return a Parzen window.', + 'desc-return': '' + }, + 'bohman': { + 'description': 'Return a Bohman window.' + }, + 'blackman': { + 'description': 'The Blackman window is a taper formed by using the ' + 'first three terms of a summation of cosines. It was designed to ' + 'have close to the minimal leakage possible. It is close to ' + 'optimal, only slightly worse than a Kaiser window.' + }, + 'nuttall': { + 'description': 'Return a minimum 4-term Blackman-Harris window ' + 'according to Nuttall. This variation is also called "Nuttall4c".' + }, + 'blackmanharris': { + 'description': 'Return a minimum 4-term Blackman-Harris window.' + }, + 'flattop': { + 'description': 'Return a flat top window.' + }, + 'bartlett': { + 'description': 'Return a Bartlett window. The Bartlett window is very ' + 'similar to a triangular window, except that the end points are ' + 'at zero. It is often used in signal processing for tapering a ' + 'signal, without generating too much ripple in the frequency ' + 'domain.', + 'desc-return': 'Returns - w : ndarray; The triangular window, with ' + 'the first and last samples equal to zero and the maximum value ' + 'normalized to 1 (though the value 1 does not appear if `M` is ' + 'even and `sym` is True).' + }, + 'hann': { + 'description': 'Return a Hann window. The Hann window is a taper ' + 'formed by using a raised cosine or sine-squared with ends that ' + 'touch zero.' + }, + 'tukey': { + 'json_conf': { + 'alpha': { + 'type': 'number', + 'description': 'Shape parameter of the Tukey window, ' + 'representing the fraction of the window inside the ' + 'cosine tapered region. If zero, the Tukey window is ' + 'equivalent to a rectangular window. If one, the Tukey ' + 'window is equivalent to a Hann window.', + } + }, + 'description': 'Return a Tukey window, also known as a tapered ' + 'cosine window.' + }, + 'barthann': { + 'description': 'Return a modified Bartlett-Hann window.' + }, + 'general_hamming': { + 'json_conf': { + 'alpha': { + 'type': 'number', + 'description': 'The window coefficient.', + } + }, + 'description': 'Return a generalized Hamming window. The generalized ' + 'Hamming window is constructed by multiplying a rectangular ' + 'window by one period of a cosine function' + }, + 'hamming': { + 'description': 'Return a Hamming window. The Hamming window is a ' + 'taper formed by using a raised cosine with non-zero endpoints, ' + 'optimized to minimize the nearest side lobe.' + }, + 'kaiser': { + 'json_conf': { + 'beta': { + 'type': 'number', + 'description': 'Shape parameter, determines trade-off between ' + 'main-lobe width and side lobe level. As beta gets large, ' + 'the window narrows.', + } + }, + 'description': 'Return a Kaiser window. The Kaiser window is a taper ' + 'formed by using a Bessel function.' + }, + 'gaussian': { + 'json_conf': { + 'std': { + 'type': 'number', + 'description': 'The standard deviation, sigma.', + } + }, + 'description': 'Return a Gaussian window.' + }, + 'general_gaussian': { + 'json_conf': { + 'p': { + 'type': 'number', + 'description': 'Shape parameter. p = 1 is identical to ' + '`gaussian`, p = 0.5 is the same shape as the Laplace ' + 'distribution.', + }, + 'sig': { + 'type': 'number', + 'description': 'The standard deviation, sigma.', + } + }, + 'description': 'Return a window with a generalized Gaussian shape.' + }, + 'chebwin': { + 'json_conf': { + 'at ': { + 'type': 'number', + 'description': 'Attenuation (in dB).', + } + }, + 'description': 'Return a Dolph-Chebyshev window.' + }, + 'cosine': { + 'description': 'Return a window with a simple cosine shape.' + }, + 'exponential': { + 'json_conf': { + 'center': { + 'type': 'number', + 'description': 'Parameter defining the center location of ' + 'the window function. The default value if not given is ' + '``center = (M-1) / 2``. This parameter must take its ' + 'default value for symmetric windows.', + }, + 'tau': { + 'type': 'number', + 'description': 'Parameter defining the decay. For ' + '``center = 0`` use ``tau = -(M-1) / ln(x)`` if ``x`` is ' + 'the fraction of the window remaining at the end.', + } + }, + 'description': 'Return an exponential (or Poisson) window.' + }, + 'taylor': { + 'json_conf': { + 'nbar': { + 'type': 'integer', + 'description': 'Number of nearly constant level sidelobes ' + 'adjacent to the mainlobe.', + }, + 'sll': { + 'type': 'number', + 'description': 'Desired suppression of sidelobe level in ' + 'decibels (dB) relative to the DC gain of the mainlobe. ' + 'This should be a positive number.', + }, + 'norm': { + 'type': 'boolean', + 'description': 'When True (default), divides the window by ' + 'the largest (middle) value for odd-length windows or the ' + 'value that would occur between the two repeated middle ' + 'values for even-length windows such that all values are ' + 'less than or equal to 1. When False the DC gain will ' + 'remain at 1 (0 dB) and the sidelobes will be `sll` dB ' + 'down.', + 'default': True + } + }, + 'description': 'Return a Taylor window. The Taylor window taper ' + 'function approximates the Dolph-Chebyshev window\'s constant ' + 'sidelobe level for a parameterized number of near-in sidelobes, ' + 'but then allows a taper beyond . The SAR (synthetic aperature ' + 'radar) community commonly uses Taylor weighting for image ' + 'formation processing because it provides strong, selectable ' + 'sidelobe suppression with minimum broadening of the mainlobe.', + 'desc-return': 'Returns - out : array; The window. When `norm` is ' + 'True (default), the maximum value is normalized to 1 (though ' + 'the value 1 does not appear if `M` is even and `sym` is True).' + }, +} + + +class CusignalWindowNode(TemplateNodeMixin, Node): + def init(self): + TemplateNodeMixin.init(self) + + port_type = PortsSpecSchema.port_type + outports = {'window': {port_type: [cp.ndarray, np.ndarray]}} + self.template_ports_setup(out_ports=outports) + + meta_outports = {'window': {}} + self.template_meta_setup(out_ports=meta_outports) + + def conf_schema(self): + windows_enum = list(_WINS_CONFIG.keys()) + + use_cpu_conf = {'use_cpu': { + 'type': 'boolean', + 'description': 'use_cpu - Use CPU for computation via ' + 'scipy::signal.windows. Default is False and runs on ' + 'GPU via cusignal.', + 'default': False + }} + + # windows configuration + win_anyof = [] + for wtype in windows_enum: + wjson_conf =_DEFAULT_WIN_JSON_CONF.copy() + wjson_conf_update = _WINS_CONFIG[wtype].get('json_conf', {}) + wjson_conf.update(wjson_conf_update) + + wdesc = '{}\n{}'.format( + _WINS_CONFIG[wtype]['description'], + _WINS_CONFIG[wtype].get('desc-return', _DEFAULT_WIN_RETDESC)) + + wjson_conf_properties = { + 'window_type': { + 'type': 'string', + 'default': wtype, + 'readOnly': True + }, + **wjson_conf, + **use_cpu_conf + } + + wjson_schema = { + 'title': wtype, + 'description': wdesc, + 'properties': wjson_conf_properties + } + + win_anyof.append(wjson_schema) + + json = { + 'title': 'Cusignal Correlation Node', + 'type': 'object', + 'default': 'general_cosine', + 'description': 'Filter Window. Parameters updated below based on ' + 'selected window.', + 'anyOf': win_anyof, + 'required': ['window_type'], + } + return ConfSchema(json=json) + + def process(self, inputs): + wintype = self.conf.get('window_type', 'general_cosine') + winmod = siwin if self.conf.get('use_cpu') else cuwin + winfn = getattr(winmod, wintype) + # Match function signature parameters from self.conf; apply defaults to + # anything not matched. + winsig = inspect.signature(winfn) + params_filter = [pp.name for pp in winsig.parameters.values() + if pp.kind == pp.POSITIONAL_OR_KEYWORD] + params_dict = {kk: self.conf[kk] for kk in params_filter + if kk in self.conf} + ba = winsig.bind(**params_dict) + ba.apply_defaults() + winout = winfn(*ba.args, **ba.kwargs) + return {'window': winout} diff --git a/gQuant/plugins/cusignal_plugin/notebooks/convolution_examples.ipynb b/gQuant/plugins/cusignal_plugin/notebooks/convolution_examples.ipynb new file mode 100644 index 00000000..129812b9 --- /dev/null +++ b/gQuant/plugins/cusignal_plugin/notebooks/convolution_examples.ipynb @@ -0,0 +1,1056 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "cc7a2633-baca-4fe9-96c1-e974ac93edef", + "metadata": {}, + "source": [ + "# CuSignal API Guide in Greenflow\n", + "\n", + "The convolution examples are taken from [cusignal convolution notebook](https://github.com/rapidsai/cusignal/blob/branch-21.08/notebooks/api_guide/convolution_examples.ipynb). The examples below showing output were run on Volta GPU V100." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "d2fb8ebd-dad7-427e-956d-f6341e14e1a8", + "metadata": {}, + "outputs": [], + "source": [ + "import cupy.testing as cptest" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "0a004f15-e585-49fe-be95-cde77c5369b0", + "metadata": {}, + "outputs": [], + "source": [ + "from greenflow.dataframe_flow import (TaskGraph, TaskSpecSchema)" + ] + }, + { + "cell_type": "markdown", + "id": "d4d0f69b-765b-4c81-84c9-994ee34be703", + "metadata": {}, + "source": [ + "## Correlate" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "3b5dfa02-edc5-4a2e-8c99-4778c07fc23b", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tgraph_corr = TaskGraph.load_taskgraph('./taskgraphs/correlate.gq.yaml')\n", + "tgraph_corr.draw(show='ipynb', show_ports=True, pydot_options={'rankdir': 'LR'})" + ] + }, + { + "attachments": { + "2baa5a4c-b5b4-4189-803c-611c24e66dfa.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "id": "9dfa6a08-f19f-49f5-a17f-5d32b2c4f9e8", + "metadata": {}, + "source": [ + "If you would like to run via GreenflowLab follow the instructions in the next cell. Running via GreenflowLab will appear as shown in the image below. The output values might differ, because of the random signal generator.\n", + "\n", + "![image.png](attachment:2baa5a4c-b5b4-4189-803c-611c24e66dfa.png)" + ] + }, + { + "cell_type": "raw", + "id": "140117d7-7649-4898-bcb7-66b333ae1427", + "metadata": {}, + "source": [ + "# To run via GreenflowLab convert this cell from raw, add an output collector, and run.\n", + "tgraph_corr.draw()" + ] + }, + { + "cell_type": "markdown", + "id": "c7a55207-0ce4-43ed-bb73-266236a8307d", + "metadata": {}, + "source": [ + "The code to generate signals for correlation is included in the \"sig_task\" via \"pycode\" parameter. Feel free to tinker with the \"pycode\" via GreenflowLab to test other types of signals. Start by drawing the graph `tgraph_corr.draw()` and then click on the nodes to edit their parameters." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "fb3eb4c2-975e-4aba-8b33-73198434845f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "# PyCode to generate output for sig_task\n", + "import cupy as cp\n", + "\n", + "sig = cp.random.rand(int(1e8))\n", + "sig_noise = sig + cp.random.randn(len(sig))\n", + "sig_corr = cp.ones(128)\n", + "\n", + "myout = {'out1': sig_noise, 'out2': sig_corr}\n" + ] + } + ], + "source": [ + "tgraph_corr.build()\n", + "gensig_code = tgraph_corr['sig_task'].conf.get('pycode')\n", + "print('# PyCode to generate output for sig_task\\n{}'.format(gensig_code))" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "19748f7f-7ef5-4bd2-b1a5-3e0a81c794af", + "metadata": {}, + "outputs": [], + "source": [ + "(corr_gpu, sig_noise, sig_corr) = tgraph_corr.run(\n", + " ['correlate_task.correlate', 'sig_task.out1', 'sig_task.out2'])" + ] + }, + { + "cell_type": "markdown", + "id": "7fe40c75-a026-4eab-a807-4e4a3c7194d0", + "metadata": {}, + "source": [ + "The \"sig_task\" is a place holder to be able to load a signal programmatically. We can use the replace spec to specify \"load\" and corresponding output ports for the \"sig_task\". This will avoid re-running \"sig_task\", and keep the signals consistent for comparison between CPU and GPU. Also, the configuration of the \"correlate_task\" is changed to \"use_cpu\" for the CPU runs. This pattern is repeated throughout the notebook." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "13d3f827-609b-4a2d-8b28-dd4db358671b", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "replace_gpu = {\n", + " 'sig_task': {\n", + " TaskSpecSchema.load: {\n", + " 'out1': sig_noise,\n", + " 'out2': sig_corr\n", + " }\n", + " }\n", + "}\n", + "\n", + "conf_cpu = tgraph_corr['correlate_task'].conf.copy()\n", + "conf_cpu.update({'use_cpu': True})\n", + "replace_cpu = {\n", + " 'sig_task': {\n", + " TaskSpecSchema.load: {\n", + " 'out1': sig_noise.get(),\n", + " 'out2': sig_corr.get()\n", + " }\n", + " },\n", + " 'correlate_task': {\n", + " TaskSpecSchema.conf: conf_cpu\n", + " }\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "d5822b6a-374c-498a-bd0f-9b99b3b202f0", + "metadata": {}, + "outputs": [], + "source": [ + "(corr_cpu,) = tgraph_corr.run(['correlate_task.correlate'], replace=replace_cpu)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "e13b657a-0678-46b7-a550-66ba8bf94264", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CORR GPU: [2.99128918e-05 3.10918362e-05 3.08941328e-05 ... 3.88921964e-05\n", + " 3.88443687e-05 3.83087120e-05]\n", + "CORR CPU: [2.99128918e-05 3.10918362e-05 3.08941328e-05 ... 3.88921964e-05\n", + " 3.88443687e-05 3.83087120e-05]\n" + ] + } + ], + "source": [ + "print('CORR GPU: {}\\nCORR CPU: {}'.format(corr_gpu, corr_cpu))\n", + "cptest.assert_array_almost_equal(corr_gpu, corr_cpu)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "d5c6a130-4c23-44f3-81eb-9e82644bdb8d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201 ms ± 4.64 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n" + ] + } + ], + "source": [ + "gpu_time = %timeit -o (corr_gpu,) = tgraph_corr.run(['correlate_task.correlate'], replace=replace_gpu)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "1bc28a8d-56eb-4880-9c8c-3b598378c0ce", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3.72 s ± 22.5 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n" + ] + } + ], + "source": [ + "cpu_time = %timeit -o (corr_cpu,) = tgraph_corr.run(['correlate_task.correlate'], replace=replace_cpu)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "cd1839bc-7b2f-4dbc-ae1e-a474ce1c4998", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "SPEEDUP: 18.6x\n" + ] + } + ], + "source": [ + "print('SPEEDUP: {}x'.format(round(cpu_time.average / gpu_time.average, 1)))" + ] + }, + { + "cell_type": "markdown", + "id": "6fab6e94-7f4d-408b-b7ca-ee4365abb29d", + "metadata": {}, + "source": [ + "## Convolve" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "6a75dc4f-3d20-4449-82bf-21e59a248257", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tgraph_conv = TaskGraph.load_taskgraph('./taskgraphs/convolve.gq.yaml')\n", + "tgraph_conv.draw(show='ipynb', show_ports=True, pydot_options={'rankdir': 'LR'})" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "77a5a6eb-60f5-4aeb-a8ef-9dfb1188be9e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "# PyCode to generate output for sig_task\n", + "import cupy as cp\n", + "sig = cp.random.rand(int(1e8))\n", + "myout = {'out1': sig}\n" + ] + } + ], + "source": [ + "tgraph_conv.build()\n", + "gensig_code = tgraph_conv['sig_task'].conf.get('pycode')\n", + "print('# PyCode to generate output for sig_task\\n{}'.format(gensig_code))" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "c50c7347-3262-4ec7-be68-3c7f09ee64f0", + "metadata": {}, + "outputs": [], + "source": [ + "(conv_gpu, sig) = tgraph_conv.run(['convolve_task.convolve', 'sig_task.out1'])" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "ab120cf3-d498-4ea4-86b6-bfa92769c176", + "metadata": {}, + "outputs": [], + "source": [ + "replace_gpu = {\n", + " 'sig_task': {\n", + " TaskSpecSchema.load: {\n", + " 'out1': sig\n", + " }\n", + " }\n", + "}\n", + "\n", + "conf_cpu = {\n", + " 'convolve_task': tgraph_conv['convolve_task'].conf.copy(),\n", + " 'win_hann': tgraph_conv['win_hann'].conf.copy()\n", + "}\n", + "conf_cpu['convolve_task'].update({'use_cpu': True})\n", + "conf_cpu['win_hann'].update({'use_cpu': True})\n", + "replace_cpu = {\n", + " 'sig_task': {\n", + " TaskSpecSchema.load: {\n", + " 'out1': sig.get()\n", + " }\n", + " },\n", + " 'win_hann': {\n", + " TaskSpecSchema.conf: conf_cpu['win_hann']\n", + " },\n", + " 'convolve_task': {\n", + " TaskSpecSchema.conf: conf_cpu['convolve_task']\n", + " }\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "046b2b5c-4ac8-45ad-84e0-5f75166fc6ad", + "metadata": {}, + "outputs": [], + "source": [ + "(conv_cpu,) = tgraph_conv.run(['convolve_task.convolve'], replace=replace_cpu)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "03a070a0-7d10-441f-a874-2a198202773d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CONV GPU: [0.24874733 0.24976785 0.25078853 ... 0.25811188 0.25710866 0.25610544]\n", + "CONV CPU: [0.24874733 0.24976785 0.25078853 ... 0.25811188 0.25710866 0.25610544]\n" + ] + } + ], + "source": [ + "print('CONV GPU: {}\\nCONV CPU: {}'.format(conv_gpu, conv_cpu))\n", + "cptest.assert_array_almost_equal(conv_gpu, conv_cpu)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "9d127ba2-17ae-4552-8037-108fd5e718f7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201 ms ± 2.84 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n" + ] + } + ], + "source": [ + "gpu_time = %timeit -o (conv_gpu,) = tgraph_conv.run(['convolve_task.convolve'], replace=replace_gpu)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "bc782cd4-819d-40c5-9aad-ad88ddc8d74a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "15.2 s ± 223 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n" + ] + } + ], + "source": [ + "cpu_time = %timeit -o (conv_cpu,) = tgraph_conv.run(['convolve_task.convolve'], replace=replace_cpu)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "a26c54f6-3640-47b9-95a6-832e209874dc", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "SPEEDUP: 75.8x\n" + ] + } + ], + "source": [ + "print('SPEEDUP: {}x'.format(round(cpu_time.average / gpu_time.average, 1)))" + ] + }, + { + "cell_type": "markdown", + "id": "6ae67d00-18dc-45b8-b5bd-4a69e2b9b25a", + "metadata": {}, + "source": [ + "## Convolution using the FFT Method" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "cdcffa7c-88ea-40b5-ade7-b6ecc351a8f1", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tgraph_fftconv = TaskGraph.load_taskgraph('./taskgraphs/fftconvolve.gq.yaml')\n", + "tgraph_fftconv.draw(show='ipynb', show_ports=True, pydot_options={'rankdir': 'LR'})" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "3b846d03-05e5-4854-9ae7-dcef5c288e17", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "# PyCode to generate output for sig_task\n", + "import cupy as cp\n", + "gsig = cp.random.randn(int(1e8))\n", + "gsig_reverse = gsig[::-1]\n", + "myout = {'out1': gsig, 'out2': gsig_reverse}\n" + ] + } + ], + "source": [ + "tgraph_fftconv.build()\n", + "gensig_code = tgraph_fftconv['sig_task'].conf.get('pycode')\n", + "print('# PyCode to generate output for sig_task\\n{}'.format(gensig_code))" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "89437f3a-b06d-420f-b44b-bc56acf3dd95", + "metadata": {}, + "outputs": [], + "source": [ + "(gautocorr, gsig, gsig_reverse) = tgraph_fftconv.run(\n", + " ['fftconvolve_task.fftconvolve', 'sig_task.out1', 'sig_task.out2'])" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "93c5585d-9ec6-4149-a656-83073216e244", + "metadata": {}, + "outputs": [], + "source": [ + "replace_gpu = {\n", + " 'sig_task': {\n", + " TaskSpecSchema.load: {\n", + " 'out1': gsig,\n", + " 'out2': gsig_reverse\n", + " }\n", + " }\n", + "}\n", + "\n", + "conf_cpu = tgraph_fftconv['fftconvolve_task'].conf.copy()\n", + "conf_cpu.update({'use_cpu': True})\n", + "replace_cpu = {\n", + " 'sig_task': {\n", + " TaskSpecSchema.load: {\n", + " 'out1': gsig.get(),\n", + " 'out2': gsig_reverse.get()\n", + " }\n", + " },\n", + " 'fftconvolve_task': {\n", + " TaskSpecSchema.conf: conf_cpu\n", + " }\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "0af1368b-541d-4540-b5d2-950a4121c2b3", + "metadata": {}, + "outputs": [], + "source": [ + "(cautocorr,) = tgraph_fftconv.run(['fftconvolve_task.fftconvolve'], replace=replace_cpu)" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "ef324d17-d3b1-4523-a158-0527c2c5f6e1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "AUTOCORR GPU: [-1.38440037 -1.4631458 0.00953183 ... 0.00953183 -1.4631458\n", + " -1.38440037]\n", + "AUTOCORR CPU: [-1.38440037 -1.4631458 0.00953183 ... 0.00953183 -1.4631458\n", + " -1.38440037]\n" + ] + } + ], + "source": [ + "print('AUTOCORR GPU: {}\\nAUTOCORR CPU: {}'.format(gautocorr, cautocorr))\n", + "cptest.assert_array_almost_equal(gautocorr, cautocorr)" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "a2affde0-af46-4fb0-819a-13fcf38bce92", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "92" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Clean up memory. FFTconvolve seems to use a lot of GPU memory.\n", + "import gc\n", + "\n", + "try:\n", + " del corr_gpu\n", + "except Exception:\n", + " pass\n", + "\n", + "try:\n", + " del conv_gpu\n", + "except Exception:\n", + " pass\n", + "\n", + "try:\n", + " del gautocorr\n", + "except Exception:\n", + " pass\n", + "\n", + "gc.collect()" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "1f6e0ada-81f7-44a1-8666-27b7fbb87814", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "415 ms ± 101 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n" + ] + } + ], + "source": [ + "gpu_time = %timeit -o (gautocorr,) = tgraph_fftconv.run(['fftconvolve_task.fftconvolve'], replace=replace_gpu)" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "413a4485-1ef6-4d7c-8a0b-3be7cdca3d88", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "24.9 s ± 681 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n" + ] + } + ], + "source": [ + "cpu_time = %timeit -o (cautocorr,) = tgraph_fftconv.run(['fftconvolve_task.fftconvolve'], replace=replace_cpu)" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "96f29d42-4242-4f45-9cbd-109fabac095d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "SPEEDUP: 60.0x\n" + ] + } + ], + "source": [ + "print('SPEEDUP: {}x'.format(round(cpu_time.average / gpu_time.average, 1)))" + ] + }, + { + "cell_type": "markdown", + "id": "d49ea2ec-b701-4eda-98b7-4d3fe8ea5a41", + "metadata": {}, + "source": [ + "## Perform 2-D Convolution and Correlation" + ] + }, + { + "cell_type": "markdown", + "id": "67281f38-0493-4cab-ba36-7fed43e2e394", + "metadata": {}, + "source": [ + "### Convolve2d" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "da47b2d6-8831-412f-842a-164d0ba849c7", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tgraph_conv2d = TaskGraph.load_taskgraph('./taskgraphs/convolve2d.gq.yaml')\n", + "tgraph_conv2d.draw(show='ipynb', show_ports=True, pydot_options={'rankdir': 'LR'})" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "1447b095-7258-43e5-a369-abd13926f026", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "# PyCode to generate output for sig_task\n", + "import cupy as cp\n", + "\n", + "gsig = cp.random.rand(int(1e4), int(1e4))\n", + "gfilt = cp.random.rand(5,5)\n", + "\n", + "myout = {'out1': gsig, 'out2': gfilt}\n" + ] + } + ], + "source": [ + "tgraph_conv2d.build()\n", + "gensig_code = tgraph_conv2d['sig_task'].conf.get('pycode')\n", + "print('# PyCode to generate output for sig_task\\n{}'.format(gensig_code))" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "a67a2fdf-a355-4986-8bfa-4f1870f15f36", + "metadata": {}, + "outputs": [], + "source": [ + "(ggrad, gsig, gfilt) = tgraph_conv2d.run(\n", + " ['convolve2d_task.convolve2d', 'sig_task.out1', 'sig_task.out2'])" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "0bfdc9d2-1f74-4bcd-8287-32e92120ad6e", + "metadata": {}, + "outputs": [], + "source": [ + "replace_gpu = {\n", + " 'sig_task': {\n", + " TaskSpecSchema.load: {\n", + " 'out1': gsig,\n", + " 'out2': gfilt\n", + " }\n", + " }\n", + "}\n", + "\n", + "conf_cpu = tgraph_conv2d['convolve2d_task'].conf.copy()\n", + "conf_cpu.update({'use_cpu': True})\n", + "replace_cpu = {\n", + " 'sig_task': {\n", + " TaskSpecSchema.load: {\n", + " 'out1': gsig.get(),\n", + " 'out2': gfilt.get()\n", + " }\n", + " },\n", + " 'convolve2d_task': {\n", + " TaskSpecSchema.conf: conf_cpu\n", + " }\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "f067abd7-147c-497e-9079-e94e0eabf04c", + "metadata": {}, + "outputs": [], + "source": [ + "(cgrad,) = tgraph_conv2d.run(['convolve2d_task.convolve2d'], replace=replace_cpu)" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "32fec3f1-9ebc-49b6-920f-9a594920a62b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CONV GRAD GPU: [[0.09418511 0.28891615 0.4714031 ... 1.10261787 0.95488512 0.37537047]\n", + " [0.3886122 1.25281041 1.92730512 ... 1.98070304 1.31874051 0.48393504]\n", + " [1.23172081 2.66928131 3.25446231 ... 1.51402005 0.93597158 0.39933616]\n", + " ...\n", + " [1.21542563 2.29897527 2.66578943 ... 2.51846612 1.38937738 1.00662108]\n", + " [0.63316965 1.62170665 2.12106402 ... 2.36277057 1.48810924 1.15980468]\n", + " [0.13636812 0.86435831 0.99863584 ... 1.36198493 0.94709058 0.4818645 ]]\n", + "CONV GRAD CPU: [[0.09418511 0.28891615 0.4714031 ... 1.10261787 0.95488512 0.37537047]\n", + " [0.3886122 1.25281041 1.92730512 ... 1.98070304 1.31874051 0.48393504]\n", + " [1.23172081 2.66928131 3.25446231 ... 1.51402005 0.93597158 0.39933616]\n", + " ...\n", + " [1.21542563 2.29897527 2.66578943 ... 2.51846612 1.38937738 1.00662108]\n", + " [0.63316965 1.62170665 2.12106402 ... 2.36277057 1.48810924 1.15980468]\n", + " [0.13636812 0.86435831 0.99863584 ... 1.36198493 0.94709058 0.4818645 ]]\n" + ] + } + ], + "source": [ + "print('CONV GRAD GPU: {}\\nCONV GRAD CPU: {}'.format(ggrad, cgrad))\n", + "cptest.assert_array_almost_equal(ggrad, cgrad)" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "id": "c3cf4525-de1a-4266-b6e6-7ce2a93da000", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "59.9 ms ± 353 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n" + ] + } + ], + "source": [ + "gpu_time = %timeit -o (ggrad,) = tgraph_conv2d.run(['convolve2d_task.convolve2d'], replace=replace_gpu)" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "id": "0e3e6e51-2f2a-4e79-a975-75cacc05953c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "8.14 s ± 4.42 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n" + ] + } + ], + "source": [ + "cpu_time = %timeit -o (cgrad,) = tgraph_conv2d.run(['convolve2d_task.convolve2d'], replace=replace_cpu)" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "id": "c5c3ad65-6893-4f32-81c2-cf1410086c86", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "SPEEDUP: 135.9x\n" + ] + } + ], + "source": [ + "print('SPEEDUP: {}x'.format(round(cpu_time.average / gpu_time.average, 1)))" + ] + }, + { + "cell_type": "markdown", + "id": "813158c4-aa9e-431d-9eed-662d4aa5134f", + "metadata": {}, + "source": [ + "### Correlate2d" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "id": "36e9d7e8-99dc-46e9-b4d9-ad9f364c71d0", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tgraph_corr2d = TaskGraph.load_taskgraph('./taskgraphs/correlate2d.gq.yaml')\n", + "tgraph_corr2d.draw(show='ipynb', show_ports=True, pydot_options={'rankdir': 'LR'})" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "id": "bdd86d15-8bef-4c44-ae11-1b537e1177af", + "metadata": {}, + "outputs": [], + "source": [ + "# re-using gsig and gfilt from above convolve2d.\n", + "# But need to update configuration for correlate2d_task\n", + "tgraph_corr2d.build()\n", + "conf_cpu = tgraph_corr2d['correlate2d_task'].conf.copy()\n", + "conf_cpu.update({'use_cpu': True})\n", + "replace_cpu = {\n", + " 'sig_task': {\n", + " TaskSpecSchema.load: {\n", + " 'out1': gsig.get(),\n", + " 'out2': gfilt.get()\n", + " }\n", + " },\n", + " 'correlate2d_task': {\n", + " TaskSpecSchema.conf: conf_cpu\n", + " }\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "id": "6127e666-2a67-4981-8855-0e855971ebee", + "metadata": {}, + "outputs": [], + "source": [ + "(ggrad_corr,) = tgraph_corr2d.run(['correlate2d_task.correlate2d'], replace=replace_gpu)" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "id": "930b7dde-2166-4e34-9ef3-89d04daa2bc2", + "metadata": {}, + "outputs": [], + "source": [ + "(cgrad_corr,) = tgraph_corr2d.run(['correlate2d_task.correlate2d'], replace=replace_cpu)" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "id": "1a76ec37-eec1-4952-a2d5-d5dc595bcdf3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CORR GRAD GPU: [[0.64565171 1.11823357 1.70111018 ... 1.14098787 0.76040673 0.11255243]\n", + " [1.42832061 1.89021729 2.67680748 ... 2.09224304 1.34321952 0.49128556]\n", + " [1.61320929 1.8473781 2.33374718 ... 2.64917959 2.00931425 0.88234215]\n", + " ...\n", + " [0.58295659 1.31072564 1.74883323 ... 2.72020388 2.13718772 0.91666393]\n", + " [0.71283266 1.62998312 1.88662539 ... 1.60067698 0.99598523 0.30371569]\n", + " [0.45479753 0.9670105 0.85598757 ... 0.38722271 0.23203973 0.07029248]]\n", + "CORR GRAD CPU: [[0.64565171 1.11823357 1.70111018 ... 1.14098787 0.76040673 0.11255243]\n", + " [1.42832061 1.89021729 2.67680748 ... 2.09224304 1.34321952 0.49128556]\n", + " [1.61320929 1.8473781 2.33374718 ... 2.64917959 2.00931425 0.88234215]\n", + " ...\n", + " [0.58295659 1.31072564 1.74883323 ... 2.72020388 2.13718772 0.91666393]\n", + " [0.71283266 1.62998312 1.88662539 ... 1.60067698 0.99598523 0.30371569]\n", + " [0.45479753 0.9670105 0.85598757 ... 0.38722271 0.23203973 0.07029248]]\n" + ] + } + ], + "source": [ + "print('CORR GRAD GPU: {}\\nCORR GRAD CPU: {}'.format(ggrad_corr, cgrad_corr))\n", + "cptest.assert_array_almost_equal(ggrad_corr, cgrad_corr)" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "id": "5b9d0984-aef8-484f-bd28-4ca942ec59ba", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "59.9 ms ± 480 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n" + ] + } + ], + "source": [ + "gpu_time = %timeit -o (ggrad_corr, ) = tgraph_corr2d.run(['correlate2d_task.correlate2d'], replace=replace_gpu)" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "id": "0ccc8932-55d5-4b07-ba16-1eecdd7e1af8", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "8.19 s ± 39.3 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n" + ] + } + ], + "source": [ + "cpu_time = %timeit -o (cgrad_corr, ) = tgraph_corr2d.run(['correlate2d_task.correlate2d'], replace=replace_cpu)" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "id": "ed066477-41df-4bc4-a09d-01357874d92a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "SPEEDUP: 136.6x\n" + ] + } + ], + "source": [ + "print('SPEEDUP: {}x'.format(round(cpu_time.average / gpu_time.average, 1)))" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/gQuant/plugins/cusignal_plugin/notebooks/sdr_examples.ipynb b/gQuant/plugins/cusignal_plugin/notebooks/sdr_examples.ipynb new file mode 100644 index 00000000..04fc2f78 --- /dev/null +++ b/gQuant/plugins/cusignal_plugin/notebooks/sdr_examples.ipynb @@ -0,0 +1,470 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "83c3ef31-a1bb-4483-9867-20713a2547bf", + "metadata": {}, + "source": [ + "# SDR Example\n", + "This notebook is loosely based on cusignal [sdr_integration](https://github.com/rapidsai/cusignal/blob/branch-21.08/notebooks/sdr/sdr_integration.ipynb) example." + ] + }, + { + "cell_type": "markdown", + "id": "534ee468-9980-4f7b-93fc-bb5f355eb411", + "metadata": {}, + "source": [ + "## Reading SDR data\n", + "In the cusignal example an instance of RTL-SDR is used to record radio IQ data. Below, a wav file is used for this purpose. Example IQ wav files can be found on the web. If the IQ wav file is not present it is downloaded from www.teske.net.br." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "ad3b986e-7c30-41e6-97fe-600c0c8f9001", + "metadata": {}, + "outputs": [], + "source": [ + "from pathlib import Path" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "c94de9ac-0e04-42c6-a533-c8c1eb9bae94", + "metadata": {}, + "outputs": [], + "source": [ + "iq_wavefile = 'SDRSharp_20161220_142714Z_1692700000Hz_IQ.wav'\n", + "if not Path(iq_wavefile).exists():\n", + " !wget https://www.teske.net.br/lucas/basebands/goes13/emwin/SDRSharp_20161220_142714Z_1692700000Hz_IQ.wav" + ] + }, + { + "cell_type": "markdown", + "id": "da329f4a-35e6-4a77-989d-fc25be90435b", + "metadata": {}, + "source": [ + "### Calculating and Plotting Power Spectral Density (PSD)\n", + "The Greenflow taskgraph \"sdr_example.gq.yaml\" loads and IQ signal, produces Welch PSD estimates, does various resampling operations, etc. This taskgraph does what the original cusignal \"sdr_integration\" notebook demonstrated." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "0746c0bc-ec37-47ce-ac24-5487d56fdbca", + "metadata": {}, + "outputs": [], + "source": [ + "from greenflow.dataframe_flow import (TaskGraph, TaskSpecSchema)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "3bdcaa5e-2ec6-4835-a35f-71043c03cf85", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tgraph_sdr = TaskGraph.load_taskgraph('./taskgraphs/sdr_example.gq.yaml')\n", + "tgraph_sdr.build()\n", + "tgraph_sdr.draw(show='ipynb', show_ports=True, pydot_options={'rankdir': 'LR'})" + ] + }, + { + "cell_type": "markdown", + "id": "21647aea-151f-4bca-af78-76ce4234a00c", + "metadata": {}, + "source": [ + "The whole graph can be run via:\n", + "```\n", + "outdemod = ['resample_demod.signal_out', 'resample_demod.samplerate_out',\n", + " 'welch_psd_demod.psd', 'welch_psd_demod.freqs']\n", + "(signal_demod, framerate_demod, psd_demod, freqs_demod) = tgraph_sdr.run(outdemod)\n", + "```\n", + "\n", + "That is all that would be required. For illustrative purproses and to compare to the \"sdr_integration\" notebook from cusignal examples, we run this taskgraph in portions. A subportion of the taskgraph is run by specifying the specific outputs desired, and one can pre-load outputs/inputs. Any operations not required for the specified outputs are not run. Below only tasks \"load_iq_wavfile\" and \"welch_ps\" are run, then the Welch output is plotted." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "7ad40ab6-81d3-4b1d-a067-1e0b7f4cd3bc", + "metadata": {}, + "outputs": [], + "source": [ + "outlist = ['load_iq_wavfile.signal', 'load_iq_wavfile.framerate',\n", + " 'welch_psd.psd', 'welch_psd.freqs']\n", + "(signal, framerate, psd, freqs) = tgraph_sdr.run(outlist)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "0d92892f-2795-4018-aa2b-bc66f0131cac", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Framerate: 156250.0\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "print('Framerate: {}'.format(framerate))\n", + "\n", + "from scipy.fftpack import fftshift\n", + "import matplotlib.pyplot as plt\n", + "\n", + "plt.semilogy(fftshift(freqs.get()), fftshift(psd.get()))\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "ad2a8dee-a72a-4d62-932d-e759b95823bf", + "metadata": {}, + "source": [ + "### Resampling and GPU to CPU comparison\n", + "As an example of some operations we resample the signal. Then compare how long this operation takes via GPU and CPU." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "b465b50d-48c2-459c-9fab-f85caa7c3191", + "metadata": {}, + "outputs": [], + "source": [ + "outlist = ['resample1p5.signal_out', 'resample1p5.samplerate_out',\n", + " 'welch_psd_resampled.psd', 'welch_psd_resampled.freqs']\n", + "(signal_re, framerate_re, psd_re, freqs_re) = tgraph_sdr.run(outlist)" + ] + }, + { + "cell_type": "markdown", + "id": "79b14f3e-9a57-4232-852b-d2cd1a91cd2c", + "metadata": {}, + "source": [ + "#### Time just the resampler\n", + "If we want to time just the resampling portion then we need to pre-load the signal." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "8823261f-107d-4bdc-9f9b-fe57ac92e675", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3.53 ms ± 47.8 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n", + "31.2 ms ± 259 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n", + "SPEEDUP: 8.8x\n" + ] + } + ], + "source": [ + "signal_gpu = signal\n", + "replace_gpu = {\n", + " 'load_iq_wavfile': {\n", + " TaskSpecSchema.load: {\n", + " 'signal': signal_gpu,\n", + " 'framerate': framerate\n", + " }\n", + " }\n", + "}\n", + "# If using GreenflowLab delete widget for better timing.\n", + "# tgraph_sdr.del_widget()\n", + "tgraph_sdr.build(replace=replace_gpu)\n", + "gpu_time = %timeit -r 7 -n 100 -o (signal_re,) = \\\n", + " tgraph_sdr.run(['resample1p5.signal_out'], build=False)\n", + "\n", + "# Now run the CPU equivalent\n", + "signal_cpu = signal_gpu.get()\n", + "resample1p5_conf_cpu = tgraph_sdr['resample1p5'].conf.copy()\n", + "resample1p5_conf_cpu['use_cpu'] = True\n", + "replace_cpu = {\n", + " 'load_iq_wavfile': {\n", + " TaskSpecSchema.load: {\n", + " 'signal': signal_cpu,\n", + " 'framerate': framerate \n", + " }\n", + " },\n", + " 'resample1p5': {\n", + " TaskSpecSchema.conf: resample1p5_conf_cpu\n", + " }\n", + "}\n", + "tgraph_sdr.build(replace=replace_cpu)\n", + "cpu_time = %timeit -r 7 -n 10 -o (signal_re,) = \\\n", + " tgraph_sdr.run(['resample1p5.signal_out'], build=False)\n", + "\n", + "print('SPEEDUP: {}x'.format(round(cpu_time.average / gpu_time.average, 1)))\n", + "\n", + "# reset the build without replace\n", + "tgraph_sdr.build()" + ] + }, + { + "cell_type": "markdown", + "id": "354efaa8-7bcf-4d66-aaff-3952a35e83e7", + "metadata": {}, + "source": [ + "The resulting PSD of resampled signal is shown below." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "4e837471-2f56-407d-8a75-f55166d7e833", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Resampled Framerate: 234375.0\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "print('Resampled Framerate: {}'.format(framerate_re))\n", + "\n", + "plt.semilogy(fftshift(freqs_re.get()), fftshift(psd_re.get()))\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "ac50cb9d-524c-446e-b743-2577b923168c", + "metadata": {}, + "source": [ + "#### Demodulate and profile\n", + "Now we can run demodulation and again compare on GPU vs CPU. The demodulation logic is set via custom code in the \"custom_demod\" task." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "17cba302-d333-42e0-98dc-0a5dff23b449", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "# Demodulation code\n", + "import numpy as np\n", + "import cupy as cp\n", + "\n", + "def custom_filter(signal, conf):\n", + " use_cpu = conf.get('use_cpu', False)\n", + " if use_cpu:\n", + " angle_sig = np.unwrap(np.angle(signal))\n", + " demod_sig = np.diff(angle_sig)\n", + " else:\n", + " angle_sig = cp.unwrap(cp.angle(signal))\n", + " demod_sig = cp.diff(angle_sig)\n", + " return demod_sig\n", + "\n" + ] + } + ], + "source": [ + "tgraph_sdr.build()\n", + "print('# Demodulation code')\n", + "print(tgraph_sdr['custom_demod'].conf['pycode'])" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "33c7b3f4-7501-4644-b847-57a339700bc1", + "metadata": {}, + "outputs": [], + "source": [ + "outdemod = ['resample_demod.signal_out', 'resample_demod.samplerate_out',\n", + " 'welch_psd_demod.psd', 'welch_psd_demod.freqs']\n", + "(signal_demod, framerate_demod, psd_demod, freqs_demod) = tgraph_sdr.run(outdemod)" + ] + }, + { + "cell_type": "markdown", + "id": "3fa132c5-347d-4dac-83a5-519c6e985098", + "metadata": {}, + "source": [ + "Let's time just the demodulation logic." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "9727f5a6-0b89-4238-a27e-75645ca3a88d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "7.79 ms ± 134 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n", + "48.1 ms ± 344 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n", + "SPEEDUP: 6.2x\n" + ] + } + ], + "source": [ + "# If using GreenflowLab delete widget for better timing.\n", + "# tgraph_sdr.del_widget()\n", + "\n", + "# pre-load the resampled signal from above.\n", + "replace_gpu = {\n", + " 'resample1p5': {\n", + " TaskSpecSchema.load: {\n", + " 'signal_out': signal_re,\n", + " 'samplerate_out': framerate_re\n", + " }\n", + " }\n", + "}\n", + "tgraph_sdr.build(replace=replace_gpu)\n", + "gpu_time = %timeit -r 7 -n 100 -o (signal_demod,) = \\\n", + " tgraph_sdr.run(['resample_demod.signal_out'], build=False)\n", + "\n", + "# Run on CPU\n", + "custom_demod_conf_cpu = tgraph_sdr['custom_demod'].conf.copy()\n", + "custom_demod_conf_cpu['use_cpu'] = True\n", + "\n", + "resample_demod_conf_cpu = tgraph_sdr['resample_demod'].conf.copy()\n", + "resample_demod_conf_cpu['use_cpu'] = True\n", + "\n", + "replace_cpu = {\n", + " 'resample1p5': {\n", + " TaskSpecSchema.load: {\n", + " 'signal_out': signal_re.get(),\n", + " 'samplerate_out': framerate_re\n", + " }\n", + " },\n", + " 'custom_demod': {\n", + " TaskSpecSchema.conf: custom_demod_conf_cpu\n", + " },\n", + " 'resample_demod': {\n", + " TaskSpecSchema.conf: resample_demod_conf_cpu\n", + " }\n", + "}\n", + "tgraph_sdr.build(replace=replace_cpu)\n", + "cpu_time = %timeit -r 7 -n 10 -o (signal_demod,) = \\\n", + " tgraph_sdr.run(['resample_demod.signal_out'], build=False)\n", + "\n", + "print('SPEEDUP: {}x'.format(round(cpu_time.average / gpu_time.average, 1)))\n" + ] + }, + { + "cell_type": "markdown", + "id": "25df0910-3b9e-4740-83b3-a03f9dba2e6d", + "metadata": {}, + "source": [ + "Original framerate 156.250kHz resampled to up = 3 down = 2 => 234.375kHz. Then the demodulation resamples to 48kHz." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "c5531669-1035-4a6d-98db-3a820fb95880", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Demod Framerate: 48000.0\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "print('Demod Framerate: {}'.format(framerate_demod))\n", + "plt.semilogy(fftshift(freqs_demod.get()), fftshift(psd_demod.get()))\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "118100b8-ab3a-4394-a043-16a4876cd1f3", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/gQuant/plugins/cusignal_plugin/notebooks/taskgraphs/convolve.gq.yaml b/gQuant/plugins/cusignal_plugin/notebooks/taskgraphs/convolve.gq.yaml new file mode 100644 index 00000000..1e626174 --- /dev/null +++ b/gQuant/plugins/cusignal_plugin/notebooks/taskgraphs/convolve.gq.yaml @@ -0,0 +1,29 @@ +- id: sig_task + type: SignalGeneratorNode + conf: + pycode: |- + import cupy as cp + sig = cp.random.rand(int(1e8)) + myout = {'out1': sig} + inputs: {} + module: greenflow_cusignal_plugin.gensig +- id: convolve_task + type: CusignalConvolveNode + conf: + mode: same + method: auto + normalize: true + use_cpu: false + inputs: + in1: sig_task.out1 + in2: win_hann.window + module: greenflow_cusignal_plugin.convolution +- id: win_hann + type: CusignalWindowNode + conf: + window_type: hann + sym: true + use_cpu: false + M: 1000 + inputs: {} + module: greenflow_cusignal_plugin.windows diff --git a/gQuant/plugins/cusignal_plugin/notebooks/taskgraphs/convolve2d.gq.yaml b/gQuant/plugins/cusignal_plugin/notebooks/taskgraphs/convolve2d.gq.yaml new file mode 100644 index 00000000..8328b7a0 --- /dev/null +++ b/gQuant/plugins/cusignal_plugin/notebooks/taskgraphs/convolve2d.gq.yaml @@ -0,0 +1,23 @@ +- id: sig_task + type: SignalGeneratorNode + conf: + pycode: |- + import cupy as cp + + gsig = cp.random.rand(int(1e4), int(1e4)) + gfilt = cp.random.rand(5,5) + + myout = {'out1': gsig, 'out2': gfilt} + inputs: {} + module: greenflow_cusignal_plugin.gensig +- id: convolve2d_task + type: CusignalConvolve2dNode + conf: + mode: full + boundary: fill + fillvalue: 0 + use_cpu: false + inputs: + in1: sig_task.out1 + in2: sig_task.out2 + module: greenflow_cusignal_plugin.convolution diff --git a/gQuant/plugins/cusignal_plugin/notebooks/taskgraphs/correlate.gq.yaml b/gQuant/plugins/cusignal_plugin/notebooks/taskgraphs/correlate.gq.yaml new file mode 100644 index 00000000..44c370d1 --- /dev/null +++ b/gQuant/plugins/cusignal_plugin/notebooks/taskgraphs/correlate.gq.yaml @@ -0,0 +1,22 @@ +- id: sig_task + type: SignalGeneratorNode + conf: + pycode: |- + import cupy as cp + + sig = cp.random.rand(int(1e8)) + sig_noise = sig + cp.random.randn(len(sig)) + sig_corr = cp.ones(128) + + myout = {'out1': sig_noise, 'out2': sig_corr} + inputs: {} + module: greenflow_cusignal_plugin.gensig +- id: correlate_task + type: CusignalCorrelationNode + conf: + mode: same + scale: 1000000 + inputs: + in1: sig_task.out1 + in2: sig_task.out2 + module: greenflow_cusignal_plugin.convolution diff --git a/gQuant/plugins/cusignal_plugin/notebooks/taskgraphs/correlate2d.gq.yaml b/gQuant/plugins/cusignal_plugin/notebooks/taskgraphs/correlate2d.gq.yaml new file mode 100644 index 00000000..6dda8ae8 --- /dev/null +++ b/gQuant/plugins/cusignal_plugin/notebooks/taskgraphs/correlate2d.gq.yaml @@ -0,0 +1,23 @@ +- id: sig_task + type: SignalGeneratorNode + conf: + pycode: |- + import cupy as cp + + gsig = cp.random.rand(int(1e4), int(1e4)) + gfilt = cp.random.rand(5,5) + + myout = {'out1': gsig, 'out2': gfilt} + inputs: {} + module: greenflow_cusignal_plugin.gensig +- id: correlate2d_task + type: CusignalCorrelate2dNode + conf: + mode: full + boundary: fill + fillvalue: 0 + use_cpu: false + inputs: + in1: sig_task.out1 + in2: sig_task.out2 + module: greenflow_cusignal_plugin.convolution diff --git a/gQuant/plugins/cusignal_plugin/notebooks/taskgraphs/fftconvolve.gq.yaml b/gQuant/plugins/cusignal_plugin/notebooks/taskgraphs/fftconvolve.gq.yaml new file mode 100644 index 00000000..671d308f --- /dev/null +++ b/gQuant/plugins/cusignal_plugin/notebooks/taskgraphs/fftconvolve.gq.yaml @@ -0,0 +1,20 @@ +- id: fftconvolve_task + type: CusignalFFTConvolveNode + conf: + mode: full + axes: [] + use_cpu: false + inputs: + in1: sig_task.out1 + in2: sig_task.out2 + module: greenflow_cusignal_plugin.convolution +- id: sig_task + type: SignalGeneratorNode + conf: + pycode: |- + import cupy as cp + gsig = cp.random.randn(int(1e8)) + gsig_reverse = gsig[::-1] + myout = {'out1': gsig, 'out2': gsig_reverse} + inputs: {} + module: greenflow_cusignal_plugin.gensig diff --git a/gQuant/plugins/cusignal_plugin/notebooks/taskgraphs/sdr_example.gq.yaml b/gQuant/plugins/cusignal_plugin/notebooks/taskgraphs/sdr_example.gq.yaml new file mode 100644 index 00000000..97d1c5f1 --- /dev/null +++ b/gQuant/plugins/cusignal_plugin/notebooks/taskgraphs/sdr_example.gq.yaml @@ -0,0 +1,101 @@ +- id: load_iq_wavfile + type: IQwavefileNode + conf: + duration: 3 + use_cpu: false + wavefile: ./SDRSharp_20161220_142714Z_1692700000Hz_IQ.wav + inputs: {} + module: greenflow_cusignal_plugin.gensig +- id: welch_psd + type: WelchPSD_Node + conf: + samplerate: 1 + window: hann + detrend: constant + return_onesided: false + scaling: density + axis: -1 + average: mean + use_cpu: false + inputs: + signal: load_iq_wavfile.signal + samplerate: load_iq_wavfile.framerate + module: greenflow_cusignal_plugin.spectral_analysis +- id: resample1p5 + type: CusignalResamplePolyNode + conf: + axis: 0 + window: flattop + gpupath: true + use_cpu: false + padtype: constant + up: 3 + down: 2 + inputs: + signal: load_iq_wavfile.signal + samplerate: load_iq_wavfile.framerate + module: greenflow_cusignal_plugin.filtering +- id: welch_psd_resampled + type: WelchPSD_Node + conf: + samplerate: 1 + window: hann + detrend: constant + return_onesided: false + scaling: density + axis: -1 + average: mean + use_cpu: false + nfft: 1024 + inputs: + signal: resample1p5.signal_out + samplerate: resample1p5.samplerate_out + module: greenflow_cusignal_plugin.spectral_analysis +- id: custom_demod + type: CustomFilterNode + conf: + pycode: | + import numpy as np + import cupy as cp + + def custom_filter(signal, conf): + use_cpu = conf.get('use_cpu', False) + if use_cpu: + angle_sig = np.unwrap(np.angle(signal)) + demod_sig = np.diff(angle_sig) + else: + angle_sig = cp.unwrap(cp.angle(signal)) + demod_sig = cp.diff(angle_sig) + return demod_sig + inputs: + signal: resample1p5.signal_out + module: greenflow_cusignal_plugin.filtering +- id: resample_demod + type: CusignalResamplePolyNode + conf: + axis: 0 + window: flattop + gpupath: true + use_cpu: false + padtype: constant + new_samplerate: 48000 + inputs: + signal: custom_demod.signal_out + samplerate: resample1p5.samplerate_out + module: greenflow_cusignal_plugin.filtering +- id: welch_psd_demod + type: WelchPSD_Node + conf: + samplerate: 1 + window: hann + detrend: constant + return_onesided: false + scaling: density + axis: -1 + average: mean + use_cpu: false + nfft: 1024 + inputs: + signal: resample_demod.signal_out + samplerate: resample_demod.samplerate_out + module: greenflow_cusignal_plugin.spectral_analysis diff --git a/gQuant/plugins/cusignal_plugin/notebooks/taskgraphs/window_signal.gq.yaml b/gQuant/plugins/cusignal_plugin/notebooks/taskgraphs/window_signal.gq.yaml new file mode 100644 index 00000000..fbf69a43 --- /dev/null +++ b/gQuant/plugins/cusignal_plugin/notebooks/taskgraphs/window_signal.gq.yaml @@ -0,0 +1,9 @@ +- id: winsig + type: CusignalWindowNode + conf: + window_type: general_cosine + sym: true + use_cpu: false + M: 10000000 + inputs: {} + module: greenflow_cusignal_plugin.windows diff --git a/gQuant/plugins/cusignal_plugin/notebooks/windows_examples.ipynb b/gQuant/plugins/cusignal_plugin/notebooks/windows_examples.ipynb new file mode 100644 index 00000000..cbbdb033 --- /dev/null +++ b/gQuant/plugins/cusignal_plugin/notebooks/windows_examples.ipynb @@ -0,0 +1,459 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "5c7f98a2-d4c1-4d55-b1af-26fdc64b1ee8", + "metadata": {}, + "source": [ + "## Benchmarking Scipy Signal vs cuSignal Time to Create Windows in Greenflow" + ] + }, + { + "cell_type": "markdown", + "id": "6cdd64ff-0e65-47ce-9bc0-cb274b5a5162", + "metadata": {}, + "source": [ + "The windows examples were taken from the example [cusignal windows notebook](https://github.com/rapidsai/cusignal/blob/branch-21.08/notebooks/api_guide/windows_examples.ipynb)." + ] + }, + { + "cell_type": "markdown", + "id": "67b10a18-fd7c-4779-8eb1-90fada4c2223", + "metadata": {}, + "source": [ + "### General Parameters" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "4715e285-12f5-4970-9c4b-0aee9a06413a", + "metadata": {}, + "outputs": [], + "source": [ + "import cupy.testing as cptest" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "0789f1b6-e15d-40ca-b35b-717f2bb697b0", + "metadata": {}, + "outputs": [], + "source": [ + "from greenflow.dataframe_flow import (TaskGraph, TaskSpecSchema)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "69c42bc1-df38-48f3-ad74-840a52588915", + "metadata": {}, + "outputs": [], + "source": [ + "# Num Points in Array - Reduce if getting out of memory errors\n", + "M = int(1e7)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "baab0011-effb-428b-8146-3535b156c046", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tgraph_win = TaskGraph.load_taskgraph('./taskgraphs/window_signal.gq.yaml')\n", + "tgraph_win.build()\n", + "tgraph_win.draw(show='ipynb', show_ports=True, pydot_options={'rankdir': 'LR'})" + ] + }, + { + "cell_type": "markdown", + "id": "23004111-06e4-42df-99cf-9efd1f41b28c", + "metadata": {}, + "source": [ + "### General Cosine" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "f4c89c4a-416d-40bc-bcd2-5341d2e82704", + "metadata": {}, + "outputs": [], + "source": [ + "HFT90D = [1, 1.942604, 1.340318, 0.440811, 0.043097]\n", + "win_params = {\n", + " 'window_type': 'general_cosine',\n", + " 'M': M,\n", + " 'a': HFT90D,\n", + " 'sym': False\n", + "}\n", + "\n", + "replace_gpu = {\n", + " 'winsig': {\n", + " TaskSpecSchema.conf: win_params\n", + " }\n", + "}\n", + "\n", + "replace_cpu = {\n", + " 'winsig': {\n", + " TaskSpecSchema.conf: {\n", + " **win_params,\n", + " 'use_cpu': True\n", + " }\n", + " }\n", + "}\n", + "\n", + "(gwin,) = tgraph_win.run(['winsig.window'], replace=replace_gpu)\n", + "(cwin,) = tgraph_win.run(['winsig.window'], replace=replace_cpu)\n", + "cptest.assert_array_almost_equal(gwin, cwin)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "f7bfae1e-deaf-4351-819c-6edf4984fcb3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3.57 ms ± 25.2 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n" + ] + } + ], + "source": [ + "gpu_time = %timeit -o (gwin,) = tgraph_win.run(['winsig.window'], replace=replace_gpu)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "e520f92d-2495-4e60-864e-d6b618740ccb", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "910 ms ± 1.71 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n" + ] + } + ], + "source": [ + "cpu_time = %timeit -o (cwin,) = tgraph_win.run(['winsig.window'], replace=replace_cpu)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "3be6053c-11bd-4df5-8d80-083d90d24f74", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "SPEEDUP: 255.2x\n" + ] + } + ], + "source": [ + "print('SPEEDUP: {}x'.format(round(cpu_time.average / gpu_time.average, 1)))" + ] + }, + { + "cell_type": "markdown", + "id": "4dc62437-e509-4708-82af-50bb883e4fac", + "metadata": {}, + "source": [ + "### Timing CuSignal Windows" + ] + }, + { + "cell_type": "markdown", + "id": "bf2ca44f-a3e3-47a5-b40d-edf14256fedf", + "metadata": {}, + "source": [ + "Using the base taskgraph for generating a window we can use the programmatic API to profile and compare generating windows via cusignal on GPU and scipy on CPU." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "7a3193d3-a02b-4fcd-9bc2-19c821cbde5a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "WINDOW TYPE: boxcar\n", + "GPU TIMING\n", + "2.07 ms ± 52.6 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n", + "CPU TIMING\n", + "21.4 ms ± 61 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n", + "SPEEDUP: 10.3x\n", + "\n", + "\n", + "WINDOW TYPE: triang\n", + "GPU TIMING\n", + "2.05 ms ± 8.82 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n", + "CPU TIMING\n", + "70.4 ms ± 182 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n", + "SPEEDUP: 34.4x\n", + "\n", + "\n", + "WINDOW TYPE: bohman\n", + "GPU TIMING\n", + "2.05 ms ± 8.12 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n", + "CPU TIMING\n", + "446 ms ± 1.16 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "SPEEDUP: 218.0x\n", + "\n", + "\n", + "WINDOW TYPE: blackman\n", + "GPU TIMING\n", + "2.98 ms ± 8.52 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n", + "CPU TIMING\n", + "525 ms ± 1.32 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "SPEEDUP: 175.9x\n", + "\n", + "\n", + "WINDOW TYPE: nuttall\n", + "GPU TIMING\n", + "3.03 ms ± 16.1 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n", + "CPU TIMING\n", + "719 ms ± 920 µs per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "SPEEDUP: 237.3x\n", + "\n", + "\n", + "WINDOW TYPE: blackmanharris\n", + "GPU TIMING\n", + "3.02 ms ± 15.3 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n", + "CPU TIMING\n", + "718 ms ± 1.03 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "SPEEDUP: 237.6x\n", + "\n", + "\n", + "WINDOW TYPE: flattop\n", + "GPU TIMING\n", + "3.09 ms ± 26.7 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n", + "CPU TIMING\n", + "936 ms ± 833 µs per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "SPEEDUP: 302.9x\n", + "\n", + "\n", + "WINDOW TYPE: bartlett\n", + "GPU TIMING\n", + "2.08 ms ± 22.9 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n", + "CPU TIMING\n", + "181 ms ± 216 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n", + "SPEEDUP: 86.9x\n", + "\n", + "\n", + "WINDOW TYPE: hann\n", + "GPU TIMING\n", + "2.93 ms ± 20.6 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n", + "CPU TIMING\n", + "338 ms ± 143 µs per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "SPEEDUP: 115.4x\n", + "\n", + "\n", + "WINDOW TYPE: tukey\n", + "GPU TIMING\n", + "2.05 ms ± 8.33 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n", + "CPU TIMING\n", + "138 ms ± 640 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n", + "SPEEDUP: 67.3x\n", + "\n", + "\n", + "WINDOW TYPE: barthann\n", + "GPU TIMING\n", + "2.05 ms ± 15.6 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n", + "CPU TIMING\n", + "317 ms ± 859 µs per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "SPEEDUP: 154.8x\n", + "\n", + "\n", + "WINDOW TYPE: general_hamming\n", + "GPU TIMING\n", + "2.93 ms ± 22.2 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n", + "CPU TIMING\n", + "336 ms ± 1.32 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "SPEEDUP: 114.7x\n", + "\n", + "\n", + "WINDOW TYPE: hamming\n", + "GPU TIMING\n", + "2.1 ms ± 12.7 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n", + "CPU TIMING\n", + "338 ms ± 1.21 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "SPEEDUP: 161.1x\n", + "\n", + "\n", + "WINDOW TYPE: kaiser\n", + "GPU TIMING\n", + "2.05 ms ± 10.6 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n", + "CPU TIMING\n", + "742 ms ± 654 µs per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "SPEEDUP: 361.9x\n", + "\n", + "\n", + "WINDOW TYPE: gaussian\n", + "GPU TIMING\n", + "2.05 ms ± 16.6 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n", + "CPU TIMING\n", + "208 ms ± 734 µs per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "SPEEDUP: 101.5x\n", + "\n", + "\n", + "WINDOW TYPE: general_gaussian\n", + "GPU TIMING\n", + "2.08 ms ± 48.3 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n", + "CPU TIMING\n", + "433 ms ± 1.37 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "SPEEDUP: 207.9x\n", + "\n", + "\n", + "WINDOW TYPE: cosine\n", + "GPU TIMING\n", + "2.05 ms ± 15.1 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n", + "CPU TIMING\n", + "175 ms ± 379 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n", + "SPEEDUP: 85.3x\n", + "\n", + "\n", + "WINDOW TYPE: exponential\n", + "GPU TIMING\n", + "2.05 ms ± 5.35 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n", + "CPU TIMING\n", + "208 ms ± 622 µs per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "SPEEDUP: 101.6x\n", + "\n", + "\n" + ] + } + ], + "source": [ + "from copy import deepcopy\n", + "\n", + "default_params = {'M': M} # M is defined above\n", + "wins_map = {\n", + " 'boxcar': {},\n", + " 'triang': {},\n", + " 'bohman': {},\n", + " 'blackman': {},\n", + " 'nuttall': {},\n", + " 'blackmanharris': {},\n", + " 'flattop': {},\n", + " 'bartlett': {},\n", + " 'hann': {},\n", + " 'tukey': {\n", + " 'params': {\n", + " 'alpha': 0.5,\n", + " 'sym': True\n", + " }\n", + " },\n", + " 'barthann': {},\n", + " 'general_hamming': {\n", + " 'params': {\n", + " 'alpha': 0.5,\n", + " 'sym': True\n", + " }\n", + " },\n", + " 'hamming': {},\n", + " 'kaiser': {\n", + " 'params': {\n", + " 'beta': 0.5\n", + " }\n", + " },\n", + " 'gaussian': {\n", + " 'params': {\n", + " 'std': 7\n", + " }\n", + " },\n", + " 'general_gaussian': {\n", + " 'params': {\n", + " 'p': 1.5,\n", + " 'sig': 7, # for older API\n", + " }\n", + " },\n", + " 'cosine': {},\n", + " 'exponential': {\n", + " 'params': {\n", + " 'tau': 3.0\n", + " }\n", + " }\n", + "}\n", + "\n", + "for wintype, winconf in wins_map.items():\n", + " win_params = default_params.copy()\n", + " win_params['window_type'] = wintype\n", + " win_params.update(winconf.get('params', {}))\n", + " replace_gpu = {\n", + " 'winsig': {\n", + " TaskSpecSchema.conf: win_params,\n", + " }\n", + " }\n", + " replace_cpu = deepcopy(replace_gpu)\n", + " replace_cpu['winsig'][TaskSpecSchema.conf]['use_cpu'] = True\n", + " print('WINDOW TYPE: {}'.format(wintype))\n", + " print('GPU TIMING')\n", + " tgraph_win.build(replace=replace_gpu)\n", + " gpu_time = %timeit -o (gwin,) = tgraph_win.run(['winsig.window'], build=False)\n", + " print('CPU TIMING')\n", + " tgraph_win.build(replace=replace_cpu)\n", + " cpu_time = %timeit -o (cwin,) = tgraph_win.run(['winsig.window'], build=False)\n", + " print('SPEEDUP: {}x'.format(round(cpu_time.average / gpu_time.average, 1)))\n", + " print('\\n')\n", + "\n", + "# reset tgraph build\n", + "tgraph_win.build()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e829e95b-f25d-40a4-b301-00a9f2b39243", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/gQuant/plugins/cusignal_plugin/setup.py b/gQuant/plugins/cusignal_plugin/setup.py new file mode 100644 index 00000000..acedd7a0 --- /dev/null +++ b/gQuant/plugins/cusignal_plugin/setup.py @@ -0,0 +1,23 @@ +''' +Greenflow Cusignal Plugin +''' +from setuptools import setup, find_packages + +setup( + name='greenflow_cusignal_plugin', + version='1.0', + description='greenflow cusignal plugin - RAPIDS Cusignal Nodes for Greenflow', # noqa: E501 + install_requires=["greenflow", "cusignal"], + packages=find_packages(include=['greenflow_cusignal_plugin', + 'greenflow_cusignal_plugin.*']), + entry_points={ + 'greenflow.plugin': [ + 'greenflow_cusignal_plugin = greenflow_cusignal_plugin', + 'greenflow_cusignal_plugin.convolution = greenflow_cusignal_plugin.convolution', # noqa: E501 + 'greenflow_cusignal_plugin.filtering = greenflow_cusignal_plugin.filtering', # noqa: E501 + 'greenflow_cusignal_plugin.gensig = greenflow_cusignal_plugin.gensig', # noqa: E501 + 'greenflow_cusignal_plugin.spectral_analysis = greenflow_cusignal_plugin.spectral_analysis', # noqa: E501 + 'greenflow_cusignal_plugin.windows = greenflow_cusignal_plugin.windows' # noqa: E501 + ], + } +) diff --git a/gQuant/plugins/gquant_plugin/greenflow_gquant_plugin/ml/splitDataNode.py b/gQuant/plugins/gquant_plugin/greenflow_gquant_plugin/ml/splitDataNode.py index f8957d6d..eb81a592 100644 --- a/gQuant/plugins/gquant_plugin/greenflow_gquant_plugin/ml/splitDataNode.py +++ b/gQuant/plugins/gquant_plugin/greenflow_gquant_plugin/ml/splitDataNode.py @@ -127,7 +127,7 @@ def process(self, inputs): train_cols.remove(target_col) conf = copy.copy(self.conf) del conf['target'] - r = cuml.preprocessing.model_selection.train_test_split( + r = cuml.train_test_split( input_df[train_cols], input_df[target_col], **conf) r[0].index = r[2].index r[0][target_col] = r[2] diff --git a/gQuant/plugins/gquant_plugin/greenflow_gquant_plugin/transform/addSignIndicator.py b/gQuant/plugins/gquant_plugin/greenflow_gquant_plugin/transform/addSignIndicator.py index 3cdc88eb..cd6c66de 100644 --- a/gQuant/plugins/gquant_plugin/greenflow_gquant_plugin/transform/addSignIndicator.py +++ b/gQuant/plugins/gquant_plugin/greenflow_gquant_plugin/transform/addSignIndicator.py @@ -49,6 +49,24 @@ def init(self): out_ports=meta_outports ) + def update(self): + TemplateNodeMixin.update(self) + meta_inports = self.template_meta_setup().inports + required = meta_inports[self.INPUT_PORT_NAME] + if 'column' in self.conf: + col_name = self.conf['column'] + input_meta = self.get_input_meta() + if self.INPUT_PORT_NAME not in input_meta: + required[col_name] = None + else: + col_from_inport = input_meta[self.INPUT_PORT_NAME] + if col_name in col_from_inport: + required[col_name] = col_from_inport[col_name] + else: + required[col_name] = None + meta_inports[self.INPUT_PORT_NAME] = required + self.template_meta_setup(in_ports=meta_inports, out_ports=None) + def conf_schema(self): json = { "title": "Add Sign Indicator configure", diff --git a/gQuant/plugins/gquant_plugin/greenflow_gquant_plugin/transform/averageNode.py b/gQuant/plugins/gquant_plugin/greenflow_gquant_plugin/transform/averageNode.py index 7bee6b56..0d8f47af 100644 --- a/gQuant/plugins/gquant_plugin/greenflow_gquant_plugin/transform/averageNode.py +++ b/gQuant/plugins/gquant_plugin/greenflow_gquant_plugin/transform/averageNode.py @@ -53,6 +53,24 @@ def init(self): out_ports=meta_outports ) + def update(self): + TemplateNodeMixin.update(self) + meta_inports = self.template_meta_setup().inports + required = meta_inports[self.INPUT_PORT_NAME] + if 'column' in self.conf: + col_name = self.conf['column'] + input_meta = self.get_input_meta() + if self.INPUT_PORT_NAME not in input_meta: + required[col_name] = None + else: + col_from_inport = input_meta[self.INPUT_PORT_NAME] + if col_name in col_from_inport: + required[col_name] = col_from_inport[col_name] + else: + required[col_name] = None + meta_inports[self.INPUT_PORT_NAME] = required + self.template_meta_setup(in_ports=meta_inports, out_ports=None) + def conf_schema(self): input_meta = self.get_input_meta() json = { diff --git a/gQuant/plugins/gquant_plugin/greenflow_gquant_plugin/transform/dropNode.py b/gQuant/plugins/gquant_plugin/greenflow_gquant_plugin/transform/dropNode.py index fd85a8e0..32a177ba 100644 --- a/gQuant/plugins/gquant_plugin/greenflow_gquant_plugin/transform/dropNode.py +++ b/gQuant/plugins/gquant_plugin/greenflow_gquant_plugin/transform/dropNode.py @@ -49,6 +49,25 @@ def init(self): out_ports=meta_outports ) + def update(self): + TemplateNodeMixin.update(self) + meta_inports = self.template_meta_setup().inports + required = meta_inports[self.INPUT_PORT_NAME] + if 'columns' in self.conf: + input_meta = self.get_input_meta() + if self.INPUT_PORT_NAME not in input_meta: + for col in self.conf['columns']: + required[col] = None + else: + col_from_inport = input_meta[self.INPUT_PORT_NAME] + for col in self.conf['columns']: + if col in col_from_inport: + required[col] = col_from_inport[col] + else: + required[col] = None + meta_inports[self.INPUT_PORT_NAME] = required + self.template_meta_setup(in_ports=meta_inports, out_ports=None) + def conf_schema(self): json = { "title": "Drop Column configure", diff --git a/gQuant/plugins/gquant_plugin/greenflow_gquant_plugin/transform/leftMergeNode.py b/gQuant/plugins/gquant_plugin/greenflow_gquant_plugin/transform/leftMergeNode.py index af068032..ad910d31 100644 --- a/gQuant/plugins/gquant_plugin/greenflow_gquant_plugin/transform/leftMergeNode.py +++ b/gQuant/plugins/gquant_plugin/greenflow_gquant_plugin/transform/leftMergeNode.py @@ -71,13 +71,36 @@ def update(self): elif self.INPUT_PORT_RIGHT_NAME in input_meta: col_from_right_inport = input_meta[self.INPUT_PORT_RIGHT_NAME] output_cols = col_from_right_inport - meta_outports = self.template_meta_setup().outports + meta_data = self.template_meta_setup() + meta_outports = meta_data.outports + meta_inports = meta_data.inports + left_required = meta_inports[self.INPUT_PORT_LEFT_NAME] + right_required = meta_inports[self.INPUT_PORT_RIGHT_NAME] + if 'column' in self.conf: + col_name = self.conf['column'] + input_meta = self.get_input_meta() + if self.INPUT_PORT_LEFT_NAME not in input_meta: + left_required[col_name] = None + else: + col_from_inport = input_meta[self.INPUT_PORT_LEFT_NAME] + if col_name in col_from_inport: + left_required[col_name] = col_from_inport[col_name] + else: + left_required[col_name] = None + if self.INPUT_PORT_RIGHT_NAME not in input_meta: + right_required[col_name] = None + else: + col_from_inport = input_meta[self.INPUT_PORT_RIGHT_NAME] + if col_name in col_from_inport: + right_required[col_name] = col_from_inport[col_name] + else: + right_required[col_name] = None + meta_inports[self.INPUT_PORT_LEFT_NAME] = left_required + meta_inports[self.INPUT_PORT_RIGHT_NAME] = right_required meta_outports[self.OUTPUT_PORT_NAME][MetaDataSchema.META_DATA] = \ output_cols - self.template_meta_setup( - in_ports=None, - out_ports=meta_outports - ) + self.template_meta_setup(in_ports=meta_inports, + out_ports=meta_outports) def conf_schema(self): json = { diff --git a/gQuant/plugins/gquant_plugin/greenflow_gquant_plugin/transform/maxNode.py b/gQuant/plugins/gquant_plugin/greenflow_gquant_plugin/transform/maxNode.py index e342a9c6..ffc7a6fc 100644 --- a/gQuant/plugins/gquant_plugin/greenflow_gquant_plugin/transform/maxNode.py +++ b/gQuant/plugins/gquant_plugin/greenflow_gquant_plugin/transform/maxNode.py @@ -50,6 +50,24 @@ def init(self): out_ports=meta_outports ) + def update(self): + TemplateNodeMixin.update(self) + meta_inports = self.template_meta_setup().inports + required = meta_inports[self.INPUT_PORT_NAME] + if 'column' in self.conf: + col_name = self.conf['column'] + input_meta = self.get_input_meta() + if self.INPUT_PORT_NAME not in input_meta: + required[col_name] = None + else: + col_from_inport = input_meta[self.INPUT_PORT_NAME] + if col_name in col_from_inport: + required[col_name] = col_from_inport[col_name] + else: + required[col_name] = None + meta_inports[self.INPUT_PORT_NAME] = required + self.template_meta_setup(in_ports=meta_inports, out_ports=None) + def conf_schema(self): json = { "title": "Maximum Value Node configure", diff --git a/gQuant/plugins/gquant_plugin/greenflow_gquant_plugin/transform/minNode.py b/gQuant/plugins/gquant_plugin/greenflow_gquant_plugin/transform/minNode.py index 601ff466..d8221940 100644 --- a/gQuant/plugins/gquant_plugin/greenflow_gquant_plugin/transform/minNode.py +++ b/gQuant/plugins/gquant_plugin/greenflow_gquant_plugin/transform/minNode.py @@ -51,6 +51,24 @@ def init(self): out_ports=meta_outports ) + def update(self): + TemplateNodeMixin.update(self) + meta_inports = self.template_meta_setup().inports + required = meta_inports[self.INPUT_PORT_NAME] + if 'column' in self.conf: + col_name = self.conf['column'] + input_meta = self.get_input_meta() + if self.INPUT_PORT_NAME not in input_meta: + required[col_name] = None + else: + col_from_inport = input_meta[self.INPUT_PORT_NAME] + if col_name in col_from_inport: + required[col_name] = col_from_inport[col_name] + else: + required[col_name] = None + meta_inports[self.INPUT_PORT_NAME] = required + self.template_meta_setup(in_ports=meta_inports, out_ports=None) + def conf_schema(self): json = { "title": "Minimum Value Node configure", diff --git a/gQuant/plugins/gquant_plugin/greenflow_gquant_plugin/transform/onehotEncoding.py b/gQuant/plugins/gquant_plugin/greenflow_gquant_plugin/transform/onehotEncoding.py index 2ce2f2e3..ae705169 100644 --- a/gQuant/plugins/gquant_plugin/greenflow_gquant_plugin/transform/onehotEncoding.py +++ b/gQuant/plugins/gquant_plugin/greenflow_gquant_plugin/transform/onehotEncoding.py @@ -53,6 +53,26 @@ def init(self): out_ports=meta_outports ) + def update(self): + TemplateNodeMixin.update(self) + meta_inports = self.template_meta_setup().inports + required = meta_inports[self.INPUT_PORT_NAME] + if len(self.conf) > 0: + input_meta = self.get_input_meta() + if self.INPUT_PORT_NAME not in input_meta: + for col in self.conf: + required[col['column']] = None + else: + col_from_inport = input_meta[self.INPUT_PORT_NAME] + for col in self.conf: + col_name = col['column'] + if col_name in col_from_inport: + required[col_name] = col_from_inport[col_name] + else: + required[col_name] = None + meta_inports[self.INPUT_PORT_NAME] = required + self.template_meta_setup(in_ports=meta_inports, out_ports=None) + def conf_schema(self): json = { "title": "One Hot Encoding configure", diff --git a/gQuant/plugins/gquant_plugin/greenflow_gquant_plugin/transform/sortNode.py b/gQuant/plugins/gquant_plugin/greenflow_gquant_plugin/transform/sortNode.py index 51da6c47..a922e40d 100644 --- a/gQuant/plugins/gquant_plugin/greenflow_gquant_plugin/transform/sortNode.py +++ b/gQuant/plugins/gquant_plugin/greenflow_gquant_plugin/transform/sortNode.py @@ -50,6 +50,25 @@ def init(self): out_ports=meta_outports ) + def update(self): + TemplateNodeMixin.update(self) + meta_inports = self.template_meta_setup().inports + required = meta_inports[self.INPUT_PORT_NAME] + if 'keys' in self.conf: + input_meta = self.get_input_meta() + if self.INPUT_PORT_NAME not in input_meta: + for col in self.conf['keys']: + required[col] = None + else: + col_from_inport = input_meta[self.INPUT_PORT_NAME] + for col in self.conf['keys']: + if col in col_from_inport: + required[col] = col_from_inport[col] + else: + required[col] = None + meta_inports[self.INPUT_PORT_NAME] = required + self.template_meta_setup(in_ports=meta_inports, out_ports=None) + def conf_schema(self): json = { "title": "Sort Column configure", diff --git a/gQuant/plugins/gquant_plugin/greenflow_gquant_plugin/transform/valueFilterNode.py b/gQuant/plugins/gquant_plugin/greenflow_gquant_plugin/transform/valueFilterNode.py index da257121..d08a1110 100644 --- a/gQuant/plugins/gquant_plugin/greenflow_gquant_plugin/transform/valueFilterNode.py +++ b/gQuant/plugins/gquant_plugin/greenflow_gquant_plugin/transform/valueFilterNode.py @@ -49,6 +49,26 @@ def init(self): out_ports=meta_outports ) + def update(self): + TemplateNodeMixin.update(self) + meta_inports = self.template_meta_setup().inports + required = meta_inports[self.INPUT_PORT_NAME] + if len(self.conf) > 0: + input_meta = self.get_input_meta() + if self.INPUT_PORT_NAME not in input_meta: + for col in self.conf: + required[col['column']] = None + else: + col_from_inport = input_meta[self.INPUT_PORT_NAME] + for col in self.conf: + col_name = col['column'] + if col_name in col_from_inport: + required[col_name] = col_from_inport[col_name] + else: + required[col_name] = None + meta_inports[self.INPUT_PORT_NAME] = required + self.template_meta_setup(in_ports=meta_inports, out_ports=None) + def conf_schema(self): json = { "title": "Value Filter Node configure", diff --git a/gQuant/plugins/gquant_plugin/notebooks/02_single_stock_trade.ipynb b/gQuant/plugins/gquant_plugin/notebooks/02_single_stock_trade.ipynb index 461d7811..a1c8fafd 100644 --- a/gQuant/plugins/gquant_plugin/notebooks/02_single_stock_trade.ipynb +++ b/gQuant/plugins/gquant_plugin/notebooks/02_single_stock_trade.ipynb @@ -86,7 +86,6 @@ " in4: sharpe_ratio.sharpe_out\n", " in5: cumulative_return.cum_return\n", " in6: stock_data.cudf_out\n", - " module: rapids_modules\n", " type: Output_Collector\n" ] } diff --git a/gQuant/plugins/gquant_plugin/setup.py b/gQuant/plugins/gquant_plugin/setup.py index 21a2adec..d023e781 100644 --- a/gQuant/plugins/gquant_plugin/setup.py +++ b/gQuant/plugins/gquant_plugin/setup.py @@ -2,7 +2,7 @@ setup( name='greenflow_gquant_plugin', - version='0.0.2', + version='0.0.3', install_requires=[ "greenflow", "bqplot", "tables", "ray[tune]", "matplotlib", "ray[default]", "mplfinance" diff --git a/gQuant/plugins/gquant_plugin/taskgraphs/get_return_feature.gq.yaml b/gQuant/plugins/gquant_plugin/taskgraphs/get_return_feature.gq.yaml index a22b1f94..93607ec9 100644 --- a/gQuant/plugins/gquant_plugin/taskgraphs/get_return_feature.gq.yaml +++ b/gQuant/plugins/gquant_plugin/taskgraphs/get_return_feature.gq.yaml @@ -9,7 +9,6 @@ inputs: in1: stock_data.cudf_out in2: add_return_feature.stock_out - module: rapids_modules type: Output_Collector - conf: - column: volume diff --git a/gQuant/plugins/gquant_plugin/taskgraphs/portfolio_trade.gq.yaml b/gQuant/plugins/gquant_plugin/taskgraphs/portfolio_trade.gq.yaml index e0ef0221..d6bf6521 100644 --- a/gQuant/plugins/gquant_plugin/taskgraphs/portfolio_trade.gq.yaml +++ b/gQuant/plugins/gquant_plugin/taskgraphs/portfolio_trade.gq.yaml @@ -74,5 +74,4 @@ inputs: in1: cumulative_return.cum_return in2: sharpe_ratio.sharpe_out - module: rapids_modules type: Output_Collector diff --git a/gQuant/plugins/gquant_plugin/taskgraphs/simple_trade.gq.yaml b/gQuant/plugins/gquant_plugin/taskgraphs/simple_trade.gq.yaml index a2eaa541..d4e966c5 100644 --- a/gQuant/plugins/gquant_plugin/taskgraphs/simple_trade.gq.yaml +++ b/gQuant/plugins/gquant_plugin/taskgraphs/simple_trade.gq.yaml @@ -27,7 +27,6 @@ in4: sharpe_ratio.sharpe_out in5: cumulative_return.cum_return in6: stock_data.cudf_out - module: rapids_modules type: Output_Collector - conf: keys: diff --git a/gQuant/plugins/gquant_plugin/taskgraphs/tutorial_intro.gq.yaml b/gQuant/plugins/gquant_plugin/taskgraphs/tutorial_intro.gq.yaml index 8378fa05..bbc5eb4d 100644 --- a/gQuant/plugins/gquant_plugin/taskgraphs/tutorial_intro.gq.yaml +++ b/gQuant/plugins/gquant_plugin/taskgraphs/tutorial_intro.gq.yaml @@ -9,7 +9,6 @@ inputs: in1: csv_output2.df_out in2: csv_output1.df_out - module: rapids_modules type: Output_Collector - conf: input: diff --git a/gQuant/plugins/gquant_plugin/tests/unit/test_performance.py b/gQuant/plugins/gquant_plugin/tests/unit/test_performance.py index 5841d221..297e396b 100644 --- a/gQuant/plugins/gquant_plugin/tests/unit/test_performance.py +++ b/gQuant/plugins/gquant_plugin/tests/unit/test_performance.py @@ -47,9 +47,10 @@ def setUp(self): 'ports_setup.classificationGenerator.py': 2, 'ports_setup.csvStockLoader.py': 3, 'ports_setup.taskGraph.py': 5, - 'ports_setup._node_flow.py': 304, - 'ports_setup.template_node_mixin.py': 61, - 'ports_setup_ext._node_taskgraph_extension_mixin.py': 61 + 'ports_setup._node_flow.py': 320, + 'ports_setup.template_node_mixin.py': 77, + 'ports_setup_ext._node_taskgraph_extension_mixin.py': 77, + 'ports_setup.output_collector_node.py': 5 } self.meta_setup_ref = { @@ -60,9 +61,10 @@ def setUp(self): 'meta_setup.csvStockLoader.py': 3, 'meta_setup.taskGraph.py': 5, 'meta_setup.node.py': 5, - 'meta_setup._node_flow.py': 158, + 'meta_setup._node_flow.py': 177, 'meta_setup.template_node_mixin.py': 47, 'meta_setup_ext._node_taskgraph_extension_mixin.py': 47, + 'meta_setup.output_collector_node.py': 5 } tgraphpath = str(topdir) + \ diff --git a/gQuant/plugins/hrp_plugin/LICENSE b/gQuant/plugins/hrp_plugin/LICENSE new file mode 100644 index 00000000..d02d7012 --- /dev/null +++ b/gQuant/plugins/hrp_plugin/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "{}" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright 2021 GlobalFSITeam / munich_re + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/gQuant/plugins/hrp_plugin/README.md b/gQuant/plugins/hrp_plugin/README.md new file mode 100644 index 00000000..3fcd6cbe --- /dev/null +++ b/gQuant/plugins/hrp_plugin/README.md @@ -0,0 +1,99 @@ +## Greenflow Plugin for Hierarchical Risk Parity(HRP) diversification + +This package includes a set of Greenflow nodes[1] that accelerate the investment workflow in the GPU described in the paper[2]. It has following steps + +* Load CSV data +* Run bootstrap to generate 1 million scenarios +* Compute assets distances to run hierarchical clustering and HRP weights for the assets +* Compute the weights for the assets based on naïve RP method +* Compute the Sharpe ratios difference between these two methods (HRP-NRP) +* Calculate features from assets return mean, std, drawdown, correlation. It also computes std, mean across assets and across yearly time slices. It computes 30 features in total. +* Use the features and target value (the Sharpe ratio difference) to train a XGBoost model +* Run HPO to find out the best parameters for the XGBoost model +* Compute the Shap values from the XGBoost model and find out which feature explains the Sharpe difference via visualization + +It leverage the Numba GPU kernel[3] to accelerate customized computation. Dask[4] is used to parallelize the Bootstrap sample computation in different GPUs. + + +## How to install + +### Method 1. Docker +In this project directory, build the docker image: +```bash +docker build --network=host -f docker/Dockerfile -t hrp_example . +``` +Launch the container by: +```bash +docker run -it --rm -p8888:8888 --gpus all hrp_example +``` +In case you have the data files in `/path/to/pricess.csv`, you can mount it when launching the container +```bash +docker run -it --rm -p8888:8888 -v/path/to/:/workspace/notebooks/data/ --gpus all hrp_example +``` + +### Method 2, Conda Install +#### Create a new Python environment +```bash +conda create -n test python=3.8 +conda activate test +``` + +#### Install the Greenflow + +To install the Greenflow graph computation library, run the following command: +```bash +pip install greenflow +``` + +#### Install the greenflowlab JupyterLab plugin +To install `greenflowlab` JupyterLab plugin, make sure `nodejs` of version [12^14^15] is installed. E.g: +```bash +conda install -c conda-forge python-graphviz nodejs=12.4.0 pydot +``` +install `greenflowlab` by: +```bash +pip install greenflowlab +``` + +#### Install the latest RAPIDS +```bash +conda install -y -c rapidsai -c nvidia -c conda-forge rapids=21.06 cudatoolkit=11.0 +``` + +#### Install the Greenflow RAPIDS plugin +Install `greenflow_gquant_plugin`: +```bash +pip install greenflow_gquant_plugin +``` + +#### Install the greenflow_hrp_plugin +To install this plugin, clone this repo first. Run following command at the root directory of this project +```bash +pip install . +``` + +#### Run the examples +Launching the Jupyter Lab[5] by, +```bash +jupyter-lab --allow-root --ip=0.0.0.0 --no-browser --NotebookApp.token='' +``` +Example notebooks are in the notebooks directory + +#### Run unit tests +Run all the unit tests +```bash +python -m unittest tests/unit/test_*.py -v +``` + +## Make tar release +```bash +bash make_tar.sh +``` + +## References + +1. https://github.com/NVIDIA/fsi-samples/tree/main/greenflow +2. Markus J, Stephan K et al. Interpretable Machine Learning for Diversified Portfolio Construction, The Journal of Financial Data Science Summer 2021, Jan 2021 +3. https://numba.pydata.org/ +4. https://dask.org/ +5. http://jupyterlab.io/ diff --git a/gQuant/plugins/hrp_plugin/docker/Dockerfile b/gQuant/plugins/hrp_plugin/docker/Dockerfile new file mode 100644 index 00000000..073d06b1 --- /dev/null +++ b/gQuant/plugins/hrp_plugin/docker/Dockerfile @@ -0,0 +1,28 @@ +FROM nvidia/cuda:11.2.1-devel-ubuntu20.04 +RUN apt-get update && \ + apt-get install -y libfontconfig1 libxrender1 wget && \ + rm -rf /var/lib/apt/lists/* +RUN wget \ + https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh \ + && bash Miniconda3-latest-Linux-x86_64.sh -b \ + && rm -f Miniconda3-latest-Linux-x86_64.sh +ENV PATH="/root/miniconda3/bin:${PATH}" +RUN conda init +RUN conda install -y -c conda-forge python-graphviz nodejs=12.4.0 pydot +RUN conda install -y -c rapidsai -c nvidia -c conda-forge rapids=21.06 python=3.8 cudatoolkit=11.0 +RUN conda install -y -c conda-forge ruamel.yaml +RUN pip install greenflow +RUN pip install greenflowlab +RUN pip install greenflow_dask_plugin +RUN pip install greenflow_gquant_plugin +WORKDIR /workspace +COPY greenflow_hrp_plugin greenflow_hrp_plugin +COPY setup.py . +RUN pip install . +COPY notebooks notebooks +ENTRYPOINT jupyter-lab --allow-root --ip=0.0.0.0 --no-browser --NotebookApp.token='' + + + + + diff --git a/gQuant/plugins/hrp_plugin/greenflow_hrp_plugin/__init__.py b/gQuant/plugins/hrp_plugin/greenflow_hrp_plugin/__init__.py new file mode 100644 index 00000000..5eeb79ff --- /dev/null +++ b/gQuant/plugins/hrp_plugin/greenflow_hrp_plugin/__init__.py @@ -0,0 +1,42 @@ +""" + //////////////////////////////////////////////////////////////////////////// + // + // Copyright (C) NVIDIA Corporation. All rights reserved. + // + // NVIDIA Sample Code + // + // Please refer to the NVIDIA end user license agreement (EULA) associated + // with this source code for terms and conditions that govern your use of + // this software. Any use, reproduction, disclosure, or distribution of + // this software and related documentation outside the terms of the EULA + // is strictly prohibited. + // + //////////////////////////////////////////////////////////////////////////// +""" + +from .loadCsvNode import LoadCsvNode +from .bootstrapNode import BootstrapNode +from .logReturnNode import LogReturnNode +from .distanceNode import DistanceNode +from .hierarchicalClusteringNode import HierarchicalClusteringNode +from .hrpWeight import HRPWeightNode +from .portfolioNode import PortfolioNode +from .performanceMetricNode import PerformanceMetricNode +from .nrpWeightNode import NRPWeightNode +from .maxDrawdownNode import MaxDrawdownNode +from .featureNode import FeatureNode +from .aggregateTimeFeature import AggregateTimeFeatureNode +from .mergeNode import MergeNode +from .diffNode import DiffNode +from .rSquaredNode import RSquaredNode +from .shapSummaryPlotNode import ShapSummaryPlotPlotNode +from .leverageNode import LeverageNode +from .rawDataNode import RawDataNode +from .transactionCostNode import TransactionCostNode + +__all__ = ["LoadCsvNode", "BootstrapNode", "LogReturnNode", + "DistanceNode", "HierarchicalClusteringNode", "HRPWeightNode", + "PortfolioNode", "PerformanceMetricNode", "NRPWeightNode", + "MaxDrawdownNode", "FeatureNode", "AggregateTimeFeatureNode", + "MergeNode", "DiffNode", "RSquaredNode", "ShapSummaryPlotPlotNode", + "LeverageNode", "RawDataNode", "TransactionCostNode"] diff --git a/gQuant/plugins/hrp_plugin/greenflow_hrp_plugin/aggregateTimeFeature.py b/gQuant/plugins/hrp_plugin/greenflow_hrp_plugin/aggregateTimeFeature.py new file mode 100644 index 00000000..ead5b7ff --- /dev/null +++ b/gQuant/plugins/hrp_plugin/greenflow_hrp_plugin/aggregateTimeFeature.py @@ -0,0 +1,134 @@ +""" + //////////////////////////////////////////////////////////////////////////// + // + // Copyright (C) NVIDIA Corporation. All rights reserved. + // + // NVIDIA Sample Code + // + // Please refer to the NVIDIA end user license agreement (EULA) associated + // with this source code for terms and conditions that govern your use of + // this software. Any use, reproduction, disclosure, or distribution of + // this software and related documentation outside the terms of the EULA + // is strictly prohibited. + // + //////////////////////////////////////////////////////////////////////////// +""" + +from greenflow.dataframe_flow import ConfSchema +from greenflow.dataframe_flow.portsSpecSchema import PortsSpecSchema +from greenflow.dataframe_flow.template_node_mixin import TemplateNodeMixin +from greenflow.dataframe_flow.metaSpec import MetaDataSchema +from greenflow.dataframe_flow import Node +import cudf + + +class AggregateTimeFeatureNode(TemplateNodeMixin, Node): + + def init(self): + TemplateNodeMixin.init(self) + self.INPUT_PORT_NAME = 'in' + self.OUTPUT_PORT_NAME = 'out' + self.delayed_process = True + self.infer_meta = False + port_type = PortsSpecSchema.port_type + port_inports = { + self.INPUT_PORT_NAME: { + port_type: [ + "pandas.DataFrame", "cudf.DataFrame", + "dask_cudf.DataFrame", "dask.dataframe.DataFrame" + ] + } + } + port_outports = { + self.OUTPUT_PORT_NAME: { + port_type: "${port:in}" + } + } + cols_required = { + 'sample_id': 'int64', + 'year': 'int16', + 'month': 'int16', + } + + meta_inports = { + self.INPUT_PORT_NAME: cols_required + } + meta_outports = { + self.OUTPUT_PORT_NAME: { + MetaDataSchema.META_OP: MetaDataSchema.META_OP_RETENTION, + MetaDataSchema.META_DATA: {} + } + } + self.template_ports_setup( + in_ports=port_inports, + out_ports=port_outports + ) + self.template_meta_setup( + in_ports=meta_inports, + out_ports=meta_outports + ) + + def update(self): + TemplateNodeMixin.update(self) + input_meta = self.get_input_meta() + meta_outports = self.template_meta_setup().outports + meta_inports = self.template_meta_setup().inports + required = meta_inports[self.INPUT_PORT_NAME] + if self.INPUT_PORT_NAME not in input_meta: + col_from_inport = { + 'sample_id': 'int64' + } + col_ref = {} + else: + col_from_inport = { + 'sample_id': 'int64' + } + col_ref = input_meta[self.INPUT_PORT_NAME].copy() + + for key in col_ref.keys(): + if key in required: + continue + new_key = key+"_mean" + col_from_inport[new_key] = col_ref[key] + for key in col_ref.keys(): + if key in required: + continue + new_key = key+"_std" + col_from_inport[new_key] = col_ref[key] + meta_outports[self.OUTPUT_PORT_NAME] = col_from_inport + self.template_meta_setup( + in_ports=None, + out_ports=meta_outports + ) + + def conf_schema(self): + json = { + "title": "Aggregate feature across time, get mean and std", + "type": "object", + "properties": { + }, + } + + ui = { + } + return ConfSchema(json=json, ui=ui) + + def process(self, inputs): + df = inputs[self.INPUT_PORT_NAME] + output = {} + + col = list(df.columns) + col.remove('year') + col.remove('month') + + mdf = df[col].groupby('sample_id').mean() + mdf.columns = [c+"_mean" for c in mdf.columns] + + sdf = df[col].groupby('sample_id').std() + sdf.columns = [c+"_std" for c in sdf.columns] + + out = cudf.merge(mdf, sdf, + left_index=True, + right_index=True).reset_index() + output.update({self.OUTPUT_PORT_NAME: out}) + return output diff --git a/gQuant/plugins/hrp_plugin/greenflow_hrp_plugin/bootstrapNode.py b/gQuant/plugins/hrp_plugin/greenflow_hrp_plugin/bootstrapNode.py new file mode 100644 index 00000000..658900af --- /dev/null +++ b/gQuant/plugins/hrp_plugin/greenflow_hrp_plugin/bootstrapNode.py @@ -0,0 +1,146 @@ +""" + //////////////////////////////////////////////////////////////////////////// + // + // Copyright (C) NVIDIA Corporation. All rights reserved. + // + // NVIDIA Sample Code + // + // Please refer to the NVIDIA end user license agreement (EULA) associated + // with this source code for terms and conditions that govern your use of + // this software. Any use, reproduction, disclosure, or distribution of + // this software and related documentation outside the terms of the EULA + // is strictly prohibited. + // + //////////////////////////////////////////////////////////////////////////// +""" + +import cudf +from greenflow.dataframe_flow import Node +from greenflow.dataframe_flow import PortsSpecSchema +from greenflow.dataframe_flow import ConfSchema +from greenflow.dataframe_flow.template_node_mixin import TemplateNodeMixin +from .kernels import run_bootstrap +import cupy +import dask +import dask_cudf +from collections import OrderedDict + + +class BootstrapNode(TemplateNodeMixin, Node): + + def init(self): + TemplateNodeMixin.init(self) + self.INPUT_PORT_NAME = 'in' + self.OUTPUT_PORT_NAME = 'out' + self.OUTPUT_DASK_PORT = 'dask_df' + port_type = PortsSpecSchema.port_type + port_inports = { + self.INPUT_PORT_NAME: { + port_type: [ + "pandas.DataFrame", "cudf.DataFrame", + ] + }, + } + port_outports = { + self.OUTPUT_PORT_NAME: { + port_type: "${port:in}" + }, + self.OUTPUT_DASK_PORT: { + port_type: ["dask_cudf.DataFrame", "dask.dataframe.DataFrame"] + } + } + self.template_ports_setup( + in_ports=port_inports, + out_ports=port_outports + ) + + def update(self): + TemplateNodeMixin.update(self) + meta_outports = self.template_meta_setup().outports + meta_inports = self.template_meta_setup().inports + col_required = { + "date": "date" + } + input_meta = self.get_input_meta() + json = OrderedDict() + if self.INPUT_PORT_NAME in input_meta: + assets = len(input_meta[self.INPUT_PORT_NAME]) - 1 + for i in range(assets): + json[i] = 'float64' + json['date'] = "datetime64[ns]" + json['sample_id'] = 'int64' + json['year'] = 'int16' + json['month'] = 'int16' + meta_inports[self.INPUT_PORT_NAME] = col_required + meta_outports[self.OUTPUT_DASK_PORT] = json + meta_outports[self.OUTPUT_PORT_NAME] = json + self.template_meta_setup( + in_ports=meta_inports, + out_ports=meta_outports + ) + + def conf_schema(self): + json = { + "title": "Generate bootstrap dataframe", + "type": "object", + "properties": { + "samples": { + "type": "integer", + "description": "Number of samples to bootstrap" + }, + "partitions": { + "type": "integer", + "description": "Number of partitions for Dask Dataframe" + }, + "offset": { + "type": "integer", + "description": "Sample id offset", + "default": 0 + }, + }, + "required": ["samples"], + } + + ui = { + } + return ConfSchema(json=json, ui=ui) + + def _process(self, df, partition_id): + number_samples = self.conf['samples'] + all_dates = df['date'] + cols = list(df.columns) + cols.remove('date') + price_matrix = df[cols].values + result = run_bootstrap(price_matrix, number_samples=number_samples) + # print('bootstrap') + total_samples, assets, length = result.shape + datetime_col = cudf.concat([all_dates] * + total_samples).reset_index(drop=True) + result = result.transpose([0, 2, 1]).reshape(-1, assets) + df = cudf.DataFrame(result) + df['date'] = datetime_col + sample_id = cupy.repeat(cupy.arange(0, total_samples), length) + df['sample_id'] = sample_id + partition_id * number_samples + df['year'] = df['date'].dt.year + df['month'] = df['date'].dt.month - 1 + return df + + def process(self, inputs): + df = inputs[self.INPUT_PORT_NAME] + # df = df.drop('datetime', axis=1) + output = {} + if self.outport_connected(self.OUTPUT_PORT_NAME): + offset = self.conf.get('offset', 0) + out_df = self._process(df, offset) + output.update({self.OUTPUT_PORT_NAME: out_df}) + if self.outport_connected(self.OUTPUT_DASK_PORT): + partitions = self.conf['partitions'] + out_dfs = [ + dask.delayed(self._process)(df, i) for i in range(partitions) + ] + meta = self.meta_setup().outports[self.OUTPUT_DASK_PORT] + meta['date'] = 'datetime64[ns]' + dask_df = dask_cudf.from_delayed( + out_dfs, meta=meta) + output.update({self.OUTPUT_DASK_PORT: dask_df}) + return output diff --git a/gQuant/plugins/hrp_plugin/greenflow_hrp_plugin/client.py b/gQuant/plugins/hrp_plugin/greenflow_hrp_plugin/client.py new file mode 100644 index 00000000..e1c6b108 --- /dev/null +++ b/gQuant/plugins/hrp_plugin/greenflow_hrp_plugin/client.py @@ -0,0 +1,18 @@ +""" + //////////////////////////////////////////////////////////////////////////// + // + // Copyright (C) NVIDIA Corporation. All rights reserved. + // + // NVIDIA Sample Code + // + // Please refer to the NVIDIA end user license agreement (EULA) associated + // with this source code for terms and conditions that govern your use of + // this software. Any use, reproduction, disclosure, or distribution of + // this software and related documentation outside the terms of the EULA + // is strictly prohibited. + // + //////////////////////////////////////////////////////////////////////////// +""" + +validation = {} +display = {} diff --git a/gQuant/plugins/hrp_plugin/greenflow_hrp_plugin/diffNode.py b/gQuant/plugins/hrp_plugin/greenflow_hrp_plugin/diffNode.py new file mode 100644 index 00000000..deada4fe --- /dev/null +++ b/gQuant/plugins/hrp_plugin/greenflow_hrp_plugin/diffNode.py @@ -0,0 +1,98 @@ +""" + //////////////////////////////////////////////////////////////////////////// + // + // Copyright (C) NVIDIA Corporation. All rights reserved. + // + // NVIDIA Sample Code + // + // Please refer to the NVIDIA end user license agreement (EULA) associated + // with this source code for terms and conditions that govern your use of + // this software. Any use, reproduction, disclosure, or distribution of + // this software and related documentation outside the terms of the EULA + // is strictly prohibited. + // + //////////////////////////////////////////////////////////////////////////// +""" + +from greenflow.dataframe_flow import (ConfSchema, PortsSpecSchema) +from greenflow.dataframe_flow.template_node_mixin import TemplateNodeMixin +from greenflow.dataframe_flow import Node +from greenflow.dataframe_flow.metaSpec import MetaDataSchema + + +class DiffNode(TemplateNodeMixin, Node): + + def init(self): + TemplateNodeMixin.init(self) + self.delayed_process = True + self.infer_meta = False + self.OUTPUT_PORT_NAME = 'out' + self.DIFF_A = 'diff_a' + self.DIFF_B = 'diff_b' + port_type = PortsSpecSchema.port_type + port_inports = { + self.DIFF_A: { + port_type: [ + "pandas.DataFrame", "cudf.DataFrame", + "dask_cudf.DataFrame", "dask.dataframe.DataFrame" + ] + }, + self.DIFF_B: { + port_type: [ + "pandas.DataFrame", "cudf.DataFrame", + "dask_cudf.DataFrame", "dask.dataframe.DataFrame" + ] + } + } + port_outports = { + self.OUTPUT_PORT_NAME: { + port_type: "${port:diff_a}" + }, + } + col_required = { + 'sample_id': 'int64', + 'portfolio': 'float64', + } + + meta_inports = { + self.DIFF_A: col_required, + self.DIFF_B: col_required + } + output_meta = { + 'sample_id': 'int64', + 'portfolio': 'float64', + } + meta_outports = { + self.OUTPUT_PORT_NAME: { + MetaDataSchema.META_OP: MetaDataSchema.META_OP_RETENTION, + MetaDataSchema.META_DATA: output_meta + } + } + self.template_ports_setup(in_ports=port_inports, + out_ports=port_outports) + self.template_meta_setup( + in_ports=meta_inports, + out_ports=meta_outports + ) + + def conf_schema(self): + json = { + "title": "Calculate Sharpe diff", + "type": "object", + "properties": { + }, + } + + ui = { + } + return ConfSchema(json=json, ui=ui) + + def process(self, inputs): + df_a = inputs[self.DIFF_A].set_index('sample_id') + df_b = inputs[self.DIFF_B].set_index('sample_id') + + # df = df.drop('datetime', axis=1) + output = {} + diff = df_a - df_b + output.update({self.OUTPUT_PORT_NAME: diff.reset_index()}) + return output diff --git a/gQuant/plugins/hrp_plugin/greenflow_hrp_plugin/distanceNode.py b/gQuant/plugins/hrp_plugin/greenflow_hrp_plugin/distanceNode.py new file mode 100644 index 00000000..4400d334 --- /dev/null +++ b/gQuant/plugins/hrp_plugin/greenflow_hrp_plugin/distanceNode.py @@ -0,0 +1,205 @@ +""" + //////////////////////////////////////////////////////////////////////////// + // + // Copyright (C) NVIDIA Corporation. All rights reserved. + // + // NVIDIA Sample Code + // + // Please refer to the NVIDIA end user license agreement (EULA) associated + // with this source code for terms and conditions that govern your use of + // this software. Any use, reproduction, disclosure, or distribution of + // this software and related documentation outside the terms of the EULA + // is strictly prohibited. + // + //////////////////////////////////////////////////////////////////////////// +""" + +from greenflow.dataframe_flow import ConfSchema, PortsSpecSchema +from greenflow.dataframe_flow.template_node_mixin import TemplateNodeMixin +from greenflow.dataframe_flow import Node +from .kernels import compute_cov_distance +import cupy +import cudf + + +class DistanceNode(TemplateNodeMixin, Node): + + def init(self): + TemplateNodeMixin.init(self) + self.delayed_process = True + self.infer_meta = False + self.INPUT_PORT_NAME = 'in' + self.COV_DF = 'cov_df' + self.MEAN_DF = 'mean_df' + self.STD_DF = 'std_df' + self.CORR_DF = 'corr_df' + self.DISTANCE_DF = 'distance_df' + port_type = PortsSpecSchema.port_type + port_inports = { + self.INPUT_PORT_NAME: { + port_type: [ + "pandas.DataFrame", "cudf.DataFrame", + "dask_cudf.DataFrame", "dask.dataframe.DataFrame" + ] + } + } + port_outports = { + self.MEAN_DF: { + port_type: "${port:in}" + }, + self.STD_DF: { + port_type: "${port:in}" + }, + self.COV_DF: { + port_type: "${port:in}" + }, + self.CORR_DF: { + port_type: "${port:in}" + }, + self.DISTANCE_DF: { + port_type: "${port:in}" + } + } + self.template_ports_setup(in_ports=port_inports, + out_ports=port_outports) + + def update(self): + TemplateNodeMixin.update(self) + meta_outports = self.template_meta_setup().outports + meta_inports = self.template_meta_setup().inports + sub_dict = { + 'year': 'int16', + 'month': 'int16', + 'sample_id': 'int64', + } + required = { + "date": "datetime64[ns]", + } + required.update(sub_dict) + meta_inports[self.INPUT_PORT_NAME] = required + json_cov = {} + json_dis = {} + json_mean = {} + json_corr = {} + json_std = {} + input_meta = self.get_input_meta() + if self.INPUT_PORT_NAME in input_meta: + assets = len(input_meta[self.INPUT_PORT_NAME]) - 4 + for i in range(assets*assets): + json_cov[i] = 'float64' + for i in range(assets): + json_mean[i] = 'float64' + json_std[i] = 'float64' + for i in range(assets*(assets-1)//2): + json_dis[i] = 'float64' + json_corr[i] = 'float64' + json_cov.update(sub_dict) + json_dis.update(sub_dict) + json_mean.update(sub_dict) + json_std.update(sub_dict) + json_corr.update(sub_dict) + meta_outports[self.MEAN_DF] = json_mean + meta_outports[self.STD_DF] = json_std + meta_outports[self.COV_DF] = json_cov + meta_outports[self.CORR_DF] = json_corr + meta_outports[self.DISTANCE_DF] = json_dis + self.template_meta_setup( + in_ports=meta_inports, + out_ports=meta_outports + ) + + def conf_schema(self): + json = { + "title": "Compute the Distance Matrix and Cov df", + "type": "object", + "properties": { + "window": { + 'type': "integer", + "title": "Window size", + "description": """the number of months used to compute the + distance and vairance""" + } + }, + "required": ["window"], + } + + ui = { + } + return ConfSchema(json=json, ui=ui) + + def process(self, inputs): + df = inputs[self.INPUT_PORT_NAME] + all_sample_ids = df['sample_id'].unique() + total_samples = len(all_sample_ids) + window = self.conf['window'] + means, cov, distance, all_dates = compute_cov_distance(total_samples, + df, + window=window) + + total_samples, num_months, assets, assets = cov.shape + + months_id = all_dates.dt.year*12 + (all_dates.dt.month-1) + months_id = months_id - months_id.min() + mid = (cupy.arange(months_id.max() + 1) + + (all_dates.dt.month - 1)[0])[window:] + minyear = all_dates.dt.year.min() + if len(mid) == 0: + mid = cupy.array([0]) + months = mid % 12 + years = mid // 12 + minyear + + output = {} + # print(num_months, len(mid)) + if self.outport_connected(self.MEAN_DF): + df_mean = cudf.DataFrame( + means.reshape(total_samples*num_months, -1)) + df_mean['year'] = cupy.concatenate( + [years]*total_samples).astype(cupy.int16) + df_mean['month'] = cupy.concatenate( + [months]*total_samples).astype(cupy.int16) + df_mean['sample_id'] = cupy.repeat(cupy.arange( + total_samples) + all_sample_ids.min(), len(mid)) + output.update({self.MEAN_DF: df_mean}) + if self.outport_connected(self.STD_DF): + data_ma = cov.reshape(total_samples*num_months, assets, assets) + diagonzied = cupy.diagonal(data_ma, 0, 1, 2) # get var + diagonzied = cupy.sqrt(diagonzied) # get std + df_std = cudf.DataFrame(diagonzied) + df_std['year'] = cupy.concatenate( + [years]*total_samples).astype(cupy.int16) + df_std['month'] = cupy.concatenate( + [months]*total_samples).astype(cupy.int16) + df_std['sample_id'] = cupy.repeat(cupy.arange( + total_samples) + all_sample_ids.min(), len(mid)) + output.update({self.STD_DF: df_std}) + if self.outport_connected(self.COV_DF): + df_cov = cudf.DataFrame(cov.reshape(total_samples*num_months, -1)) + df_cov['year'] = cupy.concatenate( + [years]*total_samples).astype(cupy.int16) + df_cov['month'] = cupy.concatenate( + [months]*total_samples).astype(cupy.int16) + df_cov['sample_id'] = cupy.repeat(cupy.arange( + total_samples) + all_sample_ids.min(), len(mid)) + output.update({self.COV_DF: df_cov}) + if self.outport_connected(self.CORR_DF): + dis_ma = distance.reshape(total_samples*num_months, -1) + dis_ma = 1 - 2.0 * dis_ma + df_corr = cudf.DataFrame(dis_ma) + df_corr['year'] = cupy.concatenate( + [years]*total_samples).astype(cupy.int16) + df_corr['month'] = cupy.concatenate( + [months]*total_samples).astype(cupy.int16) + df_corr['sample_id'] = cupy.repeat(cupy.arange( + total_samples) + all_sample_ids.min(), len(mid)) + output.update({self.CORR_DF: df_corr}) + if self.outport_connected(self.DISTANCE_DF): + df_dis = cudf.DataFrame(distance.reshape(total_samples*num_months, + -1)) + df_dis['year'] = cupy.concatenate( + [years]*total_samples).astype(cupy.int16) + df_dis['month'] = cupy.concatenate( + [months]*total_samples).astype(cupy.int16) + df_dis['sample_id'] = cupy.repeat(cupy.arange( + total_samples) + all_sample_ids.min(), len(mid)) + output.update({self.DISTANCE_DF: df_dis}) + return output diff --git a/gQuant/plugins/hrp_plugin/greenflow_hrp_plugin/featureNode.py b/gQuant/plugins/hrp_plugin/greenflow_hrp_plugin/featureNode.py new file mode 100644 index 00000000..ba6b6f12 --- /dev/null +++ b/gQuant/plugins/hrp_plugin/greenflow_hrp_plugin/featureNode.py @@ -0,0 +1,123 @@ +""" + //////////////////////////////////////////////////////////////////////////// + // + // Copyright (C) NVIDIA Corporation. All rights reserved. + // + // NVIDIA Sample Code + // + // Please refer to the NVIDIA end user license agreement (EULA) associated + // with this source code for terms and conditions that govern your use of + // this software. Any use, reproduction, disclosure, or distribution of + // this software and related documentation outside the terms of the EULA + // is strictly prohibited. + // + //////////////////////////////////////////////////////////////////////////// +""" + +from greenflow.dataframe_flow import (ConfSchema, PortsSpecSchema) +from greenflow.dataframe_flow.template_node_mixin import TemplateNodeMixin +from greenflow.dataframe_flow import Node + + +class FeatureNode(TemplateNodeMixin, Node): + + def init(self): + TemplateNodeMixin.init(self) + self.delayed_process = True + self.infer_meta = False + self.SIGNAL_DF = 'signal_df' + self.FEATURE_DF = 'feature_df' + self.OUTPUT_PORT_NAME = 'out' + port_type = PortsSpecSchema.port_type + port_inports = { + self.SIGNAL_DF: { + port_type: [ + "pandas.DataFrame", "cudf.DataFrame", + "dask_cudf.DataFrame", "dask.dataframe.DataFrame" + ] + }, + self.FEATURE_DF: { + port_type: [ + "pandas.DataFrame", "cudf.DataFrame", + "dask_cudf.DataFrame", "dask.dataframe.DataFrame" + ], + PortsSpecSchema.optional: True + } + } + port_outports = { + self.OUTPUT_PORT_NAME: { + port_type: "${port:signal_df}" + }, + } + self.template_ports_setup(in_ports=port_inports, + out_ports=port_outports) + + def conf_schema(self): + json = { + "title": "Calculate the std and mean across assets as features", + "type": "object", + "properties": { + "name": { + "type": "string", + "title": "Feature Name" + } + }, + } + + ui = { + } + return ConfSchema(json=json, ui=ui) + + def update(self): + TemplateNodeMixin.update(self) + meta_outports = self.template_meta_setup().outports + meta_inports = self.template_meta_setup().inports + required = { + 'year': 'int16', + 'month': 'int16', + 'sample_id': 'int64', + } + name = self.conf.get("name", "feature") + + input_meta = self.get_input_meta() + if self.FEATURE_DF not in input_meta: + col_from_inport = required.copy() + else: + col_from_inport = input_meta[self.FEATURE_DF].copy() + + meta_inports[self.SIGNAL_DF] = required + meta_inports[self.FEATURE_DF] = required + + # additional ports + cols = { + name+"_mean": "float64", + name+"_std": "float64" + } + col_from_inport.update(cols) + meta_outports[self.OUTPUT_PORT_NAME] = col_from_inport + self.template_meta_setup( + in_ports=meta_inports, + out_ports=meta_outports + ) + + def process(self, inputs): + df = inputs[self.SIGNAL_DF] + name = self.conf.get("name", "feature") + if self.FEATURE_DF not in inputs: + output_df = df[['year', 'month', 'sample_id']].copy() + else: + output_df = inputs[self.FEATURE_DF] + + # df = df.drop('datetime', axis=1) + output = {} + if self.outport_connected(self.OUTPUT_PORT_NAME): + col = list(df.columns) + col.remove('sample_id') + col.remove('year') + col.remove('month') + mean_val = df[col].values.mean(axis=1) + std_val = df[col].values.std(axis=1) + output_df[name+'_mean'] = mean_val + output_df[name+'_std'] = std_val + output.update({self.OUTPUT_PORT_NAME: output_df}) + return output diff --git a/gQuant/plugins/hrp_plugin/greenflow_hrp_plugin/hierarchicalClusteringNode.py b/gQuant/plugins/hrp_plugin/greenflow_hrp_plugin/hierarchicalClusteringNode.py new file mode 100644 index 00000000..0bb7c82e --- /dev/null +++ b/gQuant/plugins/hrp_plugin/greenflow_hrp_plugin/hierarchicalClusteringNode.py @@ -0,0 +1,112 @@ +""" + //////////////////////////////////////////////////////////////////////////// + // + // Copyright (C) NVIDIA Corporation. All rights reserved. + // + // NVIDIA Sample Code + // + // Please refer to the NVIDIA end user license agreement (EULA) associated + // with this source code for terms and conditions that govern your use of + // this software. Any use, reproduction, disclosure, or distribution of + // this software and related documentation outside the terms of the EULA + // is strictly prohibited. + // + //////////////////////////////////////////////////////////////////////////// +""" + +from greenflow.dataframe_flow import ConfSchema, PortsSpecSchema +from greenflow.dataframe_flow.template_node_mixin import TemplateNodeMixin +from greenflow.dataframe_flow import Node +from .kernels import get_orders +import math +import cudf + + +class HierarchicalClusteringNode(TemplateNodeMixin, Node): + + def init(self): + TemplateNodeMixin.init(self) + self.delayed_process = True + self.infer_meta = False + self.INPUT_PORT_NAME = 'in' + self.OUTPUT_PORT_NAME = 'out' + port_type = PortsSpecSchema.port_type + port_inports = { + self.INPUT_PORT_NAME: { + port_type: [ + "pandas.DataFrame", "cudf.DataFrame", + "dask_cudf.DataFrame", "dask.dataframe.DataFrame" + ] + } + } + port_outports = { + self.OUTPUT_PORT_NAME: { + port_type: "${port:in}" + }, + } + self.template_ports_setup(in_ports=port_inports, + out_ports=port_outports) + + def conf_schema(self): + json = { + "title": "Hierachical Clustering Node", + "type": "object", + "properties": { + }, + } + + ui = { + } + return ConfSchema(json=json, ui=ui) + + def update(self): + TemplateNodeMixin.update(self) + meta_outports = self.template_meta_setup().outports + meta_inports = self.template_meta_setup().inports + required = { + 'month': 'int16', + 'year': 'int16', + 'sample_id': 'int64', + } + meta_inports[self.INPUT_PORT_NAME] = required + json = {} + input_meta = self.get_input_meta() + if self.INPUT_PORT_NAME in input_meta: + num = len(input_meta[self.INPUT_PORT_NAME]) - 3 + assets = (1 + int(math.sqrt(1 + 8 * num))) // 2 + for i in range(assets): + json[i] = 'int64' + json.update(required) + meta_outports[self.OUTPUT_PORT_NAME] = json + self.template_meta_setup( + in_ports=meta_inports, + out_ports=meta_outports + ) + + def process(self, inputs): + input_meta = self.get_input_meta() + df = inputs[self.INPUT_PORT_NAME] + all_sample_ids = df['sample_id'].unique() + total_samples = len(all_sample_ids) + if self.INPUT_PORT_NAME in input_meta: + num = len(input_meta[self.INPUT_PORT_NAME]) - 3 + assets = (1 + int(math.sqrt(1 + 8 * num))) // 2 + df = inputs[self.INPUT_PORT_NAME] + + output = {} + col = list(df.columns) + col.remove('sample_id') + col.remove('year') + col.remove('month') + distance = df[col].values + distance = distance.reshape( + total_samples, -1, assets*(assets-1)//2) + _, num_months, _ = distance.shape + orders = get_orders(total_samples, num_months, assets, distance) + orders = orders.reshape(-1, assets) + order_df = cudf.DataFrame(orders) + order_df['month'] = df['month'] + order_df['year'] = df['year'] + order_df['sample_id'] = df['sample_id'] + output.update({self.OUTPUT_PORT_NAME: order_df}) + return output diff --git a/gQuant/plugins/hrp_plugin/greenflow_hrp_plugin/hrpWeight.py b/gQuant/plugins/hrp_plugin/greenflow_hrp_plugin/hrpWeight.py new file mode 100644 index 00000000..b84324eb --- /dev/null +++ b/gQuant/plugins/hrp_plugin/greenflow_hrp_plugin/hrpWeight.py @@ -0,0 +1,135 @@ +""" + //////////////////////////////////////////////////////////////////////////// + // + // Copyright (C) NVIDIA Corporation. All rights reserved. + // + // NVIDIA Sample Code + // + // Please refer to the NVIDIA end user license agreement (EULA) associated + // with this source code for terms and conditions that govern your use of + // this software. Any use, reproduction, disclosure, or distribution of + // this software and related documentation outside the terms of the EULA + // is strictly prohibited. + // + //////////////////////////////////////////////////////////////////////////// +""" + +from greenflow.dataframe_flow import (ConfSchema, PortsSpecSchema) +from greenflow.dataframe_flow import Node +from greenflow.dataframe_flow.template_node_mixin import TemplateNodeMixin +from .kernels import get_weights +import cudf +import math + + +class HRPWeightNode(TemplateNodeMixin, Node): + + def init(self): + TemplateNodeMixin.init(self) + self.COV_IN = 'covariance_df' + self.ORDER_IN = 'asset_order_df' + self.OUTPUT_PORT_NAME = 'out' + self.delayed_process = True + self.infer_meta = False + port_type = PortsSpecSchema.port_type + port_inports = { + self.COV_IN: { + port_type: [ + "pandas.DataFrame", "cudf.DataFrame", + "dask_cudf.DataFrame", "dask.dataframe.DataFrame" + ] + }, + self.ORDER_IN: { + port_type: [ + "pandas.DataFrame", "cudf.DataFrame", + "dask_cudf.DataFrame", "dask.dataframe.DataFrame" + ] + } + } + port_outports = { + self.OUTPUT_PORT_NAME: { + port_type: "${port:covariance_df}" + }, + } + self.template_ports_setup(in_ports=port_inports, + out_ports=port_outports) + + def conf_schema(self): + json = { + "title": "Compute the HRP weights", + "type": "object", + "properties": { + }, + } + + ui = { + } + return ConfSchema(json=json, ui=ui) + + def update(self): + TemplateNodeMixin.update(self) + meta_outports = self.template_meta_setup().outports + meta_inports = self.template_meta_setup().inports + required = { + 'month': 'int16', + 'year': 'int16', + 'sample_id': 'int64', + } + meta_inports[self.COV_IN] = required + meta_inports[self.ORDER_IN] = required + json = {} + input_meta = self.get_input_meta() + if self.COV_IN in input_meta: + assets = int(math.sqrt(len(input_meta[self.COV_IN]) - 3)) + for i in range(assets): + json[i] = 'float64' + elif self.ORDER_IN in input_meta: + assets = len(input_meta[self.ORDER_IN]) - 3 + for i in range(assets): + json[i] = 'float64' + json.update(required) + meta_outports[self.OUTPUT_PORT_NAME] = json + self.template_meta_setup( + in_ports=meta_inports, + out_ports=meta_outports + ) + + def process(self, inputs): + input_meta = self.get_input_meta() + df_cov = inputs[self.COV_IN] + df_order = inputs[self.ORDER_IN] + all_sample_ids = df_cov['sample_id'].unique() + # print(all_sample_ids - df_order['sample_id'].unique()) + total_samples = len(all_sample_ids) + input_meta = self.get_input_meta() + if self.COV_IN in input_meta: + assets = int(math.sqrt(len(input_meta[self.COV_IN]) - 3)) + elif self.ORDER_IN in input_meta: + assets = len(input_meta[self.ORDER_IN]) - 3 + + output = {} + col = list(df_cov.columns) + col.remove('sample_id') + col.remove('year') + col.remove('month') + cov = df_cov[col].values + cov = cov.reshape( + total_samples, -1, assets, assets) + _, num_months, _, _ = cov.shape + + col = list(df_order.columns) + col.remove('sample_id') + col.remove('year') + col.remove('month') + order = df_order[col].values + order = order.reshape( + total_samples, -1, assets) + weights = get_weights(total_samples, cov, + order, num_months, assets) + weights = weights.reshape(-1, assets) + weight_df = cudf.DataFrame(weights) + weight_df['month'] = df_order['month'] + weight_df['year'] = df_order['year'] + weight_df['sample_id'] = df_order['sample_id'] + output.update({self.OUTPUT_PORT_NAME: weight_df}) + return output diff --git a/gQuant/plugins/hrp_plugin/greenflow_hrp_plugin/kernels.py b/gQuant/plugins/hrp_plugin/greenflow_hrp_plugin/kernels.py new file mode 100644 index 00000000..2494493c --- /dev/null +++ b/gQuant/plugins/hrp_plugin/greenflow_hrp_plugin/kernels.py @@ -0,0 +1,747 @@ +""" + //////////////////////////////////////////////////////////////////////////// + // + // Copyright (C) NVIDIA Corporation. All rights reserved. + // + // NVIDIA Sample Code + // + // Please refer to the NVIDIA end user license agreement (EULA) associated + // with this source code for terms and conditions that govern your use of + // this software. Any use, reproduction, disclosure, or distribution of + // this software and related documentation outside the terms of the EULA + // is strictly prohibited. + // + //////////////////////////////////////////////////////////////////////////// +""" + +from numba import cuda +import numba +import cupy +import math + +MAX_ASSETS = 32 +MAX_YEARS = 24 +PARENT_MAX_ASSETS = 2 * MAX_ASSETS - 1 +SUM_LEN = 256 * 32 +# MAX_SHARE = 256 * MAX_YEARS * 4 + + +@cuda.jit +def boot_strap(result, ref, block_size, num_positions, positions): + sample, assets, length = result.shape + i = cuda.threadIdx.x + sample_id = cuda.blockIdx.x // num_positions + position_id = cuda.blockIdx.x % num_positions + sample_at = positions[cuda.blockIdx.x] + for k in range(i, block_size*assets, cuda.blockDim.x): + asset_id = k // block_size + loc = k % block_size + if (position_id * block_size + loc + 1 < length): + result[sample_id, asset_id, position_id * block_size + + loc + 1] = ref[asset_id, sample_at + loc] + + +@cuda.jit(device=True) +def gpu_sum(array): + i = cuda.threadIdx.x + total_len = SUM_LEN + length = total_len + while length > 0: + length = length // 2 + for k in range(i, length, cuda.blockDim.x): + if k+length < total_len: + array[k] += array[k + length] + cuda.syncthreads() + + +@cuda.jit +def compute_cov(means, cov, distance, returns, months_starts, num_months, + assets, time_len, window): + """ + means of size [sample, months, assets] + num_months should be 60 - 12, as the windows size is one year 12 months + """ + shared = cuda.shared.array(shape=0, dtype=numba.float32) + shared_buffer_size = shared.size + i = cuda.threadIdx.x + sample_id = cuda.blockIdx.x // num_months + step_id = cuda.blockIdx.x % num_months + start_id = months_starts[step_id] + end_id = months_starts[ + step_id + + window] if step_id + window < months_starts.size else time_len + for a in range(assets): + # copy asset return to shared + for k in range(i, shared_buffer_size, cuda.blockDim.x): + shared[k] = 0 + cuda.syncthreads() + for k in range(i + start_id, end_id, cuda.blockDim.x): + shared[k - start_id] = returns[sample_id, a, k] + cuda.syncthreads() + gpu_sum(shared) + if i == 0: + means[sample_id, step_id, a] = shared[0] / (end_id - start_id) + cuda.syncthreads() + for a in range(assets): + for b in range(a, assets): + # copy asset return to shared + for k in range(i, shared_buffer_size, cuda.blockDim.x): + shared[k] = 0 + cuda.syncthreads() + mean_a = means[sample_id, step_id, a] + mean_b = means[sample_id, step_id, b] + for k in range(i + start_id, end_id, cuda.blockDim.x): + shared[k - start_id] = (returns[sample_id, a, k] - mean_a) * ( + returns[sample_id, b, k] - mean_b) + cuda.syncthreads() + gpu_sum(shared) + if i == 0: + cov[sample_id, step_id, a, b] = shared[0] / (end_id - start_id) + cov[sample_id, step_id, b, a] = shared[0] / (end_id - start_id) + cuda.syncthreads() + # compute distance + for k in range(i, assets*assets, cuda.blockDim.x): + a = k // assets + b = k % assets + if b > a: + var_a = cov[sample_id, step_id, a, a] + var_b = cov[sample_id, step_id, b, b] + cov_ab = cov[sample_id, step_id, a, b] + dis_ab = math.sqrt((1.0 - cov_ab / math.sqrt(var_a * var_b)) / 2.0) + offset = (2 * assets - 1 - a) * a // 2 + (b - a - 1) + shared[offset] = dis_ab + # distance[sample_id, step_id, offset] = dis_ab + cuda.syncthreads() + + # compute distance of the distance + for k in range(i, assets*assets, cuda.blockDim.x): + a = k // assets + b = k % assets + if b > a: + summ = 0.0 + for col_id in range(assets): + if col_id > a: + offset_a = (2 * assets - 1 - a) * a // 2 + (col_id - a - 1) + val_a = shared[offset_a] + elif col_id < a: + offset_a = (2 * assets - 1 - col_id) * col_id // 2 + ( + a - col_id - 1) + val_a = shared[offset_a] + else: + val_a = 0.0 + if col_id > b: + offset_b = (2 * assets - 1 - b) * b // 2 + (col_id - b - 1) + val_b = shared[offset_b] + elif col_id < b: + offset_b = (2 * assets - 1 - col_id) * col_id // 2 + ( + b - col_id - 1) + val_b = shared[offset_b] + else: + val_b = 0.0 + summ += (val_a - val_b) * (val_a - val_b) + offset = (2 * assets - 1 - a) * a // 2 + (b - a - 1) + distance[sample_id, step_id, offset] = math.sqrt(summ) + + +@cuda.jit +def leverage_for_target_vol(leverage, returns, months_starts, num_months, + window, long_window, + short_window, target_vol): + """ + each block calculate for one rebalancing month, + leverage of shape [sample, months] + returns of shape [sample, time_len] + num_months should be 60 - 12, as the windows size is one year 12 months + """ + # shared = cuda.shared.array(MAX_SHARE, dtype=numba.float64) + shared = cuda.shared.array(shape=0, dtype=numba.float32) + total_samples, time_len = returns.shape + # means = cuda.shared.array(1, dtype=numba.float64) + # sds = cuda.shared.array(2, dtype=numba.float64) + # means = shared[-1:] + # sds = shared[-3:-1] + + annual_const = math.sqrt(252.) + shared_buffer_size = shared.size + i = cuda.threadIdx.x + sample_id = cuda.blockIdx.x // num_months + step_id = cuda.blockIdx.x % num_months + start_id = months_starts[step_id] + end_id = months_starts[ + step_id + + window] if step_id + window < months_starts.size else time_len + + # calculate the means for the long window + start_id = end_id - long_window + # copy asset return to shared + for k in range(i, shared_buffer_size, cuda.blockDim.x): + shared[k] = 0 + cuda.syncthreads() + for k in range(i + start_id, end_id, cuda.blockDim.x): + shared[k - start_id] = returns[sample_id, k] + cuda.syncthreads() + + gpu_sum(shared) + cuda.syncthreads() + means = shared[0] / (end_id - start_id) + + # calculate the std for the long window + # copy asset return to shared + for k in range(i, shared_buffer_size, cuda.blockDim.x): + shared[k] = 0 + cuda.syncthreads() + for k in range(i + start_id, end_id, cuda.blockDim.x): + shared[k - start_id] = (returns[sample_id, k] - + means) * (returns[sample_id, k] - means) + + cuda.syncthreads() + gpu_sum(shared) + + sd_long = math.sqrt(shared[0] / (end_id - start_id)) + + # calculate the means for the short window + start_id = end_id - short_window + # copy asset return to shared + for k in range(i, shared_buffer_size, cuda.blockDim.x): + shared[k] = 0 + cuda.syncthreads() + for k in range(i + start_id, end_id, cuda.blockDim.x): + shared[k - start_id] = returns[sample_id, k] + cuda.syncthreads() + gpu_sum(shared) + + cuda.syncthreads() + means = shared[0] / (end_id - start_id) + cuda.syncthreads() + + # calculate the std for the short window + for k in range(i, shared_buffer_size, cuda.blockDim.x): + shared[k] = 0 + cuda.syncthreads() + for k in range(i + start_id, end_id, cuda.blockDim.x): + shared[k - start_id] = (returns[sample_id, k] - means) * ( + returns[sample_id, k] - means) + cuda.syncthreads() + gpu_sum(shared) + + sd_short = math.sqrt(shared[0] / (end_id - start_id)) + if i == 0: + lev = target_vol / (max(sd_short, sd_long)*annual_const) + leverage[sample_id, step_id] = lev + + +@cuda.jit(device=True) +def find(x, parent): + p = x + + while parent[x] != x: + x = parent[x] + + while parent[p] != x: + p, parent[p] = parent[p], x + return x + + +@cuda.jit(device=True) +def label(Z, n, parent): + """Correctly label clusters in unsorted dendrogram.""" + next_label = n + for i in range(n - 1): + x, y = int(Z[i, 0]), int(Z[i, 1]) + x_root, y_root = find(x, parent), find(y, parent) + if x_root < y_root: + Z[i, 0], Z[i, 1] = x_root, y_root + else: + Z[i, 0], Z[i, 1] = y_root, x_root + parent[x_root] = next_label + parent[y_root] = next_label + next_label += 1 + + +@cuda.jit(device=True) +def mergeSort(a, L, R): + current_size = 1 + # Outer loop for traversing Each + # sub array of current_size + while current_size < len(a): + left = 0 + # Inner loop for merge call + # in a sub array + # Each complete Iteration sorts + # the iterating sub array + while left < len(a)-1: + # mid index = left index of + # sub array + current sub + # array size - 1 + mid = min((left + current_size - 1), (len(a)-1)) + # (False result,True result) + # [Condition] Can use current_size + # if 2 * current_size < len(a)-1 + # else len(a)-1 + if 2 * current_size + left - 1 > len(a)-1: + right = len(a) - 1 + else: + right = 2 * current_size + left - 1 + # Merge call for each sub array + merge(a, left, mid, right, L, R) + left = left + current_size*2 + # Increasing sub array size by + # multiple of 2 + current_size = 2 * current_size + + +@cuda.jit(device=True) +def merge(a, ll, m, r, L, R): + n1 = m - ll + 1 + n2 = r - m + L[:, :] = 0 + R[:, :] = 0 + for i in range(0, n1): + L[i, 0] = a[ll + i, 0] + L[i, 1] = a[ll + i, 1] + L[i, 2] = a[ll + i, 2] + for i in range(0, n2): + R[i, 0] = a[m + i + 1, 0] + R[i, 1] = a[m + i + 1, 1] + R[i, 2] = a[m + i + 1, 2] + + i, j, k = 0, 0, ll + while i < n1 and j < n2: + if L[i, 2] > R[j, 2]: + a[k, 0] = R[j, 0] + a[k, 1] = R[j, 1] + a[k, 2] = R[j, 2] + j += 1 + else: + a[k, 0] = L[i, 0] + a[k, 1] = L[i, 1] + a[k, 2] = L[i, 2] + i += 1 + k += 1 + + while i < n1: + a[k, 0] = L[i, 0] + a[k, 1] = L[i, 1] + a[k, 2] = L[i, 2] + i += 1 + k += 1 + + while j < n2: + a[k, 0] = R[j, 0] + a[k, 1] = R[j, 1] + a[k, 2] = R[j, 2] + j += 1 + k += 1 + + +@cuda.jit(device=True) +def condensed_index(n, i, j): + """ + Calculate the condensed index of element (i, j) in an n x n condensed + matrix. + """ + if i < j: + return n * i - (i * (i + 1) // 2) + (j - i - 1) + elif i > j: + return n * j - (j * (j + 1) // 2) + (i - j - 1) + + +@cuda.jit(device=True) +def my_seriation(Z, N, stack, result): + """Returns the order implied by a hierarchical tree (dendrogram). + + :param Z: A hierarchical tree (dendrogram). + :param N: The number of points given to the clustering process. + :param cur_index: The position in the tree for the recursive traversal. + + :return: The order implied by the hierarchical tree Z. + """ + o_point = -1 + stack_point = 0 + stack[0] = N + N - 2 + + while stack_point >= 0: + v = stack[stack_point] + stack_point -= 1 + left = int(Z[v - N, 0]) + right = int(Z[v - N, 1]) + + if right >= N: + stack_point += 1 + stack[stack_point] = right + + if left >= N: + stack_point += 1 + stack[stack_point] = left + + if left < N: + o_point += 1 + result[o_point] = left + + if right < N: + o_point += 1 + result[o_point] = right + return result + + +@cuda.jit +def single_linkage(output, orders, dists, num_months, n): + """ + dists is shape [sample, months, distance] + output is of shape [sample, months, n-1, 3] + """ + large = 1e200 + merged = cuda.shared.array(MAX_ASSETS, dtype=numba.int64) + merged[:] = 0 + D = cuda.shared.array(MAX_ASSETS, dtype=numba.float64) + D[:] = large + L = cuda.shared.array(shape=(MAX_ASSETS, 3), dtype=numba.float64) + R = cuda.shared.array(shape=(MAX_ASSETS, 3), dtype=numba.float64) + parent = cuda.shared.array(PARENT_MAX_ASSETS, dtype=numba.int64) + for k in range(PARENT_MAX_ASSETS): + parent[k] = k + stack = cuda.shared.array(MAX_ASSETS, dtype=numba.int64) + sample_id = cuda.blockIdx.x // num_months + step_id = cuda.blockIdx.x % num_months + x = 0 + for k in range(n - 1): + current_min = large + merged[x] = 1 + for i in range(n): + if merged[i] == 1: + continue + dis_id = int(condensed_index(n, x, i)) + + dist = dists[sample_id, step_id, dis_id] + # print(k, i, dis_id, dist, D[i]) + if D[i] > dist: + D[i] = dist + + if D[i] < current_min: + y = i + current_min = D[i] + + output[sample_id, step_id, k, 0] = x + output[sample_id, step_id, k, 1] = y + output[sample_id, step_id, k, 2] = current_min + x = y + # # Sort Z by cluster distances. + mergeSort(output[sample_id, step_id], L, R) + # # Find correct cluster labels and compute cluster sizes inplace. + label(output[sample_id, step_id], n, parent) + my_seriation(output[sample_id, step_id], n, + stack, orders[sample_id, step_id]) + + +@cuda.jit +def HRP_weights(weights, covariances, res_order, N, num_months): + """ + covariances, [samples, number, N, N] + res_order, [sample, number, N] + """ + start_pos = cuda.shared.array(MAX_ASSETS, dtype=numba.int64) + end_pos = cuda.shared.array(MAX_ASSETS, dtype=numba.int64) + old_start_pos = cuda.shared.array(MAX_ASSETS, dtype=numba.int64) + old_end_pos = cuda.shared.array(MAX_ASSETS, dtype=numba.int64) + parity_w = cuda.shared.array(MAX_ASSETS, dtype=numba.float64) + + sample_id = cuda.blockIdx.x // num_months + step_id = cuda.blockIdx.x % num_months + + cluster_num = 1 + old_cluster_num = 1 + start_pos[0] = 0 + end_pos[0] = N + old_start_pos[0] = 0 + old_end_pos[0] = N + + while cluster_num > 0: + cluster_num = 0 + for i in range(old_cluster_num): + start = old_start_pos[i] + end = old_end_pos[i] + half = (end - start) // 2 + if half > 0: + start_pos[cluster_num] = start + end_pos[cluster_num] = start + half + cluster_num += 1 + if half > 0: + start_pos[cluster_num] = start + half + end_pos[cluster_num] = end + cluster_num += 1 + for subcluster in range(0, cluster_num, 2): + left_s = start_pos[subcluster] + left_e = end_pos[subcluster] + right_s = start_pos[subcluster+1] + right_e = end_pos[subcluster+1] + summ = 0.0 + for i in range(left_s, left_e): + idd = res_order[sample_id, step_id, i] + parity_w[i - left_s] = 1.0 / \ + covariances[sample_id, step_id, idd, idd] + # print('parity', i, parity_w[i - left_s]) + summ += parity_w[i - left_s] + + for i in range(left_s, left_e): + parity_w[i - left_s] *= 1.0 / summ + + summ = 0.0 + for i in range(left_s, left_e): + idd_x = res_order[sample_id, step_id, i] + for j in range(left_s, left_e): + idd_y = res_order[sample_id, step_id, j] + summ += parity_w[i - left_s]*parity_w[j - left_s] * \ + covariances[sample_id, step_id, idd_x, idd_y] + left_cluster_var = summ + + summ = 0.0 + for i in range(right_s, right_e): + idd = res_order[sample_id, step_id, i] + parity_w[i - right_s] = 1.0 / \ + covariances[sample_id, step_id, idd, idd] + summ += parity_w[i - right_s] + + for i in range(right_s, right_e): + parity_w[i - right_s] *= 1.0 / summ + + summ = 0.0 + for i in range(right_s, right_e): + idd_x = res_order[sample_id, step_id, i] + for j in range(right_s, right_e): + idd_y = res_order[sample_id, step_id, j] + summ += parity_w[i - right_s]*parity_w[j - right_s] * \ + covariances[sample_id, step_id, idd_x, idd_y] + right_cluster_var = summ + + alloc_factor = 1 - left_cluster_var / \ + (left_cluster_var + right_cluster_var) + + for i in range(left_s, left_e): + idd = res_order[sample_id, step_id, i] + weights[sample_id, step_id, idd] *= alloc_factor + for i in range(right_s, right_e): + idd = res_order[sample_id, step_id, i] + weights[sample_id, step_id, idd] *= 1 - alloc_factor + for i in range(cluster_num): + old_start_pos[i] = start_pos[i] + old_end_pos[i] = end_pos[i] + old_cluster_num = cluster_num + + +@cuda.jit +def drawdown_kernel(drawdown, returns, months_starts, window): + """ + returns, [samples, assets, length] + drawdown, [smaples, months, assets] + num_months should be 60 - 12, as the windows size is one year 12 months + """ + # shared = cuda.shared.array(shape=0, dtype=numba.float64) + # shared_buffer_size = shared.size + total_samples, assets, time_len = returns.shape + _, num_months, _ = drawdown.shape + i = cuda.threadIdx.x + sample_id = cuda.blockIdx.x // num_months + step_id = cuda.blockIdx.x % num_months + start_id = months_starts[step_id] + end_id = months_starts[ + step_id + + window] if step_id + window < months_starts.size else time_len + for a in range(i, assets, cuda.blockDim.x): + cumsum = 0.0 + currentMax = 1.0 + minDrawDown = 100.0 + + for k in range(start_id, end_id): + cumsum += returns[sample_id, a, k] + value = math.exp(cumsum) + if value > currentMax: + currentMax = value + currDrawdown = value / currentMax - 1.0 + if currDrawdown < minDrawDown: + minDrawDown = currDrawdown + drawdown[sample_id, step_id, a] = -minDrawDown + + +def get_drawdown(log_return, total_samples, negative=False, window=12): + first_sample = log_return['sample_id'].min().item() + all_dates = log_return[first_sample == log_return['sample_id']]['date'] + all_dates = all_dates.reset_index(drop=True) + months_start = _get_month_start_pos(all_dates) + log_return_ma = _get_log_return_matrix(total_samples, log_return) + if negative: + log_return_ma = -1.0 * log_return_ma + _, assets, timelen = log_return_ma.shape + number_of_threads = 128 + num_months = len(months_start) - window + if num_months == 0: # use all the months to compute + num_months = 1 + number_of_blocks = num_months * total_samples + drawdown = cupy.zeros((total_samples, num_months, assets)) + drawdown_kernel[(number_of_blocks, ), + (number_of_threads, )](drawdown, log_return_ma, + months_start, window) + return drawdown, all_dates + + +def get_drawdown_metric(log_return, total_samples): + first_sample = log_return['sample_id'].min().item() + all_dates = log_return[first_sample == log_return['sample_id']]['date'] + all_dates = all_dates.reset_index(drop=True) + months_start = _get_month_start_pos(all_dates) + # log_return_ma = _get_log_return_matrix(total_samples, log_return) + port_return_ma = log_return['portfolio'].values.reshape( + total_samples, 1, -1) + _, assets, timelen = port_return_ma.shape + number_of_threads = 128 + window = len(months_start) + num_months = len(months_start) - window + if num_months == 0: # use all the months to compute + num_months = 1 + number_of_blocks = num_months * total_samples + drawdown = cupy.zeros((total_samples, num_months, assets)) + drawdown_kernel[(number_of_blocks, ), + (number_of_threads, )](drawdown, port_return_ma, + months_start, window) + return drawdown, all_dates + + +def get_weights(total_samples, cov, orders, num_months, assets): + + number_of_threads = 1 + + number_of_blocks = num_months * total_samples + + weights = cupy.ones((total_samples, num_months, assets)) + + HRP_weights[(number_of_blocks,), (number_of_threads,)]( + weights, + cov, + orders, + assets, + num_months) + return weights + + +def get_orders(total_samples, num_months, assets, distance): + number_of_threads = 1 + number_of_blocks = num_months * total_samples + + output = cupy.zeros((total_samples, num_months, assets-1, 3)) + orders = cupy.zeros((total_samples, num_months, assets), dtype=cupy.int64) + single_linkage[(number_of_blocks,), (number_of_threads,)]( + output, + orders, + distance, + num_months, assets) + return orders + + +def run_bootstrap(v, number_samples=2, block_size=60, number_of_threads=256): + """ + @v, stock price matrix. [time, stocks] + @number_samples, number of samples + @block_size, sample block size + """ + length, assets = v.shape # get the time length and the number of assets, + init_prices = v[0, :].reshape(1, -1, 1) # initial prices for all assets + v = cupy.log(v) + # compute the price difference, dimension of [length -1, assets] + ref = cupy.diff(v, axis=0) + # output results + output = cupy.zeros((number_samples, assets, length)) + # sample starting position, exclusive + sample_range = length - block_size + # number of positions to sample to cover the whole seq length + num_positions = (length - 2) // block_size + 1 + sample_positions = cupy.random.randint( + 0, sample_range, + num_positions * number_samples) # compute random starting posistion + number_of_blocks = len(sample_positions) + boot_strap[(number_of_blocks,), (number_of_threads,)]( + output, + ref.T, + block_size, + num_positions, + sample_positions) + # reshape the results [number_samples, number assets, time] + # output = output.reshape(number_samples, assets, length) + # convert it into prices + return (cupy.exp(output.cumsum(axis=2)) * init_prices) + + +def _get_month_start_pos(all_dates): + months_id = all_dates.dt.year*12 + (all_dates.dt.month-1) + months_id = months_id - months_id.min() + # months_id = months_id[1:] + month_start = months_id - months_id.shift(1) + month_start[0] = 1 + months_start = cupy.where((month_start == 1).values)[0] + # print('month start position', months_start) + return months_start + + +def _get_log_return_matrix(total_samples, log_return): + col = list(log_return.columns) + col.remove('date') + col.remove('sample_id') + col.remove('year') + col.remove('month') + log_return_ma = log_return[col].values + log_return_ma = log_return_ma.reshape(total_samples, -1, len(col)) + log_return_ma = log_return_ma.transpose((0, 2, 1)) + # sample #, assets dim, time length + return log_return_ma + + +def compute_cov_distance(total_samples, + log_return, + window=12): + first_sample = log_return['sample_id'].min().item() + all_dates = log_return[first_sample == log_return['sample_id']]['date'] + all_dates = all_dates.reset_index(drop=True) + months_start = _get_month_start_pos(all_dates) + log_return_ma = _get_log_return_matrix(total_samples, log_return) + _, assets, timelen = log_return_ma.shape + number_of_threads = 256 + num_months = len(months_start) - window + # print('num', num_months, len(months_start), window) + if num_months == 0: # this case, use all the data to compute + num_months = 1 + number_of_blocks = num_months * total_samples + means = cupy.zeros((total_samples, num_months, assets)) + cov = cupy.zeros((total_samples, num_months, assets, assets)) + distance = cupy.zeros( + (total_samples, num_months, (assets - 1) * assets // 2)) + + compute_cov[(number_of_blocks, ), (number_of_threads, ), 0, + 256 * MAX_YEARS * 8](means, cov, distance, log_return_ma, + months_start, num_months, assets, timelen, + window) + return means, cov, distance, all_dates + + +def compute_leverage(total_samples, + log_return, + long_window=59, + short_window=19, + target_vol=0.05): + first_sample = log_return['sample_id'].min().item() + all_dates = log_return[first_sample == log_return['sample_id']]['date'] + all_dates = all_dates.reset_index(drop=True) + months_start = _get_month_start_pos(all_dates) + for window in range(len(months_start)): + if (months_start[window] - long_window) > 0: + break + port_return_ma = log_return['portfolio'].values.reshape(total_samples, -1) + number_of_threads = 256 + num_months = len(months_start) - window + if num_months == 0: # this case, use all the data to compute + num_months = 1 + number_of_blocks = num_months * total_samples + leverage = cupy.zeros((total_samples, num_months)) + leverage_for_target_vol[(number_of_blocks, ), (number_of_threads, ), 0, + 256 * MAX_YEARS * 8](leverage, port_return_ma, + months_start, num_months, + window, long_window, + short_window, target_vol) + return leverage, all_dates, window diff --git a/gQuant/plugins/hrp_plugin/greenflow_hrp_plugin/leverageNode.py b/gQuant/plugins/hrp_plugin/greenflow_hrp_plugin/leverageNode.py new file mode 100644 index 00000000..ca333193 --- /dev/null +++ b/gQuant/plugins/hrp_plugin/greenflow_hrp_plugin/leverageNode.py @@ -0,0 +1,145 @@ +""" + //////////////////////////////////////////////////////////////////////////// + // + // Copyright (C) NVIDIA Corporation. All rights reserved. + // + // NVIDIA Sample Code + // + // Please refer to the NVIDIA end user license agreement (EULA) associated + // with this source code for terms and conditions that govern your use of + // this software. Any use, reproduction, disclosure, or distribution of + // this software and related documentation outside the terms of the EULA + // is strictly prohibited. + // + //////////////////////////////////////////////////////////////////////////// +""" + +from greenflow.dataframe_flow import ConfSchema, PortsSpecSchema +from greenflow.dataframe_flow.template_node_mixin import TemplateNodeMixin +from greenflow.dataframe_flow.metaSpec import MetaDataSchema +from greenflow.dataframe_flow import Node +from .kernels import compute_leverage +import cupy +import cudf + + +class LeverageNode(TemplateNodeMixin, Node): + + def init(self): + TemplateNodeMixin.init(self) + self.delayed_process = True + self.infer_meta = False + self.LEVERAGE_DF = 'lev_df' + self.INPUT_PORT_NAME = "in" + port_type = PortsSpecSchema.port_type + port_inports = { + self.INPUT_PORT_NAME: { + port_type: [ + "pandas.DataFrame", "cudf.DataFrame", + "dask_cudf.DataFrame", "dask.dataframe.DataFrame" + ] + } + } + port_outports = { + self.LEVERAGE_DF: { + port_type: "${port:in}" + }, + } + + sub_dict = { + "date": "datetime64[ns]", + 'sample_id': 'int64', + 'year': 'int16', + 'month': 'int16', + 'portfolio': "float64", + } + + meta_inports = { + self.INPUT_PORT_NAME: sub_dict + } + meta_outports = { + self.LEVERAGE_DF: { + MetaDataSchema.META_OP: MetaDataSchema.META_OP_RETENTION, + MetaDataSchema.META_DATA: sub_dict + } + } + self.template_ports_setup(in_ports=port_inports, + out_ports=port_outports) + self.template_meta_setup( + in_ports=meta_inports, + out_ports=meta_outports + ) + + def conf_schema(self): + json = { + "title": "Compute the Leverage to match the target volatility", + "type": "object", + "properties": { + "target_vol": { + 'type': "number", + "title": "Target Volativity", + "description": """The target volatility to match""", + "default": 0.05 + }, + "long_window": { + 'type': "integer", + "title": "Long window size", + "description": """the large number of days in the past to compute + volatility""", + "default": 59 + }, + "short_window": { + 'type': "integer", + "title": "Short window size", + "description": """the small number of days in the past to compute + volatility""", + "default": 19 + } + }, + } + + ui = { + } + return ConfSchema(json=json, ui=ui) + + def process(self, inputs): + df = inputs[self.INPUT_PORT_NAME] + all_sample_ids = df['sample_id'].unique() + total_samples = len(all_sample_ids) + lev, all_dates, window = compute_leverage(total_samples, df, + **self.conf) + + total_samples, num_months = lev.shape + + months_id = all_dates.dt.year*12 + (all_dates.dt.month-1) + months_id = months_id - months_id.min() + mid = (cupy.arange(months_id.max() + 1) + + (all_dates.dt.month - 1)[0])[window:] + + minyear = all_dates.dt.year.min() + if len(mid) == 0: + mid = cupy.array([0]) + months = mid % 12 + years = mid // 12 + minyear + + output = {} + df_lev = cudf.DataFrame( + {'leverage': lev.reshape(total_samples * num_months)}) + df_lev['year'] = cupy.concatenate( + [years]*total_samples).astype(cupy.int16) + df_lev['month'] = cupy.concatenate( + [months]*total_samples).astype(cupy.int16) + df_lev['sample_id'] = cupy.repeat(cupy.arange( + total_samples) + all_sample_ids.min(), len(mid)) + + date_df = df[['date', 'sample_id', 'year', 'month', 'portfolio']] + expand_table = date_df.reset_index().merge( + df_lev, on=['sample_id', 'year', 'month'], + how='left').set_index('index') + expand_table['portfolio'] = expand_table[ + 'portfolio'] * expand_table['leverage'] + expand_table = expand_table.dropna()[[ + 'date', 'sample_id', 'year', 'month', 'portfolio' + ]] + output.update({self.LEVERAGE_DF: expand_table}) + return output diff --git a/gQuant/plugins/hrp_plugin/greenflow_hrp_plugin/loadCsvNode.py b/gQuant/plugins/hrp_plugin/greenflow_hrp_plugin/loadCsvNode.py new file mode 100644 index 00000000..2e4199d3 --- /dev/null +++ b/gQuant/plugins/hrp_plugin/greenflow_hrp_plugin/loadCsvNode.py @@ -0,0 +1,117 @@ +""" + //////////////////////////////////////////////////////////////////////////// + // + // Copyright (C) NVIDIA Corporation. All rights reserved. + // + // NVIDIA Sample Code + // + // Please refer to the NVIDIA end user license agreement (EULA) associated + // with this source code for terms and conditions that govern your use of + // this software. Any use, reproduction, disclosure, or distribution of + // this software and related documentation outside the terms of the EULA + // is strictly prohibited. + // + //////////////////////////////////////////////////////////////////////////// +""" + +import cudf +from greenflow.dataframe_flow import Node, MetaData +from greenflow.dataframe_flow import NodePorts, PortsSpecSchema +from greenflow.dataframe_flow.util import get_file_path +from greenflow.dataframe_flow import ConfSchema + + +class LoadCsvNode(Node): + + def ports_setup(self): + input_ports = {} + output_ports = { + 'df_out': { + PortsSpecSchema.port_type: cudf.DataFrame + } + } + return NodePorts(inports=input_ports, outports=output_ports) + + def conf_schema(self): + json = { + "title": "Load stock data", + "type": "object", + "properties": { + "csvfile": { + "type": "string", + "description": "csv tick data" + }, + "17assets": { + "type": "boolean", + "description": "17 assets dataset" + } + }, + "required": ["csvfile"], + } + + ui = { + "csvfile": {"ui:widget": "CsvFileSelector"} + } + return ConfSchema(json=json, ui=ui) + + def init(self): + pass + + def meta_setup(self): + df_out_10 = { + 'date': 'date', + 'AAA': 'float64', + 'BBB': 'float64', + 'CCC': 'float64', + 'DDD': 'float64', + 'EEE': 'float64', + 'FFF': 'float64', + 'GGG': 'float64', + 'HHH': 'float64', + 'III': 'float64', + 'JJJ': 'float64', + } + + df_out_17 = { + 'date': 'date', + 'BZA Index (Equities)': 'float64', + 'CLA Comdty (Commodities)': 'float64', + 'CNA Comdty (Fixed Income)': 'float64', + 'ESA Index (Equities)': 'float64', + 'G A Comdty (Fixed Income)': 'float64', + 'GCA Comdty (Commodities)': 'float64', + 'HIA Index (Equities)': 'float64', + 'NKA Index (Equities)': 'float64', + 'NQA Index (Equities)': 'float64', + 'RXA Comdty (Fixed Income)': 'float64', + 'SIA Comdty (Commodities)': 'float64', + 'SMA Index (Equities)': 'float64', + 'TYA Comdty (Fixed Income)': 'float64', + 'VGA Index (Equities)': 'float64', + 'XMA Comdty (Fixed Income)': 'float64', + 'XPA Index (Equities)': 'float64', + 'Z A Index (Equities)': 'float64', + } + assets_17 = self.conf.get('17assets', False) + columns_out = { + } + columns_out['df_out'] = df_out_17 if assets_17 else df_out_10 + return MetaData(inports={}, outports=columns_out) + + def process(self, inputs): + import dask.distributed + try: + client = dask.distributed.client.default_client() + except ValueError: + from dask_cuda import LocalCUDACluster + cluster = LocalCUDACluster() + from dask.distributed import Client + client = Client(cluster) # noqa + print('start new Cluster') + filename = get_file_path(self.conf['csvfile']) + df = cudf.read_csv(filename, parse_dates=[0]) + df.columns = ['date']+[c for c in df.columns][1:] + output = {} + if self.outport_connected('df_out'): + output.update({'df_out': df}) + return output diff --git a/gQuant/plugins/hrp_plugin/greenflow_hrp_plugin/logReturnNode.py b/gQuant/plugins/hrp_plugin/greenflow_hrp_plugin/logReturnNode.py new file mode 100644 index 00000000..68bb8958 --- /dev/null +++ b/gQuant/plugins/hrp_plugin/greenflow_hrp_plugin/logReturnNode.py @@ -0,0 +1,106 @@ +""" + //////////////////////////////////////////////////////////////////////////// + // + // Copyright (C) NVIDIA Corporation. All rights reserved. + // + // NVIDIA Sample Code + // + // Please refer to the NVIDIA end user license agreement (EULA) associated + // with this source code for terms and conditions that govern your use of + // this software. Any use, reproduction, disclosure, or distribution of + // this software and related documentation outside the terms of the EULA + // is strictly prohibited. + // + //////////////////////////////////////////////////////////////////////////// +""" + +from greenflow.dataframe_flow import ConfSchema, PortsSpecSchema +from greenflow.dataframe_flow.template_node_mixin import TemplateNodeMixin +from greenflow.dataframe_flow import Node +from greenflow.dataframe_flow.metaSpec import MetaDataSchema + + +class LogReturnNode(TemplateNodeMixin, Node): + + def init(self): + TemplateNodeMixin.init(self) + self.delayed_process = True + self.infer_meta = False + self.INPUT_PORT_NAME = "in" + self.OUTPUT_PORT_NAME = "out" + port_type = PortsSpecSchema.port_type + port_inports = { + self.INPUT_PORT_NAME: { + port_type: [ + "pandas.DataFrame", "cudf.DataFrame", + "dask_cudf.DataFrame", "dask.dataframe.DataFrame" + ] + } + } + port_outports = { + self.OUTPUT_PORT_NAME: { + port_type: "${port:in}" + }, + } + required = { + "date": "datetime64[ns]", + 'sample_id': 'int64', + 'year': 'int16', + 'month': 'int16', + } + meta_inports = { + self.INPUT_PORT_NAME: required + } + meta_outports = { + self.OUTPUT_PORT_NAME: { + MetaDataSchema.META_OP: MetaDataSchema.META_OP_ADDITION, + MetaDataSchema.META_REF_INPUT: self.INPUT_PORT_NAME, + MetaDataSchema.META_DATA: {} + } + } + self.template_ports_setup(in_ports=port_inports, + out_ports=port_outports) + self.template_meta_setup( + in_ports=meta_inports, + out_ports=meta_outports + ) + + def conf_schema(self): + json = { + "title": "Compute the log return dataframe", + "type": "object", + "properties": { + }, + } + + ui = { + } + return ConfSchema(json=json, ui=ui) + + def process(self, inputs): + df = inputs[self.INPUT_PORT_NAME] + # df = df.drop('datetime', axis=1) + output = {} + col = list(df.columns) + col.remove('date') + col.remove('sample_id') + col.remove('year') + col.remove('month') + + logprice = df[col].log() + log_return = logprice - logprice.shift(1) + log_return['date'] = df['date'] + log_return['sample_id'] = df['sample_id'] + log_return['year'] = df['year'] + log_return['month'] = df['month'] + log_return['corrupted'] = df['sample_id'] - \ + df['sample_id'].shift(1) + log_return = log_return.dropna() + corrupted = log_return['corrupted'] == 1 + # print('corruped rows', corrupted.sum()) + log_return[corrupted] = None + log_return = log_return.dropna() + log_return = log_return.drop('corrupted', axis=1) + + output.update({self.OUTPUT_PORT_NAME: log_return}) + return output diff --git a/gQuant/plugins/hrp_plugin/greenflow_hrp_plugin/maxDrawdownNode.py b/gQuant/plugins/hrp_plugin/greenflow_hrp_plugin/maxDrawdownNode.py new file mode 100644 index 00000000..903fe0e5 --- /dev/null +++ b/gQuant/plugins/hrp_plugin/greenflow_hrp_plugin/maxDrawdownNode.py @@ -0,0 +1,135 @@ +""" + //////////////////////////////////////////////////////////////////////////// + // + // Copyright (C) NVIDIA Corporation. All rights reserved. + // + // NVIDIA Sample Code + // + // Please refer to the NVIDIA end user license agreement (EULA) associated + // with this source code for terms and conditions that govern your use of + // this software. Any use, reproduction, disclosure, or distribution of + // this software and related documentation outside the terms of the EULA + // is strictly prohibited. + // + //////////////////////////////////////////////////////////////////////////// +""" + +from greenflow.dataframe_flow import ConfSchema, PortsSpecSchema +from greenflow.dataframe_flow.template_node_mixin import TemplateNodeMixin +from greenflow.dataframe_flow import Node +from .kernels import get_drawdown +import cupy +import cudf + + +class MaxDrawdownNode(TemplateNodeMixin, Node): + + def init(self): + TemplateNodeMixin.init(self) + self.delayed_process = True + self.infer_meta = False + self.INPUT_PORT_NAME = 'logreturn_df' + self.OUTPUT_PORT_NAME = "out" + port_type = PortsSpecSchema.port_type + port_inports = { + self.INPUT_PORT_NAME: { + port_type: [ + "pandas.DataFrame", "cudf.DataFrame", + "dask_cudf.DataFrame", "dask.dataframe.DataFrame" + ] + } + } + port_outports = { + self.OUTPUT_PORT_NAME: { + port_type: "${port:logreturn_df}" + }, + } + self.template_ports_setup(in_ports=port_inports, + out_ports=port_outports) + + def conf_schema(self): + json = { + "title": "Compute the Maximum Drawdown Matrix Dataframe", + "type": "object", + "properties": { + "window": { + 'type': "integer", + "title": "Window size", + "description": """the number of months used to compute the + distance and vairance""" + }, + "negative": { + 'type': "boolean", + "title": "Negative return", + "description": """Compute + max drawdown on negative return""", + "default": False + } + + }, + "required": ["window"], + } + + ui = { + } + return ConfSchema(json=json, ui=ui) + + def update(self): + TemplateNodeMixin.update(self) + meta_outports = self.template_meta_setup().outports + meta_inports = self.template_meta_setup().inports + sub_dict = { + 'year': 'int16', + 'month': 'int16', + 'sample_id': 'int64', + } + required = { + "date": "datetime64[ns]", + } + required.update(sub_dict) + meta_inports[self.INPUT_PORT_NAME] = required + json_drawdown = {} + input_meta = self.get_input_meta() + if self.INPUT_PORT_NAME in input_meta: + assets = len(input_meta[self.INPUT_PORT_NAME]) - 4 + for i in range(assets): + json_drawdown[i] = 'float64' + json_drawdown.update(sub_dict) + meta_outports[self.OUTPUT_PORT_NAME] = json_drawdown + self.template_meta_setup( + in_ports=meta_inports, + out_ports=meta_outports + ) + + def process(self, inputs): + df = inputs[self.INPUT_PORT_NAME] + all_sample_ids = df['sample_id'].unique() + total_samples = len(all_sample_ids) + window = self.conf['window'] + negative = self.conf.get("negative", False) + drawdown, all_dates = get_drawdown(df, total_samples, + negative=negative, window=window) + + total_samples, num_months, assets = drawdown.shape + + months_id = all_dates.dt.year*12 + (all_dates.dt.month-1) + months_id = months_id - months_id.min() + mid = (cupy.arange(months_id.max() + 1) + + (all_dates.dt.month - 1)[0])[window:] + minyear = all_dates.dt.year.min() + if len(mid) == 0: + mid = cupy.array([0]) + months = mid % 12 + years = mid // 12 + minyear + + output = {} + df_drawdown = cudf.DataFrame( + drawdown.reshape(total_samples*num_months, -1)) + df_drawdown['year'] = cupy.concatenate( + [years]*total_samples).astype(cupy.int16) + df_drawdown['month'] = cupy.concatenate( + [months]*total_samples).astype(cupy.int16) + df_drawdown['sample_id'] = cupy.repeat(cupy.arange( + total_samples) + all_sample_ids.min(), len(mid)) + output.update({self.OUTPUT_PORT_NAME: df_drawdown}) + return output diff --git a/gQuant/plugins/hrp_plugin/greenflow_hrp_plugin/mergeNode.py b/gQuant/plugins/hrp_plugin/greenflow_hrp_plugin/mergeNode.py new file mode 100644 index 00000000..db169427 --- /dev/null +++ b/gQuant/plugins/hrp_plugin/greenflow_hrp_plugin/mergeNode.py @@ -0,0 +1,130 @@ +""" + //////////////////////////////////////////////////////////////////////////// + // + // Copyright (C) NVIDIA Corporation. All rights reserved. + // + // NVIDIA Sample Code + // + // Please refer to the NVIDIA end user license agreement (EULA) associated + // with this source code for terms and conditions that govern your use of + // this software. Any use, reproduction, disclosure, or distribution of + // this software and related documentation outside the terms of the EULA + // is strictly prohibited. + // + //////////////////////////////////////////////////////////////////////////// +""" + +from greenflow.dataframe_flow import Node +from greenflow.dataframe_flow.portsSpecSchema import ConfSchema +from greenflow.dataframe_flow.portsSpecSchema import PortsSpecSchema +from greenflow.dataframe_flow.template_node_mixin import TemplateNodeMixin +import cudf + + +class MergeNode(TemplateNodeMixin, Node): + + def init(self): + TemplateNodeMixin.init(self) + self.INPUT_PORT_LEFT_NAME = 'left' + self.INPUT_PORT_RIGHT_NAME = 'right' + self.OUTPUT_PORT_NAME = 'merged' + self.delayed_process = True + self.infer_meta = False + port_type = PortsSpecSchema.port_type + port_inports = { + self.INPUT_PORT_LEFT_NAME: { + port_type: [ + "pandas.DataFrame", "cudf.DataFrame", + "dask_cudf.DataFrame", "dask.dataframe.DataFrame" + ] + }, + self.INPUT_PORT_RIGHT_NAME: { + port_type: [ + "pandas.DataFrame", "cudf.DataFrame", + "dask_cudf.DataFrame", "dask.dataframe.DataFrame" + ] + } + } + port_outports = { + self.OUTPUT_PORT_NAME: { + port_type: "${port:left}" + }, + } + self.template_ports_setup(in_ports=port_inports, + out_ports=port_outports) + + def update(self): + TemplateNodeMixin.update(self) + meta_outports = self.template_meta_setup().outports + meta_inports = self.template_meta_setup().inports + cols_required = {} + input_meta = self.get_input_meta() + if (self.INPUT_PORT_LEFT_NAME in input_meta + and self.INPUT_PORT_RIGHT_NAME in input_meta): + col_from_left_inport = input_meta[self.INPUT_PORT_LEFT_NAME] + col_from_right_inport = input_meta[self.INPUT_PORT_RIGHT_NAME] + col_from_left_inport.update(col_from_right_inport) + meta_outports[self.OUTPUT_PORT_NAME] = col_from_left_inport + elif self.INPUT_PORT_LEFT_NAME in input_meta: + col_from_left_inport = input_meta[self.INPUT_PORT_LEFT_NAME] + meta_outports[self.OUTPUT_PORT_NAME] = col_from_left_inport + elif self.INPUT_PORT_RIGHT_NAME in input_meta: + col_from_right_inport = input_meta[self.INPUT_PORT_RIGHT_NAME] + meta_outports[self.OUTPUT_PORT_NAME] = col_from_right_inport + else: + meta_outports[self.OUTPUT_PORT_NAME] = {} + meta_inports[self.INPUT_PORT_RIGHT_NAME] = cols_required + meta_inports[self.INPUT_PORT_LEFT_NAME] = cols_required + self.template_meta_setup( + in_ports=meta_inports, + out_ports=meta_outports + ) + + def conf_schema(self): + json = { + "title": "DataFrame Merge configure", + "type": "object", + "description": """Merge two dataframes""", + "properties": { + "column": { + "type": "string", + "description": "column name on which to do the merge" + } + }, + "required": ["column"], + } + input_meta = self.get_input_meta() + if (self.INPUT_PORT_LEFT_NAME in input_meta + and self.INPUT_PORT_RIGHT_NAME in input_meta): + col_left_inport = input_meta[self.INPUT_PORT_LEFT_NAME] + col_right_inport = input_meta[self.INPUT_PORT_RIGHT_NAME] + enums1 = set([col for col in col_left_inport.keys()]) + enums2 = set([col for col in col_right_inport.keys()]) + json['properties']['column']['enum'] = list( + enums1.intersection(enums2)) + ui = {} + return ConfSchema(json=json, ui=ui) + else: + ui = { + "column": {"ui:widget": "text"} + } + return ConfSchema(json=json, ui=ui) + + def process(self, inputs): + """ + left merge the two dataframes in the inputs. the `on column` is defined + in the `column` of the node's conf + + Arguments + ------- + inputs: list + list of input dataframes. + Returns + ------- + dataframe + """ + df1 = inputs[self.INPUT_PORT_LEFT_NAME] + df2 = inputs[self.INPUT_PORT_RIGHT_NAME] + return {self.OUTPUT_PORT_NAME: cudf.merge(df1, df2, + on=self.conf['column'], + how='inner')} diff --git a/gQuant/plugins/hrp_plugin/greenflow_hrp_plugin/nrpWeightNode.py b/gQuant/plugins/hrp_plugin/greenflow_hrp_plugin/nrpWeightNode.py new file mode 100644 index 00000000..cb18ad6b --- /dev/null +++ b/gQuant/plugins/hrp_plugin/greenflow_hrp_plugin/nrpWeightNode.py @@ -0,0 +1,107 @@ +""" + //////////////////////////////////////////////////////////////////////////// + // + // Copyright (C) NVIDIA Corporation. All rights reserved. + // + // NVIDIA Sample Code + // + // Please refer to the NVIDIA end user license agreement (EULA) associated + // with this source code for terms and conditions that govern your use of + // this software. Any use, reproduction, disclosure, or distribution of + // this software and related documentation outside the terms of the EULA + // is strictly prohibited. + // + //////////////////////////////////////////////////////////////////////////// +""" + +from greenflow.dataframe_flow import ConfSchema, PortsSpecSchema +from greenflow.dataframe_flow.template_node_mixin import TemplateNodeMixin +from greenflow.dataframe_flow import Node +import math +import cupy +import cudf + + +class NRPWeightNode(TemplateNodeMixin, Node): + + def init(self): + TemplateNodeMixin.init(self) + self.INPUT_PORT_NAME = 'in' + self.OUTPUT_PORT_NAME = 'out' + self.delayed_process = True + self.infer_meta = False + port_type = PortsSpecSchema.port_type + port_inports = { + self.INPUT_PORT_NAME: { + port_type: [ + "pandas.DataFrame", "cudf.DataFrame", + "dask_cudf.DataFrame", "dask.dataframe.DataFrame" + ] + } + } + port_outports = { + self.OUTPUT_PORT_NAME: { + port_type: "${port:in}" + }, + } + self.template_ports_setup(in_ports=port_inports, + out_ports=port_outports) + + def conf_schema(self): + json = { + "title": "Compute the Sharpe Ratio", + "type": "object", + "properties": { + }, + } + + ui = { + } + return ConfSchema(json=json, ui=ui) + + def update(self): + TemplateNodeMixin.update(self) + meta_outports = self.template_meta_setup().outports + meta_inports = self.template_meta_setup().inports + required = { + 'month': 'int16', + 'year': 'int16', + 'sample_id': 'int64', + } + meta_inports[self.INPUT_PORT_NAME] = required + json = {} + input_meta = self.get_input_meta() + if self.INPUT_PORT_NAME in input_meta: + assets = int(math.sqrt(len(input_meta[self.INPUT_PORT_NAME]) - 3)) + for i in range(assets): + json[i] = 'float64' + json.update(required) + meta_outports[self.OUTPUT_PORT_NAME] = json + self.template_meta_setup( + in_ports=meta_inports, + out_ports=meta_outports + ) + + def process(self, inputs): + df = inputs[self.INPUT_PORT_NAME] + + all_sample_ids = df['sample_id'].unique() + total_samples = len(all_sample_ids) + + # df = df.drop('datetime', axis=1) + input_meta = self.get_input_meta() + if self.INPUT_PORT_NAME in input_meta: + assets = int(math.sqrt(len(input_meta[self.INPUT_PORT_NAME]) - 3)) + output = {} + data_ma = df[list(range(assets*assets))].values + data_ma = data_ma.reshape(total_samples, -1, assets, assets) + diagonzied = cupy.diagonal(data_ma, 0, 2, 3) + diagonzied = cupy.sqrt(1.0 / diagonzied) # inverse variance + diagonzied = diagonzied / diagonzied.sum(axis=2, keepdims=True) + diagonzied = diagonzied.reshape(-1, assets) + weight_df = cudf.DataFrame(diagonzied) + weight_df['month'] = df['month'] + weight_df['year'] = df['year'] + weight_df['sample_id'] = df['sample_id'] + output.update({self.OUTPUT_PORT_NAME: weight_df}) + return output diff --git a/gQuant/plugins/hrp_plugin/greenflow_hrp_plugin/performanceMetricNode.py b/gQuant/plugins/hrp_plugin/greenflow_hrp_plugin/performanceMetricNode.py new file mode 100644 index 00000000..301d1c45 --- /dev/null +++ b/gQuant/plugins/hrp_plugin/greenflow_hrp_plugin/performanceMetricNode.py @@ -0,0 +1,161 @@ +""" + //////////////////////////////////////////////////////////////////////////// + // + // Copyright (C) NVIDIA Corporation. All rights reserved. + // + // NVIDIA Sample Code + // + // Please refer to the NVIDIA end user license agreement (EULA) associated + // with this source code for terms and conditions that govern your use of + // this software. Any use, reproduction, disclosure, or distribution of + // this software and related documentation outside the terms of the EULA + // is strictly prohibited. + // + //////////////////////////////////////////////////////////////////////////// +""" + +from greenflow.dataframe_flow import ConfSchema, PortsSpecSchema +from greenflow.dataframe_flow.metaSpec import MetaDataSchema +from greenflow.dataframe_flow.template_node_mixin import TemplateNodeMixin +from greenflow.dataframe_flow import Node +import math +import datetime +import cudf +import cupy +from .kernels import get_drawdown_metric + + +class PerformanceMetricNode(TemplateNodeMixin, Node): + + def init(self): + TemplateNodeMixin.init(self) + self.delayed_process = True + self.infer_meta = False + self.INPUT_PORT_NAME = 'in' + self.RET_DF = 'ret_df' + self.SD_DF = 'sd_df' + self.SHARPE_DF = 'sharpe_df' + self.CALMAR_DF = 'calmar_df' + self.MDD_DF = 'maxdd_df' + port_type = PortsSpecSchema.port_type + port_inports = { + self.INPUT_PORT_NAME: { + port_type: [ + "pandas.DataFrame", "cudf.DataFrame", + "dask_cudf.DataFrame", "dask.dataframe.DataFrame" + ] + } + } + port_outports = { + self.RET_DF: { + port_type: "${port:in}" + }, + self.SD_DF: { + port_type: "${port:in}" + }, + self.SHARPE_DF: { + port_type: "${port:in}" + }, + self.CALMAR_DF: { + port_type: "${port:in}" + }, + self.MDD_DF: { + port_type: "${port:in}" + } + } + required = { + "date": "datetime64[ns]", + 'sample_id': 'int64', + 'portfolio': 'float64' + } + output = { + 'sample_id': 'int64', + 'portfolio': 'float64', + } + meta_inports = { + self.INPUT_PORT_NAME: required + } + meta_outports = { + self.RET_DF: { + MetaDataSchema.META_OP: MetaDataSchema.META_OP_RETENTION, + MetaDataSchema.META_DATA: output + }, + self.SD_DF: { + MetaDataSchema.META_OP: MetaDataSchema.META_OP_RETENTION, + MetaDataSchema.META_DATA: output + }, + self.SHARPE_DF: { + MetaDataSchema.META_OP: MetaDataSchema.META_OP_RETENTION, + MetaDataSchema.META_DATA: output + }, + self.CALMAR_DF: { + MetaDataSchema.META_OP: MetaDataSchema.META_OP_RETENTION, + MetaDataSchema.META_DATA: output + }, + self.MDD_DF: { + MetaDataSchema.META_OP: MetaDataSchema.META_OP_RETENTION, + MetaDataSchema.META_DATA: output + } + } + self.template_ports_setup(in_ports=port_inports, + out_ports=port_outports) + self.template_meta_setup( + in_ports=meta_inports, + out_ports=meta_outports + ) + + def conf_schema(self): + json = { + "title": "Compute the Sharpe Ratio", + "type": "object", + "properties": { + }, + } + + ui = { + } + return ConfSchema(json=json, ui=ui) + + def process(self, inputs): + df = inputs[self.INPUT_PORT_NAME] + # df = df.drop('datetime', axis=1) + output = {} + df = df.sort_values(['date']) + group_obj = df.groupby('sample_id') + beg = datetime.datetime.utcfromtimestamp( + group_obj.nth(0)['date'].values[0].item() // 1e9) + end = datetime.datetime.utcfromtimestamp( + group_obj.nth(-1)['date'].values[0].item() // 1e9) + total_days = (end - beg).days + total = cudf.exp(group_obj['portfolio'].sum()) + avg_return = cupy.power(total, (365/total_days)) - 1.0 + return_series = cudf.Series(avg_return) + return_series.index = total.index + mean_df = cudf.DataFrame({'portfolio': return_series}) + # mean_df = df.groupby(['sample_id']).agg({'portfolio': 'mean'}) + std_df = df.groupby(['sample_id']).agg( + {'portfolio': 'std'}) * math.sqrt(252) + + if self.outport_connected(self.SHARPE_DF): + # sort by dates + out_df = (mean_df / std_df).reset_index() + output.update({self.SHARPE_DF: out_df}) + if self.outport_connected(self.SD_DF): + output.update({self.SD_DF: std_df.reset_index()}) + if self.outport_connected(self.RET_DF): + output.update({self.RET_DF: mean_df.reset_index()}) + if (self.outport_connected(self.MDD_DF) or + self.outport_connected(self.CALMAR_DF)): + all_sample_ids = df['sample_id'].unique() + total_samples = len(all_sample_ids) + drawdown, all_dates = get_drawdown_metric(df, total_samples) + drawdown_series = cudf.Series( + cupy.abs(drawdown.reshape(total_samples))) + drawdown_series.index = mean_df.index + drawdown_df = cudf.DataFrame({'portfolio': drawdown_series}) + if self.outport_connected(self.MDD_DF): + output.update({self.MDD_DF: drawdown_df.reset_index()}) + if self.outport_connected(self.CALMAR_DF): + calmar_df = (mean_df / drawdown_df).reset_index() + output.update({self.CALMAR_DF: calmar_df}) + return output diff --git a/gQuant/plugins/hrp_plugin/greenflow_hrp_plugin/portfolioNode.py b/gQuant/plugins/hrp_plugin/greenflow_hrp_plugin/portfolioNode.py new file mode 100644 index 00000000..3842359d --- /dev/null +++ b/gQuant/plugins/hrp_plugin/greenflow_hrp_plugin/portfolioNode.py @@ -0,0 +1,163 @@ +""" + //////////////////////////////////////////////////////////////////////////// + // + // Copyright (C) NVIDIA Corporation. All rights reserved. + // + // NVIDIA Sample Code + // + // Please refer to the NVIDIA end user license agreement (EULA) associated + // with this source code for terms and conditions that govern your use of + // this software. Any use, reproduction, disclosure, or distribution of + // this software and related documentation outside the terms of the EULA + // is strictly prohibited. + // + //////////////////////////////////////////////////////////////////////////// +""" + +from greenflow.dataframe_flow import (ConfSchema, PortsSpecSchema) +from greenflow.dataframe_flow.template_node_mixin import TemplateNodeMixin +from greenflow.dataframe_flow import Node +import cudf +import cupy + + +class PortfolioNode(TemplateNodeMixin, Node): + + def init(self): + TemplateNodeMixin.init(self) + self.delayed_process = True + self.infer_meta = False + self.RETURN_IN = 'return_df' + self.WEIGHT_IN = 'weight_df' + self.TRANS_IN = 'transaction_df' + self.OUTPUT_PORT_NAME = 'out' + port_type = PortsSpecSchema.port_type + port_inports = { + self.RETURN_IN: { + port_type: [ + "pandas.DataFrame", "cudf.DataFrame", + "dask_cudf.DataFrame", "dask.dataframe.DataFrame" + ] + }, + self.WEIGHT_IN: { + port_type: [ + "pandas.DataFrame", "cudf.DataFrame", + "dask_cudf.DataFrame", "dask.dataframe.DataFrame" + ] + }, + self.TRANS_IN: { + port_type: [ + "pandas.DataFrame", "cudf.DataFrame", + "dask_cudf.DataFrame", "dask.dataframe.DataFrame" + ] + } + } + port_outports = { + self.OUTPUT_PORT_NAME: { + port_type: "${port:return_df}" + }, + } + self.template_ports_setup(in_ports=port_inports, + out_ports=port_outports) + + def conf_schema(self): + json = { + "title": "Construct the portfolio", + "type": "object", + "properties": { + }, + } + + ui = { + } + return ConfSchema(json=json, ui=ui) + + def update(self): + TemplateNodeMixin.update(self) + meta_outports = self.template_meta_setup().outports + meta_inports = self.template_meta_setup().inports + return_required = { + "date": "datetime64[ns]", + 'sample_id': 'int64', + 'year': 'int16', + 'month': 'int16', + } + weight_required = { + 'sample_id': 'int64', + 'year': 'int16', + 'month': 'int16', + } + tran_required = { + 'sample_id': 'int64', + 'year': 'int16', + 'month': 'int16', + } + + addition = { + 'portfolio': 'float64' + } + + input_meta = self.get_input_meta() + if self.RETURN_IN not in input_meta: + col_from_inport = return_required.copy() + else: + col_from_inport = input_meta[self.RETURN_IN].copy() + meta_inports[self.RETURN_IN] = return_required + meta_inports[self.WEIGHT_IN] = weight_required + meta_inports[self.TRANS_IN] = tran_required + col_from_inport.update(addition) + # additional ports + meta_outports[self.OUTPUT_PORT_NAME] = col_from_inport + self.template_meta_setup( + in_ports=meta_inports, + out_ports=meta_outports + ) + + def process(self, inputs): + input_meta = self.get_input_meta() + if self.RETURN_IN in input_meta: + assets = len(input_meta[self.RETURN_IN]) - 4 + elif self.WEIGHT_IN in input_meta: + assets = len(input_meta[self.WEIGHT_IN]) - 3 + elif self.TRANS_IN in input_meta: + assets = len(input_meta[self.TRANS_IN]) - 3 + + return_df = inputs[self.RETURN_IN] + weight_df = inputs[self.WEIGHT_IN] + date_df = return_df[['date', 'sample_id', 'year', 'month']] + + expand_table = date_df.reset_index().merge( + weight_df, on=['sample_id', 'year', 'month'], + how='left').set_index('index') + + price_table = return_df[list(range(assets))] + weight_table = expand_table[list(range(assets))] + + if self.TRANS_IN in input_meta: + tran_df = inputs[self.TRANS_IN] + tran_expand_table = date_df.reset_index().merge( + tran_df, on=['sample_id', 'year', + 'month'], how='left').set_index('index') + tran_expand_table = tran_expand_table.sort_index().dropna() + months = (tran_expand_table['year'] * 12 + + tran_expand_table['month']).values + months = ((months[1:] - months[:-1]) != 0).astype(cupy.float64) + months = cupy.pad(months, ((1, 0)), mode='constant') + months[0] = 1.0 + tran_table = tran_expand_table[list(range(assets))].values + tran_table = tran_table * months[:, None] + tran_table = cudf.DataFrame(tran_table) + tran_table.index = tran_expand_table.index + + apply_table = (price_table * weight_table).sort_index().dropna() + # hack to fix the column names + apply_table.columns = list(range(assets)) + apply_weight = (apply_table - tran_table).sum(axis=1) + else: + apply_weight = (price_table * weight_table).sum(axis=1) + + return_df['portfolio'] = apply_weight.astype('float64') + return_df = return_df.dropna() + output = {} + output.update({self.OUTPUT_PORT_NAME: return_df}) + return output diff --git a/gQuant/plugins/hrp_plugin/greenflow_hrp_plugin/rSquaredNode.py b/gQuant/plugins/hrp_plugin/greenflow_hrp_plugin/rSquaredNode.py new file mode 100644 index 00000000..3655244f --- /dev/null +++ b/gQuant/plugins/hrp_plugin/greenflow_hrp_plugin/rSquaredNode.py @@ -0,0 +1,102 @@ +""" + //////////////////////////////////////////////////////////////////////////// + // + // Copyright (C) NVIDIA Corporation. All rights reserved. + // + // NVIDIA Sample Code + // + // Please refer to the NVIDIA end user license agreement (EULA) associated + // with this source code for terms and conditions that govern your use of + // this software. Any use, reproduction, disclosure, or distribution of + // this software and related documentation outside the terms of the EULA + // is strictly prohibited. + // + //////////////////////////////////////////////////////////////////////////// +""" + +from greenflow.dataframe_flow import ConfSchema, PortsSpecSchema +from greenflow.dataframe_flow.template_node_mixin import TemplateNodeMixin +from greenflow.dataframe_flow.metaSpec import MetaDataSchema +from greenflow.dataframe_flow import Node +from dask.dataframe import DataFrame as DaskDataFrame + + +class RSquaredNode(TemplateNodeMixin, Node): + + def init(self): + TemplateNodeMixin.init(self) + self.INPUT_PORT_NAME = 'in' + self.OUTPUT_PORT_NAME = 'out' + port_type = PortsSpecSchema.port_type + port_inports = { + self.INPUT_PORT_NAME: { + port_type: [ + "pandas.DataFrame", "cudf.DataFrame" + ] + }, + } + port_outports = { + self.OUTPUT_PORT_NAME: { + port_type: "builtins.float" + }, + } + meta_inports = { + self.INPUT_PORT_NAME: {} + } + meta_outports = { + self.OUTPUT_PORT_NAME: { + MetaDataSchema.META_OP: MetaDataSchema.META_OP_ADDITION, + MetaDataSchema.META_REF_INPUT: self.INPUT_PORT_NAME, + MetaDataSchema.META_DATA: {} + } + } + self.template_ports_setup(in_ports=port_inports, + out_ports=port_outports) + self.template_meta_setup( + in_ports=meta_inports, + out_ports=meta_outports + ) + + def conf_schema(self): + json = { + "title": "Compute the R-squared score for regression problems", + "type": "object", + "properties": { + "columns": { + "type": "array", + "items": { + "type": "string" + }, + "description": """Two columns used to compute the + R-squared score""", + "minItems": 2, + "maxItems": 2 + } + }, + "required": ["columns"] + } + + input_meta = self.get_input_meta() + if self.INPUT_PORT_NAME in input_meta: + col_from_inport = input_meta[self.INPUT_PORT_NAME] + enums = [col for col in col_from_inport.keys()] + json['properties']['columns']['items']['enum'] = enums + ui = {} + return ConfSchema(json=json, ui=ui) + else: + ui = { + "column": {"ui:widget": "text"} + } + return ConfSchema(json=json, ui=ui) + + def process(self, inputs): + df = inputs[self.INPUT_PORT_NAME] + # df = df.drop('datetime', axis=1) + output = {} + subdf = df[self.conf['columns']] + if isinstance(subdf, DaskDataFrame): + result = subdf.corr().compute().values[0, 1]**2 + else: + result = subdf.corr().values[0, 1]**2 + output.update({self.OUTPUT_PORT_NAME: result.item()}) + return output diff --git a/gQuant/plugins/hrp_plugin/greenflow_hrp_plugin/rawDataNode.py b/gQuant/plugins/hrp_plugin/greenflow_hrp_plugin/rawDataNode.py new file mode 100644 index 00000000..a497333b --- /dev/null +++ b/gQuant/plugins/hrp_plugin/greenflow_hrp_plugin/rawDataNode.py @@ -0,0 +1,101 @@ +""" + //////////////////////////////////////////////////////////////////////////// + // + // Copyright (C) NVIDIA Corporation. All rights reserved. + // + // NVIDIA Sample Code + // + // Please refer to the NVIDIA end user license agreement (EULA) associated + // with this source code for terms and conditions that govern your use of + // this software. Any use, reproduction, disclosure, or distribution of + // this software and related documentation outside the terms of the EULA + // is strictly prohibited. + // + //////////////////////////////////////////////////////////////////////////// +""" + +from greenflow.dataframe_flow import Node +from greenflow.dataframe_flow import PortsSpecSchema +from greenflow.dataframe_flow import ConfSchema +from greenflow.dataframe_flow.template_node_mixin import TemplateNodeMixin +from collections import OrderedDict + + +class RawDataNode(TemplateNodeMixin, Node): + + def init(self): + TemplateNodeMixin.init(self) + self.INPUT_PORT_NAME = 'in' + self.OUTPUT_PORT_NAME = 'out' + port_type = PortsSpecSchema.port_type + port_inports = { + self.INPUT_PORT_NAME: { + port_type: [ + "pandas.DataFrame", "cudf.DataFrame" + ] + }, + } + port_outports = { + self.OUTPUT_PORT_NAME: { + port_type: "${port:in}" + }, + } + self.template_ports_setup(in_ports=port_inports, + out_ports=port_outports) + + def conf_schema(self): + json = { + "title": "Pass along the raw dataframe dataframe", + "type": "object", + "properties": { + }, + } + + ui = { + } + return ConfSchema(json=json, ui=ui) + + def update(self): + TemplateNodeMixin.update(self) + meta_outports = self.template_meta_setup().outports + meta_inports = self.template_meta_setup().inports + required = { + "date": "date" + } + input_meta = self.get_input_meta() + json = OrderedDict() + if self.INPUT_PORT_NAME in input_meta: + assets = len(input_meta[self.INPUT_PORT_NAME]) - 1 + for i in range(assets): + json[i] = 'float64' + json['date'] = "datetime64[ns]" + json['sample_id'] = 'int64' + json['year'] = 'int16' + json['month'] = 'int16' + meta_outports[self.INPUT_PORT_NAME] = required + meta_outports[self.OUTPUT_PORT_NAME] = json + self.template_meta_setup( + in_ports=meta_inports, + out_ports=meta_outports + ) + + def _process(self, df, partition_id): + all_dates = df['date'] + cols = list(df.columns) + cols.remove('date') + df = df[cols] + df.columns = list(range(len(df.columns))) + df['date'] = all_dates + df['sample_id'] = partition_id + df['year'] = df['date'].dt.year + df['month'] = df['date'].dt.month - 1 + return df + + def process(self, inputs): + df = inputs[self.INPUT_PORT_NAME] + # df = df.drop('datetime', axis=1) + output = {} + offset = self.conf.get('offset', 0) + out_df = self._process(df, offset) + output.update({self.OUTPUT_PORT_NAME: out_df}) + return output diff --git a/gQuant/plugins/hrp_plugin/greenflow_hrp_plugin/shapSummaryPlotNode.py b/gQuant/plugins/hrp_plugin/greenflow_hrp_plugin/shapSummaryPlotNode.py new file mode 100644 index 00000000..969ce8ef --- /dev/null +++ b/gQuant/plugins/hrp_plugin/greenflow_hrp_plugin/shapSummaryPlotNode.py @@ -0,0 +1,191 @@ +""" + //////////////////////////////////////////////////////////////////////////// + // + // Copyright (C) NVIDIA Corporation. All rights reserved. + // + // NVIDIA Sample Code + // + // Please refer to the NVIDIA end user license agreement (EULA) associated + // with this source code for terms and conditions that govern your use of + // this software. Any use, reproduction, disclosure, or distribution of + // this software and related documentation outside the terms of the EULA + // is strictly prohibited. + // + //////////////////////////////////////////////////////////////////////////// +""" + +from greenflow.dataframe_flow import Node +from greenflow.dataframe_flow.portsSpecSchema import (ConfSchema, + PortsSpecSchema, + NodePorts) +from greenflow.dataframe_flow.template_node_mixin import TemplateNodeMixin +from greenflow.dataframe_flow.metaSpec import MetaDataSchema +import cudf +from xgboost import Booster +import pandas as pd +from matplotlib.figure import Figure +from dask.dataframe import DataFrame as DaskDataFrame +import shap + + +class ShapSummaryPlotPlotNode(TemplateNodeMixin, Node): + + def init(self): + TemplateNodeMixin.init(self) + self.SHAP_INPUT_PORT_NAME = 'shap_in' + self.MODEL_INPUT_PORT_NAME = 'model_in' + self.DATA_INPUT_PORT_NAME = 'data_in' + self.OUTPUT_PORT_NAME = 'summary_plot' + port_type = PortsSpecSchema.port_type + port_inports = { + self.SHAP_INPUT_PORT_NAME: { + port_type: [ + "pandas.DataFrame", "cudf.DataFrame", + "dask_cudf.DataFrame", "dask.dataframe.DataFrame" + ] + }, + self.MODEL_INPUT_PORT_NAME: { + port_type: [ + "xgboost.Booster", "builtins.dict", + "dask_cudf.DataFrame", "dask.dataframe.DataFrame" + ] + }, + self.DATA_INPUT_PORT_NAME: { + port_type: [ + "pandas.DataFrame", "cudf.DataFrame", + "dask_cudf.DataFrame", "dask.dataframe.DataFrame" + ] + } + } + port_outports = { + self.OUTPUT_PORT_NAME: { + port_type: "matplotlib.figure.Figure" + }, + } + meta_inports = { + self.MODEL_INPUT_PORT_NAME: {}, + self.DATA_INPUT_PORT_NAME: {}, + self.SHAP_INPUT_PORT_NAME: {} + } + meta_outports = { + self.OUTPUT_PORT_NAME: { + MetaDataSchema.META_OP: MetaDataSchema.META_OP_RETENTION, + MetaDataSchema.META_DATA: {} + } + } + self.template_ports_setup(in_ports=port_inports, + out_ports=port_outports) + self.template_meta_setup( + in_ports=meta_inports, + out_ports=meta_outports + ) + + def conf_schema(self): + json = { + "title": "Shap Summary Plot Node", + "type": "object", + "description": """Plot the Shap summary""", + "properties": { + "max_display": { + "type": "integer", + "description": """ + How many top features to include in the plot + (default is 20, or 7 for interaction plots) + """, + "default": 20 + }, + "plot_type": { + "type": "string", + "description": """ + "dot" (default for single output), "bar" (default for + multi-output), "violin", + """, + "enum": ["dot", "bar", "violin"] + } + } + } + # input_meta = self.get_input_meta() + ui = { + } + return ConfSchema(json=json, ui=ui) + + def ports_setup(self): + types = [cudf.DataFrame, + DaskDataFrame, + pd.DataFrame] + port_type = PortsSpecSchema.port_type + input_ports = { + self.SHAP_INPUT_PORT_NAME: { + port_type: types + }, + self.MODEL_INPUT_PORT_NAME: { + port_type: [Booster, dict] + }, + self.DATA_INPUT_PORT_NAME: { + port_type: types + } + } + output_ports = { + self.OUTPUT_PORT_NAME: { + port_type: Figure + } + } + input_connections = self.get_connected_inports() + if (self.SHAP_INPUT_PORT_NAME in input_connections): + determined_type = input_connections[self.SHAP_INPUT_PORT_NAME] + input_ports[self.SHAP_INPUT_PORT_NAME] = { + port_type: determined_type + } + if (self.DATA_INPUT_PORT_NAME in input_connections): + determined_type = input_connections[self.DATA_INPUT_PORT_NAME] + input_ports[self.DATA_INPUT_PORT_NAME] = { + port_type: determined_type + } + if (self.MODEL_INPUT_PORT_NAME in input_connections): + determined_type = input_connections[self.MODEL_INPUT_PORT_NAME] + input_ports[self.MODEL_INPUT_PORT_NAME] = { + port_type: determined_type + } + ports = NodePorts(inports=input_ports, outports=output_ports) + return ports + + def process(self, inputs): + """ + Plot the lines from the input dataframe. The plotted lines are the + columns in the input dataframe which are specified in the `lines` of + node's `conf` + The plot title is defined in the `title` of the node's `conf` + + Arguments + ------- + inputs: list + list of input dataframes. + Returns + ------- + Figure + """ + import matplotlib.pyplot as pl + pl.figure() + shap_values = inputs[self.SHAP_INPUT_PORT_NAME] + df = inputs[self.DATA_INPUT_PORT_NAME] + if isinstance(shap_values, DaskDataFrame): + shap_values = shap_values.compute() + if isinstance(df, DaskDataFrame): + df = df.compute() + if isinstance(shap_values, cudf.DataFrame): + shap_values = shap_values.values.get() + else: + shap_values = shap_values.values + if isinstance(df, cudf.DataFrame): + df = df.to_pandas() + input_meta = self.get_input_meta() + required_cols = input_meta[ + self.MODEL_INPUT_PORT_NAME]['train'] + df = df[required_cols] + self.conf['show'] = False + # max_display = self.conf.get('max_display', 20) + # plot_type = self.conf.get('plot_type', 'bar') + shap.summary_plot(shap_values[:, :-1], + df, **self.conf) + f = pl.gcf() + return {self.OUTPUT_PORT_NAME: f} diff --git a/gQuant/plugins/hrp_plugin/greenflow_hrp_plugin/transactionCostNode.py b/gQuant/plugins/hrp_plugin/greenflow_hrp_plugin/transactionCostNode.py new file mode 100644 index 00000000..a53d33ed --- /dev/null +++ b/gQuant/plugins/hrp_plugin/greenflow_hrp_plugin/transactionCostNode.py @@ -0,0 +1,112 @@ +""" + //////////////////////////////////////////////////////////////////////////// + // + // Copyright (C) NVIDIA Corporation. All rights reserved. + // + // NVIDIA Sample Code + // + // Please refer to the NVIDIA end user license agreement (EULA) associated + // with this source code for terms and conditions that govern your use of + // this software. Any use, reproduction, disclosure, or distribution of + // this software and related documentation outside the terms of the EULA + // is strictly prohibited. + // + //////////////////////////////////////////////////////////////////////////// +""" + +from greenflow.dataframe_flow import ConfSchema, PortsSpecSchema +from greenflow.dataframe_flow.template_node_mixin import TemplateNodeMixin +from greenflow.dataframe_flow import Node +import cupy +import cudf + + +class TransactionCostNode(TemplateNodeMixin, Node): + + def init(self): + TemplateNodeMixin.init(self) + self.delayed_process = True + self.infer_meta = False + self.INPUT_PORT_NAME = 'logreturn_df' + self.OUTPUT_PORT_NAME = 'out' + port_type = PortsSpecSchema.port_type + port_inports = { + self.INPUT_PORT_NAME: { + port_type: [ + "pandas.DataFrame", "cudf.DataFrame", + "dask_cudf.DataFrame", "dask.dataframe.DataFrame" + ] + }, + } + port_outports = { + self.OUTPUT_PORT_NAME: { + port_type: "${port:logreturn_df}" + }, + } + self.template_ports_setup(in_ports=port_inports, + out_ports=port_outports) + + def conf_schema(self): + json = { + "title": "Compute the Transaction Cost", + "type": "object", + "properties": { + "cost": { + 'type': "number", + "title": "transaction cost", + "default": 2e-4 + }, + }, + } + + ui = { + } + return ConfSchema(json=json, ui=ui) + + def update(self): + TemplateNodeMixin.update(self) + meta_outports = self.template_meta_setup().outports + meta_inports = self.template_meta_setup().inports + sub_dict = { + 'year': 'int16', + 'month': 'int16', + 'sample_id': 'int64', + } + required = { + } + required.update(sub_dict) + meta_inports[self.INPUT_PORT_NAME] = required + json_drawdown = {} + input_meta = self.get_input_meta() + if self.INPUT_PORT_NAME in input_meta: + assets = len(input_meta[self.INPUT_PORT_NAME]) - 3 + for i in range(assets): + json_drawdown[i] = 'float64' + json_drawdown.update(sub_dict) + meta_outports[self.OUTPUT_PORT_NAME] = json_drawdown + self.template_meta_setup( + in_ports=meta_inports, + out_ports=meta_outports + ) + + def process(self, inputs): + df = inputs[self.INPUT_PORT_NAME] + input_meta = self.get_input_meta() + assets = len(input_meta[self.INPUT_PORT_NAME]) - 3 + all_sample_ids = df['sample_id'].unique() + total_samples = len(all_sample_ids) + cost = self.conf.get('cost', 2e-4) + data = df[list(range(assets))].values + r = data.reshape(total_samples, -1, assets) + tcost = cupy.abs(r[:, 1:, :] - r[:, :-1, :]) + tcost = cupy.pad(tcost, ((0, 0), (1, 0), (0, 0)), mode='constant') + tcost = tcost * cost + tcost = tcost.reshape(-1, assets) + cost_df = cudf.DataFrame(tcost) + cost_df.index = df.index + cost_df['year'] = df['year'] + cost_df['month'] = df['month'] + cost_df['sample_id'] = df['sample_id'] + output = {} + output.update({self.OUTPUT_PORT_NAME: cost_df}) + return output diff --git a/gQuant/plugins/hrp_plugin/make_tar.sh b/gQuant/plugins/hrp_plugin/make_tar.sh new file mode 100644 index 00000000..f93a3a3d --- /dev/null +++ b/gQuant/plugins/hrp_plugin/make_tar.sh @@ -0,0 +1,9 @@ +#!/bin/bash +ext=`date +"%y_%m.tgz"` +root=. +mandatory="$root/README.md $root/setup.py" +common="$root/greenflow_hrp_plugin $root/notebooks $root/docker" +#doc=$root/Documents +excl="--exclude=*/notebooks/data/pricess.csv --exclude=*/.ipynb_checkpoints/* --exclude=*/notebooks/ray* --exclude=*/__pycache__* --exclude=*/dask-worker-space* --exclude=*/.*" + +tar cvfz "Nvidia_FSI_MunichRe_v"$ext $excl $mandatory $common diff --git a/gQuant/plugins/hrp_plugin/notebooks/10assets.ipynb b/gQuant/plugins/hrp_plugin/notebooks/10assets.ipynb new file mode 100644 index 00000000..8545e192 --- /dev/null +++ b/gQuant/plugins/hrp_plugin/notebooks/10assets.ipynb @@ -0,0 +1,2859 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## GPU Accelerated Interpretable Machine Learning for Diversified Portfolio Construction\n", + "\n", + "In this notebook, we accelerated a pipeline to benchmark Hierarchical Risk Parity (HRP) relative to Naive Risk Parity (NRP) in the GPU as described in the [paper](https://papers.ssrn.com/sol3/papers.cfm?abstract_id=3730144). It is an example of diversification strategy allocating to liquid multi-asset futures markets with dynamic leverage (\"volatility target\"). This workflow includes following steps:\n", + "\n", + "* Load csv data of asset daily prices\n", + "* Run block bootstrap to generate 100k different scenarios.\n", + "* Compute the log returns for each scenario. \n", + "* Compute assets distances to run hierarchical clustering and Hierarchical Risk Parity (HRP) weights for the assets\n", + "* Compute the weights for the assets based on the Naïve Risk Parity (NRP) method.\n", + "* Compute the transaction cost based on weights adjustment on the rebalancing days\n", + "* At every rebalancing date, calculate the portfolio leverage to reach the volatility target.\n", + "* Compute the Average annual Returns, Std Returns, Sharpe Ratios, Maximum Drawdown, and Calmar Ratio performance metrics for these two methods (HRP-NRP)\n", + "\n", + "## Background\n", + "\n", + "**Naive Risk Parity** Naive Risk Parity (NRP), is here called naive because it ignores the correlation among the assets. In an RP portfolio, an asset weight is indirectly proportional to its historical volatility as explained in Roncalli (2013). More formally, the weight $w_i$ for the i-th asset with i spanning the portfolio universe $i =1,...,N$ is\n", + "$$ w_i = \\frac{\\sigma_i^{-1}}{\\sum_{j}\\sigma_j^{-1}}$$\n", + "where $\\sigma_i = \\sqrt{\\sum_{ii}}$ denotes the volatility of asset i.\n", + "\n", + "**HRP** The standard HRP approach (Lopez de Prado (2016a)) uses a tree clustering algorithm to perform a quasi-diagonalization of the covariance matrix. After the quasi-diagonalization is carried\n", + "out, a recursive bi-sectioning method is used to define the weights of each asset within the portfolio. \n", + "\n", + "**Performance metrics**\n", + "\n", + "Statistics | Short | Description\n", + "--- | --- | ----\n", + "Volatility | SD | Annualized volatility\n", + "Returns | RET | Annualized returns\n", + "Maximum Drawdown | MDD | Drawdowns percentage\n", + "Sharpe ratio | SR | The ratio between returns and volatility (annualized)\n", + "Calmar Ratio | Calmar | The ratio between annualized returns and max drawdown\n", + "\n", + "\n", + "**Backtests**\n", + "The strategies are rebalanced every month. At every rebalancing date, the portfolio leverage is set to reach the volatility target of $\\sigma_{target} = 5\\%$ annualized in a hindsight. The portfolio leverage\n", + "determines the total market value of the portfolio and thus the position quantities of each instrument. The estimation of realized volatility used for the updated leverage number is the\n", + "maximum of the volatilities of the portfolio measured over 20 and 60 trading days, respectively $\\sigma_{t=20}$ and $\\sigma_{t=60}$. The target weight is calculated as\n", + "$$W_{target} = \\frac{\\sigma_{target}} {\\max(\\sigma_{t=20}, \\sigma_{t=60})}$$\n", + "\n", + "Start the Dask cluster for distributed computation" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "
\n", + "

Client

\n", + "\n", + "		\n", + "

Cluster

\n", + "
    \n", + "
  • Workers: 4
    • \n", + "
  • Cores: 4
    • \n", + "
  • Memory: 251.82 GiB
    • \n", + "
\n", + "
" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# run this cell if you need Dask\n", + "from dask_cuda import LocalCUDACluster\n", + "import dask\n", + "dask.config.set({\"distributed.comm.timeouts.tcp\": \"90s\"})\n", + "cluster = LocalCUDACluster()\n", + "from dask.distributed import Client\n", + "client = Client(cluster)\n", + "client" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Results for the empirical dataset \n", + "\n", + "Following is the workflow from CSV data loading to backtest performance metrics computation. Note, the stock price csv file is synthetic in this example. Please use a realistic one for meaning results." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "bfe067386e03430894903767b77acea1", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "GreenflowWidget(sub=HBox(), value=[OrderedDict([('id', 'load_raw_csv'), ('type', 'LoadCsvNode'), ('conf', {'cs…" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import cupy\n", + "import cudf\n", + "import matplotlib.pyplot as pl\n", + "from greenflow.dataframe_flow import TaskGraph\n", + "from IPython.display import display, HTML\n", + "taskGraph=TaskGraph.load_taskgraph('./10assets/workflow_empirical.gq.yaml')\n", + "taskGraph.draw()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can run the workflow by clicking on the button in the widget or we can run following command. The result will be saved in the `result` variable" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "result = taskGraph.run()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "All the intermediate result can be fetched by the keys of `result` variable. We can list all the keys by running: " + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "('hrp_nrp_diff.out',\n", + " 'raw.out',\n", + " 'log_return.out',\n", + " 'assets_order.out',\n", + " 'hrp_weight.out',\n", + " 'portfolio_construct_hrp.out',\n", + " 'portfolio_construct_nrp.out',\n", + " 'nrp_weight.out',\n", + " 'distance_node.cov_df',\n", + " 'distance_node.distance_df',\n", + " 'leverage_hrp.lev_df',\n", + " 'leverage_nrp.lev_df',\n", + " 'performance_nrp.calmar_df',\n", + " 'performance_hrp.calmar_df',\n", + " 'performance_nrp.sharpe_df',\n", + " 'performance_nrp.sd_df',\n", + " 'performance_nrp.ret_df',\n", + " 'performance_nrp.maxdd_df',\n", + " 'performance_hrp.ret_df',\n", + " 'performance_hrp.sd_df',\n", + " 'performance_hrp.sharpe_df',\n", + " 'performance_hrp.maxdd_df')" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "result.get_keys()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's plot the empirical dataset strategies performances" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "date = result['leverage_nrp.lev_df'].sort_index()['date'].values.get()\n", + "pl.plot(date, cupy.exp(cupy.cumsum(result['leverage_hrp.lev_df'].sort_index()['portfolio'].values)).get(), color='g', label='HRP')\n", + "pl.plot(date, cupy.exp(cupy.cumsum(result['leverage_nrp.lev_df'].sort_index()['portfolio'].values)).get(), color='b', label='NRP')\n", + "pl.legend()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Organize all the performance metrics in a table" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
NRPHRP
metrics
SD0.0491310.049988
RET0.0053200.004651
MDD0.0379030.047971
Calmar0.1403650.096955
SR0.1082870.093042
\n", + "
" + ], + "text/plain": [ + " NRP HRP\n", + "metrics \n", + "SD 0.049131 0.049988\n", + "RET 0.005320 0.004651\n", + "MDD 0.037903 0.047971\n", + "Calmar 0.140365 0.096955\n", + "SR 0.108287 0.093042" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "nrp_metrics = [result['performance_nrp.sd_df']['portfolio'].values.item(),\n", + " result['performance_nrp.ret_df']['portfolio'].values.item(),\n", + " result['performance_nrp.maxdd_df']['portfolio'].values.item(),\n", + " result['performance_nrp.calmar_df']['portfolio'].values.item(),\n", + " result['performance_nrp.sharpe_df']['portfolio'].values.item()]\n", + "hrp_metrics = [result['performance_hrp.sd_df']['portfolio'].values.item(),\n", + " result['performance_hrp.ret_df']['portfolio'].values.item(),\n", + " result['performance_hrp.maxdd_df']['portfolio'].values.item(),\n", + " result['performance_hrp.calmar_df']['portfolio'].values.item(),\n", + " result['performance_hrp.sharpe_df']['portfolio'].values.item()]\n", + "metrics = ['SD', 'RET', 'MDD', 'Calmar', 'SR']\n", + "df = cudf.DataFrame({'metrics': metrics, 'NRP': nrp_metrics, 'HRP': hrp_metrics})\n", + "df.set_index('metrics')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Robustness of the strategies\n", + "\n", + "Bootstrapped dataset To account for the non-stationarity of futures return time series, we generate an additional dataset of time-series by block bootstrapping (Hall (1985), Carlstein and others(1986), Fengler and Schwendner(2004) and Lohre, Rother, and Schaefer (2020)):\n", + "\n", + "* Blocks with a fixed length, but a random starting point in time are defined from the futures return time-series. One block corresponds to 60 business days. This block length is motivated by a typical monthly or quarterly rebalancing frequency of dynamic rule-based strategies and by the empirical market dynamics that happen on this time scale. Papenbrock and Schwendner (2015) found multi-asset correlation patterns to change at a typical frequency of a few months.\n", + "* A new return time-series is constructed by sampling the blocks with replacement to reconstruct a time-series with the same length of the original time-series. \n", + "\n", + "We added a Bootstrap Node to accelerate the bootstrap computation in the GPU. Run 4096 bootstrap samples, we can build a distribution of the performance metrics. Following is the workflow of running the bootstrap." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "be5f4b3ef43949f5bbaba5f583f8fd03", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "GreenflowWidget(sub=HBox(), value=[OrderedDict([('id', 'load_raw_csv'), ('type', 'LoadCsvNode'), ('conf', {'cs…" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "taskGraph=TaskGraph.load_taskgraph('./10assets/workflow_bootstrap.gq.yaml')\n", + "taskGraph.draw()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Collect the results and list all the result keys:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "('hrp_nrp_diff.out',\n", + " 'performance_nrp.ret_df',\n", + " 'performance_nrp.sd_df',\n", + " 'performance_nrp.sharpe_df',\n", + " 'performance_hrp.ret_df',\n", + " 'performance_hrp.sd_df',\n", + " 'performance_hrp.sharpe_df',\n", + " 'performance_hrp.maxdd_df',\n", + " 'performance_nrp.calmar_df',\n", + " 'performance_hrp.calmar_df',\n", + " 'performance_nrp.maxdd_df')" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "result = taskGraph.run()\n", + "result.get_keys()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Draw the performance statistics distribution:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAEGCAYAAACevtWaAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAAbxklEQVR4nO3df5Ac5X3n8feXBWuBWYT1g83aIif5rOjOyLbs3SLn8gXPnhMHJxTYnMwhXBY6fKy4wslZYOewifHUYSrEglPOkR1KOlGSy6CVT4gAKv+QjvKEXDnE3iVCgGWBRJR4w5Zk/QB2wBJo/b0/pmeZXc3vnt6Z7v28qra2p/uZ7s/O7nz3mad7njF3R0REkuWsVgcQEZHmU3EXEUkgFXcRkQRScRcRSSAVdxGRBDq71QEA5s2b5wsXLqzY5rXXXuP888+fnkBNELe8oMzTIW55IX6Z45YXGs88PDx81N3nl9zo7i3/6u3t9Wp+9KMfVW3TTuKW112Zp0Pc8rrHL3Pc8ro3nhkY8jJ1VcMyIiIJpOIuIpJAKu4iIgnUFidURUTCevPNNxkZGWH27Nns27ev1XHqUi1zZ2cnCxYs4Jxzzql5nyruIpIIIyMjdHV1MXfuXC644IJWx6nL2NgYXV1dJbe5O8eOHWNkZIRFixbVvE8Ny4hIIpw8eZK5c+diZq2O0lRmxty5czl58mRd91NxF5HESFphL2jk51JxFxFJII25i0giZbKZ5u4vXX1/qVSKXC43cXvz5s0MDQ2xfv16MpkMGzduZP78+bzxxht85StfYcWKFQDcdNNN/PjHP2b27NmcddZZfPOb3+RDH/pQqLwq7tIUxU+kWp4EIjPRmjVr+MIXvsALL7xAb28vy5cvn7gCZu3atSxfvpxdu3axevVq9u7dG+pYGpYREZlmixcv5rzzzuPEiRNnbLvssss4cOBA6GOo5y4i0iS/+tWvWLZs2cTt48ePc+WVV57R7qmnnmLx4sVcdNFFZ2x77LHHeO973xs6S9Xibmb3A1cAR9x9abBuG7AkaHIh8LK7LzOzhcA+YH+w7Ul3vyl0ShGRGDj33HPZs2fPxO3CmHvBunXr2LhxIy+++CI/+MEPJt33i1/8Il/72teYP38+mzZtCp2llp77ZmA98O3CCnf/T4VlM7sXeKWo/UF3XxY6mYhIwhTG3Hfs2MHKlSs5ePAgnZ2dwFtj7s1Sdczd3Z8AjpfaZvmLL68BtjYtkYhIwl199dX09fWxZcuWyI4Rdsz9d4DD7v5C0bpFZvYPwKvAn7r734Y8hohI3dr9qq077riD6667jhtvvDGS/Vt+vvcqjfJj6TsLY+5F6/8KOODu9wa3ZwEpdz9mZr3AXwOXuPurJfY5AAwAdHd39w4ODlbMkMvlSKVStfxMbSFueSFc5tHc6MRyT6qnWZGqitvjHLe8EJ/Ms2fP5t3vfjfj4+N0dHS0Ok5dasl84MABXnnllUnr+vv7h929r1T7hnvuZnY2cDXQW1jn7qeAU8HysJkdBH4LGJp6f3ffAGwA6Ovr83Q6XfF42WyWam3aSdzyQrjMxde5r0ivaE6gGsTtcY5bXohP5n379tHV1VVxEq52VUvmzs5OPvCBD9S8zzDXuf8u8HN3HymsMLP5ZtYRLL8LWAy8GOIYIiLSgKrF3cy2An8HLDGzETP7bLDpWs48kXoZsNfMnga2Aze5e8mTsSIiEp2qwzLuXvI1truvKrHuIeCh8LFERCQMTT8gIpJAmn5A6qIJwkTiQcVdRBIpk5n+/ZkZt9xyC/feey8A99xzD7lcjkwmM+1T/mpYRkSkSWbNmsWOHTs4evRoye1r1qxhz549PPLII6xevZo333xzYtvatWvZs2cPd999N6tXrw6dRcVdJozmRslkM03/kAORmeLss89mYGCAdevWVWw3HVP+qriLiDTRzTffzAMPPHDGu0mLtcWUvyIiUrsLLriAlStX8o1vfINzzz130rbpnPJXPXcRkSb7/Oc/z6ZNm3jttdcmrV+zZg379+9n27ZtrFy5kpMnT05sK4y57969m6VLl07dZd1U3KWqwji8xuJFajNnzhyuueaasj3wOEz5KyLSlpp9KWS9br31VtavX192e9RT/qq4i4g0SS6Xm1ju7u7m9ddfn7idmfLfpre3l/37859Iet999zV9JksNy4iIJJCKu4hIAmlYRkrSyVOJo1o+WS6OGvm51HMXkUTo7Ozk2LFjiSvw7s6xY8fo7Oys637quYtIIixYsICRkRFefvnlugthq508ebJi5s7OThYsWFDXPlXcRSQRzjnnHBYtWkQ2m63rs0bbQRSZNSwjIpJAKu4iIgmk4i4ikkBVx9zN7H7gCuCIuy8N1mWAG4FfBs2+7O7fC7Z9CfgsMA78sbv/MILcEkP6iD6R6VNLz30zcHmJ9evcfVnwVSjs7wGuBS4J7vMtM+toVlgREalN1eLu7k8Ax2vc31XAoLufcvd/BA4Al4bIJyIiDbBaLvg3s4XAzinDMquAV4Eh4FZ3P2Fm64En3f07QbtNwPfdfXuJfQ4AAwDd3d29g4ODFTPkcjlSqVTNP1irxS0vwPFXjnOq41TN7XtSPRPLo7nRkuuL1dKmXnF7nOOWF+KXOW55ofHM/f39w+7eV2pbo9e5/xVwJ+DB93uBGwAr0bbkfw933wBsAOjr6/N0Ol3xgNlslmpt2knc8gJs3bmV/an9NbdfkV4xsVw8nl68vlgtbeoVt8c5bnkhfpnjlheiydzQ1TLuftjdx93918BG3hp6GQEuLmq6AHgpXEQREalXQ8XdzIpfU38SeDZYfhS41sxmmdkiYDHwk3ARRUSkXrVcCrkVSAPzzGwE+CqQNrNl5IdcDgGrAdz9OTP7LvAz4DRws7uPR5Jc2pYueRRpvarF3d1LDY6W/Whud78LuCtMKGkv2c3pieX0qmzLcohI7fQOVRGRBFJxFxFJIBV3EZEEUnEXEUkgfViHNEyfsyrSvtRzFxFJIPXcJVLq3Yu0hnruIiIJpOIuDcluTk96c5OItBcNy0hk9M5WkdZRz11EJIFU3EVEEkjDMjNcJjP5e7009CLSntRzFxFJIBV3EZEEUnEXEUkgjbnPcNlDWQAy2SxLWBJuX8H4u8beRVpPxV1aQh/FJxItFXcpS+9AFYkvjbmLiCRQ1eJuZveb2REze7Zo3Voz+7mZ7TWzh83swmD9QjP7lZntCb7uizC7iIiUUUvPfTNw+ZR1u4Gl7v4+4HngS0XbDrr7suDrpubEFBGRelQdc3f3J8xs4ZR1u4puPgksb3IuiTGN1Yu0nrl79Ub54r7T3ZeW2PYYsM3dvxO0e458b/5V4E/d/W/L7HMAGADo7u7uHRwcrJghl8uRSqWqZm0Xccn7/KEcAF3zxpg1PotTHacmto0d7Tqjfde8sbLbKincr5SeVE9d+yoWl8e5IG55IX6Z45YXGs/c398/7O59pbaFulrGzG4HTgMPBKtGgd9092Nm1gv8tZld4u6vTr2vu28ANgD09fV5Op2ueKxsNku1Nu0kLnkzwTXp6VVDLMktYX9q/8S27Pb0Ge3Tq4bKbqukcL9SVqRX1LWvYnF5nAvilhfilzlueSGazA1fLWNm1wNXAJ/2oPvv7qfc/ViwPAwcBH6rGUFFRKR2DfXczexy4L8DH3H314vWzweOu/u4mb0LWAy82JSkUrdG3yikMXOR+Kta3M1sK5AG5pnZCPBV8lfHzAJ2mxnAk8GVMZcB/8PMTgPjwE3ufjyi7FKCPpBaRKC2q2VKDYhuKtP2IeChsKFERCQcvUNVgPxQzNjRLg3JiCSE5paRujRa/DVjpMj0Us9dRCSBVNxFRBJIwzIzRLvMn15qeKZdsokkiXruIiIJpJ67tJVMNjPppG2hh68evUh91HMXEUkg9dwlFjQuL1If9dxFRBJIPfcZJrs5TSbb6hQiEjX13EVEEkg99xmg3eeL0dQEIs2nnruISAKp5z4DZQ9lWx1BRCKmnruISAKpuIuIJJCGZaQlaj3Jq5OtIo1Rz11EJIGqFnczu9/MjpjZs0Xr5pjZbjN7Ifj+9qJtXzKzA2a238x+P6rgIiJSXi09983A5VPW3QY87u6LgceD25jZe4BrgUuC+3zLzDqallZERGpStbi7+xPA8SmrrwK2BMtbgE8UrR9091Pu/o/AAeDS5kQVEZFambtXb2S2ENjp7kuD2y+7+4VF20+4+9vNbD3wpLt/J1i/Cfi+u28vsc8BYACgu7u7d3BwsGKGXC5HKpWq9edquVblHc2NnrFu7GhXTfed0zXO8bHWvdDqmjcGlM5b2AbQk+qZWNbfRfTiljlueaHxzP39/cPu3ldqW7OvlrES60r+93D3DcAGgL6+Pk+n0xV3nM1mqdamnbQqb/HUuBNZtteW47p0jgezrXtSpFcNAaXzFrYBrEivmFjW30X04pY5bnkhmsyNXi1z2Mx6AILvR4L1I8DFRe0WAC81Hk9ERBrRaHF/FLg+WL4eeKRo/bVmNsvMFgGLgZ+EiygiIvWqOixjZluBNDDPzEaArwJ3A981s88C/wx8CsDdnzOz7wI/A04DN7v7eETZZYYqHnpKk25ZDpF2VrW4u/uKMps+Wqb9XcBdYUKJiEg4eoeqiEgCqbiLiCSQiruISAKpuIuIJJCm/E2wdv/sVBGJjoq7xErxPyzN8S5Snop7AqnHLiIacxcRSSD13GOo+B2amXSmbDsRmbnUc5dYG82NkslmSs6GKTKTqbiLiCSQiruISAKpuIuIJJCKu4hIAulqGYkFXbsvUh/13EVEEkjFXUQkgVTcRUQSSGPu0jY0ri7SPOq5i4gkUMM9dzNbAmwrWvUu4A7gQuBG4JfB+i+7+/caPY6IiNSv4eLu7vuBZQBm1gH8C/Aw8J+Bde5+TzMCiohI/Zo1LPNR4KC7/1OT9iciIiGYu4ffidn9wFPuvt7MMsAq4FVgCLjV3U+UuM8AMADQ3d3dOzg4WPEYuVyOVCoVOut0iTLvaG50Yrkn1XPGtrGjXQ3td07XOMfHOkJlm05d88aYNT6LUx2nztg29XFpF3H7O4b4ZY5bXmg8c39//7C795XaFrq4m9nbgJeAS9z9sJl1A0cBB+4Eetz9hkr76Ovr86GhoYrHyWazpNPpUFmnU5R5K83nnslmGr7q5Lp0jgez8XlSpFdlWZJbwv7U/jO2tes893H7O4b4ZY5bXmg8s5mVLe7NuBTy4+R77YcBCt+DA28EdjbhGCJ1mTq/e7sWe5GoNKO4rwC2Fm6YWY+7F8YNPgk824RjSBn6kAoRKSVUcTez84DfA1YXrf66mS0jPyxzaMo2ERGZBqGKu7u/Dsydsu4zoRKJiEhoeoeqiEgCaW6ZhNC8LCJSTMU9JnTiVETqoWEZEZEEUnFvY5lM/ktKy25ON/xuXJGk07CMzDiV3uErkhTquYuIJJCKu4hIAmlYJuZ0CaSIlKKeu4hIAqm4i4gkkIZlJJEKw1XpVVlgyiWl6WkOI9ICKu4xpbF2EalEwzIiIgmk4i4ikkAalmlj2UNZADLZbEtziEj8qLi3mcmzP6ZblCKeKp2HKPyjhMmPqqYikKRScY8RnUQVkVqpuLcZFfD66TETOVPYD8g+BIwB48Bpd+8zsznANmAh+Q/IvsbdT4SLObOpeIlIvZpxtUy/uy9z977g9m3A4+6+GHg8uC0iItMoikshrwK2BMtbgE9EcAwREakgbHF3YJeZDZvZQLCu291HAYLvF4U8hoiI1MncvfE7m73D3V8ys4uA3cAfAY+6+4VFbU64+9tL3HcAGADo7u7uHRwcrHisXC5HKpVqOOt0azTv84dyEaSpzZyucY6PdbTs+I2olrlr3hjApI/jK6ybqifV09xwJcTt7xjilzlueaHxzP39/cNFQ+KThDqh6u4vBd+PmNnDwKXAYTPrcfdRM+sBjpS57wZgA0BfX5+n0+mKx8pms1Rr004azZsJJrpqhevSOR7MxutJUS1zetUQANnt6TPWTbUivaKp2UqJ298xxC9z3PJCNJkbHpYxs/PNrKuwDHwMeBZ4FLg+aHY98EjYkCIiUp8wPfdu4GEzK+znQXf/gZn9FPiumX0W+GfgU+FjikwvvXNV4q7h4u7uLwLvL7H+GPDRMKFERCQczQopIpJAKu4iIgmk4i4ikkCaOEwkMHm65dLrdXJV4kI9dxGRBFJxFxFJIBV3EZEEUnEXEUkgFXcRkQTS1TJtIJPN6NOWRKSp1HMXEUkgFXcRkQRScRcRSSAVd5ESspvTOg8isabiLiKSQLpapkXKzWMizaXet8xU6rmLiCSQeu4iddAMkRIX6rmLiCSQirtIE2SymYmvSm1Gc6M63yLTouFhGTO7GPg28BvAr4EN7v6/zCwD3Aj8Mmj6ZXf/XtigIs1S7iRrelV2WnOIRCnMmPtp4FZ3f8rMuoBhM9sdbFvn7veEjyciIo1ouLi7+ygwGiyPmdk+4J3NCpZEejmeLPp9Sjszdw+/E7OFwBPAUuAWYBXwKjBEvnd/osR9BoABgO7u7t7BwcGKx8jlcqRSqdBZp0upvKO50bLtx452RR2pqjld4xwf62h1jLo0M3PXvLGJ5am/j+Jt1fSkekquH82NMmt8Fqc6TpVt046S8Nxrd41m7u/vH3b3vlLbQhd3M0sBfwPc5e47zKwbOAo4cCfQ4+43VNpHX1+fDw0NVTxONpslnU6HyjqdSuUtjOmWGttthzfbXJfO8WA2Xk+KZmYu/r1M/X00Oh5ffLlkJpthSW4J+1P7Y3UZZRKee+2u0cxmVra4h7rO3czOAR4CHnD3HQDufrho+0ZgZ5hjJF07FHWJjoZupFUavhTSzAzYBOxz9/9ZtL749eYngWcbjyciIo0I03P/MPAZ4Bkz2xOs+zKwwsyWkR+WOQSsDnEMERFpQJirZf4fYCU26Zr2IpNflqdblEJEZhrNLdMCGmePn+LfWbPf7KT5aiQKKu4RKFwVoZNp8aJ/upIkmltGRCSBVNxFRBJIwzLTQC/3k6nwe41qwjGNxUsY6rmLiCSQeu4iLaCT7RI1FXeRmNFwjdRCxV0kpCivgRdplIq7SBOFPcmq4RppFhX3EDKZohvBy+P8kzvNkuXl526XeKvl6qdKRb7U/av9M1DRl3qpuEdk7GgX2e3pVscQkRlKl0KKiCSQeu51mvzyOFOmlcj0a+QqGl15k1wq7iFkD2UnltMtSyEzWbmxeBVtUXEXSTgV+plJxV1kmmQ3p3lHOtfqGGXpn0CyqLg3QBOBSa3q/VuZzsnIJNlU3GtQyxNCBV+iEnXBl2SaUcV94k1HRS85Cy8/C9smvquHI9NoaudAnQUNE4UV2XXuZna5me03swNmdltUxxERkTNF0nM3sw7gm8DvASPAT83sUXf/WRTHK1bvf/tC++yhNADpVUz6Xky9KWmlRqYtaFTx8yhddKFvmFe0UfS+1bsvL6phmUuBA+7+IoCZDQJXAZEU9+JfcPETIJN9q02pa9IrFWsVcomDSn+nhcIfdsx+NDcaqqgXjp/Jlh72rKcTVql9oc2S3JJ6I57x8xUfo9yxa1lf7z6bydy9+Ts1Ww5c7u7/Jbj9GeC33f1zRW0GgIHg5hJgf5XdzgOONj1sdOKWF5R5OsQtL8Qvc9zyQuOZ/5W7zy+1Iaqeu5VYN+m/iLtvADbUvEOzIXfvCxtsusQtLyjzdIhbXohf5rjlhWgyR3VCdQS4uOj2AuCliI4lIiJTRFXcfwosNrNFZvY24Frg0YiOJSIiU0QyLOPup83sc8APgQ7gfnd/LuRuax7CaRNxywvKPB3ilhfilzlueSGCzJGcUBURkdbSh3WIiCSQiruISAK1pLhXm5rA8r4RbN9rZh+csr3DzP7BzHYWrdtmZnuCr0NmticGmZeZ2ZNB5iEzu7TN877fzP7OzJ4xs8fM7IJm5Q2bOfidP1N4LIvWzzGz3Wb2QvD97W2e91Nm9pyZ/drMmn45X0SZ15rZz4P2D5vZhW2e986g7R4z22Vm72hW3qgyF23/gpm5mc2rGsTdp/WL/AnWg8C7gLcBTwPvmdLmD4Dvk79e/t8Bfz9l+y3Ag8DOMse4F7ij3TMDu4CPF90/2+Z5fwp8JFi+AbizXR5j4BAwr8R+vw7cFizfBvx5m+f9t+Tf1JcF+pr1+Eac+WPA2cHyn8fgMb6gaPmPgfva/TEOtl1M/iKVfyrXpvirFT33iakJ3P0NoDA1QbGrgG973pPAhWbWA2BmC4A/BP53qZ2bmQHXAFtjkNmBQu93Ns17L0BUeZcATwTLu4H/2KS8oTNXcBWwJVjeAnyinfO6+z53r/Zu7UZFlXmXu58Obj5J/n0t7Zz31aKb5zPlDZbtmDmwDviTWvO2ori/E/hF0e2RYF2tbf6C/A/46zL7/x3gsLu/EDppbXlqafMXlM78eWCtmf0CuAf4UnPiRpb3WeDKYPlTTH6jWlhhMzuwy8yGLT+1RUG3u48CBN8vavO8UZqOzDeQ75U2Q2R5zeyu4Hn3aeCOJuWNLLOZXQn8i7s/XWuQVhT3qlMTlGtjZlcAR9x9uML+V9DcXnvZPLW0qZL5vwJr3P1iYA2wKVzMyllqaVMl7w3AzWY2DHQBb4SLWT1PHW0+7O4fBD5OPuNlTcxWStzyVstTS5uKmc3sduA08EDYoDVkqaVN2bzufnvwvHsA+FyJfTSq6ZnN7Dzgdur8J9SK4l7L1ATl2nwYuNLMDpF/ufMfzOw7hUZmdjZwNbAtJpmvB3YEy/+H/Eu6ts3r7j9394+5ey/5f6AHm5Q3bGbcvfD9CPAwbz2Wh4uGm3qAI22eN0qRZTaz64ErgE97MEDcznmLPEhzhxejyPyvgUXA08HzcgHwlJn9RsUkzTqRUOsX+XfFvhiELZxwuGRKmz9k8gmHn5TYT5opJ1SBy4G/iUtmYB+QDpY/Cgy3ed6Lgu9nAd8GbmiHx5j8uGlX0fKPyc9KCrCWySdUv97OeYvum6X5J1SjeowvJz+d9/yY5F1cdP8/Ara3e+Yp9z9EDSdUm/aLqPMB+APgefI9v9uDdTcBNwXLRv7DPg4Cz5T6I6d0cd9c2EccMgP/HhgO/gD+Huht87z/Ldjn88DdBO9wbnVm8lcmPB18PVe4b7BtLvA48ELwfU6b5/0k+Z7dKeAw8MMYPMYHyI8h7wm+mnn1SRR5HyJ//mgv8BjwznZ/jKfs/xA1FHdNPyAikkB6h6qISAKpuIuIJJCKu4hIAqm4i4gkkIq7iEgCqbiLBMzs9mBGxsKMgb9tZtlghr+9wcyH65s566FIVFTcRQAz+xD5d1h+0N3fB/wub83/8elg3fvIX3/+SGtSitROxV0krwc46u6nANz9qAdvBS/w/Cx/fwL8ppm9vwUZRWqm4i6Stwu42MyeN7NvmdlHSjVy93Hy7yD8N9OaTqROKu4igLvngF5gAPglsM3MVpVpXmpWP5G2cnarA4i0i6BXngWyZvYM+Vk7JzGzDuC95Cd9E2lb6rmLAGa2xMwWF61aRv7jzIrbnAP8GfALd987jfFE6qaeu0heCvjL4DLH0+RnOhwAtgMPmNkpYBbwfznzY9NE2o5mhRQRSSANy4iIJJCKu4hIAqm4i4gkkIq7iEgCqbiLiCSQiruISAKpuIuIJND/Bwdz7m3KSYwlAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "result['performance_hrp.sd_df'].to_pandas()['portfolio'].hist(bins=100, color='g', alpha=.5, label='HRP')\n", + "result['performance_nrp.sd_df'].to_pandas()['portfolio'].hist(bins=100, color='b', alpha=.5, label='NRP')\n", + "pl.xlabel('SD')\n", + "pl.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "result['performance_hrp.ret_df'].to_pandas()['portfolio'].hist(bins=100, color='g', alpha=.5, label='HRP')\n", + "result['performance_nrp.ret_df'].to_pandas()['portfolio'].hist(bins=100, color='b', alpha=.5, label='NRP')\n", + "pl.xlabel('RET')\n", + "pl.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "result['performance_hrp.maxdd_df'].to_pandas()['portfolio'].hist(bins=100, color='g', alpha=.5, label='HRP')\n", + "result['performance_nrp.maxdd_df'].to_pandas()['portfolio'].hist(bins=100, color='b', alpha=.5, label='NRP')\n", + "pl.xlabel('MDD')\n", + "pl.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "result['performance_hrp.sharpe_df'].to_pandas()['portfolio'].hist(bins=100, color='g', alpha=.5, label='HRP')\n", + "result['performance_nrp.sharpe_df'].to_pandas()['portfolio'].hist(bins=100, color='b', alpha=.5, label='NRP')\n", + "pl.xlabel('SR')\n", + "pl.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "result['performance_hrp.calmar_df'].to_pandas()['portfolio'].hist(bins=100, color='g', alpha=.5, label='HRP')\n", + "result['performance_nrp.calmar_df'].to_pandas()['portfolio'].hist(bins=100, color='b', alpha=.5, label='NRP')\n", + "pl.xlabel('Calmar')\n", + "pl.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "result['hrp_nrp_diff.out'].to_pandas()['portfolio'].hist(bins=100, color='g', label='HRP-NRP')\n", + "pl.xlabel('Calmar(HRP) - Calmar(NRP)')\n", + "pl.legend()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Interpretable Machine Learning\n", + "In this section, we train a supervised learnin gmodel to fit the spread between the Calmar ratios of HRP and the NRP using statistical features of the bootstrapped\n", + "datasets. \n", + "\n", + "**The features**\n", + "\n", + "To characterize the portfolio universe, we select a set of classical statistical features plus a set of quantities that can indicate properties of the hierarchical structure of the asset universe. This particular set of features is tailored to both strategies, and without the help of ML it would be quite difficult to link them to the performances of the strategies. We also look at some features that encode non-stationarity properties. Whenever the feature name has the suffix `_std`., we measure the standard deviation of the statistical property across time. That helps to identify the heterogeneity of that property across the years. \n", + "\n", + "In total, we use 30 features associated with the portfolio universe. For example, X_mean_mean identifies the mean across assets of the mean returns across time. In other words, it provides information regarding the overall trend of the returns of the full portfolio. The `X_mean_mean_std` instead represents how the overall trend changes across years and is measured by the standard deviation of the `X_mean_means` measured year by year. Another feature is `X_mean_std` that measures the heterogeneity of the returns across the assets. A high value of this quantity means that the overall trend of the returns is characterized by a very heterogeneous behaviour across assets (in general features that have names ending with `X_std` have been measured with the standard deviation of X across assets). `corr_mean` is the mean of the entries of the correlation matrix (only the lower diagonal terms) and together with `corr_std` (their standard deviation) they provide information on the independence of the asset from the rest of the universe. For example, a negative value of `corr_mean` suggests that there is a high number of assets that are anti-correlated. A value close to zero can represent either a portfolio with independent assets or one with the same degree of positive and negative correlations. In this case, `corr_std` would discriminate between the two possibilities. \n", + "\n", + "Following is the workflow to calculate all the features for each bootstrap sample in the GPU" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "207912fc126e428583d0eeeafc4dec4f", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "GreenflowWidget(sub=HBox(), value=[OrderedDict([('id', 'load_raw_csv'), ('type', 'LoadCsvNode'), ('conf', {'cs…" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "taskGraph=TaskGraph.load_taskgraph('./10assets/feature_computation_workflow.gq.yaml')\n", + "taskGraph.draw()" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
sample_idmax_drawdown_mean_meanmax_drawdown_std_meanmax_raise_mean_meanmax_raise_std_meanmean_mean_meanmean_std_meanstd_mean_meanstd_std_meancorr_mean_mean...all_max_drawdown_meanall_max_drawdown_stdall_max_raise_meanall_max_raise_stdall_mean_meanall_mean_stdall_std_meanall_std_stdall_corr_meanall_corr_std
035170.4144190.1630830.4341590.1566330.0001300.0014970.1085950.058899-1.005899...0.5576730.2176570.6409520.1684300.0002510.0001980.1093660.060513-0.9965730.045879
18010.4043070.1511550.4280550.1720930.0003550.0015410.1054740.059430-1.002208...0.6077570.1943910.6307580.2367140.0001990.0006770.1072330.058736-0.9963760.048835
224220.3994630.1530920.4346720.1631520.0004080.0011410.1097190.061432-1.001743...0.5434050.1827860.6246950.1913630.0002140.0005040.1088970.060183-0.9935160.045806
340350.4017330.1617600.4386210.1678510.0004440.0010190.1086710.064088-0.997431...0.5086210.1728700.6491520.1966480.0004820.0004250.1076770.061167-0.9927330.046570
423570.4291710.1659710.4205370.169629-0.0000450.0014510.1101690.059183-1.004206...0.6156520.1912620.5804430.218954-0.0000350.0006220.1112910.059861-0.9902470.056629
..................................................................
409132580.4021160.1677250.4151870.1519540.0000540.0013410.1012880.053939-1.004581...0.6047200.1887580.6040700.2111400.0000550.0002860.1035550.053839-0.9962250.048285
409237280.3954070.1552750.4376430.1736660.0005300.0015840.1062560.061717-1.003591...0.5377380.1641190.6524010.2306680.0005660.0008410.1074480.061347-0.9901690.051332
409332050.4160150.1623600.4324380.1703550.0002050.0013910.1086460.058865-1.004680...0.6015630.1844180.6340270.2058000.0001870.0005360.1098290.059270-0.9913890.054740
40941600.3899220.1534720.4242470.1467240.0003190.0011600.1013970.051962-1.001794...0.5287220.1801560.6304280.2110980.0003680.0006120.1009220.050804-0.9970310.041969
409520080.4171270.1656090.4252160.1631760.0000510.0012690.1087370.061715-0.989853...0.5834410.1788050.6094470.2009280.0001190.0004510.1075890.059118-0.9844520.044359
\n", + "

4096 rows × 33 columns

\n", + "
" + ], + "text/plain": [ + " sample_id max_drawdown_mean_mean max_drawdown_std_mean \\\n", + "0 3517 0.414419 0.163083 \n", + "1 801 0.404307 0.151155 \n", + "2 2422 0.399463 0.153092 \n", + "3 4035 0.401733 0.161760 \n", + "4 2357 0.429171 0.165971 \n", + "... ... ... ... \n", + "4091 3258 0.402116 0.167725 \n", + "4092 3728 0.395407 0.155275 \n", + "4093 3205 0.416015 0.162360 \n", + "4094 160 0.389922 0.153472 \n", + "4095 2008 0.417127 0.165609 \n", + "\n", + " max_raise_mean_mean max_raise_std_mean mean_mean_mean mean_std_mean \\\n", + "0 0.434159 0.156633 0.000130 0.001497 \n", + "1 0.428055 0.172093 0.000355 0.001541 \n", + "2 0.434672 0.163152 0.000408 0.001141 \n", + "3 0.438621 0.167851 0.000444 0.001019 \n", + "4 0.420537 0.169629 -0.000045 0.001451 \n", + "... ... ... ... ... \n", + "4091 0.415187 0.151954 0.000054 0.001341 \n", + "4092 0.437643 0.173666 0.000530 0.001584 \n", + "4093 0.432438 0.170355 0.000205 0.001391 \n", + "4094 0.424247 0.146724 0.000319 0.001160 \n", + "4095 0.425216 0.163176 0.000051 0.001269 \n", + "\n", + " std_mean_mean std_std_mean corr_mean_mean ... all_max_drawdown_mean \\\n", + "0 0.108595 0.058899 -1.005899 ... 0.557673 \n", + "1 0.105474 0.059430 -1.002208 ... 0.607757 \n", + "2 0.109719 0.061432 -1.001743 ... 0.543405 \n", + "3 0.108671 0.064088 -0.997431 ... 0.508621 \n", + "4 0.110169 0.059183 -1.004206 ... 0.615652 \n", + "... ... ... ... ... ... \n", + "4091 0.101288 0.053939 -1.004581 ... 0.604720 \n", + "4092 0.106256 0.061717 -1.003591 ... 0.537738 \n", + "4093 0.108646 0.058865 -1.004680 ... 0.601563 \n", + "4094 0.101397 0.051962 -1.001794 ... 0.528722 \n", + "4095 0.108737 0.061715 -0.989853 ... 0.583441 \n", + "\n", + " all_max_drawdown_std all_max_raise_mean all_max_raise_std \\\n", + "0 0.217657 0.640952 0.168430 \n", + "1 0.194391 0.630758 0.236714 \n", + "2 0.182786 0.624695 0.191363 \n", + "3 0.172870 0.649152 0.196648 \n", + "4 0.191262 0.580443 0.218954 \n", + "... ... ... ... \n", + "4091 0.188758 0.604070 0.211140 \n", + "4092 0.164119 0.652401 0.230668 \n", + "4093 0.184418 0.634027 0.205800 \n", + "4094 0.180156 0.630428 0.211098 \n", + "4095 0.178805 0.609447 0.200928 \n", + "\n", + " all_mean_mean all_mean_std all_std_mean all_std_std all_corr_mean \\\n", + "0 0.000251 0.000198 0.109366 0.060513 -0.996573 \n", + "1 0.000199 0.000677 0.107233 0.058736 -0.996376 \n", + "2 0.000214 0.000504 0.108897 0.060183 -0.993516 \n", + "3 0.000482 0.000425 0.107677 0.061167 -0.992733 \n", + "4 -0.000035 0.000622 0.111291 0.059861 -0.990247 \n", + "... ... ... ... ... ... \n", + "4091 0.000055 0.000286 0.103555 0.053839 -0.996225 \n", + "4092 0.000566 0.000841 0.107448 0.061347 -0.990169 \n", + "4093 0.000187 0.000536 0.109829 0.059270 -0.991389 \n", + "4094 0.000368 0.000612 0.100922 0.050804 -0.997031 \n", + "4095 0.000119 0.000451 0.107589 0.059118 -0.984452 \n", + "\n", + " all_corr_std \n", + "0 0.045879 \n", + "1 0.048835 \n", + "2 0.045806 \n", + "3 0.046570 \n", + "4 0.056629 \n", + "... ... \n", + "4091 0.048285 \n", + "4092 0.051332 \n", + "4093 0.054740 \n", + "4094 0.041969 \n", + "4095 0.044359 \n", + "\n", + "[4096 rows x 33 columns]" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "del result\n", + "result = taskGraph.run()\n", + "result['merge_features.merged']" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The taskgrpah is a bit complicated, we can use `CompositeNode` to group the sub-graph into a single node. Here is a simplified version of it:" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "37e5de28c974470bb7e82126a56e8286", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "GreenflowWidget(sub=HBox(), value=[OrderedDict([('id', ''), ('type', 'Output_Collector'), ('conf', {}), ('inpu…" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "taskGraph=TaskGraph.load_taskgraph('./10assets/all_feature_simplified.gq.yaml')\n", + "taskGraph.draw()" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
sample_idmax_drawdown_mean_meanmax_drawdown_std_meanmax_raise_mean_meanmax_raise_std_meanmean_mean_meanmean_std_meanstd_mean_meanstd_std_meancorr_mean_mean...all_max_drawdown_meanall_max_drawdown_stdall_max_raise_meanall_max_raise_stdall_mean_meanall_mean_stdall_std_meanall_std_stdall_corr_meanall_corr_std
0220.4003540.1604720.4371770.1593460.0002890.0015500.1062580.059693-1.008242...0.5890480.1615980.6529990.2284250.0001330.0005700.1062710.058131-0.9985420.042687
112490.4068820.1451030.4233030.1488210.0001610.0010870.1034730.055421-1.007879...0.5827820.1635010.6442380.1702180.0002890.0005330.1045390.054696-1.0023880.045890
235680.4094800.1639400.4210960.1688310.0001870.0013530.1106010.063448-1.000735...0.5737640.1810130.6213720.2226250.0001980.0004980.1107070.063310-0.9904610.051229
325980.3811230.1566240.4296140.1570950.0004800.0013700.1024670.055241-0.988822...0.5345510.2157330.6401410.1970260.0003300.0006210.1041230.056334-0.9861280.049234
419300.4390270.1856080.4198090.155029-0.0003730.0016050.1102730.060777-1.004084...0.6247940.2031400.6030900.196278-0.0002480.0010200.1103370.060284-0.9955690.049347
..................................................................
409140460.4043750.1599150.4212130.1567420.0001910.0013730.1048100.056199-1.001768...0.5645250.2008150.6424400.1910220.0002050.0004470.1045430.055001-0.9922300.060576
409222720.4197380.1792440.4439850.1666110.0001850.0015080.1087490.059995-0.999435...0.5832150.2315340.6691630.2077590.0001620.0006970.1099210.061281-0.9907200.047009
409314480.4160090.1552860.4437510.1741480.0004040.0012880.1105850.061753-1.004288...0.5647210.1754850.6551760.2282830.0003930.0005130.1101140.060194-0.9982850.045960
40942030.4174500.1667860.4087130.155884-0.0001270.0014100.1040420.056706-1.010077...0.6073430.1958080.5644140.163626-0.0001110.0003390.1052680.057975-1.0001430.050108
409512540.4150090.1684200.4339250.1649530.0001320.0015270.1062960.057759-1.004749...0.5853690.1867470.6430130.2150970.0000770.0007500.1063200.056729-0.9988370.046722
\n", + "

4096 rows × 33 columns

\n", + "
" + ], + "text/plain": [ + " sample_id max_drawdown_mean_mean max_drawdown_std_mean \\\n", + "0 22 0.400354 0.160472 \n", + "1 1249 0.406882 0.145103 \n", + "2 3568 0.409480 0.163940 \n", + "3 2598 0.381123 0.156624 \n", + "4 1930 0.439027 0.185608 \n", + "... ... ... ... \n", + "4091 4046 0.404375 0.159915 \n", + "4092 2272 0.419738 0.179244 \n", + "4093 1448 0.416009 0.155286 \n", + "4094 203 0.417450 0.166786 \n", + "4095 1254 0.415009 0.168420 \n", + "\n", + " max_raise_mean_mean max_raise_std_mean mean_mean_mean mean_std_mean \\\n", + "0 0.437177 0.159346 0.000289 0.001550 \n", + "1 0.423303 0.148821 0.000161 0.001087 \n", + "2 0.421096 0.168831 0.000187 0.001353 \n", + "3 0.429614 0.157095 0.000480 0.001370 \n", + "4 0.419809 0.155029 -0.000373 0.001605 \n", + "... ... ... ... ... \n", + "4091 0.421213 0.156742 0.000191 0.001373 \n", + "4092 0.443985 0.166611 0.000185 0.001508 \n", + "4093 0.443751 0.174148 0.000404 0.001288 \n", + "4094 0.408713 0.155884 -0.000127 0.001410 \n", + "4095 0.433925 0.164953 0.000132 0.001527 \n", + "\n", + " std_mean_mean std_std_mean corr_mean_mean ... all_max_drawdown_mean \\\n", + "0 0.106258 0.059693 -1.008242 ... 0.589048 \n", + "1 0.103473 0.055421 -1.007879 ... 0.582782 \n", + "2 0.110601 0.063448 -1.000735 ... 0.573764 \n", + "3 0.102467 0.055241 -0.988822 ... 0.534551 \n", + "4 0.110273 0.060777 -1.004084 ... 0.624794 \n", + "... ... ... ... ... ... \n", + "4091 0.104810 0.056199 -1.001768 ... 0.564525 \n", + "4092 0.108749 0.059995 -0.999435 ... 0.583215 \n", + "4093 0.110585 0.061753 -1.004288 ... 0.564721 \n", + "4094 0.104042 0.056706 -1.010077 ... 0.607343 \n", + "4095 0.106296 0.057759 -1.004749 ... 0.585369 \n", + "\n", + " all_max_drawdown_std all_max_raise_mean all_max_raise_std \\\n", + "0 0.161598 0.652999 0.228425 \n", + "1 0.163501 0.644238 0.170218 \n", + "2 0.181013 0.621372 0.222625 \n", + "3 0.215733 0.640141 0.197026 \n", + "4 0.203140 0.603090 0.196278 \n", + "... ... ... ... \n", + "4091 0.200815 0.642440 0.191022 \n", + "4092 0.231534 0.669163 0.207759 \n", + "4093 0.175485 0.655176 0.228283 \n", + "4094 0.195808 0.564414 0.163626 \n", + "4095 0.186747 0.643013 0.215097 \n", + "\n", + " all_mean_mean all_mean_std all_std_mean all_std_std all_corr_mean \\\n", + "0 0.000133 0.000570 0.106271 0.058131 -0.998542 \n", + "1 0.000289 0.000533 0.104539 0.054696 -1.002388 \n", + "2 0.000198 0.000498 0.110707 0.063310 -0.990461 \n", + "3 0.000330 0.000621 0.104123 0.056334 -0.986128 \n", + "4 -0.000248 0.001020 0.110337 0.060284 -0.995569 \n", + "... ... ... ... ... ... \n", + "4091 0.000205 0.000447 0.104543 0.055001 -0.992230 \n", + "4092 0.000162 0.000697 0.109921 0.061281 -0.990720 \n", + "4093 0.000393 0.000513 0.110114 0.060194 -0.998285 \n", + "4094 -0.000111 0.000339 0.105268 0.057975 -1.000143 \n", + "4095 0.000077 0.000750 0.106320 0.056729 -0.998837 \n", + "\n", + " all_corr_std \n", + "0 0.042687 \n", + "1 0.045890 \n", + "2 0.051229 \n", + "3 0.049234 \n", + "4 0.049347 \n", + "... ... \n", + "4091 0.060576 \n", + "4092 0.047009 \n", + "4093 0.045960 \n", + "4094 0.050108 \n", + "4095 0.046722 \n", + "\n", + "[4096 rows x 33 columns]" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "del result\n", + "result = taskGraph.run()\n", + "result['merge_features.merged']" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## The ML learning model\n", + "\n", + "For the supervised learning algorithm, we selected XGBoost (Chen and Guestrin (2016)) , a gradient tree boosting library that is fast and accurate as described in the paper. This algorithm can construct non-linear relations among the features. Moreover, for large datasets, it can scale across GPUs to speed-up the learning process. Another benefit of using XGBoost is that it produces fast explanations.\n", + "\n", + "To assess the stability of the explanations, the set of bootstrapped datasets, each across 17 multi-asset futures, is split into 90% training and 10% test set. We trained the model as a regression, to learn the difference between the Calmar ratio obtained with HRP minus the Calmar ratio obtained by HRP. " + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "9c4c0b68568545fba07f50c594739c38", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "GreenflowWidget(sub=HBox(), value=[OrderedDict([('id', ''), ('type', 'Output_Collector'), ('conf', {}), ('inpu…" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "taskGraph=TaskGraph.load_taskgraph('./10assets/xgboost_performance.gq.yaml')\n", + "taskGraph.draw()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Run and collect the results:" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "del result\n", + "result = taskGraph.run()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's check the R-squared score for both Train dataset and Test dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train R-Squared: 0.9996047474788272 Test R-Squared: 0.04970422996337347\n" + ] + } + ], + "source": [ + "print('Train R-Squared:', result['train_rsquared.out'], 'Test R-Squared:', result['test_rsquared.out'])" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Test')" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "pl.plot(result['test_infer.out'].portfolio.values.get(), result['test_infer.out'].predict.values.get(), 'g.')\n", + "pl.xlabel('true')\n", + "pl.ylabel('predict')\n", + "pl.title('Test')" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Train')" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "pl.plot(result['train_infer.out'].portfolio.values.get(), result['train_infer.out'].predict.values.get(), 'b.')\n", + "pl.xlabel('true')\n", + "pl.ylabel('predict')\n", + "pl.title('Train')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Clearly the XGBoost model is over-fitted as we only use 4096 data points. We will use more data points later" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## The explanation method\n", + "\n", + "We will use Shapley values of feature contribution to explain the ML result. In simple words, what Shapley values tell us is how much each feature (the statistical properties of the asset universe described above) has contributed to a specific outcome of the ML model. Because of the complexity (non-linearity) of the model, this is a non-trivial task. The Shapley value is a quantity introduced in co-operative game theory to provide the fair payout to a player (the features) with respect to its contribution to the common goal (ML prediction). The SHAP framework (Lundberg and Lee (2017)) provides a tool to evaluate this quantity even in a model agnostic way. It allows comparing these quantitative explanations among different models.\n", + "\n", + "Shapley values can be computed from the XGboost inference node. Following is the workflow to visualize the feature contributions. " + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "069042e9909145ba85998ce48839f574", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "GreenflowWidget(sub=HBox(), value=[OrderedDict([('id', ''), ('type', 'Output_Collector'), ('conf', {}), ('inpu…" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "taskGraph=TaskGraph.load_taskgraph('./10assets/xgboost_shap.gq.yaml')\n", + "taskGraph.draw()" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "del result\n", + "result = taskGraph.run()" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "

Shap Summary, Train

" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "display(HTML('

Shap Summary, Train

'))\n", + "result['train_shap_dot.summary_plot']" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "

Shap Summary, Train

" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "display(HTML('

Shap Summary, Train

'))\n", + "result['train_shap_bar.summary_plot']" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "

Shap Summary, Test

" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAowAAAI4CAYAAADgaLi1AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOydd7QdVdmHnz0zp5fba3LTQ0JCCJBN7xC6CAiCgCBYEBXFXpFmF7ufBUTpCIgoRjrSOwNJCCEhvSe3l3NPn5n9/TEnt6UCCSnsZ6277syu7+xpv3l3OUIphUaj0Wg0Go1GsymMHW2ARqPRaDQajWbnRgtGjUaj0Wg0Gs1m0YJRo9FoNBqNRrNZtGDUaDQajUaj0WwWLRg1Go1Go9FoNJtFC0aNRqPRaDQazWbRglGj0Wg0Go3mfUYIsUwIsdeQMFsIcZQQ4lohxDlbUcbVQohfbD8r+7Hej0o0Go1Go9FoNFuHUurKHW3DULSHUaPRaDQajWYnQghxsxDistJ2mRDin0KI+UKI/wkhbh3iVRwmhHiwFP+AECK6PWzSHkaN5v1F/7SSZocwY8YMAE499dQdbIlGs1Mhtk+pHxn8rFf3baqee4UQuQH7e2wkzZVAp1JqohCiEngN+OeAeAnsD3QDjwDnA395l5ZvEi0YNRqNRqPRaHYMZyml3ly/I4SwN5LmaOCLAEqpDiHEv4fEP6KU6irlfxkYuz0M1V3SGo1Go9FoNNsUMeTvPRe2ud6pgR5Kl+3kDNSCUaPRaDQajWbn5UngEwBCiArgtB1hhBaMGo1Go9FoNNuUbephvBaoFULMBW4Hnscfr/i+oscwajQajUaj0bzPKKVGbSRMljafGhCcBs5VSuWEEEngOeCWUvqrh+QftL8t0YJRo9FoNBqNZpuyTSdfVwAPCSFMIAzcqZR6fFtWsDVowajRaDQajUazk6KUagGm7Wg7tGDUaDQajUaj2aZsn+UddyR60otGo9FoNBqNZrNowajRaDQajUaj2SxaMGo0Go1Go9FoNosew6jRaDQajUazTdFjGDUajUaj0Wg0HzC0YNRoNBqNRqPRbBYtGDUajWYH8doqhzE/7qHsii7+8HyOdMpBKbXN68n2OChvmxeLlyni3PQCxcrLKQ77Bt6T87d9JRrNLsk2/WnAnQI9hlGj0Wh2EJf/O8vSDg9TKa65q4e5v25lj9EhLr1mNOGoOShttrtIT0ueqpFRrOCG3/qFrEvHqiwVwyKESnk9V3HP9+fR/eQSCpVhGs4tbDPb1/3hTVZc/jx7u69hoqAzg/vZ2zAW/Gib1aHRaHYetGDUaDSa95GW1iIrVhYZPy6EAhrTGT68tpWQYeIZghWLs9hPdXLYydUA9HYUeOt/rTx/83IKaZf6CXHO++3eBML9grJ1QYo7vz2PdLdDsjbIhb+dQrI2xKKXOph2wx2Ma19B0TB5JHwsfPy9H0Prg6uYdflroMLMFHszUS0gTha2vXNUo9lF2T28igPRglGj0Wi2AZ5S3D1fkS7CeXsKooENXxiLl+b5+ZXLCfdkcZJhPrt/iNbZizEUFC2TNTXVOMLgoXaL1bOLHDZnKXff2UY+6yGUohAIsHxJntdmrOOgjw4DYOFja3n4qrlkgiGEEPQ055n7v1YOPnc4sWWraWxfAUDAc5ny0lyWP7GW9LosY04cRrgyNMg+pRRd9yzC7SlQcd4emLHABsegii5zP/YkhqcIKBeXMHOZwtiytdRd/9Ht0LIajWZnQAtGjUaj2QZ88X8ef5zlu9h+80SBRz8EjeOiffEvPtLGf25fxx6LmjEArwXWLDUJlbxyAcclXCiwuKqMm2d6HP6fBcxd20o4GEAAmUgE1/S9ig/etJaudXlynQWWPLQazzQxlQKlUEC8OghAtDqOIwys0gDGnkKEly99CYCZv5vH2U8cTyAaIPWfxWSfX0NmUQ+d9y1FoGi5+iWa/jadxAkjBx3n2r++jZNyMBF4GChcBILVFeMIvJ6h8lCH1HPr6Hl0FYkjGig/ZXD+LZGf2Uzq7vkEJ1WRvHCvd3gWNJqdhd3Pwyi2xwBrjUazSfQNt4swc2aGF1/qpakpyCknl2EYm38BjLrBYXkP4CnoLTClpZMbv1TFAZMiPPb7RTw9ow2Uoqo305enYJoEXRfwL4y1leUsKEswpbWD6u4UhlIUAxZvVVVQP/DKUYpwIY+hQHgeVtGBAfYdeGCMg7+/N17O5bFD/87k1rfptSL8c9Ix9MRi1HR0UdPRzf6HVVK2tJXcUyv7bMhj4mBh4DCChZQd20jLsCnkRJzGb07ljU89T/qlNjwBqfIgCEV5T56wVyTpZTGHxcmvzlLERCFIHt1Iwzf3JXlCEz2/fJnC6+uInb0n0dMnoBwX5yePoeY3Y158IEWCrD7pPpTjH2xiWjnlX9iX0MXyvZ3Mt1fDT/8NiTBcfTZUJt5beZrdie2j7MR5g5/16s5dXkFqwajRvL/s1jecpxTfe9rl2ZWKk8cafPcQc8uZtjFvz0nzyD/biCdMzvxkHWUVG3arvr7a5VuPFAhZgl+fHGR89eBJJCtXFTj7Z50sTkQozzucuHeAmV6QCVWCqOfy+hqXj+wV4KtHhOhOufzh7h5u6wxR6CzQmy7SalqYnkfIEjx0VJFXfzzXL7j0vBX4F0JPIo7lOAQch0IwQNEK0BsMsqQ8SVk6w77LVmF6ip8esDcfaumgulgEwHBdQsVi35sumMuhSt5Hs+hQtbaDUacMp6wuzMJ7V9DuCpqrylk0cnifHfvPms/RcxdiKm/QchldIoyrAkziVSppZUlkDEvDo8kXY+zrzSMvLBanx9NRHSIXtUr2eIxqbgfHxMUkQgELF3d9J5YBDSfV4jzwdmlfEDhpHME5SwmtWEOGuB8eMEgV+8VckDxx0rB3I8Vej2x5JeWHJCl/63VIROC3n4SRtf1te9Vd8MQcOG4qXHWOH+66MOrzsKodhYFTPwwmNmFeeQrG0RO2+rrS7LZsJ8F4/hDBeIcWjLsyUsrDgGdt294hJ1JKORxYCYy2bXvZjrBheyClvAKYbtv2UTvalp2Q93TDKaUQYsPLdVPhm0ozNP098z2+86xHVQRuOclkz6qNl6WU4s+2y8+fdxhRJrj9IwGayvrlxo2zXD7zkO8xI+dQE1Qc1GRw29lhXl6n+NITHiET/nK8yQENom8JmaG2z17n8sn7i6TycN3xAWrjgs8+5FL0FP93vMUxowSzW+CiBx3SRbhgL4O/z1dYAuJ2M29ZIWKOyxcai3zve8P7jlcpxXcfKfCzZ52+E7Ffo8H0vYLcNV8xrQ5uOdnkvmfSXPSCBevt8hQjU1kaM3kyhqBTKY5q72JEhUGwPkLuudVEikU6knFuHDOCHP1vobH5HBe/sQDXsvBMg4JhkDYEUWHgBAIYnovleSjAEwYvN9aRtyxOmTmXaKGIAlbUV9MTi5DMF4jn8oSyeZxwEIQgY5q+gHQcKjpThNM5LNejNRnlvsl78KkXZuOGTRaNHMaauuq+Nj7x+dfZZ8kqQGGgEICHoMWIE/BA8iQZK8z/qo4DYFxmIfumZgLQSh2PNx6JY/V/EFS0ZAnnXAI4DKOdIA4pYmQJAYIgecrIECJFJcsBQYZKUlQjMEp2eAQokCJBjDQBioDAxURhIHBJsI4CZRgUCU8IklX1ELGIfmQs5lW39NlT+P6FBL51Ml0f/yfFf79JmB4ipFH43fXKNAi0/xKjLLKJO4Y+gc/A61Op/n3Xhcv/Bv95BQ6bBH/7AoSDcPvTqKvuQtSWwa1fgnENg8vYXH3bMt17zfPBQAvGrUSPYdRsNVLKi4ArbNset6Nt+aDxyFKP8x7wyLvwx+kGF07uF2lff8Llt695jC6D/55lsUflhs+l37zm8e1nPJJBCJrQnIGvScFPjzDpySvOe8DDVbCkG879r8usTwx+NBRdxdkzPO5f6KHSDgDLuhRffrjIP8/pnzixKlV6RjoeFDxaizBjnsuPnihww2KT7rwfffDtDqeOgv8s8RX0lFp48mMWsQCccZ/Lw/OKfdL63HsL1FeaLO3y94+/y8EwwDCh4AEKrnreBWGA60E4ypGdPUxI55jXbbL/9TleT1mMSMKKlMIr4Gcq+fnmdXi8/qpf2YoUtP29wH7l5qCXa0W+wNhUFoCIC02FAk+Ob2BVMsrYtm4+lctheorynl727EkxK9nvJes2LJ5vamT/tg4AAkA+EiEfCGC5Hp4DMaUIKoWHomCafpdzyZvYG49COETS9cCyCBR6ieby5IBUJEQ6EsYJBohmslS2dVEMWVBweHFEIwKIOi7FrEdtWyfrqivwTJNwLk93MMCi2krGtnTgAhkRpMuIELJclOOyzm0iYPb2HUfYzfZt19BMVa6D5ngNAMGcQ2U+R84yqXG7iaoCCrBwCCPwEBRMweyqYZzc8iBGyfuoCBCkSJReTByKBAGDJD2YrF84Ug34c8lRBQg8AuTfThHmbbKUkVnczMCOZvGje+CHtxFRcXKMIk01QYolaQq4ip4J15F87UsYw8oH3zCeB+f/Hu56wU89fTJ870w479fQ0Qs/uwDKY/DZP0PeP0/8/VkYU4t38XGIC3+HUAqWNKNO+AFiVTsMr4L/fBv22siYzkVr4UM/hsXr4LKT4Nef3DANwKo2OOVHMHclfOJouPHzWxaBHSm/7FcWwmkHwN1fA+v99/x/8Njl9eEGaMG4GaSUAdu2izvaDo3m8497dOT87Use9Th/T4FpCGY1K375qv9iXdgJ33/W5e7TBt/WHVnFV5/0PVit/e98fvaK4oJJCstQuAO+hRd1bVj/PW8r/r1IbeAfndU8OKAphu/JUEBZEEwDHI+OnCLr9KfzFNy/pH9/Tgv8+jWPEXHBwwvdQfXkHEgXBuf1XMADip6f1gDCAhQMyxfYM+03VqLoEn6zE29kDct6AAS4Az0tgmzGA68IpRnBzy5xOOJAQTBXpBAwMQXs0dU/7hBgUXWSlWUxf7umnFdG1JG2IrTHIgRdl/HZHIvCIQQwKZvDGtKTE/U8MkLgWCYP1VaQEoIDWzs4dF0rtb1pmhNx5jXWMXl18wYuaSX8j4VgLk99d4pG1UpneZJwvgCGwMXACwleb6pnVFs3puMRyinivW00rupmbX0ZylA8v98k8qEgDa0dnPHEKxjKZNb+48iHgyS708RezZN3DUKFIvlggOXhkYzLLCFAgSJhjKxFIp9HCCjL5vCUwHSgjXIEEKaIgz9hx0TR6LYzqWUxGaropBGFhUmROD1Y+BdHkAIOAQwGCxqBh4lHf4d+qS2wMMkSIk2+NzIgHAKefw2ESRGhkyxV5IgRJo1D2PdYNneTv+phIjd+bHAjP/pGSSyW6nt8ji/m1nb6QV+5CQImFJzB+R58nVyxnOiA8+0tbcPEhaXN8J07YMZ32YCr7vLHWQL85r/w8SNh2tgN0/3kPnhjub/9t//BeYfDsXtvmG4gv3sAXiwNBbjvJbj3RfjYYZvPo9FshPdFMEoplwE3AscC+wNLgfOBycAPgBrgH8Cltm07UsqbgOlAOX6X7Q9t276zVNangWuAfW3bbpFS1gKz8D1ff9uCHeOBvwDTgCXATUPinyqVNQo4BvixlPL2ku3TgCDwBvBl27Zfk1KaQBtwsm3bL0opxwCLgWtt276qVOY84Erbtv8hpawHbgCOBJqBnw+p3wK+C1xUOvaZwOW2bb8ppawu5WmybXuNlPJY4HHgk7Zt31TK2wEca9v2q1JKBXwBuBiYCMwFLrJte7M/xSClrCjZeAz+9bES+BzgAH8GglLK9W6HD9m2/ZSU8hTgOmAE8BSwaHN1DKjrauBwwAY+if/a/xHwT/xzsz+wAPi4bdvzBrTRN0ttVFs6ri/Ztv1aKf5Y4MfAHiWb/1eKbynFPwW8hn+OjwdagK/atn3/1tj8XkmlUiQSiXe8bQ4YZGYK6O3tpSw5OBzAcx3W39br8woBhlC4asMv3lwmzaiamD9rtxQ2pmxDG0zDF0cYAgKGL9QEiKA5qK76uIC8B0GDPuMsg4nDBD8blucrzwb8t3nB9V+4AzAFFPM5KA628+fHWVSHC1z6eIDCei0p8IXf+veyB8L1MAIGKjD4saa25ks/60DU8j2jvQXeXBegkHcgVyTpeYTwCHgeRcPAUIqgN/hnU9KBEO1RX7AUTJO6osP4njRBxyVvCB6tqaQ+naEhl8cxDLJBv1vUFTC6N8MRq9YR8jw8wyCpFKF0hnRFGXMsiyNnzyYbCZONRQgW8phFByXALBQxSsKkoquHQiRINh4FITALRRSCZVVlmE6pBYQgqFwqe1LMnjiKfMi3YW1NJQvHDUcpg3zYD+spizFnVBPxnhwoRXVPivpcL8vYjygp8gRxsyGiuCixfnkds9TSgjbKGE7boDYSpZPVSy2qdI26BHCHiEPVl1b07RulfYHAv61NBC4h+r+AIgPqcwlgMfBbX2BRIECeDEkCJYFqoPAW+PkGXvOZfI4oQzAHXEeGQJliwytrrxHkoiEUNcRoxcPAIYxJulSGsUFdqVSKxNAb2TQ2/kwYkm6gnZt6huQdh0GLJ23Khg/o9vZi6HNnd/A3vp8/DfgJ4PNABTAb+BdwNDAVmAJ8GDi7lPY5YB980XQtcLOUchKAbds34gulO6SUAeAO4LGtEIsWMANfYNQCZwGXbiTpJ4HfAWWl/wbwR2AkUA+8DtxX8j66+ALpuFLe4/DF0nGlOhvxhcsTpfg7ABdfWB2BL3oG8g3gQuBkoAF4FnhMSpm0bbsNX6xOL6WdPrAu4ED8J+lrA8q7CDgTqMYXfr/fTBMNtCFaOt5y4CPAKtu2X8RvryW2bcdLf0+VRPJ9+CKtvNRmn9mKetZzBLAQv20/ji88/4ovdiuBecBvB6S/FjgNOBGoAv4GPFISugB54DL8j5ApQOOQ/OBfi7/CP8f/B9wipdzg/bA9GPiQeifbNx5vMioJ9TG49WSDslKX55QawTWHGVSEQdYLfnFsaIO8FWHB9cebVEd8MTixEirC8KPDDKaNiFMVEfz5eIPqiB9328nmBjZ8dA/BhZMEiSAQMiFmQdTigOFiUF0njze4VJqEh/R4TagSfPnAKDNOFQwzXIZFFBdO8osyBRzaJPiqNLhERogF+/ONKIOvHxrgomkxer4eYO4lFvs1CCrCUB8fXMd/z7RY9CmT2olx3qhMkDcN1sbDrBhbTlkQyoTnuycFgPInFXvrRaeCtSloSTMsIbj/rZLnSAh6hWBOfRmuaVBWKFJRcBjfkaahJ0tA+EvZpKLhQbaYypdE82IRHixPgoKE69ITjZCOhBFAwRCkgwGmdXQRKglQA6ju6iHsOARcl/qWdnJGlFGLVxHM5smGIzTXV9NZlqAYHDCZRykMo99z6gYDfKi5lVNbOygGBwpoRTDvEMwP9owtGtmIO+SceYaBZwi/DUJh1sbimGYBJUyWmQ19L0ChBCLooQZ0jboYrKAStyT9PCBSEneCgWJbUSRAgSAuBg4WDoFBL9uUOXiMoUmeIB0ERBYDBw+BRQcBfC+wioUxH/sefHh/VCKCI6KEcEjQhYEiyOBfu7HO2QcYfN9FTzsILp3ud92aAs48EO78CkwYBtVJuP5SxK2XQ305JKMQD8PBE+BnF1Dx9SMonnwYrWX70nv+OQR/+hGojMPUUfCLT2xQVyKRgB+eB/uPg4o4XHk27DN648+EK86Cw/b0u8O/cirRkw/YMM2Q7dC3zoQT9oGyKFx0NJx50GbTf9C2NVvP+zLppeRh/INt29eV9k8GHgBqbdtuLYXdA6y2bfsrG8lvA3+zbfuPpf0o8CpQwB8SdIBt25mh+YaUcSi+cKtYn1ZK+RnghvWTXkrepyW2bW9iAAlIKRNADzDZtu23pJRfAM6xbfsIKeU/gIeBX+B7sE7H925Nk1IOA1YB42zbXlwq6zjgUUqTXqSUC4DrbNv+SyneAFYA37Bt++9SyuuAOtu2L5RSvlqq53f4YutKYG/bts8s5VXA2bZt/6O0fwpwu23b64XVpo7vanwx9gVgpm3b3oC4ixgyhlFK+T3gRNu2Dx8QdgcwbEuTXkp1fdS27ckDwlpKbTDwWrnDtu0KKaUotf0ptm0/MyDPHOBntm3fvpE6PoR/7dSW9p8C5tq2/YXSfgzoBfaxbXv25uzdRuzys8xuf8vjl7bHiITgL8cb1MY2/HYuuIovPu7x4hrF6eMF1x629WOm7NUelz/se4d+e2IAOWzj37U5R/GFBxzstR4fnWRyxRH9wuimOR6/fd1jTLnghuMMqqOCdSmPS/6VZ2WX4ptHBJg2zOTSf+VIFRQfm2Jy9+t5YkHB7z8S5djr07T0+qdqlOly+dERbm8NkusuUvVmJ0FXMbcsym2fT3D3IsFLaxQjO9K0LcgQ9jyqiv6kmuXhELWFIrWZDGNb2+mNxfpsfLMiSX2hyJgVa0lkcxTCQTzDoBgM4Jgm8bYuynrSmJ4iHwywYNKYvrzBfIFwsUh1cxv5YIBcNOJ7PktL9OApumNRcpEQS5TBOa/Ow/IchhfWkLcCdPdW0VaTZHlTFeuGVVKdzjJy0Uq6K5MUQ0ES3WmqW7pBKUxXEc4XyQVMCiGT8p4s47LLwROsYDi5YICu2jDBgkd5V5ZA0cNVBhEKhOkXpuV0UE0HLiZpkrhYOKXJLAA9hBlGC0J4vFU2nNG9zeTMIAvjjezXvpgYvRg4xGghN3w01q2XYO5RTeclDxCY+zYJ0YoxZRj85fNQV95Xr2cvp3D2X1FL2/FKS/2YEyrxglHM4/YgdN2pCOP99J1odjK2i/NPiQsGPeuFum2XdzK+n2MY1w7YzgDuerE4ICxREklXA+fgCyEFxPA9RgDYtp2RUt6I7yX65JbEYonhQMuQtEs3km7ZwJ1SV/CvgKPwPWjrBdR6ex4Hfl0SkkcBl+N75Y7G9wI+PqB+gOWbqb8Jv6scANu2vZLYbhpQ199K3rQ98D17V+J7aacDdw4pb2Cbp4Gt+ay6Dl+E3wI0SCn/C3zTtu3mTaQfzpA2wz+uYVtR11Abwb8Ohl4r6+2uBuLAjJIgXk+gZAdSymn43s6p+J5SUcqz0Tpt205LKWHr2kYDfHySwccnbf4FGzQF15/w7gbWy2EGz38qtMV0YUvw19M2XDIH4OIpBhdPGWxjfcLgPxcO9lY9cUm/Y/lrR/Z7CR/5TIxrH8uTDMNPT05SnzT4MuB5Jj98uoZXVrv8YE+LY8dYHFvScU8+Y3DD7ByeELgCumNBDp0SZtXLBXKBAJbjEs1mKVoWnhCUOwXGrFhLVVcK8JfD6a4qQxkGplKEC0VykRCpsjjR3iyG6+KVls4J5Qt4lkk2Gqa9urLPs1je2U2oWMTKFWhIZ0gMi1D14T3x3pjDCaueJ6BcOinjTcppWt1J0+pO5u8/gnVVZawe2UDDinUkU/m+N2jIcKlNd1CeTpOtqsE9chxj77mPpOePSkmSYmZoMghBIWTSUhcn0ZUjlnJxhQnKF4wKKBAADAwTyg+uolhTSfu/VvW1eeyAejI1I6hUXaTmh3gxUglAVZmg7KZPEEuthTufhakHE73mnL6JG9UPnLvZ68SQIwktupriDx5BvLoC88ypBC4+aLN5NBrNhuyMk17OBT6NP77srZJoshnwFSClnIgvKv8E/FRK+bBt20OFx1BWA7VSyugA0Th6I+m8Ifs/we8ePtC27bUDPIwCwLbtt6WU64AvA82l8YWP43cVH0N/t3NpRDMj8cc5bqz+lQPDSuJ5VCkc4Bn8btjL8JcDKpbqOgO/S3qTntGtxbbtNPA94HulMZe344vIC9mwbcA/rhOGhG2sXbcFbfjCd7pt269uIs1dwL34nsuekodxxnayR7Obss8wi/su2vDxaBiCK48O4H+jDGbiHmGCQUGxoDAVXHNBkkMPjHPZmhxrV8K8xnoaunqwUCilmB5I0TtgEW/T81AlT1cgKGicnGTp4jzdlWV0V5b5v+TiusR7M9R2dRAfW87KbHDQLFlPGATyRarGxGg6oIq9LxjDg1fMwYp4BJTvfUwN+X465qQqFtdVkrZbYE6u70kbbYhw3D8Ox/vjc4igRehbR+F4BuKuW/vyJkkRzxdpLy3ZIgSMvWwSZmeBuvPG4C3qIP1KM8lTRhKZtwxvaQfBTx+IuZ///WzdM5/sEyuITh9J/Kz+NRGPWZ3h7evnY0Ut9vzCngQSAWCcP8njXSAMg+BVJ72rvBrNu2OXdyhuwM4oGJP4Y/FaAaPUDToV+C/0dUf/A/iNbdtXSSlDwJ1SyumlMYWb4iV8795PpZTfwh/btkH39ybsyQCdUso48LONpPkf8HX88XTr968GQvjjMbFte1WpO/TnUsqLgQjw/SHl3Ax8U0r5DL7X7lv45+iBUhlZKeWLpbquHFDXbcBa27YXbsXxbBYp5an4YyMX4HfV5qCvX2kdvuhO2rbdUwr7O3CllPJc/PNyFP4YQ/u92jIU27aVlPK3wC+klJ+2bXth6ZwcCsyxbXsN/vnqBlJSyhHAt7e1HRrNxmioD3Dt9xuYNTvL6FFB9p7iey9//u1aHn+mFzfr8tYt3RR7HRL5HEd8dzJv/UOw+n9r/AKUIt7ZQy4S5oyf7suYveK8dtMSHng8TaE07C5QLCKUR2z6GA45PM7D35lNbyKGMgyE5xHJZhGeR7Y1x2Hf9n9Wr2tVBhWvojsUoyyfppxOlhojMDww4xZN54xi4qRyOl6K8NK/FlBQCitqcdQ/jiY0Lgm/+nDfMQaAwgl7YzzyBgDdVBAtFBnZ0kUqEmbKHUcz/JSmvvQcXkfVxXv62x/a8DsycfZEEmdP3CA8NizKftfu9x7PiEaj2ZbsjILxFnzP3CJ8oXYb/uSP9fwBX0xeU9q/DHgZX6ANFWB9lGZffxi4Hn9m7BL82cC/3oI9V+HP2G3Hn6V8JXDJkDSP4XsSHyvtzwGyfrX2gIVMOA9/lvZK+mdJD/xkvg5fZD6KPyFjFnD8AHG2vq6jBtT1FH7X671bOI6tZSx+mzSUjuFJ+kXXE6V6l5ZmiJ9m2/bTUsqz8IX0X4Cn8WeV77ON7BnKVcCXgPtLC5+n8T8GvliKvwT4JXAFMB//+jl0O9mi0Qxi5IgQI0cM7k6PRgw+fEISgOMPn8Jyu5OqUTHqJiQYe1gNz/80xJxbF4OCcDZPOJsnlM5hhco48NLxTDizwEM3ruSVVzJ4wSC5UIi64WHGfaiJs5tirJrTQ9oM8PrP3yDgeaAUwWB/d/zUs5p45W9L+eekY6nJdbK8tp7uSAWfPbecskNriY71bas8qIbDnz+Z7lkdVB5WS3TE0JEcPoH/XsaqLz3Iwn8sJ9htES26RApFQnvVDBaLGs0HmN1xlvQH+pdeNJodgL7hNIMo9Bb5+4n/I9ee7ws74Q8HMOqYhv40WZdbLp/DmqU5KitMLvjdFMrrB8/Mfv5Hb/Dm7UsxLMGx101jzIn9w4hb3u7h3pttFi+oRiA45YJ6jj69hndLvjPPQ6f9j95lvcQyBaLdDpXTh7H/Q8dtObNGs3OxXbScJz4x6FlvqFt2ec2oBaNG8/6ibzjNBqTWZHjgUy/QvSzNmBMaOfaXEsMc/H7xXEVPS554VRAruPFJR73rslhhk3B5cIO4GTNmUMgaHHfc8SQ38vva7xS34DH3Gzar//Q24bow+91/DGX7Vb3ncjWa95ntJBgvGiIYb9aCcWdCSvkQg7t4+7Bte+P9Kx9ABiy8PZRnbdveZiPDpZSHAw9tIvrHtm3/eFvVtQux+9xwmm2OW/QwA9tniZcZM/y5X6eeeuo2LddzPAxLL0uj2WXRgnEr2RnHML5rtqXY2Z15v8SzbdvPsuGSNhqNZhNsL7G4PdFiUaPZGLu8PtwAfadrNBqNRqPRaDbLbuVh1Gg0Go1Go9nRbNVv2O9iaA+jRqPRaDQajWazaMGo0Wg0HxC81R7NzzfjORv70SaNRrPtEEP+dn10l7RGo9HspKTb8rTO66ZmQpJYbXjLGTZD8RmHwp0FnlRPkdyvmiNvP5zYRpbf0Wg0mo2hBaNGo9HshHSvTHPvBS+S6yoSiJqcdctBBBe2YdZEiexfv9E8SimWzezGMAQj9ykbFOc86+AKAQK6X2/jr5+axSf/sg/xSi0aNZptze64fpoWjBqNRrMlFqyBN1fAYROhtvxdF6OUouWZZpRS1B1ZjxCb7qpa8mQLua4iAMWMywunPcK4eSsBqPnVkVR9ZRoATm+RzsfX4MQCPPVIB0tn+r8kKs9o4PjLRrNyQZpUR5GcZ1AM+/UZrqK7x2Xxa91MPa4G11UssrsJRU1GTUm86+PTaDS7L1owajQazeb4zQz45q1QdKGxEl67jkJa0HbfUrxEmNqzxxCsHPz70ao1hffUAsTEetizgbab3sJc3syytgBL/r0GgGGnNXHI9f7PnDs5l2UvthOtDFLuFckv6iFZPbgLumx1Z9/2yh/ZJE8bTf7p5cz7/lx6VxdwMVh69HgoidDZDzVTNjbB/X/0ReboLgOj5PdwTYGhFKnWPG0rsjx840oWvtoNwNEfb+So84fxTmhfV2Dl4gwj94hSUbPreCyfXqnoyClOHi0IWbvHODPNzsLudz3tVr/0otHsAugbbhdCfflm3N8+hoGDQRGFoP38j7H8H220OlEQgkilwSGPH01gb19kqbZeCtN+gruiG9cIML9+HzrXACh6aoMosX6uoeLIR06gakKSv5/3Em1rcgCMXtZKRWeaWH2Y1pRHZyJCsNdhTEcrQVxMFB2JMKOcLjJZkyImKSKsKS/n7SlNuAHfD2C4LsEx5bS1OgAMW7aGcNb/vepiwKRjWA0KgWkJikUP4XpkomECYYPTvj6OZF2QtS0ue00KU1FmbrKNZr/aw53XrcAtKlTc4vDzh3HYgTGqK0yKjuLl2VneTJtU1QU4tt5j0dwM1bUBxoyLbJdztrX85GWP7z7rT/7ZswKulooPT7IIB3a/F71ms2yXE+6ITw961lvqxl3+wtKCUaN5f9E33PvBKwth/mo4YR+oK+8Pf3ourGiFU/eH8hgAxeeW4S3tIHDKRIzKaF9S1Z4mV/dtlCswyBOkm9WMoYs6OkWUjNHvVZQhm+S9nyXf4hHK9JD7/D/IEcfFYA5jAYWFh4oqipaJi4EpXBpPrCe7osCLnm9LKFOgbk03Av9Cqe1OgTNwnqWiGBY4SahpydBCBQABiqwelqCrMk42FgEUwUyerupyslFfmFmFIo0r1vqexbI4uUSsz/6igo6yBNF8nqJpUQgFKRoG3cEA8ZjB1d9roGVRmrLqAGNKXda5ouKGx9M8cncLe3an6Q1YrEjEQQisiMHvvlPDL/7SzmOZIAtqkgA0ZHKcPG8NpoCjz62l2QgwOuBy9MExEolNi9L1vLbKZe46l+njLRrLBi/y8fIqj7fbPKrjBm15OGm0oCYqyBQV/16kSGU9wp7HkWMsRlUajLrBYXnPgAK6ckypgtlfjm12qIBmt2O7nOyi+MygZ31A/WWXv6h2WcEopTwM/7ePd8hJkFIOB1YCo23bXrYjbNDskuyaN9xOhPPv2fDQTMyjxyPOOaSvC7aPf76IOuvXgECVhxE3fxHR0Q1PzIHbn/HTTGpCPf8T0t96hPwNLyPwMGtjxGdchJHPweNv4K5OUfjrLEwyhEgBkCHKYvbCEnmWG8MBMJTDYd4TFI1yOr0GTBPCbqZP9M1nBDmC1JEigFsqJ0gei4pkjubeOG9OHY4TNKlo7SXZne07lEzEpKElRbjg9oV1R0KYUYdou0eO/u7fjtogHTWlX+JUikCuSG9ZnJ7KJJ4hCOUKeAJiPVlSyRgEzL43ZUc0Qm1nNwHXRQGtFeVkohGylokSAmWCyDtEHIe9j67myJMquejeDK+t8z10+3WnaHIVyvRFXFEIVMRE5TyeGl1NKhzos/PMuauI54vMqYhTXnQZli0QTJoceHo1DTFBdZ3F3DbFoaMs1uYE9twce4Q83PIAZ9+dw/WgLCL4vzMirO7xiFiKmevgljnKv7kEELMYkRR8YYriV68rmnMlcdlbIFZ0+IwM8JvF/Tb5jV2EtMPXD7O47tQIb6x1eXWly5FjTMZVb1rMvrLC4c1mj+PHWwwvN1jRrXhsmWLvWti/YbCofXiJR3MGPjJekAjt8vphd0ELxq1EC8Z3X78WjJp3w655w71bZrwKLd1w1sFQFtty+oH814bmLj+vZcI9z1P871uY9z2PgQMYqMtOQPz+U31ZVNFB7fUdWNCM39QuUMBgw3UHU/scRH5WF6AwcDHxME2PsNuGQQ6FRZ5KQnRjUujLt8jagyonR5cQZIjRqFZSQQfrGE+u5PEDRZg0Foo8FqupJoHTV4aDQYoICXroEknS4RDNDWWEMwWCRbevDCJZvHyYhtZeCsLEUIp80iLgOOQ9C7MkhIqWwdrGMG7QRBkGputheIpsLEymLIZrGCghiHf1kuzOkEpGScfCZBJ+t3rRMKjq7ne3pcNhWqoqyFomRcOgLRikOpMha1k4wSCxfJ63wkGWRCNkLJOyosNR6SxqgHjPAcIwmNVQxspy33MbLTic/PYanqivpCPki91923sYkc5RMAwKBjxXW07eBUt5lIdMmnrzDOvJIoIGD0VjOOvriAUgW8RwPVTARIUGCEAThFKo7jw0DpjE43jQkSMmFOnKCBii/4MjlQclGJvwuOWsEEddn8HxIBEC+0txFvYI1vXCWRMFZSHB6pTix88U+dMzWVTAJBGCLx4e4o8zoSvvF/1laXBgo2B4xOXnL7jcv1yAabBvLdx+qsmzq2D/esF+ddvnNTazWfHKOsXRTYI9Knd5vbK92E6C8ZIhgvGGXf4E7LaCUUoZsG27uB3r14JR827YNW+4d8MP7oEr7/K39xkNr/wMAls5z+5H98IVd/rbU0ZANAQvLxySyECFQojcHX0hzhl/gH+/ikEegdfn5QMHlxAeQSzSCFw62AOF0ZfGxSRInjBd9FKORZEY3QgKBPAfJQpBgTKKBHDIUk5nqXSLleyLGPDucYAEvSwvq6EnmKCurQer9LzNYZElRIw0HSTpTYTwSt65YLFAnVpNU2EFlqNYxL4IwAM6AlGS5FAKFjRWEu/1hfPapnKivWlM1yOUdfEMwBQ4hqCrpoLeCt/zGMwVKFgWhbAv1hxDYCrAdSlL9fb9kkNPLEouFKIjHiVlWYxvaSPi+IJ3TTJBtHQcPZbJHY11jMrmGKUUIc8P9wDD88hbFq6AVYkwloKG3ixKwYPDqvvaqTpX4PTlzcRK5bdHgtiNlawNB+lO+t3plZkChy9rZ1HA9/QtiYbJVkUJtKX7zp8TDaICFijlT1ASAjwPykJQykfWgUyRsClI5Iq0VkX745QCIRAohlNgZUu/wP/w1BD/WeWnm1IDD59tIm/zWLs2D0HT/6ABvz5jyO9hFFxEKt/v/awIg2kQC0LaEVgGPP5RkyObtq2eeG6V4uh7XBwP4gGwLzCZoEXjxtCCcSvZ4tNbSrkMuBE4FtgfWAqcD0wGfgDUAP8ALrVt25FS3gRMB8rxBdUPbdu+s1TWp4FrgH1t226RUtYCs4ArbNv+2xbsGA/8BZgGLAFuGhL/VKmsUcAxwI+llLeXbJ8GBIE3gC/btv2alNIE2oCTbdt+UUo5BlgMXGvb9lWlMucBV9q2/Q8pZT1wA3Ak0Az8fEj9FvBd4KLSsc8ELrdt+00pZXUpT5Nt22uklMcCjwOftG37plLeDuBY27ZflVIq4AvAxcBEYC5wkW3b87fQRkeVyr0Q/9zUA/8ELgN+CZwF9ABfsW37vgH5Tge+D4wF1uKfsztKccM31Yal+KuBw4GXgU+XivzT+jbcgr1PAa8Do/GvmRbgEvwb+DfACOB/wIW2badKearw2/54IAw8CXzRtu3mUvzlwOeAYUAncAf+9eWW4t9V22reBf95tX971lJY2QZjNr5+4GbzzlmxiUQK8gVIZSERQSmFmvEGJlkMXMB/iQughxogDigCRAjShYfRJ5D8MYKqJPzGUsCfoVzLMmpZDhgUCaOI4GHhEiJELwBZIqxgL0Io+kca+n7LJckGXpy0JwCV1T1MmbeSMtIoXCroJohDh5HoE4sAhnDZL/0aAPOY1vc2M4CA59Frhgg7DtG8y6pxNXiWSSCbx/AU1S05TNd/T+UjJsWgQUukv9u6EA5SMPu7V4OFoi+sBBRDQUzXRQl/BrWlFOWZDGHD7BOLAFWZDNmIL+SSjsuEQp4j2jp4YGQDQhgEPMX+LZ2YSrEmZuEIQW3aF9wFYVKdyxArOqRLHw81uQJht7/LvSpb4LAV7dyzV1NfWEc0iFAuR3X6bb5vOs3d8WBf2wjAyDu4CPAUWIbv4sOAjANR4XsXCy7EAuQQFIJWKc36QtafO8HKzGDRt2DAWMc5rfDgYlibBgJGv1gcUMYgCm7/V6ICih4VMYPOvG+448FDSz2ObNryGM53wkNLPdb/oE9vEZ5cobRgfB/5IP+W9CeAzwMVwGzgX8DRwFRgCvBh4OxS2ueAffBF07XAzVLKSQC2bd+IL2jukFIG8F/mj22FWLSAGfgv91p84XPpRpJ+EvgdUFb6bwB/BEbii6fXgftK3kcXeAo4rpT3OGDR+n0pZSOwB/BEKf4O/P6tEcAR+MJwIN/AF2onAw3As8BjUsqkbdtt+EJreint9IF1AQfiOyReG1DeRcCZQDW+8P79ZppoICZwFP552RM4EXgJ+DdQBfwE+JuUMlo6zuOAvwJfBirxz/X/SSmPKJW3yTYcUOcRwAqgETgV+K6U8tCttPcC4Gf418vdwG34ovEIfPE/AfhiyVZROg4F7FWyKQXcOaC8VcBJQBI4Df+a+DSDuYh317bvmVQq9cHZPmRiXxgja0glAptPPyjvhP68TVV4Y+sYSrtViTexARK+eOnt7UUcPAaBg4ca5MrtwfdohUgRIYWJSZTOvjS+wBMY+w/vE4sAqb4uZg+Fh4dFD5VkSNLFaDoZAYSw8LAoEiKNi8DBQKBYVdfvSesoT2IEi1TRRgMtxMlSIEDIcxBev7XZSIii4Yup4oBvegU4wsD0FCtGlNPakMQriRU3YGEVvD6xCGA6Htl4CGOAGFNKYQ0Qf65lgRB4QuAZBk4ggGtZuJaJUopYvkBVJoM3QAg5AwRn1jRYl4hgKRiZSjO/LMacijit4SBKCPKWiTfA46aEwDNMTlrbzpTOFAev6+Cgtm7yAwSzBygBtelcX1jQcQed0bKCQ1kqN+gcK/A9i6432GckBHTloDu/PsCvxxDgbMLhbxoQC0LIoqo6wInj+89DUwKObIJEQEG45NEcWJeAk8YIRiZLYYH+YwuYcMk0ixuOyRMw+408uNHf3pb34CGN/eVbht/1vcOfCTvhtmbr2dp1GG+wbXsegJTyTnwP40G2baeBdMlTtD9wp23bfx2Q7y4p5dfxBcxbpbDPAa8CrwAB/Jf6ljgQ3wv1Ddu2s8BCKeUv8T1+A7nXtu31Ai+DL2L63BNSyiuALwHjS/Y8DpyDL2ynAz8FfiGlLMMXc7Ns226XUg7D91qOs227G+iWUl4DPDqg7ouBn633VEkpr8UXKqcAfy/VNR24tfT/CuB3JRE0HXjStu2BA62us217Ramsm4Hbt6Kd1vM927YzwIrSuYnZtv1AqaxbgT+V2mA2cDnwW9u2ny3lfaXkmb0QeKZkw+baEGCBbdt/Lm2/LKWcBUjg+a2w9R7btl8qlX078J3SsXeUwv6Lf22B7+WcBky3bTtfiv8m0CalHG7b9irbtv85oOyZUsrb8L3j1w8Ify9t+55IJBIfnO1fXgTjG/xxiJccT6KmauvzXvcJGNcA6zrhM8dhBEzUnx5h0a0LKbTnSVsx3L3HcPC9Jw3Kq2Z8EQ74NsbCVaxlFAEKZEn0fe1bA8YixkjRRS0GitDhI4leuA+hc6fQNvpvFFt9cRGh/8VikSeLwBvw2MxQQZZyQhRwCVFBKyFyFAhi4VCWr2ElNQDU9nQwsbAIoyR9WqijizgGisreXtqSCbrLo7Q2lnFXw5lMWvs2ua4wbjGAgSJnmLTUx6jozpJKhDA81deN6lkmXsDEE2CU9Es6EaKrMkYwl8MxDTzLIlAsIoCMgq5EjFi+0OcXzQWDWK6LaxjkSuMLA54vNjtjUaKFIp5h0BaN8GpdBbGiw1uVSXIIsqbJXh0pTAWr4jHSwQAZx8NyPZwBYtB0PQKeR8SDaR09VLV1sa62ks5ggIjjUtMQoJhxodPhsBVtmALerkxQsExWxcIML4nIrOmPySw34MP7BblrjkPB9etJFl2yAYNiSUxHDUVmvZB2PChNbjeFwi2WwoNGn3fQFAo364BlYIVMHjw/wLQGg3GVHut64dNTDUaWCZ49V3DP2x51UWhLQ8ZRmAbsV2dwzp4G7VnF/73mEQ0EaQyYzG32OH2yxQEjLCBAXbniwSUeBzcKPjzO2Lr74h1sn5KAGWfAC2sUJ44ymFYvgJ3o+bCTbG8/dj8P49YKxrUDtjOAa9t265CwhJTSAK7GF2H1+B99MSg9MQHbtjNSyhuBX+F3yWa2ov7hQMuQtEs3km7ZwJ1SV/Cv8AVrOfSNfF9vz+PAr6WUiVKay4GP4HtPp5fi19cPsHwz9Tfhd5UDYNu2V+rOX9+v8ji+Z68C33N5H3Alvpd2OoO9ZDC4zdMMvNM3z8bOTV+HSqn9GVDeaOBoKeVXB+Qx8T2kW9OGQ219p/YOvbY2FjbQ1hDQXDqG9eTwPb+rpJTnAl8FxuBf30F8D+um6nwntmreCZYJl5387vN+4aRBQeLacxnx5TwLb1tMWcxi3IVj/fFjA9OUR2Hmz+GPD1PbW6QzXUV07jIqptfg1tajfvsgvOaPhfRG1RI77yiChzQRPWVcXxmjXzufzr/OhZYUkZ4ainesJEABA0W7GcV0fbe7W5oq46Oo+M10igtaKd49i2B7Fx4B9l2xmLxr0RYt49Clb/UtnC0AC8cXaqEAPdEIwlPUrO5BOKCMIKvTYwl4LlbApas8QioZohC2KAYNwjmHXCRAOJPFNSwqOjPEU3mciOlP8wkYtNXFCWZyCCCQ7yabiPV5JAOOQ9jxu5/xPBKpDEsbazGVIuJ5feKpJxwiHwjgmCaiPMwpZ1SSToTZu0uxLBZm/kyHqrVpCsEgrucxNpXl0JEWBxxTQXuHi/nUEh5cGyETCBD0PGK9GfZYuY6eZIzyrl7eHDeCvGVx5KFxxo4OcdKRMfI5jycf7yYYFHxn/yS/ek2xpsvl/OlVjOyK0N5SJF0VYVJOcOLUEJOHW3x5ncvfXs7zwNMZEgUXt1hkwv4J5LgAn9zPYK9fplnbraDoMTbicObUIBELrnnKgaIHpoDSwt3HjjS45MQQs9d6nDHJZN9Gv82+sN/ga21qrWBq7aa7kasigqsOWx+/YbrDhwsOH75tu6GH8qGxBh8au12r0HyA2Na/9HIuvlfteOCtkmiyGSC1pZQT8UXln4CfSikftm17qOAYymqgVkoZHSAaR28k3dCpkD/B7x4+0LbttSVh2LPeHtu235ZSrsPvjm0ujS98HN+7eAz93c6rS/9H4o9z3Fj9KweGlcTzqFI4wDP4XcKX4U/WKZbqOgPfg/rJLbTB9mI5cLNt29dtIn6zbfg+sxxf4FUO8cYCIKVswvcWfgR4yLbtgpTyF/jeTs1uQKgyxF6XT9p8olgYvnE6JlA9INgAOHc/uPEp6OjF+MzRlNckN8gebEpQd/VBAGQfWUzLHfOJ0YFLkHWJ8bR7YaoLKWoKPYi+q1AQnNZA8JL9mPnHFZgkiZMha5qM6VjF3usWYbrmgFGOIBDEyRK+cCrRuV10v9iFAhpWd1Gu0hSwMFAUlEVXRRi3NDkjli0S68mTiwTIRYJ0V8SIp3zPm2cIUvEAnikQnjdojJ/pFvsEo2NZCMAxDIrRCIcelmChUU3zwgxjekpeVUvQEokhlK+nLvpWA5Mn969TCfC1wwJc/ySs+Uc3btHANQyOPirJIUf4k2y8U6Yy9sZF/OfRLpaG4qyorWTi3jHOqC3gjBrLMC/ChPEh9p7cv4i3FTf50OmVfft/PhH6X1Ub/xWZvepNfnValC8dFOTx13KMqLU4XvYPLZjz1Tg3vFSgLCz4zEFBAqYgXVD8+aUizWkFvR7HTQ5wwjiLS6cKYkHBmZM3WpVGs1XsjmMYt7VgTOKPxWsFDCnlRfgetP8ClMbN/QP4jW3bV0kpQ8CdUsrp6yclbIKX8MXCT6WU38IfK/eVrbQnA3RKKeP4Y+WG8j/g68DfBuxfje/Jeg7Atu1Vpa7dn0spLwYi+JNEBnIz8E0p5TP4ns5v4bfvA6UyslLKF0t1XTmgrtuAtbZtD50C+n7xG+AmKeVLwAv4n8JTAGHbts3WteH7hY0/sem3UsqrS8MFavAnC92FP6vBwL/+ilLKg/DHSM7bUQZrdjIsEy49dquTB/epQ1WX09Pm92NO/MF+dFdXk12bId7ZTvoHzwFg1scITK7GiFjEDqkn/cI6uklSsU+ckZ8ewbpUjNyTK8gdciTOVQ/jeAGKhLFwafrOvgRHl7Hmuy/Q9t+VOHNaCeBhAD0iTDoSpHZdL4WgRbDgUtaTJ1sfIZJysBxF2/gaVpsGjhKsqK8mmsvimQZ1re2YlASqgKBTIBOOUoiEKAQC/rhNQxAvszjkyxPIvJ7n96tcFhqCcuHy3W824AiD+Qtz7DUpwvixoQ3apy5hcOWHY6ydNoJZr/TS2BRiqoz3xRsBg/0+twcTPuHxyHNpQkHBCYfFsErevGnv8jRuilF1Fp8+Ob5BeFXM4DvHDv6pxVhQ8Nrnw9w202F4mcH5U029YLdGsxm2tWC8Bd8ztwhfZNxGqWuzxB/wX+bXlPYvw59dezUbCrA+SrOvP4w/Dq0Fv+v3BuDXW7DnKvzZ1O34s5SvxJ9QMZDH8D2Jj5X25wBZv1o7OyDdefiztFfSP0v68AHx1+GLzEfxJ93MAo63bXvgbwk8ht+1u76up4AocO8WjmO7Ydv2o1LKS/Dtn4DvpZ1Lv6jdmjZ8Xyh5rE/HnwH+WmnGdCt+m99l2/Y8KeVVwP34rogn8ceP7rMj7NXs+ph1cepeupjsffMJ7FlN5EPjGeiTjO5bR3FxJ7Gz98Ss8L1k4x8+hfab5mNELaoumoiwDIYBfMN3dLe83Ezhv4sACE8fTXB0GQCNPz6Exh9D6pHl5N5oY9X1b9PVociH/cd0IO+LxWBNmL3/PZ02u43EHmUcMaGcRc+1s/jNXta9kSWbjNGY8Ij0GLieh1JwwBcn8OgjLXQ7cVAK03EJuC5NExKcc8VY4mUWpx9tUV1hsKbF5Yj9wtRX+/XuOXGw0NoYDcNCNJyxoaBcTyxq8JHjd76RH8OSBt8+ctf57WuNZkeyy67DqNHsougb7gOOyjukb3kDDEHswr0RwY2PY+t6ei2PnPM0av3SLwIO/fpkqk8fSWT0huLLcxVznmijkHWZelwN2dYcy55upmp8guEH1XD1+a+SS/XPVE+kM5z+3fFMPrZmg7I0mg8Q28WtnBefG/SsD6k/7fLuay0YNZr3F33DabaaZ857mjVPrQOg8bhGjrjl8C3k2DS//e6zrH3TF5pVtQHO+vwwRu9Xvi3M1Gh2ZbaLkMuJzw961ofVH3d5wbitu6TfNVLKhxjcxduHbdsbDkr5gCKl7N1E1LO2bZ+0ibgdgpTyu/iLmW+MkwYs5aPRaDbCYbcezor7V6BcxYjTR7ynskYf1EWyLs9ee+7L1CMrCIa2dhlejUaj0R5Gjeb9Rt9wmh3CjBkzADj11FN3sCUazU7FdvIwfmGIh/EPu7yHUX9iajQajUaj0Wg2y07TJa3RaDQajUazO7A7rsOoPYwajUaj0Wg0ms2iBaNGo9FoBuHkN/c7ChqNZsuIIX+7PrpLWqPRaDSALxQfufg51r7STnJkjNP+eTShcr2wtUaj0R5GjUaj2eG4bRmc1akdbQZv3b2M1XYHninoWpXhkc+/tKNN0mh2SRRi0N/ugBaMGo1GswPpuW0uC+uvZ+7wm1j+sYd2mB0zH2vlP7esK/WgCRCCtrldO8wejUazc6G7pDUajWYHsvY7z7E8UIEbMmn/1xqit71NzQUTKCzpou3s+6A1TfI7hxC/dNp2qf/BR3v474Pd5FpyNAnDF4slHMOgkHYIxvpfFZ0LenCyDl5jgs4ul3GjQ1jW7uFB0Wg0m0YLRo1Go3kfyT6wkOy/FxA8sJH4p/eltRihYPm/J50OhllzxQu469K0XPUCiWw3MbJkPvcvglNrCB783n7tZSjPP9jKLfdkCBeKVKUzpMNhspEwkWwOBbRH49x67otMO62e7uVpDNdjzox1pOJh5owZQSEQYMzIAD+6okGLRo1mN0cLRo1Go9kOeG1pnCcWYU6sxasrI/3UKkxcus77F3ge+RtfpfmLj2PUDyfQU6BomiAE7as8Mt98hXQ0TJnZRsAtArDyiFtZXTGMUV/aixFX7P+e7VszP8XDv1+KUVPDmLZ2LM8DoLO6nGbLpBgIYiqPTL7IqzNytJZXIN9eQjAZZVVNFYVAAIBFy4vMW5BlyqQoAC1tDguX5Bk3OkRdjX7FaD6Y7C7jFgei72aNRrPLoXJFyDsIx4GKGBjbcDh20YFUzt/+8m3QlYFvn0rr7Dwd9y8ntlc5w356CMLasE6VL9L185fJPLyUyKvzEUUHF4PW5DDcniIeghgGMTJEyNORi8OyFEkgZ1lEvDyWp2hPxChYBt1ujKSbJUWEjBtDpIos+fEsci+sIRuIYcYDjP/NAax6YBWrHlhJ1X5VTP723jhFheMoIlHfc6k8Rf4VF9d2eH3WLKZ+cwrLn2mmYWULyZYunEQUzzJBKVzDIJHOkg4UeauhllwwSDKbZ7/5SzBMgQK6oxEMT6EEGEJw910dlF1iMndhnltu6yBYcDFM+NrX65kyJUZnr0cyKjCNjb9E/zXf4YbXPPaoEvzkWItoYPMv26Kr6C1ARcRP15FRJENgmYPzFVxFpgjl4d3v5a3RvN/o35LehZBS/hlwbNu+bEfbsjmklIuAH9q2ffOOtmUnRN9wGyNXgFufAkPAhUdB0PdeuffNQq3sxPzYNERdEl5diHvj0+RueYNQvhWLPAyrhEtOhBOmwuuLIRKEKSPhmbfgkAm4zTnU0nbMM/dBPPsmtKfg40dCeWyQCd6ry1D3vIL358ehN48ZEoi8i4egi1oWM5b166kNH5+h/usSDIG48GAAnO/cT/a3z9DqDsOiQJw0LoIEXZh4gIcCVjGCaroBeItxAzwRigR5VscTGKbCUIrOcIQ9OtbSJRIUAhZZKwSAUB7KAYQgYAl6ohb5oD/+MFYTZnZdPT2hCGNHBNg7lmfBG91EZ67pq6n8sHo63u6i0O17L3PhEJ31lRieh1AKD+hKJhDAsmScLsvio8/PpBAOsrSpjpU11QNaThErOiwMB3k+HuOE7hQNRQeAULHIykm1LGpXDKsy+MaHYsyek2FEEk45voxE0uT6WR6XPlZa9zHrcO5EwZ1nhwFY3uXxr3keE6oFJ403Wdrp8auXXG58wyNXhI9PgkxOcd9bHokQXHxggCNGmrR0e7zR4nLTGx55DC4/yOKaQwxun+1QHhacO8VkSTf8d7EiZClyjuCI4YLKMNy/WLFHBaxLQ8GFT0wWRIYIWNdT3P6WIl2ECycL3mqH51crjmoS7Fu37cTp2l7FPW8rRibh9PF6jup2Yrt8TaTFlwc962PqN7v8V4sWjJqtRkr5FPC4bds/3EI6LRg3zQfjhkvn4NLr4c0V8Imj4LPHw+dvgJlL4bzD4Ztn9KctFGH8F2BFm79/zBTIFymuLuAs8z19Igih6Q2IR2eB46JggMwy8IgAAg9BgSgCv3tVIFjfkSJiFqH0SgQKLBNG1MBxU+F3n8R7bQXu4T8HVwGKIhYGigBpPCzaaGAl/eMHa1lFI81++TUxcsUIRleKHEFM8gTJ0UMjUVKEyfblEzhkiVAkhoXLEprI4osjE5cYebIBi7JiHoCMFWBlpIJkqohjCtLRAEoIvIDCUh4ZK4DpKrLRAGqA966jrhzHNKhtTjG8uYOuZJicafbFp5JRlFIE8wUAHMukvbG6r017olE80yi1L7xYX8MFT76CAN4cN4J1tVV9ZQUdh6BSrAlYpE2TcaUyUYq2oMXyUJhYsUgqHCqdJTCUYlogT+XpjfxkJhSV6MvD2l6aGoIo12NdzsQpxR0xQvDsCg8VtfyJOXkXHA8GrjFuCQgb0OuApyBo+DVaUB9UrOvxk529t8FjzRadGQ/yHiiFCBkkYybd+VJZjgem4MgmwX/OMPnsYx7zOxQfmyD402zF8lJZe1XD/A4/uSEgGYSoBVMrFWvXFhhXbXD9R8JURresF1xP8eUnPZ5Z6WG4ijeaFZ4QEDD4+RGCbxxgbrGM7cWMxR7XvOBRExHccLxBU3KX1z/r0YJxK9Fd0jsBUkoBmLZtOzvaFo1mm/Cje+H2p/3tWUvhrVVw85P+/uxlcNAecMRkf//3D/aLRYAn54ACjyrA96ipAqgHZw4Qgv24xAETXzoqIrSQpRaHKBZFjFIelXbwsDApguPCknVwfTPs0Yhaky2JRb/0AA6+R9BCYJKkmzBpcsQwcahmLR4B33PY2kuQDAViROkhgq8k0hQ3GMfkW2jQTTkWBSrpJEUcAQQo4BAmXiz0pY86RYohk0LOIVhUoCDhZhnZ046BoisY4e3yWoRSfXUJTzF5+XK8lElVxher8XSO+aNqsRwXTwi6K5NE0jmCuTxKCLKxMJGeNF7AohAJ+aJ6ffsKwbh1bQh88dgZsFBKIYRAKUVAKVzgrViUQ3p6+w9WCBKZHBfMW0TQ9Xhq/ChWV5QD4AnB2m6PW5/MU0yEBi/wFrZY2eFByOr/vFKKZ5Yr/8SbBmSdAedrAIaAdEksAhQ8iFjg9YtFgPvf8sjH8MViqRyV9ehGwPqhBpYBnuLpVfD95z3umu+nm9UyuN43B1y6noKuvP+3Ji2gRzBrrUNlJM/1Z4Y3tHcIf3lD8X8zFTilP98yMBQ3z4VvHLDFIrYLXTnF2TM8co5vz6WPeTxw5o4Tr7sCegzjboCUchlwI3AssD+wFDgfmAz8AKgB/gFcatu2I6W8CZgOlAMr8T1nd5bK+jRwDbCvbdstUspaYBZwhW3bf9uCHQr4MnBBqe6jpZQx4MfAHoAD/A/4km3bLaU8N+N3SX+6JDJ/CFwMJIB24Je2bf++lHYv4JfANCAD3AFcadt2cQt2TQeuA8YCBWCWbdvTpZT/BxwOHCyl/Daw2rbtCVLKAPAz4OOAB/x6c+UPqWsZ7+BclPKMAH4FHFoqZgbwNdu2U6X4HwMfA2qBZuD3tm3/phQ3qlTHhcB3gCbgReATtm2v3Vq73wupVIpEIrH7b7cNWYR6Xeeg3ezKFiL4gjG/pq0kC9fjSxODPF4pRuD2iUXwdYRDGJMCvlj0UynAQBGiB4coHkafYER4GGoj32StPeTH1BAY5Lf0F9sVpbItHMaxiCKKMBkEAby+tP12mSV3Vwc1rKMWgWI0S7Bw8TDwCNBGPVnCKCKU0UMZGRQCE4d1JAlS7CsnawXwDIOIUSBvBTEpUpvvwUDRS5iuQoKqtjzlZjdLq2vxECS6CjRmu2g2K/rsMgBTwMpR9RSDFq5lUtXSRVt9FQhBsqO7/2iEQEUimEUHoRSJ3jT5sgSt9VXMrq8ma1kc8+bbLB1Wx5PVFawpKydnGPRaJntkszQV/DbuDFg0tbUTdP32GdPW2ScYhVIIpUgHLEa19tJWFsYTgrquLEvjEXA9+hTqQBR+3PqeMSHAKG0bAsIm5Ddyjo3BhcUCEAxCKjOkgqE9boagIqToyG365T8iCatSCk9tJE0pqC2jtureWd2dBwIblqMUTQljs3m353a6SEks+jSnXdbfdzvNM+ddbmu2ng/qoIhPAJ8HKoDZwL+Ao4GpwBTgw8DZpbTPAfvgC8ZrgZullJMAbNu+EXgcuKMknO4AHtuSWBzAp4BzgDgwE8gDl+ELpSlAI/DbTeQ9rnQcB9q2nQAOBJ4HKAnXp4H7SmUcXEr/na2w6Vbgd0AZMAz4UelYLwOeBX5g23bctu0JpfTfBj4EHAKMBkYBI7fm4Ets9bmQUoaBJ4C3gDHAJGA4g9voLeAwfBH9GeAnUsoThtR5DnBE6fhi+Of1fWHgQ2q33v7yh6Cu3A84dm/46QXQWOnvHz6JyJmH9qUPXf5haCqNiRtRDT88F4TAEhkC503BagoSpA3RVA2fmg5Q8sjlSiJy4Evel3GesPC7qAM4BDBFhtBPTkB88piSeCiVMrIWPnc80c8dh3lgIxtXKGDgYuDhEqdIOQVigIPAQURMHCJggEsQF4vlTKRIiAJhljEGhyAeFhliZImi+h69AhcLD4siQToiYbqJ0CtCrIsmWFJWRTifpyyfIUCBmnQO4flWtVCOi4nwBLliFLluKdVr84SzHkGKFDApCr+eomHgGh7lrV2UdaQYvqwZ5XkUo2FfvA08ZNcj4Dg0rVzL8FXrqOpKkXMVd08eTz5oUdWbxnRdgsDUTI606YvFpkyWUZk8puthuh4toQDLk/G+Yod3dZMyIOC4xAtFDj+9mn2HGVRlCuy9upt9VnXR0JtHKOWfIyH8N5SAAxro9xr2FokH6RN3e/akqREexAMELDhxUqD/FAdK60qaRt93hWXA384I8uL5JpHIgFegKThnT4OYOfAaUNxxisHXpEF1xA85qAHiJU23by3MvtDkfx81+eK+gvIBXz5J04O8S0UEvnVUcKvunc9PCzOu3Lcl2P8dRF1CcNvJxmbzbs/tYQnBZfv6jRqx4NrDrK3Ou7Nvby92x196+cB5GEvcYNv2PAAp5Z34Xq2DbNtOA+nSWL39gTtt2/7rgHx3SSm/DhyFL0wAPge8CryC/2l42juw4xe2bS8ubbv44nQ966SUPwc2JT4LQBiYLKVstW27Gd+jBr4HbbZt29eX9ldLKX+C7wnckjgq4HsX62zbXgc8uYX0FwI/tW17EUCpfT61hTwD2epzgS9MhW3bV5byZqWU3wdekFJ+xrZt17bt2weU/YSU8gF8D+YjA8KvsW27bUCdn34H9mq2hklNsPRP0JbyJ6UYBiz+I7R0w/CqwbOaR9TAwj9Ac5ef1jThM8chhMCqToLrwuoOX4AGTKgr8ye0ZPKIaATzgAm4M9cierOIQB41bArmdZ8gcOVjeMs6CZ49heC5+0Bl6SXxi09ANu8POqsrh5D/9jdeugZ++xjefbNgQh3mt07COeznsK4LhaCXOHkMEqEU3t4TMPZtwvjqMYimSiI9edST83HP+xtFkoNfEGURjClj6H25ha5i+YBGEr7g60trUJnN0kuYHmVRLBiYpkJh0hGIIxwIqAI5/C7jwbJGYKBIjAlTvm4tkUyREUY77RNG0ZVXWMcPI3JgC4vvrqRqeQ+tyRj17V0YjosTCuAZwp/1DLiWgeEMHBgIlueRtyxWRqPMqqjgmRGNHN7cxqjuHj6XzZGxTIIRkwJmn5ATwEN7jOTYBpf6TI6pH23io4fU4hQ84kFBZcLg857iR4Ewj77od513Bi2UEPzmBJO2jOLJZYpjRht8/3CT7zyc5/llHudMtTh33yCf/1eO4gvtJNNF6Ohlr5Mr+cJHkiSCgo5MkJdWe/zsVUUipEiasC5lcc6eBh/by6SsNGv61U8GOff+Iiu6FMePMbjxZIuso/jsox5r0/CdA01OGuNfq8svMWnPwvAEpIt+t/PwhF/OUSMER42Anx+pWJ1SmAYMixs0pywqooJYcOsEQ0NcMPdik3VpqI4o1qZAGNCUEATMHSs6fn+syXcOVMQDkAztHgJI8874oArGgd2PGcC1bbt1SFhCSmkAV+N7pOrxP+xj+B5AAGzbzkgpb8TvJv2kbduZd2DHsoE7Uspp+F3SU4Eo/jM3vmE2sG37KSnld4ErgHuklC8C37Nt28b39B0qpewakEXQ33e3OU4DvgvMkVK24gu632wm/fCBx2HbdlpK2bIV9axnq85FaXs0MGLIcYF/XurxhfGX8D2Lw/GPOYIvNjdVZ3pA+ZptSSQETQNcLuGgLw43RigwOK6mrH/bNAfH/ej8QVn7p7UMyAJEbzl343VVxP2/jWBcfhzG5cf17VsvfQv3sOtgVScVJzRgnDUVccwUGFM/2IZoCHWORP1rJtw7k4ZkJ+t6qzDiFiPuO4nIMcPxXmmm4+DbsTyXIiYgKBIgiN/X53eIK0wUDoJsJACitIxNOELQceiIRjjg/OH03DCbqkKKDpVEKI+6QDc1d5zBqI9OwlnaSf7J5dROq2fS1H47Z8yYwZRP9VBTdwTVVRbzz3sEY3kz2WiYQN6lEDLJBwMEiw7hfA/5oEWw4Ndpj2hEAa3hEAhBRabApDXrCHiKciDdWME3b5zKdT9azaqFOXoCJjMrExxYB5//wZQhy+n0P4YsQ3DlBUnkhCDXPuUwP2txyniDz+1vERwikH7xocig/X9eEKH3jAZen5mhutpi0p798ZVRwcnjTU4ev/FLYD2TqwVvfCo4KCweFNx3+oadb9GAIBpYn8b/G0rYEoyt6Ld7ePnm698YQVMwIgkgGFv5zvNvTxrjWih+kPmgCsat5Vx879PxwFu2bXtSSpsBY+6llBPxReWfgJ9KKR9+B+PhvCH7dwH3Ah+1bbtHSvkh/DF6G8W27RuAG6SU0ZIN9wEjgOX4s5lP2Uo7BpY5GzinNEbyMOBRKeUbtm0/sRF7AVbjd0MDUBqHWftO691KlgMLbNuevLFIKeWh+F7UY4GXbdt2pZT3sp1mwWl2f4yR1Rgrf4ZyXIS1+e8tYRhY93wW5bg0WCb1rj9tVpR+ai92QB2jF3yK9mtepOO2+XiY5Evj1Uw8XAyiFCliEqNISgVRA36mrzsRZMIlE2n8wX40/ObIvi5aBQghECVRZo2uwBpdwcYIBV2OPMwXy9ErpvLiV14h0ZPGCVt0xaNEMjnfo1sqd019NQ+PHUFvwFdHBv5DYFR3ioCn+sKOPbmCUMTiih+O5NXH21k8u5cvTCpw6EnVGxoxtN2E4JQDI5xyIDiewtrEWo0bIx43OeJw/b2n0bwfaMG4eZL4k09aAUNKeRG+9++/ACWh9g/gN7ZtXyWlDAF3Simn27btbqLMLdXXDaRKkzu+vamEUsr98aeQvoo/9jFVshX8cYhfk1J+Et+7VsAXdXvYtv3wZsoM4ovkB2zbbpNSduK/H9aXuw4YNyTbbcA3Sl3Ha4Cfs/0E2n+BH5Y8q78HevHHaB5g2/a/8NvPxT9fSkp5CnAS/jnSaN41WxKLG0srzA29VMGx5TTcehKx08ay7vNPIEIWRtTAebvLzwO4mOTGVGOuzOGE/c5tV0Aorxh3ke8yE0L4s1h49zfb6DNHUbVPJelVGf53XyvFmZ3Ee9K4AbOv3HQwyC8+FiPYGKUsKpgzJ80vnnHIxEL9U4QEDN+73yO8//Qq9p9etbEqt8g7EYsazc7M7jJucSAf1EkvW8stwMvAInxP2iT8iR/r+QO+OLmmtH8ZUIXv7Xs3XILv0Uzhews3J3QS+JNT2vBnSB+PPzuY0tjDo4HT8buLO/Enk4zZChvOAeZLKXuB/wBX2bb9TCnu14CUUnZJKeeWwn6CPz7wJfwZyCvwPYHbnFJ3/7H452E+vrj+H/6kJEp23IY/nrQNOAv/uDWanYrkmXuwR/OljF/xaWquObRvIk6GIHmCTLz5cPb8yTQaT26CoImBYPgZI4mN2XhX+ru2Y2yShiPrOfjjTSghsApO/0xhT1GeybJyjcPBE4JMagpwzsnlvPrTah6+eSxn/Hof9jtvBKf9Yh9GHPDuBKJGo9l10At3azTvL/qG02xAflEnS772Cr0rc9R/YhxNl/ePusg1Zyl2FohPSPZ1b78bZszwR7eceuqpG41/9f/mM+u38/xfegmYZOIRlGUy7ZuTOeKM+o3m0Wh2A7aLK7BHfH3Qsz6pfrHLuxx1l7RGo9HsYELjKtjz/qGrP/mE6yKE6yIbjduW7HfJHrS/2srimT0UYv4i08IU7H1A2RZyajSaDwJaMG4npJQP4S90vQG2bW/bfqV3gJTyfOD6TUR/1rbtO7ZhXX/GX9B7Y0yybXvFtqpLo9G8N8ygwYm3HE66Ocurf19J16osU05rpHzY9herGs3uxu44hlF3SWs07y/6htPsELbUJa3RfEDZLsquW3xj0LO+TF23yytI7WHUaDQajUaj2Ybsjh5GPUtao9FoNBqNRrNZtIdRo9FoNBqNZpuiPYwajUaj2Q3onddNdnnvjjZDo9HsImgPo0aj0XzAmHnZyyy8ewWhvMPob06i/KgGhh1YjRnQPgSNZluwO85u1IJRo9FoPkC89d/VPPNCJ96oMqxCkVkPddD6bJ5po1dx0Z/2fU+Lg2s0mt0XLRg1Go1mN0UpxcLbF5K6by7D1FIWHzyWGf9+m2x5klhvBtcwWFhbTaRY5LZsJQfPzzBxz9iONluj2eXZHWdJa8Go0Wg0uylzr1/Ay7+YSy4WRjABsdaltaaCEStbcU0DARyyxF8/f3xzG3c8EuVMy+Lfz2Xp6XGpCSsOl1EOmxbdsQei0Wh2OFowajQazS5M8y9n0v3vJcQOqqfxpwcjzP5xiMseX0MmGYVSN3OwW7HP6sWEHAeAtuo4yvTj4oUibz+9jq++nsKuqcRUgoIwKC4o8P01iu+f6nse5zW7fO2BPJ5SXHdymCkN5vt8xBrNroD2MGo0Go1mW3PvC/Cd26EiDrd8CfYcjlIKIQTFtWmWXvA4hSU91HxpCsUVvXTdMR8zm8cyHGLdqxnJOnLPRbnf7mH2pHGcdHYNwxauYd4qqG9LE8kVyYUD5IMWya4c+biFJ6Czsox0LEwkl6dQKFLT2sGkRasY3VTPgqZ64p3dHLh6Ha2zQiyYsDe/esPgry8XcAwB8RBPXp+j3nA4apzFX86OErR2v5ekRqPx0T8NqNG8v+gbbjdBpbKQLSJqkwC4bRmE42B4DjRWDk7bnUUVPYywAek8BC1oT+Elojiz12CdcAVG6dJQciyLogeRe3Y5kQPrKbzVQa5nvRBTJOmiQASBQZheRvNmXz0Lw+NZYo6luTqOJwTLRg8jnYgSyhWZ9OYyUBDMuKiworM8Rm8kQD4ewVIK11PUtHSWaoGn992TeDrFrftPxjUEB65Yy9zaKsZ15ggqxbJ4mJXJCBRcUHDRvoLrTghiOVBWYXLTTJfLHigQC8DdZ4c4ZoxJa69HyBIkw1pYanYatsvF2C6+O+hZX6V+vMtf9FowavqQUi4DrrBt+3Yp5ShgKdBk2/aqHWrYdkZKORxYCYy2bXvZdq5O33C7Itk8vLEcRtVCXTnev2eS/djNWPkMga9PpzdURe5Hj5PHJEYnsUPqyP3oU8TNNM5zy+n9/lME3BSJQDOi6KCAPBHWsBceFlE6aWA+AnAxyBPHIUIHw0kRpUgQgSJKDhOFB7iYROlhJPNQwCIm00ktC5oqcU2DXDjIwomj+w6hqrWbyo4e3ho1jOqebpbHojwzaTShosPRS1fR1JWisrmjL/3zU8bz70kj6YyFQSnK8kVOW7SWVDDAqlgEVwjejIUpWKbf5W3AiEKew1a0Ex4T5aZABcowQClqgh5HjhLcO9shaMLNZ4UYUxegMaaYtcShMgKNNRbtacV+wwwMY5d/t2p2HbRg3Ep0l7Rmt0ZKqYDDbdt+bkfbotlFSWXhsO/6gjEZRT30fVZ8/DFy+ZEIPIb94imidGBSRjUFXAzeeiFC19GPEiXFPjyPSSMBslD0xw4KoIOReKVHcIYKspQRpRsTjxC9rGAKRQKAwsDFwsMsfW8YgIciQ4I0STygk1rf3vWvqSGfJp4haK4vJ5+MsDQe4p69RpIOWQjPn8/58dnz6K6IY7iKdYk4q6sqcExf8O3ZlqIqW2RJIkY6ZDGzvhyASDqPmcnjhgNM7MlRXXBYnoyxIBVAVRv+gYZNWoXFvSsVhBWFnMuF9+RwKg3GtfUyqiMDwJJwkCXhIB/Zy+LeCyJ6eR/NLs3uOEtar9Kq2amQUga2Jkyjed94fLYvFgF6MmR/+hi5tC/0FAYOBgYeEQoAmHg00AxAhgTdDAdC5KkiQ30pn8AhMqgaA6dvO0N1SSwCCApRk9aGoek9GlhNFw0sY09USSE2tqVAKZRS5DzwANNxML0i2WDQP4yQRTpUOgZD0FwWoRAMsK6xjjUjGkjXlOEEBNNaehjX2UtDOo9QCoRgXlWiz4ZsLITM5qlP56ku9IvhxqIDSoEl+ibcIARESnU6CuF4jOjM9JU1Iue3331vOizr1I54jWZnQwvGDxhSysullPOllCkp5Qop5U+klO9pmqOUskZK+ddSeT1SyteklBNKcVVSylullGullOuklLdIKSsH5F0mpbxSSvmklDINnCmlfEpK+Rsp5b+llD3A17ZQ/5eklEtLx7RaSvnjUvjsUpJHpZS9UsobS+H1Usr/SCm7pZQLgBPfy/G/E1KplN7e1bZH1vSLHsCaWOMLoRLutFEIPLwBHoUc4f709N9eReIUCNPNcIIUsSgCHgGyWBRQmLhEsQCB15dvcUMj9xx+FLPHjsCXmx5O2MMAkvQygtVkohYL6yuZM7KOJ6dN4sHD9mNFdTnrwiFGLVpBZVsXo5atIpHqpaGrB8PrL78il6c5Hu87zojjsWdzJ/stX8vhq9tpTGeJOS4ohTlwGJNSWMB+6SzuAIdKAYHZmwenvw6/sRSm6xF2HJQhyFr9bZM1/NdRMgRVUfHuz5fe1tvvYFuz9egxjB8wpJRnAq8Dy4B9gIeBK23bvv7djGGUUhrAc8Ba4PNAK7AX0Gbb9hop5cNAEbiwlOV2ANu2TynlXwaYwIeBWUAYeAjYDzgdeBKI2Lbd74oYXP8epXz727Y9V0pZDky0bfulUvwGXdJSyv8BPcBFQAS4FzgUPYZRsynueBrufBamjoJrzyX10DK6rn+D4PgKan58KMafHybzvf9SyFoUCNEZqCU/Zji1kVZiS1twu9cLJ48CARTrPZSKdsJU0Eoda/BIIErCcyVNdAYrmD+iiRen7IETsNhj1WqOeX0Oq6srqc+0ML5jdZ+JK606Dvv2pXTGo4zpTDO51X8pjljXyt6LV/Sla62qIBMN0RwLcu8+exAteIzoymB6in3bOog6Lgo4aPZbvDB1Ul/XcFskzGu15bxVV+ZL2dKVPG11J8OzeRYnIrgIoiFYrAwyRd/nqcrDBOMBQiZUp3NMrIBjpoZ5vMUkkC2Snp8mZEFyZIiUMvjW0UEOHaVHS2neN7ZL33Gb+N6gZ321+tEu30et78oPGLZt/3PA7kwp5W3AscD177JICewPVNu23V0KewNAStkInADsYdt2Zynsq8B8KWWDbdtrS+n/Ytv2zNJ2VkoJcK9t20+UwjYqFks4+Df8ZCnlctu2u4CXNmmslMOAY4BxJXu7pZTXAI++k4PWfMA4/0j/r0Ti1LEkTh3bH/+VU4lceDThnz4IrkfNN09C1JcB4HVmyP/0KVTeIbxPOeLZN0m3h3GsKAKP8R0rcF/K0ZNtAgTBMQnSSzqx6MIxqnhtyjicgP+orm3poT2SZN6I4VTP70ThX/yuELzZOIzvz3iSuaOqqEv1oAoVLB7dgBcK4gmBoRR4isrWbspNE6++kiMWraM9EfePQQjmlCcZ350iUixS250aNI4wUnQ4ZFULiypj5IIBUIpw0aU2X8QAeuJBrr84wYnjDBxX8buncyxpc7nooBByxPpXTbCvvC8D/rdivzdWo9ld2B3HMGrB+AFDSnku8FVgDP75D7IZgbUVjAJaBojFgTSV/i8dELZ4QNx6wbhsI3k3FrYBtm0vkVKeD3wOuFFK+QZwrW3bmxKAw0v/lw8IW7qxhBrNO0FUxRHXnb1BuFERJfKzk/sDLjqC+JA07poevFtnYTQmCF+wD/kn15J5qZWJxw/jm1VRHj33WRKruxi7qpmO8ghHvf0qEzoWECTDq9XTWBepoTsU45AVS/nU7OfIxWI8vuf+9PYkyEVCzB8/kqZ1rdQ2dxPO5wGo7E6zqrqM9rg/NlF4HnXZHJZSqECAXDBAWaqX7pKgrB8TYuyRVdzwnAdOEQxBqCfLklCANsvkM4cGOXGc361smYKvHhNBo9HsPmjB+AFCStmE3yX8EeAh27YLUspf4HsJ3y3LgFopZdK27Z4hcStL/0cBi0rbY4bEAQwZ6LTJsI1i2/Z9wH1SyiBwKXC/lLKq1I09tAt4fR/eSPrF62g0mh2I2Zgk9u0j+vYrj2mk8phGAJLAuQ8eSerBZQRHJxnTk8Nr7SUmDkTUJPhTejILH1tLTyTEVXvtzb6hLhKn7MnJXR7ZDz1J2gzRWxHGNATGgLvB8jyaOnsY0Z2iJxykOp3lhcYaGqImbk7x30Mlo9a08FZNksX7NPHQlxJURQSLQ3muecJBuYrpMsJZe8YpCwtO2lPPTdNo1qM9jJpdnTj+RKdWoCilPAi4AJj3Hsq0gdfwvXuXAW3AZPrHMD4K/FJK+Qn83rNf4ovVtZss8R1QmlwzGngGyALd+CJxveBcB4zHH2eJbdurpJRPAT+XUl6MP4bx+9vCFo1me2FVhqn4+MSNxt2mFC8eNJJkEPaq6X9JlVfAEZ8fz1tXvE5rMUFvWYTu8giVbb2YnoKg4qP2Czy75xTK8iFWJaNMPLWRL0yGP/1kJcWCSeqkPfjExxs4ZJhBMuSXfdWxIT46JUBXVnFQk14zUaP5oKBnSX+AsG17HnAVcD/QBXwb+Pt7LNPDn7CSxZ980gXcBKxfe+PjQAqYX/rron8CzLYgiH9Ma0tlfwk407btXCn+e8C1UspOKeX6cZrnASF8L+ezwK3b0B6N5n1FCMEhw8QgsbieMZ8cR/WRddSsSzEs38nze4/jJ+ccxatTx1KMWFT39vKRV19gbcjl/w7dm4uPjLDH5Bg/vmE81/zfWK68cjgnjjH7xOJ6JtUaHDLS1GJRo9kkYsjfro+eJa3RvL/oG07zvuMVXB545EHWLo/z5pyRlL+9mppUBpRCoLjhjIM477gk3z7oPa2wpdHsimwXNdcirhz0rK9V1+7yqlF7GDUajWY3xwj6QrBhZC+//fNoYpPK/QghsGIBXv5iTItFjWYboob87Q7oMYyaLSKlfAg4fGNxtm0PnfC5Per/M37X9saYZNv2ik3EaTSaIQgh+Mov9uTlPwXobc4x9dyRRMqDW86o0Wg+0OguaY3m/UXfcJodwowZMwA49dRTd7AlGs1OxXbpKl4nrhr0rK9X1+guaY1Go9FoNBrN7o3uktZoNBqNRqPZhuyO6zBqD6NGo9FoNBqNZrNoD6NGo9F8AEjM7yGyOot3QAqjLrHlDBqN5j2gPYwajUaj2cnomt1B+0stFNJF5t29lKX/XcnACY2Fe2YT+tlqWv6Zp32/3+N1ZgBwCh5LZ3XTvtpf5z7z7Cp6/vgaxbdad8hxaDSanRftYdRoNJpdlELe47Xr5jH3hgW4hqDCdOkOmHSEQ9TetZKP/HZ/XFdx60PdfOu8i1GGwZErlnHvdx4k/vuPcNcXXqfzrQ7iXi+HRR28J1YBEKBA7R+nEzx6NIFxFQhL+xY0mnfC7jiGUS+ro9G8v+gbTvOuyeQ8wkFBPueRSbv87vvL6Wx36AgFuHdsAz/5+1O8MbyKW+QklCE4qK2Tsd09/L2xAU8IBAoL+POMRzn6I3UkfvEQZazBpMhCDmR9N5oHBEwPXI/IQXVU330GoRHJHXnoGs32YrsouzXi2kHP+kZ15S6vILWHUaPRaHZylFL86NZuHnopR8RQjG7voSoCmV4PgMp8kXMWriFdE+f+vcaiSr/x/HJVOZUtK/BEo18Ogmghx/RVc4n/chYBsvQwYn0trH93upiE3DQjeBPrpSItI19l5YQj2HfOWRgB7W3UaLbE7ugZ0IJRo9FodlLyaYf7r3yLNxbmeXJYEwBZT9BmmtStasdIxonlcpiehxUKUQhYlGfzdEbDAJRl80TT/T/5J5Tiln/NoFBI0IVHHAuz9GqroAOBIE2YDOVkiLOGcTQxn1rWUHh7Nl2hl0iEsxiXHYNx9Wk4Z/8F7+mFGCdOxrrjYkRQv1I0mt0VfXdrNBrNTkKuqPjsvRleWely5pQA+y9rYZndBaEgIcdlVG8a01MUXJdwLo8XCmB5vpcxkc9TNA0+8/Ib3LXPBDLBIHWui0gm2Lujm/ZIiPPmz2XSuh4UBi4GGaKYeFgUCeLg+0UMLBQKk27qiNNOiAyVrKRNDac9W0viutepeWY+5suLEBi4975GfnIT4atP3JHNp9HsNOyOYxh3W8EopVwGXGHb9u1SylHAUqDJtu1VO9Sw94CU8uPAD23bHrWD6j8MeNa27d3qTpBS3ghYtm1ftKNt0ezaZIuKbz3jMa8DPjVF8LGJBlc/nuePszyyGY+E4RHLuzRE4WvHh1nwXBeZl9bhhC0WjK1h5JtrEGlF64hh/KjF4yOdBQ4EkvkCkzq6MIV/68U8j8qOLpxICGX6XcSBQpF4NkchHmH/VJbVlSG6w2FWNESoLRQ5pCtFqn4E2ciblGUzKARBirgYFAiUBKNPwTJ54IAptJXFOG1ejmOXvQTAMBYwj4MpUEf05YUkUJi4KIqkfvwgnY/MpnZyLd6yLozDx2EcOhquexCKOZ6Ij+Q/tVMZ3dvJF566GyufRuwzCv7xDajW4yM1mp2d3VYwajRSyquBw2zbnr6jbdHsuuQcxY9f8liZgi/sa1AThp887xCyBFccZlIT6/9+uvZFjzuezzG1uYtfPm/xp73KeGa1grwLnsIoFMHxWNQNn78lxVmLV7OkLM5qK8Lk15tZGIuycnScY5vbmNVQxXIryH74D+qQ6+JY/iNbGQaVLVkqm5ezZHIjnoCKjm46wiFunrYXyhBMyBWpzBf48OuvUJbLkgpXMnpNC4lsDgW0iiSgCCsHE4WFiwEYeDw8bRIvTRoDwG8azmHPexfR2NOGiUcRkyDQSh0JUgAYZKkodsFLa/BeCmBgov43EwcwyZEKBvnZeedx+puvccr85wh0t/gN9tRc+MTv4IEr+hu8JwM/+Cd0pvH22wPv5eUIJ49h5hEn7QfnHr59T7hGs03YrfwqgBaMuxVSyoBt28UdbYdGszvxzac9fj/TH+f3r0UuNYbHog5/f06LxxMXBPvSrujyOO3t1USLLveNamDtagABARPyDuaAd4hCMKeqjCeH1wMwu7oCrywElsHrTbUoz8+6oLGKS5+fS6BQxDUMlGEwZuEakqkCAHu9tozmhhieZXD9gXuzOhICoNs0ObW5lbNmv0aBAF2UA5AnRDdhukQcAAuHBtWNh1XqkIaO8lifna5h0hapoLGnjRWMpYMyysigCJfKCxCit/R6VBjkEQQAhcJBAGUFh18/8GcmtnZi0Du4gecN6fT59J/hHy/hYeL8deaAiBTmbU9DTRKmT93a06fRaLYRu7RglFJeDnwOGAZ0Anfgd0O776FMBXwRuAjYE5gNnA18FPgqEAX+bNv290rpo8DtwCGluEXAt2zbfqwU/0Pgw8CBtm1npZQTgZeBs9an2YwtBwB/BCYCs4BHh8QvA/4GHA0cAHxKSjkP+B0wGTCBl4DLbNteLKWsBprxu+bXSCmPBR4HPmnb9k1SSgvoAI61bftVKeV44C/ANGAJcNOQ+qPAT4CPABHgOeBLtm2vkFJOA54CKm3bLkopPwXcCBxj2/aTUso6YA3QUGq3pcCFwHeAJuBF4BO2ba/dQhuNAq4HDsQfgLUEOA/YB/guYEgp17+h9rZte4mU8pPA94Aa4H78T0GH94FUKkUikdDbu9D23PZo3/nrzkN3rn/+49xWNSj9xxozPFL0Hz8d4UBfuvXOhnQ0SLQriycEVcUinZFwXxJPCHAVWKCEAKHAEKRiYW49YAKnv76QaW8soBgOM2pROwA9sRCLR1QjAh5VqTRrY/229pgGBy2YD4BD/8SXAeb0xQm8QWF7r1rJwsY6HNNk9NoWMq31vMJwckQAQRaLInHaaEDhUEMX6+eFDixn4HZTdzMQxCOEQRGBv3yPcfTeg9rQnbMCE1BDbO7bn7uS1IFjdoprQ2/v+tvbi91xDOOuvj7CKuAkIAmc9v/s3Xd4HMX5wPHv7vWi3izJltx7wXgwBmxMMU7AmN5DCBBIJSQhBH4hhNACCQkkIZSE0EMLLQQTmukG0waDe6+yrN51d7q2+/tjV9LJuMhgW8XzeR492tsyO7t75b13ZvaAi4FL9kK55wOnYAUUbcBbQBYwDDgGuFIIcbi9rg48D4wAcoAngeeEEHn28t8CtcDddoD1LPCXbgSLGcAr9vrZwM+BH+1g1UuxAtkgVvBjAtdjBdGDgVasgBYpZS2wBGhvop2FFeAeZz8+FCtw+swOHucBy4F84AzgB9vt+8/ANPuv1D7OeUIIB/A5EAUO28m+ZgHLpJTVKeWdDRxp1z0A3LiLU9TuFmALUADkAhcBjVLKf9vL3pFSBu2/DUKIGcDd9rFkA/Pt/e4XqW9SarpvTH9nnNbx1n9oIZw3rvNt88KJji7rnzglnWHjrezc6IaUTJphBX8xTSPHaXJYUwtTWkKYLhe03wtXA5z2nkyzS7RVlRkkDYj5Pbja2oi7NEI+N0+fIPhAjOT9iaPYlpPJ4VurOraZuaEcX32CmO7AQwwNa3BMq9vF26MHd6w3gEqGsBwHbfYck/HVazhi8VoueH4hp728GK/hxIdJFmF8RMmmmXEsI5dt5FGNia/jNiJGR64RDDvIM4FArA0TE3BhEMQEnpkyA64/u8s5dHz3GAB04uB1dNRJJwo5aTBX9Jrnhpru+9NK9/XpDKOU8rmUh58LIf4FHIuVcfo6bm8fHCOEeBb4PXC9lNIAFgshFgOHAAullB0Bme2PQoir7eUvSymTQojzsAKoD4BK4IZu1OFEIAT8QUppAp8KIR4AvrXdev+UUra320SwAsJ2USHEDcBSIURAShnCyijOAh61/18L3CmE0OzHb0spDSHEYcAQ4JdSygiwVghxO3CffV50rIzgSVLKcnvez7AylFOllB8KId4GZgkhFmAF2pcDV2Jl/mbZdUl1gx3UIoR4gu4F/zFgADBUSrlyu+PfkQuAZ1MC9keFEN/vxn6UA9QF43Qm5WmUt5ocPUjD64SLJpl4nDCjpOt3bk3TuPyaQaxeFuKXQQebXW4Shkk4avDiWpODMpPc9nGQ9wNeHEmTIw/xsWQVmKaB06njSSQJOXTQtM5AEhhV3UhmW4ymvCwwTCKBJuq8ftq87vYd8+nwEjJDbfzfW5/h0kzG1DQA8KeZxxPx6pz25nIemD2Zd8YOoSIzjXGbqrnz2eeYWL8EDZMCNhAlgIM4A2uilDZsZUliCi6SHbfeAfATxYVG0qWD3QFGQ6OSUkL4KaQGPyHMiYMxLzkKc9VmtFMPwbGmAvPHD9Ce0E/4vZx938kwKKfrCb/yJDhyLFp9K66DhmDKzWhZXrSGZpgyFAqz9/YlVpS9Tt2HsZcRQpyLlV0binUsbqwm2K8rtRk0DFTbwWLqvDS7Dj7gNmAOVobLsJe1ZxiRUlYKIZ7GCpiO2a6snRkIbLaDxXYbd7DeptQHQohhwB+xsoVpdD5vc7EC0DeAB4UQWcBIrOzodcAkrCDuiZT9V0spwzvZfx7gxWoCbj/OViFENZ1Nym8A3wGeAxqxsqX3CiGysQL77QO11PMesuu/O78EfoOV2QzY+/iVHcjvyEBAbjdvR+dVUTpMyteYlN+Z8ps1dOfNTQ6nxtiDrP6BpZ1zOXG0NXWuMHl2pUFhGpw4wsGVlSafVprMKDS5br7Bfyqt9UrTNAZXNNHamGTm2jI0e4Q0ugYOB7mtLehJA8MeJV3v8xIKBpi5fBPFzdZglKjTwZLSgYS8HqbnbqXN4SLpAHciwaYBmQScIYCOkNCX0r8wN1GPlwhRvFbTsT3fTYIkGjWOIjLjTQAYAS/6ecdQOMDEn+uBrCDaOYeiu1I+YmZNQps6HJ7+AAJeXN+eCUMH7PgkTh0OWKGlduLEnZ5rRVH2nz4bMAohBmFl9k4DXpFSxoQQfwLEfq7KFcBMrABok5TSFELUktKgJISYidVU+iBW0/QhdrZvV8qBUiGElhI0DtnBetsHn3/H6hs4UUpZJ4QYDyxNqc97WE3nl2HdIicuhHgDOBUryLw4Zf/5Qgh/StCYuv8arCbnIcB6+ziDWM3XZfY684G7sK7RfDvbugCraX2AXZevRUpZgxWIXy6EGIrVLH8VVhC8o8C8HKupPtUQYO3XrYuidEeWT+PSgzv754kBGmKA9fJ85jydfyw2qQ6bXDpRx2dk8uK7IVYVFMKbmzq2ccbieNtiTN5QxoqSQsr8PiIOq0xn3MQTTrBicB4fjxlKyOtBM03SIyFueeO/lPy3hppAkMvnnsf902aTWOTHG0mQWxdhAOvx2E3TSZx4SeJwtPD50HTKsgpwJHVym8KMWNdE2tQi+N5MWF2JfvahFIwbuPuDF8OtP0Xp5/pjH8Y+GzBi9dnTsQKXuBBiGvBtYOV+rkc6VuBUB7jt5ujM9oX24I4ngZ8CjwCvAvdiNY3uyktYg1d+KYT4MzABK5iLdqM+a4FGe5BLl36A9sCbD7Gahq+zZ78J/AuokFK2B04fAZuB39vHVITVj7K9HEMI8ShwkxBiBVYG8XZgFfCJvc4GIUQZ8LOU430TuAn4sBtB824JIc6297cJaMJqom4fwFIJlAgh3FLKmD3vUeA1IcTDwLvAOVgDhlTAqPQ4h67xo8mpHzQOLjwpHU5KZ/k0FxtlI5WvbkGPRDE0jXjQxzGfr8TfGqEqK50Wt5sBra005vjJjYQYVllNTnOQhFcnnJukZG0NAHmhVi78bCFPTzmKVydMp7C6lm/ULaacUWRRiZM4YTJwkUBPOtGiQT4tLWXEuHTmVlfgnjOIIb+eiJbn3fGBKIrS7/TZQS92f7XfYmWUGoH/wwrM9rc77P1vw8q0hbGbie1+fo8Dr0spH7Kbos/H6tf33V0VKqVsxGrmPhtrBPidWIHm7vwcmAE0AwuwAs/tzccKLNv78b2DNVK5o0+hlDKBNbp7ElCN1XR93w72JYFPsQaeFGL1aUymrPOGXfbbKY/T+XL/xa9qMlbg14o1QGcR8Cd72TNY2c5KIUSjEGKIlPI9rFHw92P1t/wm8O+9VBdF2WfGHZPHiVeN4KyHD2Xw8cWUHjOA7KYWgq0RdKCwoZnBjY005PmJ+pxoaAypa+acpauY8/FSnp00pUt5ufkeZq1ZxaCaKgZvqqLNHqDSSD6NFGDiJG1qPjk/n8Iho4PcWdrKH68ZyIS7D2XUX6biVsGiouyUidblrz/QTLM/ds1UlF5LveCUvWbBLcvY8M9VHY9dWpzGYMqI44OLOOX6McQPvoenh4zCS5jj1y6l4JhSfA+fx6pbPidw3zt4XSZpf51Dy7zNJF9ehcOjEfj5YQR+dWRPHJai7E/7JJrbpN3a5b1+sPmrPh81qoBRUfYv9YJT9ppkNMm7l39M5YfVFE0vYPIEjTf+uoF6d4ARR+cz8y/T0DSNyEtr2fad5zF1jeInzsB33NCerrqi9BYqYOymAy5gFEK8gtVk+yVSyuB+rstyUgdSdtospRy3P+vSWwkhSoAVO1n8mJRy+3tD9nYH1gtO6TXmzZsHwNy5c3u4JorSq+yjgPH32wWM/9fnA8a+POjlK5FSHt/TdWingsLdk1JuwRrgpCiKoihKDzngAkZFURRFUZR9qT82JfXZUdKKoiiKoijK/qEyjIqiKIqiKHtRf7mVTiqVYVQURekn2h7/nPBvXiW5urqnq6IoSj+jMoyKoij9QMWP/0fgHuv++A23fET91An4pw5g6O2HoTlVbkBR9qf+mGFUAaOiKEo/EH5sMREyMdFoNDLRPqqi6aMqPt0WYeozs3q6eoqi9HEqYFQURelDkq0x6n78P9hcS/CG2fhnlmImDepCmRj2z/vpGAQJAxqrP6xn26qWnq20ohxgVIZRURRF6VFNx/2dvI/eQwPCR39IsvJOkiu2YSQdHevEdZ2BRjk6JmWuIP/59gKGT2kmNie95yquKEqfpjq2KIqi9CGejxd35C78ZjN1v36TRee9SdTlIIFGEo02t5t1wWIAJpev55VJE3l9y0i23eFg/acNVK5WGUdF2ZfM7f76A5VhVBRF6UMSZufbdhIHlfdvwI2bbelBAskYADFdB38atMK2jGwAog6d0avWse7MMpaUjGJrThYHnzGQC87LRtP6X/OZoih7lwoYFUVR+ohkKM5WfQTlxlByqKCRPOK4acGDvzXWsZ4zZhKMtrJgyBiePHQGmCYzN69ia1EhB5WtJFHtIOYYzfyXakmsqaM1MwD5Ac6fk0ZOpmMXNVAUpXv635cwzTT7S7K0fxNCDATKgCFSyk09XB3lq1MvuAONaUIsAR7XlxaF5m8kurwB/zGD8E7MI76xkeYT/4le2YDD5yaCD88xQ3F9uo7qWi9VrQFoa38KmbhJEMVFBDdxTQc7U9jmdRAPOoi4XawfmI/TZdCclYmpaYRdTuJOJ5pp4mkNMWrzNiI+L21+L21Dsvj+WRm0lIXQphXxeSWYDo15Gww+a9CZMEBjVpHGnxbGCCXgF0d5+OkML07d5FsvJFiwOk6pz+SgQo2KliSleU5K8xw8sAS2NZvMHgz3nuSmutHgmU+jhCMmcyZ7KMjWueWDBB63xhUH68Ter6AqYrK0pIDibI1Txzpx6FYPqk+2Jnh3k8lhgzQOKdZ4chU0tsHFE3TSPZ0f0v9Za1DWAnOGmAzO0HHoGm1xE4+TbmdUE4ZJJG6S5ul+7622hInXuevyu7NOx7pxE6+r/wUfvcg+OblrtT91ea8fYV7Z5y+iChh7ASGECcyQUr6/i3VUwNg/qBfcgeTzDXDCzVDZCD+fC3dcBICZNGgZeBXplRuI4qXMNZFBiy4h8c3bCJRvoIkiVjKWBE4cJPHSRhSvtS0GpsMkrHnRTZNAMkKIAD7CRDQv9ZlptKY7CETiaEDU7aAhJ4BmmlTl51KZm9VRvUAozGa/jy3ZmaRFoxy/eDXZ9S18MGowIY+Lirxs/Pa6zQ6ddV43ESCkdwZQOckk9U4nJpCdSOLwO6nJ8kFDFAwTXA7rTwNcOiSSBKIJQhleNBOc0QRxr7Mj2PXG4jiTBiGvm/z6Vqq8PjTgr8c7uWNBjE2Ndjk+R8c2AGluqPiBTsCtc9snBle/Z3Qs04HjBiR5bY3BwHSN1y5wMzZ/10HgPxYl+eH/4pgmTCzQ+PQSN27Hzj/ztzSbzHomydoGOGOkxlMnWkFqqqRhcu4LSZ5ZaTAiG944z0VJxo7LNAyT85+P8+TSJMOyNeZf4GZIlhp2sA/sk0BujXZ7l/f6keYv+nzAqJ59iqIo+8q1T1jBIsCf58HKrQBE7nyX9MoNAHhoIzu+mfB7W/Ft2wJAJQNI2D2GkjhowwOAmyjD2cSo5BYmJdaRbzaQcDkZkLEVwWJmmB+T66nE0CHmAo0koXQ3umnd5CO7rgHN7Ayk4prOluxMAFo8HlYOyONFMRY5bCAri/PxY32aakB60mBALGH1j0zR4HB0fAuqdzqoyfRBEitYTOV12IGei1CGFzQNU9dIuroGfm1uF60+D6amUZWTBpr1Leuq+QkrWNT4UrAI0BKDfy6x9vnqxq77NpIGr62xjntrs8n1byd2cdEsP5+foD2fsqTK5NkVxi7Xv+0Tg7UN1vSza0xe2/Tl74avbzB5ZqVVztp6+MOHyZ2W99ZGgyeXWsvX15vcumD3dVaUfUn1YdyPhBCXAz8HcoFm4BFgjr34dSGEATwlpbxECDEAuA+YCVQBt3VzH4OBjcCFwNVAKfAu8C378cWAAdwkpbw7ZbsZwK3AWKABuAe4Q0ppCiH8wGPA4YAfWAdcLaWcb297IXAtcCdwFRAAngZ+JKXc+Tuite3DgAOIA6cBIeBKYCXwT2A0IIFvSSm32dv4gRuB04EM4BPgMinlOnv5OcCvgCF2eS8CV0gpQ/byTVjn9ljgUGAT8D0p5cLdnuCvqaWlhbS0NDV9oEz73HTQNPC6aGlpwZHuI5WBA21iBkYgiN7aiJtwl+VWSGYwjA0k8ZC037oLjEbqvUFGNJV1rDuxbj0bBhYTdzoZ1lCFnjBpc3tozPHiMQ2yWlpp9flxGAbOcKTLfpJOB7VpgY7HJl3TLzFdw4v1YgVA19ANk45QyjTRTBPToYOuWUFjPAntj3dku9maYWK2r5vSAuZoj1Pbh53uoLg0PQr4mTlI4+2y1ICt68p+u3fArq6dS7eyqanb7Gp9n9NPKr9zB+u4Al3X2UWZZjxM6kd0d+qspvd8el/pj/dhVBnG/UQIMRL4PXCilDINGAe8KKWcZK8yW0oZlFJeYj9+HOt7eglwJFYAuCdOB6bb2w8GPgbWA0XARcBfhBAldt3GAS8DfwTysILYy4Bv22XpwPPACCAHeBJ4TgiRl7K/UqAAGAYcApwJnNPNup4BPAdkAzdhBYo3AqfaZZrA9Snr348VSE4DBtjH9pIQor2TWBNwHpAJzLD/rt1unxcDl2MFnPOxgvd9LvVNSk0fANO3XwiHj4JBuXDnd2FIAWlpafi/O42WmdOJ615afXl4n/o+OdOHwEM/IkY6hVSQRjMaBi4tQQ6NFFKFqzNU69CQHiTk8nY8bnb50ZMmmfVt1CWz8YRMMhrayK0KEySEQ3OQ0RYlGIuTH40wvLoO3TDQTZOMRIyR9XaaTNNodOhomhUQNjs0chIJBsZiOHUNnA7G5uhM8BlkukzSPJBtmhTXhXElDQjawbJhQCQGbZ0ZMkdbHC1poCUNDIeGxwEuzcSDQSFxhptt5GkJilwGOhD0wDNnOjlhpI7TAY54kjSXic8JDg08DrhgrMZFk61A/LrDNO6ZpVEUsN68coMaP5nmZGC6xszBOrfMcu322j19mpOgB5w6nDJK5+RR+i7Xv2aazvFDNIqD8H9TNY4q+fL6R5Xq/OpwneI0OH6YxjWHO3Za5nGj0/jNTCfF6TB7mM5vZu6+zmp6z6eV7lN9GPcTIcRQYDnwHeBlKWVryrIufRiFEMXAVmC4lHK9Pe844HV204cxJcM4VUr5qT3vNmCOlHJcynrVwKVSyv8KIe4C/FLKi1OW/wI4Xkq5w98UE0LUAhdIKV+2M4x3AlntGUUhxDPAVinlz3dzXh4G8qSUc+zHfqys4FlSymfseT+y6zpZCJEL1AClUsot9nIdKys6Z0f9QIUQl9l1nWo/3gTcLaX8o/14HLAMyJRSNu2qvnuBesEpu2SsrsJcX0u9N4Oky0XB9HwSC7dQ/2dJ8D/vYBoaEYKATpPu59WDppAeb+WQ8uXEdSdLfYPRYw6CrXEcic6nW9KhsWZyIfUZWR3NuYXVG3hyyhEAaKbJVYebzDopj8+3GazYkmD2wW5K811UtZp8ujXJQYU6eX6Nz9bEyMvQGTGw60CeLdUJNlcnmTTURVMMFlcaHDLQwbYmg20tJrh0cv0ahxZqtMZM3ttqMiRDY0xO/8vGKH3GPnnyrdLu6PJeP9q8os8/yVWT9H4ipdwghPgW8EPgfiHEEuBGKeXrO1h9oP1/c8q8jXu4y4qU6fB2j9vntX/NGgIcI4Q4LWW5jjXIBiGED6tJfA5Wc7phb5uaYazervk5lFJ+t+sqpQwLIXZU/9S6Aiyx12vnAgbZ9T0OuA4rC+nBavKu3tk+7bpi72NfB4yKskv6qAIYVdDlxeU6opSCI0ox1h/JspmP0FzrI550E3M4cbclqEvP5NWRR+CMJgi0xkn6NYKhRkzNRLM/tjQDDFMnvbmFuNuFKx7HNbKImy9NZ/mGBLOEl9GDrazgEZlwxFhPx/4Lghonju78uDh8nIcdKcl3UpJvrZfuh0GZur29g8nbrRt0a5wwtM9/hirKAUMFjPuRlPJ54HkhhBv4AfBfIUQOX846ldv/S7GakaEzUNoXNgMPSil/vJPlV2D1pTwW2GT3a6ylZ2401R5Ej5BS1my/0D63L2D1pXxQShmxM4xX7r8qKsq+oQ/Lw63HMKJZOABfwqCwvJbGWDpJTUc3DMpL8gEwdZ2cikY8bQl0E9r8LtIaWmnMy8DvMJh66QgOO6MQh1Pj6IN79rgUpb/pj30YVcC4nwghRmEFfe8BEaxMltWTHSqx+ge+DyCl3CqEeAe4TQhxEeADfrMPq3cP8K4Q4lXgVbteI7Gait8F0oEoUAe4hRBXY/UP3O+klNVCiCeAe4QQP5NSlgshMoGjsfoiAniBBjtYHIvVH1NR+oWs2lqqKeh4PMJZTyLToE4mqB6a0TG/bkA6oaCTvMoWTExcsRhNQwN8556pDBjoQdvZIBRFUZQdUINe9h838FusptBGrAEXp0sp24BfAzcKIRqEEP+w1z8Pqzm1DFgAPLqvKialXAacCPzMrl818DCdTc532HXehpXxDGONLO4plwKrgXeEEC3AUqxBNqbdN/SHWMF2K3A38ESP1VRR9rLcI7NJwxqY4tailL5xHiP+eyarxxWScOp4o1EA9EQSZzxBQ66fyuIsAle6Gfv9EIUlXhUsKso+ZqJ1+esP1KAXRdm/1AtO+XpaI5h3vky0Lo77lyegD0gnGU3wl6Pfs+5tCJimSVlhPpoJDiPJiGCcgWdb3Xbnzp3bs/VXlN5ln0RzK7S/dHmvH2v+rM9HjapJWlEUpS8J+tCuOR1vyiyHx0lunpPa2qR1k+2mCKPXLmHtiCLyRgY54YaxLFyy/bg3RVH2lf6YGVABYx8khFiONSBme5tTb53TG9gjw/+xk8Xfl1I+vj/royj91VmPHsbCX3xC27tljHGGyH9iFsdPKcCZbYeWS3q2foqi9G2qSVpR9i/1glN6xLx58wDVJK0o29knTcXLtL92ea8fb/60zzdJq0EviqIoiqIoyi6pJmlFURRFUZS9qL+MjE6lMoyKoiiKoijKLqkMo6IoygHMSJqseHIjLeVhRp1WQvaI9J6ukqL0ef2xs7oKGBVFUQ5gr9y+hoc+g7jTy+TXF/PmsWNxpLu498wAYwocPV09RVF6CRUwKoqi9EdyHYllWynzFpII67AuBlNcAFQuqmP1e7XkHpzLo2tdVGX5GFFbRjBRy6RFW2nxBriiPMgrtw7o4YNQlL6pP/ZhVAGjoihKf/PMQsxzbsdpmGS70vjPoBPwNxlkOVr4dOGHfDGvklDAR8sLtbgKcxmdaOK4tV+Q3RJh/LZy/jdxOq5NST67q4mDfzRS/ZSgoigqYFQURekLNj+1gVW3LYNIgkBjGE9biPRkK0FPgsB5EwlcO5P6N8rZepNk2Np3yTSsXlQZ8RZyo/VUZBcS3JJg8YsVRL0eKgcWgKYxMBShzu9nbdYYfIE4AKM3VFKencX7/6ynKZzkT4NHsLRe46RhGn88SsfvUgGkouyKyjAqiqIo+11bVYRlP36fYLSNiNNNudeLEcwgoWdxUGUZ8Tu/YMu9K/micBBJhxufN4fM1moAYpqTJnc6MY8Ll5lANyHmcYHW+YHmTiTxxuIdj+MuB0UNjcT9bha8XMvCY0pp8nu4Z7HJQ0vjXD/F5OfT3bgc/e9DUVGUHVMBo6IoSi+UfH89yXveQyvNJnbQMMbWbwV0TGCNVkC1N42ccCtpsRgA2zIySTqsO6V9nDsZZzKJmwjrgkMZ1FDNkMoqnDEfmevbWFOSpDY/B8PpwADCHhdRhwNvMgmApy1OW8ADQHo0zrRNFbw2djAA47bU84emND5YEuGab/i5860oq6IOZo50ctOxLgJuFUQqSn8cJa1+GrAbhBCbgGullI8JIQYDG4FBUsqtPVqxfUwI8QrwtpTytp6uSz+iXnAHsNDKRhxBJ87WMC1nPom2tQb3lTP535nH8us343znP+/yrU8+JzAyk9iiSmKGGwOI4sJHAjBxkCSha/xl+jQ2ZWTxm9c/oNKfiaFphD1OBtU24zRM6tK9xLw6rS4veY0hSpsrqNFzSXidVKcHWT5hMAmXTkLXiTkdtBgmB20sJ7c+jKFr1BRndtR7W3YG9cEAVQE/MYeDQY1bufm/j9FglNLkDfD+pLG8NaIU3+xC/na8i8vnJ3izQuewtAR/PlYn5nVRnKaR41fBpNLr7JMn5efaXV3e6yebl/X5J7/KMCo7JaU8vqfroPQxNU3wxAIozIKzjujp2nTP0x9ARQOcNwPyMna8zjvLYNEGOOFgGD3QmheNw6PvgGnCd44Gj6vLJonyFsLPrMTh1nA0NrPpyXLqloUp0MoJBMHVUk8YH+m/eYov3m0mfdQULn5jIWASlxFieDDR7U8zDRNwkkTHxG2YXPXeQh4Uo9kayOloXk4Lx/HFrSzhgIYQPkIYbpMNwUIa3RksnlBKzOPC0DTibgeapuECIg4HbWk+Ppo8hpyaOjZ53Pi8TsTWamIuFw7dQZPbTcRlHeOm7BIWDjiMcWVVZIXamLp0NVfNOgTKdObdHScRNUAz+KKsjVkroDzDR9CtMe8cJ8vrILipgvM3LmLZYVN4013I4UUa04pSPk8XroKP1sBxk2BC6V660Iqy/6g+jEq/IIRwAKaU0ujpuij9SFsMpv8a1myzHq/cCr89u2frtDs3/Buu/7c1fc+rsPgO8Lq7rvPiJ3DKH6zA8Pp/wxe3w9ABcM7t8MIn1jr/+wz++6uOTYymNioPewSjrJE0WkiiUc1wDuZDgmYLLS3pSGZg4EDD4IdvLeCdoZPQMO1GZxMHEcL4MNHxkCCCmzRipCZEvrfoYz7MmtLxWE9pMTLRqCQXPZakoLmJyoJsq++ivZ4vGqXN6wWgyeftCDpr83J4LT+bIhIMDcU6yos6ut6TMeLqPE+maUJTFEJxEgUBiFn1qPR7yYlGKWiKUJXp57RnEzQkdKCAeUuz+F8sizaXgUODN89yMHOQBm8ugdk3gmGAzw3yjzB2UPevqaIo+4QKGG1CiJ8CPwSKgQbgcaxm6OTXKNMEfgJcCIwBFgNnAWcCVwB+4O9Syl/b6/uBx4DD7WXrgKullPPt5TcDJwGHSikjQojRwMfAGe3r7KQeg7Ga0S8BfgEMA0qFEEcBvwKGACHgReAKKWXI3u4d4A0p5c1CCDdwF3AK4AUqgWuklM/a684AbgXG2ufvHuAOKeUum2DtfSyy6zALqAa+h/Wp+BegBHgTuEBK2WJvkwPcBsy26/I28BMpZZW9fJfX0r4uPwYuAkYDy4ELpZSrdlVXZTc2VXcGiwCvfdH7A8bXvuicXrPNOob2DGK7+YutYBGgJQIfrrYCxtRtU6eB+Mo6kmXNOEnYQSD4CBOkBYBGcjCwAjATnVYjm1qfny2ZmQxubACsF4COgQG4SOIiTiZbaWQgOmCgkzR8jAhvYJ1vMC4zgT/c1tHnoQ0nJhpJnPgTUYpC1VRF02jxBAFwJpKYmgamicMwSOpW/8eYrpF06lTFdDb5PZSEo4SdTmo9btyAA6h1Ofj3+OFM2LKNhKZz49HTrJ0mDIh3fcusy/FTVNUKQEPULgB4a9h42uygM2nCm5sNZg5ywBtLrGARIBKDBStUwKj0Qf0vw6h+S7rTVuB4IB04GbgYK8D6us7HCrLygDbgLSALK2g7BrhSCHG4va4OPA+MAHKAJ4HnhBB59vLfArXA3XZw+Szwl10Fi9s5z95nGlADNNnzMoEZ9t+1O9n2QuAQYIyUMh04FlgBIIQYB7wM/NE+zjnAZcC3u1mvbwN/sOvxb+BfWEHjkcBgYBRW4I0QQgNewOoLOB4oBVqAJ1LK6861vBA4HcgFyoC/dbOuX0tLS0v/nS7NgyEFHfM4enzvqdvOpo8a11nfIQVQmreDdcZ3ruP3wNQRX55/9Pgu5btG56AV+EniwMQaqlJENW34AMigHo32BL9JnCD3/fUVHI2dWbwEOlEcuEjawSN4SBIgRByXFQgSZmxkLXPr53N8w9sUJOqJ4iCEkyhWNlEjSSmbmNK4mAsXvUBpQ7k1OEbXrYARKK5vJNAWxRNPMLA5xEWrN3P9e58yc8V64qEIHxTm0+Z00uRwsMGhsTQtwMcjBnPBT85D/PJC3h5aYlXaoYGug1Ozpv0O0HUiXhe6U2NETucpm75pFa5Ewq6jaWUXgfAhQzqynabbCYeP3vvXXU2raWWPqUEvOyGE+BNQIqU866sOerEzWWdJKZ+xH/8I+D2Q2d4cLIT4BHhcSvnXnZRRi5Vde9l+PAD4HCvDVwfM3l3TckqdZ0op39vFepfZ+5pqP36HzgzjhcCvsYKvD6WUiZTt7gL8UsqLU+b9AjheSjlrN3V7B1gupfyx/XgsVsZvqpTyU3vebcAIKeWpQggBvAdkSSmj9vIcrEB6h9ck9Vraj7e/LnOAx6SUWbuq617Sv19w2+rhkbehKBsuOKrLrVt6JdO0+iFuq7f6IRZl73i9VxZZfRhPnAKThljzwlH453yrjO/NtoLJFIlNjYSeWI7DZeJoasFRXoNrTDZGYyttb28i9tFWKilCywhQ0xTAQEfT4rhJ4iVGI0EKzToCdjO0jwa8xGjDTzPWUzWTajKo79jnBkawPlhEsDVBEkjgwOGOMCMmO9ZZlzOIZyfMptHtIr0tTma8gajLR0Mgi5jLiaHrpDc1k1fb0LHN/0YNY3VBLm0aVDl04ppGjg4tuQFiugaRBFoiyblL17J6cCEb04M0pHsxNY18t8F3J+mcPNLBqCz452KD4PqtXLLhUxYdfijzfcUcUQxHl6TkL95cYvVh/MZBIIZ/jQusKLu1T96kPtPu7fJeP8X8YS9/M9w91SRtE0Kci9VMPBTrvLiBj/ZC0RUp02GgersAL4yV8UMI4cNqap2Dlfky7GXtGUaklJVCiKeBy4Fj9rAf4qbUB0KI44DrsJplPViNRdU72fYxoAD4MzBCCPEmcJWUch1Wc/IxQojTUtbXsTJ33bH9OdrRvDR7eohd1yorduzQhtV8vbWb1zK1/FBK+crXUZQNvzq9p2vRfZpmBYq7c/zB1l8qvwd+euJON3EOziTjmi8P/HEAAcC/uZbMqiY4eDClm0MkGmIYq8pZdu1KamoSDDxjINkftJLYGidwaAb+95YRJQc3MbxE0GgjnTLAg4GLRnJo1DJYNnEwo7Zspaiqls+GDMEXC5PYrOM0rbeKd4cO4YXxAyhuquPYZc00ZaUTdQfQTRNPLE5V0E9zWqBLwBjTNUL2r724TIhrUFzbwLpMr9Uv0u/CndQ56HsjuXOqm3VxF16nSSShMSnPgS/lRt+/PNQBh5YCpRwKHLqjk3fsROtPUZReQwWMgBBiEFZAdBrwipQyZmelxK633OuuAGZiNfduklKadoax491WCDETq+/dg1hN04e09znsho7g0u6T+AJwFfCg3SfyMuDKHW1oZxT/APxBCJGJ1Z/xQaxm4812GT/eg2P9qjZjBXjZOwqWe9G1VJRd0kpzoTQXAN+wdGumyOWI8yelrHWU9a85TDjjU8ooIV1rJWlCLltxkATCaGg0UUJNiZuk00H5gFwc8QQD6xtpczh5o3AqY5o2URXI4N1hQ1h4z29wGgZb0wt4WJxLjcfN4ux0smJx/K2tbMnJYF3aSA7ZWs2y7AyWFuSiYaXHYxpgmizJyuKbhUmyC9wkTbhpuocR2dYgGqvluc8nVBTlK+uPTUkqYLQEsTJiNUBcCDENq1/dyv1cj3QgitXU7BZCXI3Vrw8AIUQBVr/GnwKPAK8C9wIXfIV9ubEGjDTYweJYrH6HOySEOAarz+MSIIIVtLU3S98DvCuEeNWukwmMBPKklO9+hbrtigS+AP4qhLheSlln9/E8Vkr5FL3nWirK3pPux/+TIyn929tUm8VUaoPINjd2LDYdOkXZ2/A01LJ64FDimoOi6hYcdpejdfnZzC+ayqcjB3H+oldx2oNKBjZXMbhsK7ecNIuI00lxJMrsaIIjKxuROWlszfRw0jdyaPywlZDHTTCZ5LA8B9NmZZIbcHC+cON2qsBQUQ4EatALIKVciTWg5L9AI/B/WIHZ/naHvf9twHqspthNAEIIHWu07+tSyofs7Nr5wCwhxHf3dEdSylaskcS3CSFagbvpOnBkewVYg1EasJpzS4Hv22UtA04EfmYvqwYeJqUpfW+xj/sUrOfuZ0KIFqyR4kfZy3vLtVSUvevOS/Ct+SMlW37JyAsG0RIcTNwXxCzMRn/ul/g238XAD67i+89OY85Z+R3BIkAgHifhddHq8RByZXbMjzpcVAf8RJxOHIbJN6rq8eg6rWkBhkdiXORex6WXFHLNuATn1VXwvYIQ/76+gKuO9XPxNI8KFhVlJ0y0Ln/9gRr0oij7l3rBKftcvCLE2kmPY9REMIHlgwupSw8AGn4jzpSyz/HSxrqjp/Mv70heKcojoutcvKWyowzTMLj1TwPJKlXde5V+bZ9Ec59qf+/yXn+I+YM+HzWqJmlFUZR+xlUYYPhn5xKav4UmzcmEdC+Lv1iKI81kzvmzqHh/IpkjMzjhoGz+9+tyTt1Qwya/lxaHTlrSANMkIx7DleHt6UNRlD6pP2YGVMD4Ndi/tTxjR8uklMH9XJflWM3E29sspRy3g/n7hRDiGuCanSw+Xkq5YH/WR1EOFO5BabgvHkf7vaI2uJcAECwKMOKsIR3r3XpVAffdWUFxTZxpszPZ8kk9keYkx547kGCmawclK4pyIFJN0oqyf6kXnNIj5s2bB8DcuXN7uCaK0qvsk6bij7R/dHmvn2Z+v883SatBL4qiKIqiKMouqSZpRVEURVGUvai/jIxOpTKMiqIoiqIoyi6pDKOiKEo/lkia6P0v2aEovVp/7KyuMoyKoij91F/eCnPYBes49NKNfFGf2dPVURSlD1MZRkVRlH6oNWpS9asP+UFdEwC+9xsYN3Ir5oxj0DIDPVw7RenfVB9GRVEUpVdrbDV4b0mU5+/ewnA7WARwtrkY8tI6YrP+TPiltcRW1XUsC29o4WXxP/496HmW/eKTnqi2oii9nMowKoqi9GHVLQY3z28j2maQF0nwyaIwufWtJE2DY5wOnIkkADnRRgDqVlXzs0dbOXGxZO65xWRdfyTzfrSI9RlZBPUInkc24GyKMvLuw9E9jh48MkXpu/pjhlEFjIqiKH3J0s2Ea0Jc9pmf6nUNfDpgCHlVYXINWObQAR2f08HhWypZO7iQYEuYqWUrObzmcz7JGY27NcD335RcdfZsiu9+haJmBxUNCZwenQmfb8aVMKh9YDWOulby75pJc0UbOYN8NK1vIWN4Gv58X0+fAUVReoD6pRdF2b/UC075ysw7/4f20wcASOLAgcl9E46ipmAkrw8ZR8LhILu1lRuff4mscIRWj4eTLz8fw+kkv66BBx/4L+6kAUBdwIerzcSVNIg5Hcixwxi/ZGvHvoK00JLjZXNuHsk28IcSaC6N4NnDKZ5ZwIRTBvbIOVCUvWyfpAIXaPd3ea+fYV7S51OOKmBUlP1LveCULhJfbEMLuHGMyMXcVAN1rTC5FE3/chdzI++7PDvwCBYOOZiyQID1foMHXnyIg6q28IsTfkR1IJurX32F/JYWQk4PtcFMFo4YxhsTRpNE4/SPv+CQdZsItEWpD/hZV1TAyE1VOOImjZoPl2nYHdtNhrGeancmoWQ6ccMNaIS9LsJeJ01ZXgJpbrIbIgz+znCG33AQmtbnPw+VA5MKGLtJBYz7kRDi70BCSnlZT9dF6THqBbe/PLsQPl0HJ0+Fw0fv/fIXroIXPoHmMGQF4YKjYMyXs26blrey6tMmRpevZ2BzDfpJk9CPGA6fb6Dxu//ir+4xhJwBroh8Rv7nq8F0YBTnwahc4hos+MYcvOOLmP7ZByz+xxLuO/ysjrJlTjrxeCN/nz+P10ZNZ9aSxYyorACsJ9pdx89leX4ubU4n/oSBA3DH4pz9zoeMrKjG0DSWDyoiZ0sIK1Q0cRFnEssIEOaNvEPw1rlwGNbT1tA0GoJeGnM8JHUdXyiJK27gmJDFkQ8cRs6wtF2eskQowfp/rsaIGgy+cDiVT28iVtNGyaUj8Q1SI7eVHrFPArn3tAe6vNcfaX5XBYyKouwR9YLbH556H869w5rWNPjwVjh05J6X8/fX4c8vwZB8uO18uOpx2FgN5xyO+fvn0GIJAJ6eMI0z1y6icdhU8HoJnjEU50Ov0lTvJBKGmjQfmzIzuXnmHLbk5uLMC3DwkiXkVYSoLhiKyzRZ73UQ0eKcvUJy/YIXcWAAcT7KPYiNaaXktjVSmetl4ZgjO6r3RVYaxU0NjG6OAnDSJwsZXFvdsfze2SewqLgIU9Pw2U3RAFPWbOCUDxcBUJcWINLqAtPOaGoGJYGNVLjyKPcOoKiyBd1+1hpAWVEmUZ+OvyVGVn2UmNtBKMOF4dTJ9ut4y1rJGOankFqiGxqpGjaI4Y/NIXtCFh+e/y5r3q8l7tLJqm/DF7LOXzLDwzErTiaQ4+mo4+oXtrDoH2sxt4UoWNdIIMvFyIdmsPXRjTR9Wkv+KSWM+v2UPb+mitKVChi7SQ162QuEEBrgkFImerouiqIAz33YOW2acNMz8NKv96yMtRXwo/ut7ddUwNpK2GAHYzc+i0ayY9WKjCzeHDQKsXwTcdJp+WwTGdQTwMvj0w7n8lPPw4jZnx9eBySgfOwULgyvJT9uvW0c1JrkiZICLl28AGtssk5C87EkZzwALe40orSyyedhcCRKvdvJynQfh1ZU0P6Z9+GosRQ0NeKNx/hoxGjq09LJD4WpCvgw6fxkzAhFOuoedblIJ0IzPkBDM2Fh9iQ8sSS6CU3pXjKb2jA1jc2lOVQMzMITi9GWlqCwaSvNwSAOw8QRS9LWEsMfTpC2dD06YXxAyZI1fPqDNL7xwcmUfVZPm8/62HHEOwNYR1OUd+/bzAm/soL61qoI71y3GDNpZzazfQzc2sySU94i2mZts+mPy8k6Ip/8uYP27Loqyn6gRkn3AkKITcD9wLHAIcBG4FvAOOAmIA94BviBlDIhhHgImAVkAmXAzVLKJ+yyLgFuACZLKauFEPnAF8C1UsoHd1MPE/gZ8G1730cLIQLALcBIIAG8CVwupay2t3kYq0n6EjvIvBm4CEgD6oDbpZR/s9cdD9wOTAHCwOPAdVLK+G7q9TDgAOLAaUAIuBJYCfwTGA1I4FtSym32Nn7gRuB0IAP4BLhMSrnOXn4O8CtgiF3ei8AVUspQyjW5z74mhwKbgO9JKRfupq6Dsa7fhcDVQCnwLtb1vBq4GCupcZOU8u6U7WYAtwJjgQbgHuAOKaVpH8tjwOGAH1gHXC2lnG9veyFwLXAncBUQAJ4GfiSl7IwA9pGWlhbS0tLU9D6ebhtdhDf1xGf497yclogVLNqMUFuXG9dG/D584QgJXeelMVMY2FSPSYu1LnrHB8YfjjkeQ9eB5JdyGYbu6CjTCThMyIh2BnPadi1AQxvreS/Tz/zcTEyvg8GhFj4vzGVGWZ1dnoYzGeM3J8wh4PLja4ty1qcfU1pTwwMzZ7K5YACeZIKYU6Mh4CfudOAJx3GZBjWl6TSkB8hoijCwrJGqwnQchkHE5yLidbJhVDGGQ8cTtbKZcbeTmtw0653O1p6ktLKjFh0wm6xtfMODNKwL2+fPhTtmzW9N8+JyOTvOfzKidQSL7ccFGkY0CXTe6ifRFO8Vzzc13Xenle7rqzfu/g7wIyALWAz8BzgamARMAE4C2jv6vA8chBUw3gg8LIQYCyClvB94A3hcCOHCCsrm7y5YTPFd4GwgCHwORIHLsILWCUAR8NedbHucfRyHSinTsAKtDwDswPVd4Hm7jMPs9X/VzXqdATwHZGMF0f+0j/1UoACrWfT6lPXvxwokpwEDgI+Bl+xzAtAEnId1DmfYf9dut8+LgcuxAs75wCPdrCtYgep0oAQYbO9/PdaxXwT8RQhRAiCEGAe8DPwR6zzPwTrn37bL0rHO2wggB3gSeE4IkZeyv1L7PAzD+tJxJnDOHtT3K0t9k1LT+27a+9tzYLrdb7EoG244Z8/LOXgoXHiUNZ2bhn77BZBrL7voaOoX3s7/nXMJ0y77HRomxwciJPQAuBwETyzBQZSEQ6Oo2b55tksHwwS7aTi/qZWjvliGy84wNplhog6dWw/7JiZgoLElK48B4UoA0mMtzKxYxGf/upnjKlZh+D1syMvlvZJC2hLNHLdEcuaH7+IxkkwtL8efSDC8soIh1dVszc4hEDcYU17BwNp6BlfWEQy1kd7URqAtRkVeJtsKs4kEPFQWZdKUG6ByYA6GPZAl6nZRWFZHQVltx30dAbzxJMFwtOOx0z62Wk8Ohtd6+9iansPom6cBMOuRI0krtEL5pmwPG0bns350IWXHDmPGOUUd5z9zcJBx5w4GQDdMcmvCaJgMveEg/COsa5B1ZAEFZ5T2iuebmu670/uKud1ff9DnMoy2+6SUKwGEEE9gZaSm2RmvkBDiHaxA4Akp5QMp2z0lhLgSOApYYc/7IfApVlbNBZy8B/X4k5RyvT2dxApO21UKIW4DdhZ8xgAvME4IUSOlrAKq7GUXAIullP+wH5cLIW4F/oAV+O3OW1LK/wEIIR4F7gX+JaXcas97FrjUns4FzgVK7ToghLgBK3t6KPC+lPKVlLLXCSHuseuY6h9SyuX29vcDPxNCZEgpm9i9m6SU9fa2LwFzpJT/tJe9IoRoACYDW7Cu1zNSyv/ay1cJIe6y6/OolLIVK8PY7o9CiKuxng8v2/MiWNnapH08bwIC6wuD0h84HbDgFqhrsbKLzq94A+qHfgy3XwBpPnA54azDoaUNsoMUA797/Hh+2ZIgx4hC1hS8LVE0h4bmd0Pjd/C6HDxameQXi0yicYPrjnQzMU8j1pYkfo0ksX45J65+h4CjAX+WmzrcZDqTxEYPoqw5ncUlQ8kbnsah68rwHzaQ2p/+jcMfTtDgDUJKBs4ZDzNiWxluwyCm66zPK8BIxJm5dAkAS0tKMe3gz51IEmyL4rDDUgONN8cMYVDEymwmHQ7CPjfhNB8bRg9EM01yKxrIrm0mPRShPpJGY1aAjJYIA2obqB+Wy9CDBzD+rmk4/E7i9W148nxomkmsKkx2rh+n3Qzty/Zw7huzaWuKoTk0nG4HsbiJx+/A4eiafp1x7USm/mQ0uksnWR/FmeHCmeam9FcHEW+I4sr2qJHZirIf9dWAsSJlOgwkpZQ1281LE0LoWJm0s7EyZyZWE2RHtklKGbYDnDuAi6WU4T2ox6bUB0KIKVhN0pOwmkM1rOzjl0gp3xFCXIOVqXtaCPEh8GsppcRq+j1CCNGYsolGalvMrnWcH/v4uszDPj/29BD7/xJ7vXYuYJB9XMcB12FlIT12ParpKrX8kP0/DSs72e362nWr2G759vU9RghxWspyHau7AUIIH3AbVuYxF6tJO42Uaw5Ub9f8HEopX+lPcvbCZc1OKcPlhOzOl7RD18jJcGG9XEBP6xy0QWYADRg5DOYN265MjxPungW/EfDMh1CaBycJctrLBYbbf6leWWXQEDCspnIDMCEQT/D+iCG8UjqCw8rK+HDQIJYMGMCglgifeL/BhEgTwxvbOsowgYVjR3Dyh4twJQ1enDiCrQE/5yxYjGbC2pJ8vNVRPMUxon43rkictOYQ3kSctGgMszFEQbrJ0NPyKfzW4bimFHWpo9PfeX48g9K/dDo1XcOX1XmenN4vrdK5fYYbAJe/86NK0zXcObvYSFF6AdWHse85F7gEmA2skFIaQghJSk8iIcRorKDyXuD3QohXpZTbByw7Y2z3+CngWeBMKWWzEOJEYN7ONpZS3gfcZ/e7ux6rKbUE2Ay8IaWc0816fB2b7f8jtgu6ARBCuIEXsPr7PSiljAghLsPqF9kTNtv1+PFOll8BzMTqT7nJ7tdYyz4aCacoX8uATPjJ8d1e/ZABGn6HSTipgRMG1Yc5pa6G9UkPi/NzWDJgAADBeIIqTad8cAlr2kI8+tK/GdrcxJL8kZBwUjYgjxdmCKK6xtpsHz+a92nHSOhhZTW8NW0ccbcLHBoDMkyKHHEC8SjOQh8j7ziC7LNH7IOToShKb9bfA8Z0rC7ZNYBuD3iYBLwEHYM9ngH+IqX8rRDCAzwhhJj1FQdApGNl1FrsPnf/t7MVhRCHYGXrPsXq+9hCZ/fxR4FfCCEuBp7Aar4eDIyUUr76Feq1U/ZgnyeAe4QQP5NSlgshMrH6hM63V/MCDXawOBarz2BPuQd4VwjxKvAqVsJkJJAnpXwX6xpEsQYRue3m6Mweqqui7FVDMjU+Ot/JQzKOtynGuSd6mDBmOL95tIHcZ9djmAblwSAf5+YSc2i4gL/N/w/TyzcAUNjyIXXkEXM5CRe68ef4uPcUP8tSvtYaukZJeQ1+n86sp47Ef1DejiujKMpO9Zd+i6n66qCX7noEawDFOqAca1TtgpTld2MFkzfYjy/DGihx/Vfc3/ewMpotWNnCZ3axbhrWSN1arOBmNvbACyllJVbAdgpWs3cD1sCeoV+xXrtzKbAaeEcI0QIsxRoIYtp9An8I3CaEaMU6Z0/so3rslpRyGXAiVh/LCqym8YfpbHK+A2gEtmENnAmzXdcBRenLJuRp3HG8m1vOCTJhjNU0e9MFWdzw8CSu+/0I/vbTPC442EGhK4kGDGpu7NhWA9qOH029GEze6DQu+NM4EltacJoGEZeTiMvJttwMjr73UOZ8MlcFi4qidFA37laU/Uu94JT9Yv6qGCf8o5VvrVjE3fP/YwWFBHA9ewmB0zt/+Sa2pZkNhz1NfX2CttwgY/45k8JvDurBmivKfrVPuiu9qT3c5b3+WPPCPt8tqr83SSuKohyQppS48Ka5ePSgqbwzdATfXfwFJ2RWcvBpo7qs5y5JZ8SKbxNd04BndDaONHcP1VhRlN5MBYw7IYR4Bet+g18ipdzhyOf9QQjxLeAfO1n8fSllr7o1jBBiOdZ9D7e3WUo5bn/XR1EOFNl+jQ9/5OdBmaA0q5DS45ewTStiyg5uRePI8OA/ZEAP1FJR+qf+OEpaNUkryv6lXnBKj5g3zxrZMnfu3B6uiaL0KvsksntDe6TLe/0s8zt9PoJUGUZFURRFUZS9aPt77vUH/X2UtKIoiqIoivI1qQyjoiiKoijKXmTqfb4F+ktUwKgoinKAME14bFGMLY0GZ4x0sPmzZnx+ncOOyfzSbzkriqKkUgGjoijKAeL5JSVoj60nIxrjPzV1BEJRGrPS2bJ+COf9oGj3BSiK0i1mP/z+pQJGRVGUfs5ImmxelkHgCyfLs4MMaAlz6MZ6AuEoxVsaWOfTQQWMiqLsggoYFUVR+qmq2jin/rkeZ0WEqbUZiOXrObolQsTrwh+OAuAwTHJXV9H8xhbSZ5X0cI0VpX/oj30Y1ShpRVGUfiYaTvDZkjCX/HQLlQ0wsrGVgVtryWwK4TAMguEoqbcEHVa+jchxd1Bxxbs9V2lFUXo1lWFUFEXpJ+JxgytvLGPzugiRQIBowEeD00F2Syux7X7hxRW37hSnGyatWpB6rZjgvW/CHTN7ouqK0q+Y/TAdpwJGRVGUXq4uYlIbgZFZoKUEfku2JIgkTA4d6gLg/AdbeNpVwIjiEGPqWwnGEzg8buodDtYNK8Lb2kZGpI21hbkM3NbIiG11hL1uthZnQqXBwLjGICC6rpFkU4xoUyvh7DQKJ+ai98MmNkVRuk8FjP2YEGITcK2U8jEhxGBgIzBISrm1RyvWywgh3gDel1Je39N1UZSnVhksqTE5bYSOGKBxw8IkN39okjBhVBb8cCJUhjQ+XxqmdmUYE0gf7OXWk128vilBhtvJ9IqGjt87O31DOW8WDeCk1VuozErns4OGE/W6acpOp3xwLqWV1QRiEbYNyKTKzKSx8F9kVDbiJMbWkiD/OGwaTQVh7j7JQ82dy3DmeTn4j4fgyfLs/CDiCbj3Nahpgu/PhoG5++PUKUqvYfbD21SpgFHpt4QQDwMJKeUlPV0Xpf+LJkwWlhkUp2mMzLXao2SFQdyAw4q7tk89utTgV28liESSJGMG2UGdP33TzRubDf7+URx0jVvfd1i/cmuALxEl4fOyuh5+9ja42uIMqwtz3gdLGVrRyLKSPK5cOxhPVjokkmhAhcdNudeDKxjg4g+WM2FzFQBNW6p5adZkyvMyGLRuG+l1EdxaktaAG2ebSUZNIzoGxVRwvTiD/4waCcA3XmjkidfW4Y+1seyxTxhCBS5XG1VuP8/OPZ6L56ST7TFpWhUm487HcZZXA2A+8CYMLSSxugHt3MMxTp6Gc1QO2v89Aq9+DjPGsO4fV/DLx2oZ9tk6ps8s5JRLh3XJpNIYgs/WY44uJrmxGS3oxnFQMcnNDSTX1+OaOhCufBie+xCmDEV78grICu7rS64oBxQVMCqKonxN8aTJrEdivL/FwKHDU2e4WVIHNy20+gn+YLLJvd9wAFAXNrnoxThGW9LeWqO5ReOMZ+JgGOB2gK5Be8CkmUQcHkiY1nzAcOrM2FqJO9ONoxoOX70VI9NPbgIyW8sZ1Bxi4fBJoGnEdJ2iuuaOuma0RGgzDD7LTOej46dS0BjiVy8uZFhlHY0eLxoGTuI4SPLOkGEd2zlMk6JoHek044rGSeIgEfWTg8n3H3kF8xGDjyklnQZyqO48ORUNtFYESBLA/NtijL8tA5+LjMhanEThhY95MHMB9z/6EiEjF56A8nfGMfCJk63tqxrh0Kthcw24nETiAzDw4PrhYYQfXgKROP7cKP7aDdb6r32BefMzaLdftNevs6J0l9HLunBomnYccA6Qb5rmXE3TBJBumuZb3S1DBYx9nBDip8APgWKgAXgcqxk6ucsNd12mCfwEuBAYAywGzgLOBK4A/MDfpZS/TtlmPHA7MAUI2/W4TkoZt5c/BMwCMoEy4GYp5RP2sqOAN4BvAbcAucBrwHellC27qetk4G/ABCAJrALmAJfa5SGEOMdePQPrN+H/D/ixfRyPAL3rla30OUurTN7fYgWHSQP++VmCRQ2dWcX7vjC46zgdh64RN8CwB5x0MLGCQV3vDBTbaZq1QuegZpIOnc+K8xha38L7Bw1h+ifrWFOYQ4vbxfeXfsDIqo38e8RBHetvLsgkpzUCQE12kG0+L0n7A60qM8DK4lwctUlK6ppow4mbBJUU8Yfn3+K7588FTeO0xStwksRN3K5K+/FZ5TSRTog0sqjb7tA0ErjR7DU1DIxIkijpOKkB4NiPP6HNyOg8vieXYz40B83jhJc/s4JFQIsncNNKGx7ijy2CiFUTV21N13O2uWsdFOVApmnaT4CfAvcDZ9izI8CdwOHdLacfjuM54GwFjgfSgZOBi4G90QR7PnAKkAe0AW8BWcAw4BjgSiHE4QBCiHzgXeB5oAg4DDgO+FVKee8DB2EFjDcCDwshxqYsdwCzgUnASGAycHk36nk38DqQDRRgBbQxKeVtWEHrI1LKoP2XtI/r51jnagBQCxzZvVPy9bW0tKjpfjhdnK4RcHfMYmSOxvDMzqBwSLqBww7QAmYrRw3e7q1X2+6/ifU7fqYJhtl1ni031AZAeUaQlw8ZSavXqkBZRj7DGiu58PPX8RoGwWSS9UPzqBiUSVVxOluG5ZKWTHTu2jBZOG4QfznxMCKaBzdJHJiAxoyNZdz38Mv8+r8fMHFTDSY6RpdKdvISQ8NgGwOpJ6djvm6HjNsfrIYdYONmaJ4LJ7GONRwDg2gep3WeRxZ1CaKTWAN8tKLOADNOABMrg2tqOlx1cq95bqjp3j29r5h6178e9jNglmmavwfa35hWAaP2pBDNNM3dr6X0GUKIPwElUsqzvuqgFzvDeJaU8hn78Y+A3wOZUkrDnvcJ8LiU8q9CiCuBE6SUx6SUcTrwBynl8J3sQwIPSinvsTOMbwP5Usoae/kfgeFSylN3U9d3gHVYGctN2y17mO36MAoh5gMfSSl/Yz/Wgc3AA/tp0It6wfVTCzYnufuTJCUZGjcc7aQxCtctSBJLwnVHOBiW1Rn0xJMmpz8dY95aE3Rw6BpTCjQ2NZlUR0zQNHRdwzBBSxqYmo4vFuPwrVW8O6yY3NY25izfTKPXw+K8bNqcOqNCEUzdgW4YzF0yn+pAOm+Mnt6xz5nrNpLXGmZzQS4tAT+bXU6+yM8i5nUQTvNy0OYqfvPk+wytqyZAtGO7RvwkcLKxKMCsbUsxAR8RDJ+fpNNNvCWJAQQyo0QLMqhoysHbUMeI6CJ0IIafxC0XY362FSNqYLhduGcMxjU0neQjH6EfNAjnlUeT/PV/aHxhCwwuIOPvJ+Ia2Rl08sR78MInGKUDaNumoaV7cV8/m+h9n5JYWoXnrPG4P1sBayvhR7PQjhm37y+40l/skxamFzMe7/Jef1LTt3qsJUvTtGqg0DTNpKZp9aZpZmua5gU2mqZZ2N1yVJN0HyeEOBcrqzYU63q6gY/2QtEVKdNhoLo9WEyZl2ZPDwGOEEI0pizXsLKG7UHZ9cDZWFk9EwhgZS/bJduDRVsopfxduQj4DfC+ECIOPAbcIKVM7GT9gcCm9gdSSkMIsbkb+1GUXZpR6mBGqaPjsc8F/zx+x2+xLofGi+d6WFJjsrXF5OhBGj6XRmvM5N3NBoMzNUZma7y6weS5/zWzZmucjWk+Fg4uYnqxxpLmAPP1wXhbYqTF41y4bRv/GDKUZpzomLwx41QGxhIUJzp7prw2qpRmp84h5fXkhto4YWslkSmj+Twzj4KGED955mNaMl1EGjQcphOnZlCVno6jxSTqdvCNPx1MVmUm8fIIyWMn45s9BM2h0/pRFcmmGOmzitEcOvmAURsi9I2/Y6ypwnHhdIK/OmaH58F50oTO6TvOIfeOnZzc846E845Ex+pH0s7/m5Ryz5iw/VaK0mN62S+9vIfVFet3KfMux0rUdJsKGPswIcQgrADpNOAVKWXMzjCK/VyVzcAbUso5O1l+LlYz+WxghR2kSfbCNzsp5UasZniEEBOwmqc3Ag/SmXpPVQ4Mbn8ghNCA0q9bD0X5KibmaUzM63wZBN0ac0Z0Bp1zR2jM/VnmTrbOSJku4oq4ySkPRXi9DMCkRtcY0JrEAUScOiHN5IrXPsbwuokGfOB1Mb6mkYDdXhZ3u9GJM6jqhzzwbCOx2ihH+cOM2ryV4HElpJ04FBjD9jfTCU4r+FLN9NwAaZ/9Ys9PiKIo+8JPgHmapl0KpGmathpoBubuSSEqYOzbglj9UGuAuBBiGvBtYOV+rsejwC+EEBcDTwAxrKBspJTyVaz+lQm7nroQ4kKsvoovfd0dCyG+A8yXUm4DGu39tGcXK4FpQgg9JTv6L+A2IcR/gKXAlVhZT0Xp03wujVcv9fGTF2O8vDZJwcoGjl5fzqJhJTiSDo5btQF3IkmT30vM6SDqclHS0MjG3GwAwj4XzcNzGZjr4Lc/SGkOZoe9ShRF2QWzFyUYTdOs0DTtEGAqUII18PQT0zR3lFTZqZ7viql8ZVLKlcBvgf9iBUv/BzzZA/WoBI7GGiSzCWu09n+wmsnBGon8MVZfw3JgLLBgL+3+GOAzIUQr8CFWwPq4vex+rKbvOiFEoxDCgRXc/g2YB1QB+VjpekXp8zRN466TPWy40s+xwz00ZAQpbmxienkVPtNEA9pcTtYXFlCWn8OWgjx00ySrKURNaRZH36iadRWlPzItH5um+Yxpmh/tabAIatCLouxv6gWn7BdNLUl+92ADyzfHGbiljrxQlNzKWipzM6kq6MwgVnvcjN5QztX3TyR/WKAHa6woPWKf5AL/k/tkl/f6U2vP7clBL2Xs5LPHNM2S7pajmqQVRVH6oYw0B7f91PpJvs825nDZbeVUlQzg5PWdN0kwgdy6FiavLSfZNnYnJSmK0sedv93jQqz7Mj61J4WogPEAJIR4BZixo2VSyl71e1pCiBnAKztZfIuU8pb9WR9F6YumDHFzzQnLWPV6Ng1eP1pLiGBTmMLKBgqrG0nk+cgf2Z2bEiiK0h1G7+rD+O728zRNewd4Ffhrd8tRAeMBSEp5fE/XobuklAuwBvcoivI1jTqunonDJtHSBi0LttF0fxWO0RlMfeAIHC7VpV1RDiBRrFvidZsKGBVFUQ4QmgaDx9nfv6aMhJ+N7NkKKUo/1Zvuw6hp2o3bzfIDJ7Dz1rsdUgGjoiiKoihK/zVou8ch4A6s28x1mwoYFUVRFEVR9qJedh/Gi/ZGOSpgVBRFURRF6Uc0Tdvx73FuxzTNt7pbpgoYFUVRDkAffRHmiRebSMv18LNzM8jLcux+I0VRusXUejzF+EA31jHp/IGN3VIBo6IoygHm7bvW8Oh/64l6XXiawtyRHMutP8nZ/YaKovQJpmnu0Qjo7lABo6IoygGkPmzyndUZbJs1mKRDxxVPcujKai5+2s+5B7s5brjKNCrK19Wb7sO4t6iAUVEUpR+oDJlkesDrtD6p4pUhHFledI+DrQ1Jrvl8PM0xJ7PeXk+Onk6VaaInkriNJHqojdffbeKhJWl89kMvBxeroFFR+gtN09KB64GZQC4pP4eofhpQURTlAGDUhmh7dR3XVWZxO0Xk6ElemWsS/fX7vLckQnEijuOc0VxuFtIQzgDgYdPPaQ2NHL61huLaelyGQbOuM6tlA9eddCQ/ejnOh5foaD3fB0tR+qzedB9G4B5gIHAj8BjWTwX+EnhuTwpRAaOiKEoflGyIUD3qboz6Nq4gyeZzTyUUyOSfC5p4vmAs39OXU7q+Bn73EWnfOZbJDU0MbmxBFuWRdDvJa2rGZRgApBsGeizOuZ8sZ0xFLb+vHsHZQzVqPq6h8NgiSuZufxs3RVH6kNnAGNM06zRNS5qm+V9N0yQwD/hzdwtRAaOiKEpPaw5DdRMMLQD9yz/R98GyVi5Z4CSmO/jT0TqDHn+d7Ls/wVXvxMSBgYODypuJBK0A8KiGZo5aU96x/S/e+YI0PQHA4Vsr+XziSJKp+zFMPLE4N7/3OHmxWtZVDuX1rEPIbAyx4elNNLVMJW94GtnjMnEH1MeGouxOb7oPI6ADTfZ0q6ZpmUAFMHxPClGvfGWfEEIkgFlSynd6ui6K0pPM1iixp75Ay/bjPm3Cl1d4eynm8TejReOYwwaQvPOHbFjcwgZTZ7Krgdz1lZyedSL5Fa0MbA1xZsUwks5jOP64Iu596iUMdEDjmKXLeWnaVNA0iiNtrCrIJBBPsmxgDsWhVohbAaNuQkFNPU2BIHmhGDomhWUNjK9bRrarkc3pJRQ3VTAxspKXR02hzu1i3lNNxN2tiG2LOfcfgpIJVvN2qCxE1ZvbSB+TSe6hefvxrCqKsgcWY/VffBNYANwNtAJr9qQQFTAqe0QIsQm4Vkr5WE/XRVF6zIZKuOFpcOhw4zkwMPfL67yxGPMfr1P/QRhHRQiApuH5BC6div+l1+CLMijOwdxYydLsESweOJ6ipgqOnHMTWQxDoOGllhAmr+QsY2RdHcddfBVJh5UZfGXsaELO1/ElkgAMaGgiq6WVhox0gobJG0eM4pXSQhJOB+5Egl/P/4RBza0YukZmOMzY1ZXk1IY6qhtzO3l65CnEHW4006AoVE6+kWDB4EG8V1oEwIdF+Tz2QIT8Q/2MeHcDBR+U8dGoQQx4ajM/qPwfS7JyWZ5fyqRsOOEXwxgwzMdtb0f5tCzJEUOcLKowWFFrUpjr4uKDHJw26svZVEXpD3rBfRhTXUrnQJfLgVuBTOCCPSlEBYz9nBDCJaWM726eoih7YM7vYJXd5LuiDD76Q9flZbUw91bMtiQOOm+H5lxXQ+jq13GzGSdJWFUJwEvjZ9Poz2Rp0VhyG0MMrA4DECWXNMo4qK4ODShurQGGAeCOJ0iaDiBpl24S9bg79lWb5ifhtEY7x5xOanxepm7cxtphhaBrtKS7OwJGE1gXHEbcYW1vajrlwYHW4eVldZRZXphFuabBZnDWmyyfPJza9ABbyCYccDF3wyYyvVE2N8PDV68i8/Ix/N/LUQCeW5GE9g/RbQavbvKw6CKNifm96oNVUfqjzaZpJgFM06wBLvkqhaiAsZcSQgSxhsGfBuQBW4DvA4uwvh2cBviA94HLpZRb7O3eAb4ABgPHALcIIUYDLiAGnAz8G/jhLvZ9DvBbrFFVYeAVKeWFQoh5QAlwvxDi78BCKeVsIUQacBcwF2gBrtuD4zSBnwAXAmOwUudnAWcCVwB+4O9Syl+nbDMeuB2YYtfvceC69iBYCPEQMAvrG1QZcLOU8gl72VHAG8C3gFuwbjHwGvBdKWVLd+v9VbW0tJCWlqam+/K0aWKuq+z4um6u3tYx3bHOlhpoi6EBG7OzGFLfYK3Ll4MjDUhva6XRnwlAXPNgPa0tMdJwYQV2d/3vYQxNZ1taFmcvWE8y6cJJKyY6HqIEoxHCXi8ADmdn9k43DA7aWo3pdIA9elMzTGry0vBFYlQMyiTm0jHNzpgu6bCCzcENLdT6fVZFU7Im5TlpGJqr43FZZiYN/mDH40jYoHbbTr6XGiZJE9Y3mEzM13r+mqrpA3Z6X+ll92Gs1DTtGeAJ0zTf/6qFqPaA3usB4FDgWCAdOAWoxBrRNM3+KwVqgXlCiNQbp10M3Alk2P/BCsBexQo+f7GznQoh/MC/gB9LKdOwfjboAQAp5VyswPUSKWVQSjnb3uwvwAhgLDARKyjdkxu5nW8fXx7QBrwFZGGlUo4BrhRCHG7XLx94F3geKAIOA44DfpVS3vvAQVgB443Aw0KIsSnLHVijxiYBI4HJWGn6fS71TUpN99FpTUP7weyO+dqPj//yOmI4HDoCDZg/cRB3zziCBo+fJA40vwONBFZeD+qDGTT40gFwJBP42hL2EgADExdRMgEoCDXxr3//izGNlWgZjXw0sgA/EYKEcJHgjI/fYdrq5SwcmMOHQwsgzY0Pg7M+X0tDZjpl2ZkMqGyisKyR3KoQ2wZlsHb8AJozvFQNyKE6P5tPSwrZnJ1Bi8dNA3DMytVc/u7HnPXJSsaU1VjVMk2mrdzKtDVlHTU9ddlSRpVv7qj7qClpfGuGjzSPfW46k5/gdjA6B44p1fb99VLTanoX0weI2Vh9Fp/QNG2Tpmm3apo2YU8LURnGXsgOis4CxkspN9qz1wohdKw+BydJKcvtdX8G1ANTgQ/tdZ+VUrb/oHhYCAHwvpTy3+3zdlOFODBaCPGFlLIeq5PszuqqY2Xr5kgpK+15VwOndvd4gdullFvtbZ8Ffg9cL6U0gMVCiMXAIcBCrONfLKX8h71tuRDiVuAPWMEhUsoHUsp+SghxJXAUsCJl/v9JKVuBViHEC4DYg/oqB7q/XQrnz7T6MIodDDT0uOCdm+CjNVxVksuiQAE1tbMorqrEOb4AfU0ZvPI5iOE4xg/Hf+tWWuth7Bg3o/58EfFZd6BtrgIgpuUQNvNpIxMTaPBk8tiU6Tx8iIM3b3qYJoJk0IqGiTce5dCNSymuGYWrJI+k08HBFY1UDCnmpSHFOJJJLvnvQrwJg42jC4h7XThjCVrSg7QG/ID1LfOFMUM5feM2pny6hnENZaQlI2wNZPGzojm8fhqkBZy0nDiJti9qOdZpUqrHmHzCSKQ5hel1SYaPDDBkaia6rrHqqnRW1yQ5uNjJyhqD+jYTn0dHDNBI8/SuNIyi9EemaX4OfA5cpWnaTOBc4E1N0ypN05zY3XJUwNg7Dbb/bz+CKQ/wAhvaZ0gpW4UQ1cAgOgPGTTsoc0fzvkRKGRZCnIDVHPw7IcQGrIDuiZ1skgd4tit/445X3amKlOkwUG0Hi6nz2r8SDgGOEEI0pizXsDOadgB7PXA2MAArjROw69kuKaWsSXkcSilfUbrn0JG7Xu51w1HjATgYoCAA46z+h+SPgeljACtA+8WD2Zim2XGzbOem26ymb8C9sY5V33keY0ktm7KzuX3OMcxatQbdMMlpjdBKGq0EMYEkTswkXPH8pxRuaORvR05mQlUdK0sKAauZuTngI+yGNr8bb6iN7JpmWgKBjmo7gLBDpzYcw5kw+bx4GLWDs/j4tIk8dF4WY/LshqliL0wY2OWQZ+7gNBRl6BRlWNtMK1G/IKMcGHrZoJdUq4GVWN21RuzJhipg7J022f9H0DUrVgNEsYKm9dDR1zEf6+K3Sw22djVvh+xb4bxjN3OfBDwnhPhYSrl+B+XUYPWNHNxeJ7t++8pm4A0p5ZydLD8Xq0PvbGCFlNIQQkjYQecxRelFvvTLKppmdRscmsvYBd/j+TUGaxvggVEaJcs2kVywgcqTSmh6cQsGGs8fMYGkqZHX0MKRazZyZMUG3B9EGVcVYV1RPnGng6EVNWSGwrS6rWxisCWCBuRX1dOUEcRw6JR73ejpLg45JhfXj4dx+twcPF7Ve0lR+ir7vounA+dhdWd7HatV7sU9KUcFjL2QlLLabpq9RwhxIVaQZKcmeBS4SQixAmjEGvyxCvhkb+xbCFEATMcKyppSMnlJ+38lKd9K7IDsCeAGIcQyIII1KGdfeRT4hRDiYuAJOoPVkVLKV7H6eyawAlndPn+TgJf2YZ0UZZ87bWRK0DZ9CM7pQygFIktqqUg4+J/0si7s4HLhIG3ZWty/+4xZoRC5p5dw1cNv0BD0sa04j9UHl9KMg9xIhLjLiactTnpLmPFL1nHzrEPYlB4kfH0mbmfWTuuiKMqu9bIbd2/D6tL1BHCaaZpNu1l/h1TA2HtdDNyENcAjByto/D7wc6w+fp9iNQUvxOrTmNxJOXtKB36MNRLaiZW5/I6UcpO9/Gbgb0KIy4GPpJTHAz/FuhHoKqAZa5T0KXupPl1IKSuFEEdjnYNbsEaKbwLa+zQ+gjVQZh1WU/a/2EUfTEXp63wTcxkKfHZwyszpoxnxg9EdD4MXj+c//1iMO5hkRJufLzaZNHjdNKWnUbKpgrSmEH8+bCLrM9LJ9mu4nb3r005RlK9lmGmaFbtfbdc00zR3v5aiKHuLesEpPWLevHkAHHn4N7nl4s6eLumNrQSamvn5cUfgdMC/z/dx2njXzopRlP5mn3w7emjoc13e6y/acHqf/xamMoyKoigHkIwcF0Nm5LDh3Vq8bVECjS0snjGGNVcHyfRCXlD1V1QU5ctUwHgAEkJcA1yzk8XHSyn3WhOuEOIVYMaOlkkpgzuaryjKvvW9K4r4br2T6qo44aGDOHNWGiNyVaCoKHtLL+vDuFeogPEAJKW8Bav/3/7Y1/G7X0tRlP1J13X+fkMB73zRRtCrc8QET09XSVGUXk4FjIqiKAcgj0vjG4f4eroaitIv9ab7MGrWPbsuwbrtXK5pmhM1TTsSGGCa5tPdLUe1QSiKoiiKovRfNwLfBe4DSux5W4Gr96QQFTAqiqIoiqLsRaamdfnrYRcCJ5qm+RSdd+rYCAzdk0JUk7SiKEo/FXt7A5G7FqJFGsg8xE2jKOrpKimKsv85gFZ7uj1gDKbM6xYVMCqKovRDX3zRxPrvvc3IbWU4zATTXl3Dh98+Aub2dM0Upf/rZaOkXwHu0DTt59DRp/EmYN6eFKKapBVFUfqJaCjBG7euYNwvq5n8jM4aVyFr/KNYGRjHf4pOZemKIRxyVQX/Wdvtn5ZXFKXv+zlQCDQBGViZxVL2sA+jyjAqiqL0ce+tjfPczxcxal0Vb44fgmMATGtuYVhtc8c6ZkKnMq+YMz5YzS2myal/VM3TirKvmHrvSDFqmuYAzsAaIZ2OFSiWmaZZuadlqQyjoihKHzfvss/IiZlUDBnAlsJ8suNJPGhsLMzpWKcpK0iwJYI7bvD7h+dx31/WUlkR6cFaK4qyr5mmmQTuME2zzTTNatM0P/0qwSKoDKOiKEqfVtOUIGgCmoYraXDxRx8wrLaSRQOH8OrUiXjqmji8uo6BVU0c/v4qADIJMf7nj7Ll5iwyl38fb0GgZw9CUfqZXjAyOtU8TdPmmqa5R30Wt6cCRkVRlD6msTHB+g1tXPtGlIXlJj/VdZyGwcjKMuYu/QCAIzatYX1GBvdPnMjC4cX8+28vdG5PGpk0E4p6+OnvNjPwjOHICpOzxjv51jhHx3qmYfV11HTVGKUofZgXeFbTtA+BMjpHSmOa5gXdLUQFjIqiKL2METcIrWjEU+zHnevtmN8SNXnhlQZeeaEJTKv3enbQz1q/j4l1jWSFm7uU44m2gqbR4nZRkRFgRFsjAA4MGt1BTvj+eUTcLtzzImSHIiz41EO47BMuWfI/kuVhYuEAeF24Hzkf5+kH7b8ToCh9XG/pw2hbZv99LQd0wCiEmA4skFL2yJUVQgzEivaHSCk39UQdFBBCJIBZUsp3erouyr7V2pzEH9TR9+DNPNSaxO3RcLn2TZYtFk6yut5kSbNObm0L+bEYdVd+hLa4jsqCAPLcQ5AuPxVJnbgJbU4HOVlpjG9oIa+plXO2VuKIx3ElkqwpKGFy2RoCsSiVgSAvjhrLpK1VuI0k/5g5nruefhPQCBKh2h8kkEgQcbuIuRzMXr6Z90YN4JQXn0Fra8bASa2eS020AOe33yD+0w/JSTNxVYeoNPw0D8yjcGoGoyZpmKOK0GePI9kcR/fo6F4n8fc2YqyrwXXSWLScAInPtxGftww3EZw/PApy0qAhBLnpOzwv4Q+3EV9Sif/oQTiH5/S+LGdzGFwO8Knf4e4xdS2Q7gPXAR3K7JZpmjfsjXLUWVb6LSHEJuBaKeVjPV0XpWclEib33FbOiiVhcvKc/Pw3g8jNd+12u6cfrubtVxrw+XV++MtiRoz179V6LXm5kldvX0fUhHunT6AiPUBGxMmPs3M5KyD5yzcvpC3kxksCr9/N+uIMAKrjBnVuJ/+3dA2t6UFiPi/RtihazODfBx2DK9zK8vRsvvfuUo5btYknjx7JXYcfyvyJJZy5ZBVtTifrh+Tz2mMPUuPI5LEJkxhbWc81nzxPXlszd48/kbcHTmDq2grGb60DA1ytUUrLN9Lo9rE2twQaoOq1JrxPLmJwpIyqrNFsaMhHD7gYecEAuHcBALr+LM8cehB3lx5ESVMmv39LMvym53AXuGFbA3xzMrz4qy4f+o0PLKHikjcBcJAgf2iS9IU/Ri9I26vn/yu75Vm49knwuOCpK+DkqT1dowOLYcB5f4Z/fwAFmTD/tzChtKdr1VUv6sOoadoxO1tmmuZb3S2nl31l612EELv/RFEUpddbuqiVFUvCANTVJHjz5YbdblNTFePtV6z1ImGDec/U7vV6vXXPRsykybq8TCrSrYEnTT4PnwzN5tP8ybS5O7NXbtO0PoQ0DVw61X4PS4YPojErnYjPgzcWw2kYGOiEAxmcsWoVq4bmcdjvvstfZ88kGfRyx6lH8eJhk3lp+ni+uXQhWxPFtMXSOOOzDQxubmZR/jgeHHUCl51+Js8dOppfnzuTDflWkJoZCqMBYaevy4dhkysNDQg2VOAhjhFK0PbIoo7lhuHgz0OnsLhgAPNGjuB302cQTQatYBHg1c/h5c71AZrv+axjOomT2IYWYn//aO+e/K8q1GYFi6YJbTG4+l89XaMDz4errWARoKoRbnmuR6vTBzyw3d+LwKvA/XtSyH7JMNqZnvuBY4FDsH7D8FvAOKy7jecBzwA/kFImhBAPAbOATKwm25ullE/YZV0C3ABMllJWCyHygS+wMkkP7qYeI4B/AlOADcBD2y1/xy5rMHAMcIsQ4jG77lMAN7AE+JmU8jMhhAOoBU6QUn4ohBgKrAdulFL+1i5zJXCdlPIZIcQArB//nglUAbdtt38ncA3W7z5mAp8DP5VSLhNC5NrbDJJSbhNCHAu8AVwspXzI3rYeOFZK+akQwgR+DFwEjAaWAxdKKVft5hwdZZd7Ada1GQA8B1wG3I51P6dm4OdSyudTtjsF+A0wDKjAumaP28sG7uwc2suvB2YAHwOX2EXe234Od1Pfc4DfAgOBMPCKlPJCIcQ8rB9Zv18I8XdgoZRythAiDbgL6/cuWoDrdrePvamlpYW0tDQ1vZ+nff7OgRwAPr++223dHh3dAUbS2sbl7ugnvtfq5vZrRFvBG092qV+gLUZmSxsF9c1UZadjAhXp3i7rBBMJsu3tHIaB0+i8Gbdumjw3TfD4jIO6bFMX9DF3zf8YWbeZje6hmFpnzkBPmoT1AB8NKuiYl3DorB2QxeCaJrIM61fEctqa8SRjRB1unEaCkkg5AG34MbECyXh6EG84ZJWhQ1l6RkeZtT4/LrrezifsgvbcbUtLC76xWYQWNQKgYeAgSdSj4U1Zp8eeVx4v+D1W4AiQ4e81z/MDZjq9a6Y/5nfhtqf3tMx9pTf1YTRNc0jqY/vejNdifQZ22/7MMH4H+BGQBSwG/gMcDUwCJgAnAWfZ674PHIQVNN0IPCyEGAsgpbwfK6B53M4APg7M70aw6MT6GZzlQD5W4PODHax6MXAnVn/yO7HO0T1YN7scACwCnhdCuKSUSeAd4Dh72+OAde2PhRBFwEigPeX7OJDECmSOxAoMU/0SK1A7Aeuu7AuA+UKIdCllLVagNcted1bqvoBDgQTwWUp5FwKnA7lYgfffdnGKUjmAo7Cuyxjgm8BHwAtADnAr8KAQwm8f53FY31p+BmRjXeu7hBBH2uXt9Bym7PNIYAtQhBXMXSOEOGJXlbT3/y/gx1LKNKwfUn8AQEo51y7vEillUEo5297sL8AIYCwwETjZPt79IvVNSk3vv+nR4/3MOT2bgkIX4rA0Zp+UvdttMzKdfOdHhQwodjNqvJ/zLina5fpfZfrk346lYGSQUYEkh/vaKNASTI40c83bT2PqBie/t5ixqzfzSX46lR43esLAGU9CzKDN5SRhl5NwOIg5O7//7+iWHrph8OBjT1BcFyNGGnmJanTTCjhNIOnUaQx4mLl2M86kFXz6o3HGVNZRVxCkMj2TNt2Fz4jwjerXmVG3gEOql+BMT6cubyThuTNwjMkjbfoA8t74Nt4LJuLK1kmbnMYssw6A9Ggb/7fsNbxzR8IZh8HIIrjhHPwndDbppqWlkfvwSeR/I400Twu5/kZ8508i/Yqj9vr5/0rTbhc8cyWML4HDRsFDl/Wa5/kBMz2hFP76XRhVDCcK3Ldd+JXLPBDZ92b8HXDVnmy3P/sw3ielXAkghHgCK8M4TUoZAkJ2du8Q4Akp5QMp2z0lhLgSK4BZYc/7IfAp8AngwvrQ351DgSHAL6WUEWCtEOJ2rIxfqmellO0BXhgr6NjSvlAIcS1wOVbQsQIreD0bK7CdBfwe+JMQIgMrmPtCSlknhCjGyloOl1I2AU1CiBuA11P2fRHwh/YsoBDiRqyM2xzgSXtfs4BH7f/XAncKITT78dtSytTf/PqjlHKLXdbDwJ705fu1lDIMbLGvTUBK+T+7rEeBe+1zsBj4KfBXKeUCe9tP7MzsBcB7dh12dQ4B1kgp/25PfyyE+AIQwAe7qWccGC2E+EJKWY8VZO+QEELHet7NkVJW2vOuBk7d3clQ+r65Z+Yy98zcPdpm6vR0pk7f8aCMvaF4XDoX3jcZgCs65nrhF9fiXlDNM69HcA/L5KmjPLzyp7VMfW0FLbl+FowYSDAWJxiJsT4vh4Sm8fq4EUyuqWdwUwtp0SgbcjLBMEEDTPj1q/M5ffESkvhI4iVglDM4vo75A6dSm+kn6nFy+LqNTK4o56kHnuWdoUMZU15PfihMkdFCzuHFOC75JmnDXKy8bQktGxOUXDqW9AtHANY3yZLUg3vk3I7J502TLQ0G2f4s0u799W7Pi+bQyXn1kt2u12OOP9j6U3rO5XOsv16ql92HcUeOA/boN0L3Z8BYkTIdBpJSyprt5qXZH+rXYwVhA7C+/Aawmq0BkFKGhRD3A3dgNcmGu7H/gUD1dutu3MF6m1If2E3Bd2AFrJl0nuD2+rwB/Nlu6jwKK3g6DSt7Oste3r5/gM272P8grKZyAKSUht2cPyhlXw8KIbKwMpfPYzWpTrL39cR25aWe8xDQ3a9VO7o2HffrsM8/KeUNAY4WQlyRso0DO3jrxjncvq7dqq9djxOwPmt/J4TYANze3n1hB/IAD12v8Y6eA4rSs/weDvrGIA76RuesEx4cC4wl3pbEcd1qPl9t8klpPmU+DxFNZ2QoQiw9nTXp6WimyaKB2WSHYjR4XZiaxmmLVqbsQGNF/ig+HDiBUxd9Qj3ZeF0GhReNwDVrKscVZzF3bCYVty3CFYuRd/lkXCWdgfOkxwaxJzRNozR7vyXyFUVJoWlal3svYvUA8WJ1W+u23jhK+lysrNpsYIUdNEmgI1wXQozGCirvBX4vhHhVSrl9wLG9ciBfCOFPCRqH7GC97SPuW7Gahw+VUlbYgWFze32klKuFEJVYzbFVdv/CN7Ci92PobHYut/+XYvVz3NH+y1Ln2cHzYHs+wHtYX+Qvw7odUNze16lYGdSLd3MO9pXNwMNSyj/uZPkuz+HXYd8K5x27P+lJwHNCiI+llOv58rWsAWJY53Rn10BRejWX18H3bxtLNGby+ZY4j30SY+k7DWQnkh3rRHWdidUtoGnU+txkNTVR6cujKFSHNxGnIj2bR6adwIjCBPp/5zDZl0TL8n/p1jWltxy2vw9PUfqF1P7BvcD52z0OAWtM02ze0co70xsDxnSsvng1gC6EuBArg/YSdPRbewb4i5Tyt0IID/CEEGKW3adwZz7CCmx+bzdDFgE/72Z9wkCDECII/GEH67wJXAk8mPL4eqxs1vsAUsqtdtPubUKIiwAf1iCRVA8DVwkh3sPKgl2NdY3+Z5cREUJ8aO+rfbDGm1j9+CqklGu7cTz7wl+Ah4QQHwELsbKLEwBNSinp3jncY0KIAmA68IaUskkI0Wgvan8eVGI1ewMdGdsngBuEEMuACFYwqyh9jsetMW24m2nD3TxstjFvfgiXaSUR4rrWMZI5NxJj9tKNZFeFeafkYBpy/WwYUEhuLMR5V08gbaCvJw9DUZR97xDTNP+0/UxN064wTfOO7hbSq0Jg2yNYo2XXYWXlxtK1X9rdWMFk+40oL8PKul2/q0KllAmsDNQkoBqrOXf7/os78lusQTJ1WINOFtIZkLSbjxUUzbcfL8UKRj6w+0u2Ow8riCyzj+nR7cr5I1ZfxdexRkQfA8yWUqZ+C9h+X+9gpZffoIdIKV8HvodV/1qs5uU/A0F7le6cw69Cx0qpbxJCtGA9N76TchP0m4HzhRANQohX7Hk/xWqGXoV1nebtpbooSo85/aQssrQE/rYoWeEIwVisY5luGDw5dTz/OnoKA7fWU7yuHjKiXP3EZNKG7Lv+mYpyIDN1rctfD9vZ3UCu3ZNCNNM0d7+Woih7i3rBKftEtC3JvddvpHp5C0lNo9rnpcHtpDIQJGF/YE3bvI1Rm8qo+d3R3HjKgT1SVFFs+ySau+vgV7u811+26Jv7PWpMuWH3POBEuh7rUOA3pml2+47nvbFJWlEURdlDHq+Dn/1+OI/9vZx33m4mr66Zlqw0Emn2Z4RpYnrA/7ODueHk4K4LUxTla+klo6Tb7zjjpbPLHFiJi0rgJ3tSWL8KGO1mxxk7WialVO+QNiFE604WLZBSHr9fK7MbQohrsG5mviPHp9zKR1EU4PwfFHPe94poq43ywa2ruCWUoE3XKaSN6WdVce45k3u6ioqi7AftN+zWNO1R0zQv+LrlqSZpRdm/1AtO2a8SCZOamgQfffQaTqfJ3Llze7pKitKb7JNU4N/Ea13e638iv9ErUo5fR7/KMCqKoihdOZ0ahYUunE71XUVRDkSapqVjDQyeifXLbx3Bq2maJTvZ7Et64yhpRVEURVGUPsvUtC5/Pewe4GCsX6TLxuq7uAXrbibdpjKMiqIoiqIo/ddsYIxpmnWapiVN0/yvpmkSa/R0t4NGFTAqiqL0Q42VbXzxvyoCWW6mnDygp6ujKAeUXnDvxVQ60GRPt2qalol1v+The1KIChgVRVH6mUhznAe++znRNqvf4uInNpL9TRNXQa/6EFMUZf9YjNV/8U2sHw25G2gF1uxJISpgVBRF6Wdeu34p0YjBxNWbKaxuoDHNz6JtpWQ1hvnsiicY/eQsvIMDNJ78JMaqGrznTyLtryf0dLUVpd/oBf0WU11K50CXy7F+EjcT2KNb7aiAUVEUpR+JJU3K3qqkKJagdFstAPkNLQwrr2F9yQD+48rh2DPfIi9UR35NFQCROz8imZeO+9ih+A8r6snqK4qyl5mmuSFluga45KuUo0ZJK4qi9BNG3ODF29fiC0fxN3W9P79uWM3Tua2tLCwuYHVG5+9I1zuCLLlpBRumP0zomD/BovX7td6K0t/0plHSmuVSTdPe0jRtiT3vSE3TztqTclTAqCiK0g80r2/hxaNeIXL3YjzRBK1uN7VBPybQkOZnY3EeaY1hhq6pIRo1ufTE47ly9mw2eHNY6yumyeUn7vQRe7ucyKG/J3HqXcRP+zvGF2U9fWiKonw9NwLfBe4D2u+7uBW4ek8KUb/0oij7l3rBKfvEc1NepDZkgK7jjsYxAFPXac4O4ECjeEM9ebUtaEDY6eJbl3wTU9cYV1fPmqEFuJJJ/v7Mc4zZWE8tmTiJk0GYdK2FYEESze8m+rezMcYVk53vA5/nS3UwXlsC338YUwPtvovRjxu/38+DouyhfZL+u+Pwt7q811+x8JgeSzNqmlYGTDZNs1bTtAbTNLM0TdOAetM0s7pbjurDqCiK0gdVr2iiYUuIVt3B2us+w7k1TDbQnObG0DTimoNomgdN08E0GdDayCCsPo21iTRueOljhtQ3U53u55f52VQH/Zx7ztm8euvTgEYCBx7iZJltGJVtuAkRnHMbD449HJ+Z5LzZQRyHDYXWNprz89kWLKBk7j/R4wZgwuw/s/wP36HghzMYmNarBgAoyoHGgTUqGjqTFsGUed2iAkZFUZQ+oqk5yUuvNvPW23Vkrq2lMBQi7nThMn0Ecw3SmsJohknE76VyUAGmrqMnk+RvqyE/3tiRSnE4DIbUNwOQ3xzmhCWb+NfhY2nFSXOag/SWJAOpIkAbJh40YoCbKD7OW7ECE5PwSvD89U2SepIPhh9FZqiZ0riBRhydKDoJJl/9F96773UChxSw8rzjeTNnCEOWrmRjg8mhxw5i9iGZe+fEvLsc85XPMZqSMKkU/ZIZaE7H3ilbUb6Cnu63uJ2XgTs0Tfs5WH0agZuwbtzdbSpgVBRF6QMSCZMbbq7gkyYdTQvA8ABiayUOl5Ngcwh/OEJS1zA1CKUHMHWri7rhcGCiUWumowFZtH7ppsJNPhcYJrppUlbsYdqqagK0ASYuopjomGhoJHASx8AFaCRJQzMSHLVmMdhz3NR3BKYmcNT6FbB+BVOeWcB3f34bq/JHgVODd+FFXxtzx3u/3ol5bznm0b8lYaZhfaS9D5+X4fjHt79euYrSf1wBPIp1824XVmbxddRtdfY+IcQm4H7gWOAQYCPwLWAcVpSeBzwD/EBKmRBClMD/s3ff4VVU6QPHvzO35qZ3ICEh9CoCB1AQURAbYq9rL+uuddV1f7v2urquq+u6dl1774orFlSQIshBem8BAuk9uf3O/P6YISQsVUpIOJ/nyZO5U9+Zm3vvm/ecM5fHgZH2LiYCf5RS1tv7ewg4H8gCSoF/SymfsJd1sfd/CXAb0Bn4CbhUSlm8izgvA+7EuinnH4Fk4Hmsey69AIwDNgNXSSmnN9vut8Af7GOtBf4spfzGXjYQeNI+VwcwC7heSrnGXv6qPT8InAM0AvdLKZ/f19fV3qZVru2+Ul9fT2JioppW03s8XVsbo6g0itas76CuabjCEbqtLkK3+6ObMRNXKNK0jgmYIY0GwwdAI170xCg1vji8/ih1iR7m5WcDYGgaN4wfzwf17/D7EeexKTGRW+Q0rl44x04SrbSxebcvk62VPJ3oNh3CnEAUAE8syvANq1mendu0dOryABP6e/fq+oQmz8dtmjT/ODOmrMB/ED13avrgnd5fDoYKo6ZpHUzTLDFNsw44XdO0LCAf2GiaZsme7k+Nkt59lwLXAqlYd03/BDgWGAgMAE4FzhVCeIHvgaVAV6AvkAv8q9m+lgJHAYlYN9R8WAhxwjbHOw84GsgB4rFGOe2OfKwbcna1j3EDMAl41I79Y+CVLSsLIa7GGil1ob38DuBjIcSWrwwygXvtOLpg/Wfy5jbHPBsrcdvypeZPCSHydzPe3bqudqytfW33WvM3KTWtpvdkOiXFQUGOi+YDFbVIFFck2pQsArgiBh2KKkkqr6XG62FjchLJtcGm5QY67qCJKFpPvr+MURtX8OPzr/Lof7/FG4kQdjr5xwjBT7md2ZCcws1jxlOYlIJVP3RhAC3HbsWaphpJaFpiAmazjxi/y82MLr3AjlU3DI7v79vr6+M5WYBDR7MTUwD9hH6t/nyp6bYx3c5t+00uz5mmOefXJIugKox74gUp5TIAIcTbWAnWEVLKRqBRCDEFq0oWBjQp5d32dgEhxF3ATCHEb6WUMSll84TreyHEf7GqbF83m3+flLKi2fF290abAXtbA1gghFgAzJFSzrL39SZwmxAiWUpZi3XX9/ullAvs7b8UQvyAVaV7UEq5sNm+Q0KI+4BFQoh4+9wBvpdSfm5PfyyEqAEOB9bvRry7e13fBk6hda+torQah0Pj7js68M33DXy9NEQoFOX47gkEigLUrHLgjMXANHGHYhB1ML9nHgG3G4DFvXPILqtFN6E+xUtxxxQylzWQGvTjIIaGybmLl9GvrJzrTz8BX3RrgmlqOn6Xi7DuJGzEEcaDixAOgrw5dBivDTuCJ+dPhsoYVatTGBiFLEoBjSld++BK0Bg+uiPLTh/Hdck5dF26grUVMcQJeRzVO2kHZ7sHjuiF9tNDOCYvwqiNoQ3ojHbBsL3fr6LshYOhwsj/jgA/Zm92phLG3de8ydIPxKSU5dvMSwQKgDw7aWrOBDoAm4QQN2JVv3KxntA4rIRoR8drtPe9O8rsZLF5XNvGjr2/Wjvep4UQTzZbx4l1jyaEEN2wqpPD7W22FBAy7Li2jXVP493d6wqtf20VpVXFxzs4Y0IyZ0zYMsf6VpalPb0suXc+mNCQ5GV9XiZ55ZWMWLGK8sREJg/oy7xh+aQ0BvAneuhQVUsMHR0NJ2bTp0q/sgqe//otUgMVzMvMoyw+md/Om4Ovwck6d2dyolUYUR20IM6nzqHvqWN4OxG6JPfFXFVC6NjH8W8yiB57OBUPnIczLx/RAdwujSHAEIAhffb9hRnaA21oD9QwF0VpYZ/exk0ljPveemCllLLf9hYKIUYCj2BVvWZLKWNCiA/ZT/eC2g3rgXuklB/sYPlzWP0eD5NSVgoh+gOLaJ1429q1VZQDou+1fVhzTHdu+zLI6V8uIKemjuMWLMZlGBiAP8FHWUoy4QQPeSVldF9XQgAPIZzE6414Das5N+h0MD89k1PXFbFg4tNsih9Ah3N70uGTW9B9LnBqmLVBNJ8LzeNiVLMYtB4d8Gx8BE9jCC3BS0egY2tcDEU5CGw7sKyVODVNO5atn4HbPsY0ze93e2f7ODgFvgAeFELcDvwbq89fJ2CYlPITIAmr0085YAohxgMnYQ3uaA3/BO4VQqzC6kPoxSoEVEgpl9vxrgJqhBAZHMD+ftvR1q6tohwwE/q6mNDXxU+eTNb+qxiXYTU0rM7pRHlKChoQc7mIC0XICNfxyrChOGMGrx17GOfPWYBYtZF/HjWcGV3yeCHzfFbeGk+H7RxHS/XtMAZN0yBhL0c9K4qyr5QBLzd7XLnNYxNrPMBuUYNe9jEppR+rwtUXWI7V7PsdVp8+sPrSvQH8DFRgDRj55IAHapNSvgj8HWsgTDWwAbgLa+g9wM3AKKAOmIaVtLWKtnZtFaU1OOtDxMImNV4rcQs5W9YFal1xrMjqyPq8BO47/xgKs9NoTHAy9sounD/QwRPHO/jlhh0nhYqi7NrB8F3Spml2MU2zYCc/u50sgvpqQEU50NQLTtmvCiduZMqNszF0SAkE8bvdrOhdgKZpOCJRfF445Y6e5PhrmXnL9+jVAUae2In4F85s7dAVpTXsl2zukWOmtXiv//OUUQdFG/XeUE3SiqIo7Uj+KblkvbGG4l+qqPb5MAFPmpvk/jVkdW7k3ItOspqOSeMEeRlmYxg9Ja61w1aUduUgGSW9T6mEsQ2xb1q9dAeL35RS/v5AxrMrQojngIt2sLivlHLDgYxHUQ4FmqZx0rujWfDcCioW11BwUg7dJnRm4sSJTcub1nU50FSyqCjKblAJYxtiJ1gJrR3H7rIT2IMqiVWUQ4Gmaxx+be/WDkNRDlntscKoBr0oiqIoiqIoO6UqjIqiKIqiKPuQqjAqiqIoiqIohxxVYVQURWmnjJiJ7mh/lQ5FOdi1xwqjShgVRVHaoRnvb+b7VzZCnJNBp3eiQXOTkBJu7bAURWmjVMKoKIrSzvhrI0x9bi2dN1XjCkVYvLmOko4d6XNMFcamGiLPzkRL8+G6/ig0t/oYUJR9TVUYFUVRlINetDGCmLsW2TmLt44ZRHpDgNMWrmJDOIOqP/4NbywEgLGsFO+L57VytIqitAUqYVQURWknGv0GvywPYZQ2EgLuPns0GtCjqpbv+hVw+qJVhHUn7lgEHQP/pJV4gdC7C4guKsV92RBcPdJb+SwUpe0z21+BUSWMiqIo7UEgaPD7B8oprYgCMLhfF0xN46p5y8mt9xN16IxZsxhHRMdPPCvTOlDhSCa/9wt0X7EKgNDD3xP/0/V4hue25qkoinIQUgmjoihKGxMOGTz1xCa+K9Qw3A4a4t3EVYfwhGLougaaxqounRi7vJD8ukbKkhJJCQT4avBQjl28gIz6OiIOjXJvPN02FTXtVzdjbDj2bbzje5Hz0glo9X7ITkJzqY8KRdkTqg+joiiK0qoM0+T6f5QxrcxLGjEIgxmOMNXno4ceoiAYJqJpxFxOjiitJqqBLxwh6nBSmpLGt4cN5oIZUzBw4IwZzM3qRk5jFS7TIIoTAlD0/UZS8v+PhNpqjA6p6HPvIxaE0LQNuAPVuJIdcMZw8Lpb+3IoinKAHLQJoxCiELhTSvmmEKILsA7oLKUs2umGBzEhxEXAg1LKLq10/KOAaVLK9vevj6K0M9/MD/HdwhCdspwsC+jUVkZwBWP8XOekpsJJumk2rasBjjgHS3QvXYLWrXM6NDSiGyYdNteyvsDbtG5VfDxTuvSgwREPpkmXmkoCpo8wMSI4SaWS7KoNeAkQxYOjpIbGbndTF8rANDXAIJUN6O6XccZ7cKTHoR3dA6JRuGIsjO53gK+Uohx8VIVRURRF2aVFK0P8640aTMPk+otSGNTHu8N1v1xrcPlXBo7SIHlVjaSEI/R3BngmpSMhlxOWx/BEwnQNhNEAF2F8wMZELwm1fpwmlCR5CaTE4agP0U1uRnbOItTg5+Rpc0gIhkkIhljauzOaCRu9Lr4ZPYKrflxA19oKelWVAhoGDjIoBzR0YhhY1UMTHWcwiIn1ARjU3TQST0a4FMINfN5RcEvWafjCIV656BlEQyk8eglcNQ4e/giengQF2eDQYc4q0HU4dSi8cj24XdZFeGIiPPY5dMmC3x0P970PLgfccRb88wsor4UHfwMXH7M/nzZFUXZCJYwHESGES0oZae04FEXZO3//TzXlVTEAHnmxmncf77jd9QzT5LyJBqGAgShrQAPqdSc/kEQg2WOVDkMxkiMxmtcrIpqGIxpjVXIc9SlxRB3Wt7x2jIRY0CmdC6YtZvT6NXhMKwbDAxVJiZjAkQvXcPnyXwCNLOqa9unAIISXUjqSzxrAAKyEUSMCmGyIz2BTfDqYBQxqmEd+qJDfXHgdfreVEF95zu9Z8M//g6ufg/wsuP0ta+ebqlqe+NvTYGRvuPYkWLkZbn7Fml9UCbNXQcQauMNVz4JdMeWKp2H8EEhL3LMnQ1FagaEqjPuWEOIPwDVADlANvIXVDB3bi32awA3AZUAfYAFwLnAOcAvgA56TUt5hr+8D3gRG2MtWA3+WUn5rL38QOBUYLqUMCCF6A7OBs7ess5NYhgHPAL2B+cA32ywvBF4GjgWGAVcKIZYBTwL9AAcwC7heSrlGCJEBlGI1zW8WQowFJgNXSClfEUI4gSpgrJRyjhCiB/AiMARYC7yyzfF9wMPAmUAcMB24UUq5QQgxBJgCpEkpI0KIK4GXgDFSyh+EENnAZqCjfd3WAZcAtwGdgZ+AS6WUxbu4RpcBdwJPA38EkoHn7bheAMbZx7lKSjm92Xa/Bf5gH2st1nP2jb1s4I6uob38VXt+EOvvohG4X0r5/M5i3Rfq6+tJTExU0+18Ohze2lwcjpg7XL+uroFQLA7dNFskhDGHBro9x+MgGNSIYf3RmkAIOHV9CZnBEK+IHlT5PDhjMY5fWUR5zMGgwhIMhwb2O+msfr2amsgW9Cug+8oSIrqDYjMVXyyAA4ihU0U6Jjr1JJNCNQA6EZyESGEDs3w9rR1qGst8fcgNbyDkcDXF7Xd5rAnThPoAOxOsrsMLWxNCmxnbmhw3nyYag0hsvzxfavrQnVZ2n97Kxy8CTgKSgNOAK4Cr9sF+LwJOBzKxkoLvgVSgGzAGuFUIMcJeVwc+BnoA6cA7wEdCiEx7+T1ABfC0nWB9CDyxG8liMjDJXj8NuBm4djur/hYrkU0APsP6PLgXK4nuAjRgJbRIKSuAhcBx9rbHYSW44+zHw4EoMNdOHicCS4As4Gzg99sc+5/AEfZPvn2eE4UQDmAe1ufSkTs41nHAYillWbP9nQccbcceD9y/k0vUXD6QAnQFjsJK+CcBj2I9bx/TLNkVQlwN/Bm40F5+B/CxEKK7vcoOr2EzZ2NdnzT7eE8JIfJ3M95frfmblJpuv9PX/iYZtwtcTrj2gpQdrp+SnMhTY3UibgdFKXGYgMMwSNWaNTTEu6hLj6PaoVOnaZTEuRhTWUNKNEaHyjoul6u4asYSnn3+S/LqAgwIBZl0zADOufJshvzpSh4+bgTu8Nb9GbrG3EHdiDp0Ak4P6xwdqXYlYOCwBr0AlWSxmVx0QugEgTCg4zK27sdrBPHEojzx+Ws4Y1ESQgGe+PxVa+HtZ8GZR1h9GgE6pULnjK3nNLwH3utPsaYP6wLXn2Svl4Z297ngdkKcG+2ucyAtwWrGfuACyE7Z78+dmj60pvcXE63FT3vQqhVGKeVHzR7OE0K8AYzFqjDtjce2DI4RQnwI/A24V0ppAAuEEAuAocBMKeW2ycSjQog/28u/lFLGhBC/wUqgZgAlwH27EcMpWJWrR6SUJjBHCPEfrCSnuRellPPs6QBWQrhFSAhxH7BICBEvpWzEqigeB7xu/74TeFIIodmPf5BSGkKII4EC4E9SygCwSgjxGFbVDiGEjlURPFVKucmedxNWhXKYlPInIcQPwHFCiGlYifaNwK3A7faxJm9zLvfZSS1CiLfZ/eQ/YG/b/PmZI6WcZe/rTeA2IUSylLLWjuN+KeUCe/sv7VjPxxpUtKtrCPC9lPJze/pjIUQNcDiwfjdjVpQdGj3Ux1GD4wBwOHb+YXH1QJ3L+2tEjUQ0MxGHaaK7NO6YbjJ1o8kRwTqGT15GTlcfna7px2V3bSIjHAFdx4yZTPhaEopzsWBAFyIuFxrwZe88VmWmAvDqkYdz0aLVpIbDRFwuHKbJxoIssktryCivw+/2MGNwLzrVV3P04iVEDZMYOo34CGCShFUpbHCm0bO2mI0JGThcJoO7lmL2O5rrn7iAq10aDq8Px61/BjTw2FXH/1wHT/9262jqYNiqPsZ5Wl6Ef/8WHr3U2k7TrIRT18DhgDvOtiqLHheKorSe1m6SvgCrutbVjsWN1Xy4t5o3g/qBMjsZaT4v0Y4hDvg7MB7IwOq4k4hVnQRASlkihHgfK1EZs82+diQXWG8ni1us2856hc0fCCG6YVXWhttxbNk+AysBnQy8LIRIBXpiVd/uBgZiJXFvNzt+mZTSv4PjZwJerObcLefZIIQoY2uT8mTgUuAjoAarWvqsECINK7H/3Tbn0vy6N9rx747tPT/bPofY+6vFSoSfFkI82WwdJ1bFeneu4bax7mm8irJLu0oUm3M5NFzbrP+3o7dMpcOVRzXNf/HhPJ57YjPm6gaKcjNZn55EuDGEHu9mSw3PpKWiZCeDV22ksEMOKQ2NOIwYQZ8TU4NwgsmNP71N1PBQTRZeglZMhDFIJZiXgefxM8kcczgJz/1MntdF3DVD0bxbE7imm+s4Hf97cs1vvbOz2/A0X9b8vo+6Dp7WbgxTlD3THkdJt9qrUAjRGauy9yDQUUqZjNWP7UBf5VuA0VgJULKUMgWrP2VTHEKI0cDlWP0NnxZCxO/GfjcB+Xblb4uC7ay3bfL5HFAPHCalTAJG2vO37OdHrKbz67FukRPBSuzOwEqQtlT9NgFZdjP69o5fjtXk3DRPCJGA1Xy90Z71LVal9UzgW7tv6TSspvUOdiytYT1Wv82UZj8JUspr7OW7uoaK0mb17uDkib/l0e/UbNYmJ7Cgcwe+Fz1Y2imLOpcTTJPRm8rwxGLWBi4d2T2P4xbPp2NlJfHBIN5whJrsBAp7ZuD2RokzgiRRSw7riKMBR49M0n+8ivjpf8Cz9hG0s45ET40j/rbR+G4e0SJZVBTl0NCaFcYErIS1HIgIIY4ALgaWHeA4krASp0rAbTdHp2xZaA/ueAdrgMVrwFfAs1jNuTvzBdbAiz8JIf4JDMDqoxnajXhWATX2IJcW/QDtgTc/YTUN323P/g54AyiWUq6y583CSqz+Zp9TJ6x+lFv2YwghXgceEEIsxaogPgYsB36211krhNgI3NTsfL8DHgB+ata8e6D9E7hXCLEKa1CTF2tgT4WUcjm7uIaK0h5cfUk6V1+y9Xufp06t4+UXQ2RtLiEpFiNDi7IpyRq93ICDqKaRU1VJcaq9jaaR0uCnS2U9JeSSTDWOIblkTP8jmroht6LsFVVh3IeklMuwBpR8hpWs/AUrMTvQHrePvxlYg9X8WQhN/fzeAr6RUr5iN5tehNWv78qd7VRKWYPVzH0eVsXySaxEc1duBkYBdVjVvC+2s863WEnRloE3U7BGKjf1KZRSRrFGdw8EyrCarl/YzrEkMAfYgDXi+dRtRqlPtvf9Q7PHSfxv/8UDRkr5IlY3glewru0G4C5gS9ljd66horQro0cncdMfOzDg973IGtMBZySGI2Y1YBy7fBU5tXX03LwRh2HdsiazspqupbX0WnsVKf84CcfbvydO3qaSRUVRtkszzW17uyiKsh+pF5yy3837tpybPgoRDoW4ZMZCEkIhdC+Mq5qKNxplvacbDc58ej43kvRT8lo7XEVpTfulFHjHKfNavNf/9YtBbb7kqG7crSiK0s5E0DmiuBKAwj5dyairo8fxlczufzITJkxgQCvHpyhK29PmEkYhxCSs5sb/IaVMOMCxLMG6h+C21ksp1ReqAkKIPGDpDha/KaXc9t6QiqLspQEjUpjxeQUlG4LEJ+hc8dwwZspvdr2hoij7hNnm64n/q80ljFLKk1o7hi1UUrhrUsoNWAOcFEU5QOLiHdzweA9qyiMkp7twqdvSKIqyl9pcwqgoiqLsmtOlk9HJs+sVFUXZ59rjd0mrfzsVRVEURVGUnVIVRkVRFEVRlH2oPd6HUSWMiqIoh5D1yxv5cWIFqdluxp2ThSduO1/npyiKsg2VMCqKorRzsXAM029SU+ph8v9NJc4fZlFeBvU1US64sXNrh6co7Y6qMCqKoigHvXcWRPh5fZTT+rvoXVHNlAunoTdEcHnDdCusxgSySqpZ2C0JUAmjoii7phJGRVGUduTNeREu/sD6yvqnZkT499R5pDVEAHAEY2zISuaNE4YR8Lrp5a9rzVAVpd1So6QVRVGUg9qzn9U0TUcdOlUNzb4a3jSZengP/HEeTE1jeXwyBTeW0/3WCiYtCB34YBVFaTNUwqgoitJOhBoijP3iFxwxAwBXNMYLw/uxqEM6IafG4rwsludkNK1vAlET/GG48dU6aosDrRS5orQvptbypz1QTdKKoihtVNmPJcy9aTax2jCdj0wnYcF8fr+4jB4lNZiajqlBo9vF06MGkhjJJyMQYqPPS1Y0hsM0qXLoOAHdNAlF4MI/bWZVTiq9+8Vxxzgvwzq2k086RVH2mkoYlUOeEOJO4Dgp5TGtHYuiNBdZXkH4lxI80XqcSU6YMAQDjcJp5ehOjcVXTCNUGwWgcNImhlTVEXUauAwAq8qoa1F+u3Q1GhBBY+TmMkoTfPyc2wF3nBeHaQIQF40xtyCTkmQfK8tgxvONnNUxxlUj3Ij+XrTt9Mmauy5CUbXBmD4uEuNUg5WibGHS/v7ZUgmj0m4JIS4D7pRSdm/tWJSD0Px1UFQFY/qDz0PN9FJi/ihpx3VC03/dm725qgSWFUMsAj8thy4d4Zi+aH1z/ndlfwjzqUnwzNfW41OHwBfzIDUB7YKRNG6IsO7ZDXwwvCub0334whH+8pubWJzej4TyGO5IjGBaOpr9wWSiEcGDI+rAHQ3j9oM7FMMf76Iq20oK3aaJOxaj9+YyMqvqePfIw5vCieoaKXVhnGGDPlVr8EQMvqrI47t5DSRnejjh2GRylpaxZnWUYLybdZ0S+KbKiWZCyuQQWryL0blwU0+D+74OUWfoHN/bwWX9dbrluQFYXmmyqsZkVI5GildjWpFJMGoyNl9jWhGEYyZDsmBGkUmvdI2e6SoJVZSDhUoY2zkhhEtKGdnVPEU5pLwxFS59GkwThnZjzXFns+7hJQBkn9uFAe+N3uNdmlOXY57wGISigIFGA6Bh6onw8Q1opw3eunIognnUHWjz1mECJm60f/8A6LCuDvOX91jrHExlh0bum/EaAN92H8DXPfsyYkEV1a4UahITyGvczMb4jmimRmZDIw3E4ySCNxQlvtHAQ5TE2jCBYg9lHZMAcIajuIMRMiIxEoIhGrzW900bmoY3avDop89zysrZGGh8lDOecncmS/KyeT7Wm9HFUZZkJ1PhcZNYFMZwOcGtU6k7IAAfrYKi76rJrwuSBny50ce0/0a588IkYh3jmPCJQcSAHqkwvgCe+MW6HH3SYFkVYJokGAYNYXA74MsLXIwtUEmj0va0x1HSKmE8SAkhEoB7gTOBTGAD8DvgF+Bhe34cMB24UUq5wd5uCjAf6AKMAR4SQvQGXEAYOA14D7hmJ8eeYh+nADgOKAOuBjTgCSAP+A64REpZb2+TDvwdOB7wAj8AN0gpS+3lf7CPmQNUA29hVf9i9nITuA64HOgNLAEuk1Iu38V1SgVesM/VCWy0jxMFngPcQogGe/VTpJRThBDjgUft85gCrN7ZMZR26PWpVrIIMGcNmzesalpU+n4hfV8diSNuz94ezXdm28kiWOMJHWhEMY0I5pszWyaMizegzVsHYNcHY7R8O9bwUU9W9fqmOeNWL+KFIbnUeeOZdVgPIi4nvnAWXdevI70KvFGrCTqKixqXlwxqm2qPWVUN/DygC8n+INnBGgBcMYNzZi3kmwE9WZ+ejImGx4hx8sqfAVjr7o6n3kMudeRW1rEuK5n1uemszEgAoMrnBn8UtvmimJz6YNN0l5oAJfFuwLZ1PwAAaxlJREFUJs/0s7mvl4gVIquq4TX/1m2WVdkTBjSErclwDN5eHFMJo6IcJNQr8eD1H2A4MBZIAk4HSoB/AkfYP/lABTBRCNH8bfsK4Ekg2f4NcA7wFVby+cfdOP7FwCNAClaC+QZW0ng0VjLaC7gBQAihAZ9iDbrsb8dVD7zdbH9FwEn2uZxmx3jVNse8DDgLyMBK/P69G3H+CfDZx0zBSqSLpJQ/Ab8H1kopE+yfKUKIrsDHwEP2+k8Cv92N4+wT9fX1avpgmO6f1zSPZB/e3olNDz0F8U3J4p7sU+vfvNnZBAyslFQn3COz5fp5GZg+d7P1NXubrdvHXBGSg1tHLZf7Ejlj8QLqM1xEXFZ8fnc8htuB3711XxU+L/84bnDLHlQarO6YzeIunVmRn4NmJ27VcXGsT08BNGKaRlh3sCE5C4CQ5m2+B9yRKEUJnhbz0ICwsTX5BgLOrW9FAZdOUihKlxwX/TO2RuR2QM+Urbf7iXOaW/fXTPekcNN0q//NqOl2Ob2/mJrW4qc90EzT3PVaygElhMgCSoH+UsolzebrQCNwqpTyW3teAlAFjJZS/mRXB9dKKa9ott2rQJ6UcsxuHn8KsERKeZ39uC9WxW+YlHKOPe/vQA8p5RlCCAH8CKRKKUP28nSsZLazlLJoO8f4hx3TufZjEzhXSvmB/Xg88KaUMnUXsd4LnIhVnZwnpTSaLbuMbfowCiHuAE6UUo5qNu8tIOcADXpRL7iDQSgCf/sUNpTD748n0q0z6x5cSMwfpctfBhDXJWGPd2maJjz5LeYv69HWFsG6zZgZ6WjnHwW3noTWLJECYPZKzNMewSytR9N0uHgkRB1QWQ+1DYQDEWKLivEaARpdHioiBawb2QVffZTpiT2bdnP60s9piCayPL4Hm5MSeXrUYNZmpnL/f2dw4qJ1xDSN2UN6MLNXPiGHTmooQlIkgjMSZaPHw6Ls9KZ9RYA+lcXcMfNzStxJ+GuzSQhFKUpP4pFLjqZr1M8SXyLlbi96zMCoC+NxwG9HuPnvBp2uSSbjIw2sWREkJdlBUpJOp44uzjspCYcTHpcmSytNLuyjcXiWxoOzDIJRuPowjdeWmIRiMLIDfLfOYECWxk3DHejt5MNWOWjtlz+wP5y9tMV7/b8+7Nvm/5BVk/TBqYv9e+U28zOxmnvXbpkhpWwQQpRhfb/XT/bswu3sc3vzdqa42bR/B/O2lGUKAA9QauWOTYJYzb5FQogLgFuArlh/d25g1k6O2dhs/zvzKFZz+2tARyHEF8D/bWkK345c/vdarMNqKlcOFR4X3HNO00MX0PPxoXu1S03T4A/Ht/j02eknxPCeaMUvoa0rhbRESIlvGSLAJ7PhxW/xdM2j811nUpBtJbLONwop+qWGDH8DnhmJuHAxc2BH/j1yGNgJ1t3jR7IqvwO5sRhBt5OVGszPSsNpGIyrrKV7gx8zzoPHMAjpOk7DIKhrJOHl9aFnMCUrneMPc/PnI3WGZfu4toMbSCYQMdnUALkJOpvqHGTG6yR5tWbNATv+H+/WoS2vyD+P3ZpED8reOv+iAdsk14rSxrSXqmJzKmE8OBXav3sAS5vNLwdCWAnaGmiqMGZhNeFuYfC/tjdvX1mPleClNa/wbSGE6Ay8idVcPElKGbYrjGLbdfeUlLIRuAO4QwjRwT7Oo8AlbP+cNwEnbDOvYG/jUJRfRdOga4cdLz9jOJwxHPc2s8XFXRAXW9OrxnZg093TOLuikGVrMpncvau1wDT5b35Hbpk5H5euMf/YYaBDND2eSR0TyWoIMmZ1CT0bA4R0nVS/n41eDzXpXkIFmZzbxcVfTo3H62r5wRfn0uieCqDRLR1FUQ4RKmE8CEkpy4QQHwLP2M2q64Fu9uLXgQeEEEuBGuAxYDnwcyuEuoXEGmjzLyHEvVLKSiFEJjBWSvkukIDVX7YciAghjsDqI7lsbw8shJiANWhlJdCAVdXcMvKgBMgSQiRJKbd8ae47wN12xfMD4BisPpVyb2NRlNbQ49zu9DjX6nXxwh3TGFlVT1liPJ5IjJjDQY3bRcDtRDNNzDg3OK2u62UJXjpWbCItpBHTdUauWEHylxcwuH8cjl95WyFFUSxGO3wJqUEvB68rsJKwqVgDSD4DOgA3YyU3c7BGTnfE6tMY2/5u9j+7qng61t/TXCFEPTAbKxlDSrkMuAfrHGqAv2AlbvtCN2AiUIdVmQ3Y+wf4HvgWWCeEqBFCjJZSrgHOBu62Y7kZeGkfxaIorSr/ziP489yFJAVCuAyD3Kp6qrLTmdGvB6YJ3mDLu2ll1TZw5ZQfuPr77+h+fjeGHuZTyaKiKNulBr0oyoGlXnDKflX+ZRFfXDKL8iQf3Spq+eqkgRQlJbHC46bM6SAuzgEeBz1LaxhVWMbtV/jwFiTjFp1aO3RFaQ375T+k685b3uK9/un3erf5/8RUk7SiKEo7knlyLof/ezizXytiw0ldufy4FF55o5xkr5f+q4voVVhCZXoyumFQ0yuLpHP6tHbIiqK0ASphPAQJIW4Hbt/B4pOklNMOZDy70uzG29uaJqU86YAGoyhtwKALOjPogs5Nj/v18fL9yz/gm19Hg+kms6KWkNvJ6N9k7mQviqL8Wob6LmmlPZBSPoR14+o2QUq55zfFUxSlSXLvFJyjnMT6JtHl70ECm/x0PruA/PPVDQIURdk9KmFUFEU5RMTSnQxZekFrh6Eo7V57vA+jGiWtKIqiKIqi7JSqMCqKoiiKouxD6j6MiqIoiqIoyiFHJYyKoijtnL8kQHhmlP/O7Mj436zg7FvWs7ZG3RJUUfYXQ9Na/LQHqklaURSlvVpWRO3yeib9cQmxqMkocy0Rl4fK7BTevqKcOz4cgqa+2UVRlN2gEkZFUZR26K37pzN5UYDum1x0idrVRE2jIsXHks7ZZPv9/PJ1OUNOymrdQBWlHWqPo6RVwqgoitKONC6qYtp9i1i2IoQryUdGWQXxoQDhODdBp5MuNRUM+XEDIU2jtji9tcNVFKWNUAmjoihKW9UYhDmroWs25GXSuLiK+UM/ISkU4yTAk1DFhtRkGlKzqUxOBKDCobPG7aaguJToQz8zMzeBvDTI7peMK059JCjKvtAeR0mrdwdFUZS2qD5ASNxF8UoPuq7R4d0zWPl9AC0UA0ADUhti9GpYycvDujdtpscMAIrTUihYvpHVV/3AGl1HG5TBWa8fSVyiqzXORlGUg5xKGBVFUQ5SpmkSfHMhsY21xF08EEfn5KZlxlPfsnhVLl49QK5RQuC8N6hK7kEcTqx00SQePzomSfWN1CXGW9vp1s0xosDmnAwMNOKCUVhcxbibN/DMXXmUL6rHNE2ImbhcGkcel4rbo26qoSiHMpUwtmNCiELgTinlm0KILsA6oLOUsmg/H/coYJqUsh0W5RXlV5BroKwOjhsAbifRH1aDYeAY0wOtWed4Mxoj9O1a9FQv7iM603jTFzT8+yeqncm47p5KkncjPnSCAwaw/Gcdt67TIVbF0uwCPISIOV3EagDdIJ0qDENjYXoOOSuq8WVFQIOo08nGtAR80SCGrhGO8xBO8GKaoAVNHr5tHWkxgxjwfUYKm+M8dJtWhbtbAutqNMZ3g2PydbxxOkd31slJbPkyn7cihGHA4N7uFuemKIcSk/b3t68SRmW3HcikU1EOZm8tNXhrmclhmfDASB3nOzPhrZ8wfHGEGh3o/iCa14HjhD44Qo3E7vgMEw2H6IR/+CCMp2cAsPncYfR+7zz4ej7mk5MILayipsiLiQNfRgwq6qjVs0mPlOMhiLNRx8CFMWsl8/uPJytWwcLEDkzvMQSArkXFiIp1uGIxqqKZVAPrtWS+PKYbI5ZtIiEcomtVMe8ddgQnF24i5tDBTuo0DXL8AVxxXvy6ztLkeFbZVcmFOOm+oJZhjQHeLUnm9RkaPsNgVEMDaQk663xx9Mt30cUZY/LsICZg9EqgzNTwGTGuP8rDlUd6AVi6IcJln0aoMnVuGeHk2qG79zH07pIYry826Jeh8ddjHLgd7e8DWVEOZiphVBRF2QPzSk0u/tLABCatg57r1nH55S+AaaIDDuIwcWIC0W+XY3gB3ABEZSn+pRKvva+Mj+ayduUJdD39UbRgBC+QSCp1dCRUYWAQT3djJVYTs4aBRgNJONE4bO0GfP4Iz543tim2wo7ZCKyEcUs6lV9Ri+HVeG9Mb66Y8zM9Kks4rKqMn3Ky6VdRjRPrGxxiGizITGV5Tjq6YZJeF2hx3usSfPSpriNsApj4NY1g1CSp2E+eK8yM2kSkaZACbE72srZOx1kTBODa96J0z3BwdHcnp78SZFV8HADXTTU5Is9kcPbOk79FZQYXfh7DMGHSGpNEt8bdoxy/5ulTlAOivdysuzmVMLZxQog/ANcAOUA18BZWM3TsV+5PAx4ELgcSgUrgMSnlv4EF9morhBAm8IiU8gEhRA/gRWAIsBZ4ZTePdQwwGbgEeADoAHwEXA88BpwN1AE3Syk/brbd6cBdQDegGHhQSvmWvSwXeMmOxQ0sBG6SUs61l98LjAJmA1fZu3xWSnnP7l6jvVFfX09iYqKabsPT6+tMmn9HSuOKEjC3ztGIYTZ/azWarYxOUadMuq+2CvTLs7Mxivx0DUaa1nASBsBBlATqmvZqbW3ixk+IRJL9fub17mole/ZaaXX11iF1rWlm1KFzZPFmRkxbRXLID0CX2ggfHZ7H+4f1pF9lLSdt3My8jHSWd8kEh44BBEyD09aVkhGOUu1y8nlOBpXulgNi6p1W0ua1B9Js+ZAMuhxo0RYnzvqqGFXVAapjzftCaqyvM+nha9jpNd9QB0azi76yIgzE7XB9Na2md3da2X2qF3PbVwScBCQBpwFXsDUR+jXGAZcCw6WUicBwYIa9bKD9u5eUMsFOFp3ARGAJkIWV5P1+D47nAI4BBgB9gBOBWcCnQDrwMPCyEMIHIIQYB/wHuAlIs2N9SghxtL0/HXgGyMdKQH8BPhZCNP+kOxrYAHQCJgC3CyFG7kHMv1rzNyk13Tanj8vXGJhpzUtyw4jLD4fDOgNgOhxEiNvafyknBf1P45r2oZ8ziIZ3r+ClUSN48cgjefSOyxk+MhvGHWZt73QQJgEvjcRTi04MaPkVfiYOAg4HUZxUpiaSEgjgC4XxhcOcM+dHcqLlJFDPhtw0NndKZW3nFJyBGHM7FfBdQT++6CMoT0jAjMUIOp3MzU7nadEXl1MDx9aPhJDHSU4ogsc06RCOMLa0mgF1jU3Jodsw6OkPYQJFcR4Azh3kJDUcpntlPW6fE9P+FpmuGTrj+7tJT0vi/B6gG9Y+8uIMjsvXdnnNj83XGNzB2leCG64f5tlvz6+aPrSm9xf11YDKQUdK+VGzh/OEEG8AY4Hnf+Uuw4AX6CeEKJdSlgKlO1l/OFAA/ElKGQBWCSEeA17Yg2PeIaX0AxuEEFOAeCnlfwGEEK8DzwI9sCqcfwD+JaWcZm/7sxDiTawq5Y9Syg1YySD29ncCN9rbL7Vnr5RSPmdPzxZCzAcEWxNjRdmhBLfGT79xsKgCuiRBVrwPc9Y9sGgjWqdUvMUNkOhBq/Wj9e6AlhyHeemRmP4I+sBcjga6f3kmm+rhxixwOTT48jaYX4jWIYX4GJhTVsARBWjrK2k86yVcDY320U3c8UH0Ri9uR4gOZdWUZySTFAoRH/RTUFmGy4ixNrMjq/vk4A0HSd9YgcOugPoTfcQ8blzAJcvW8Ndhh+F3OamO8/Bjj054gxGCXut/q14VdS3Oe3C0kb5D4rj+/ASWlZtkZzpx1PnwxGmsDzgYmqORl+mk4tREGutjxHdwM6/EjccwGNLZSbzH+tD898UJ/GZ1hLIQnNDLhde56w9Tn0tjxiVOFpaZ5CdpZCe0jw9gRWlLVMLYxgkhLgBuAbpiPZ9urArdryKlnCKEuB24E3hfCPETVkInd7BJLlBmJ3xbrNuDQ8aklOXNHvuhqR0OKaVfCAFW8zhYyemxQohbmm3jAKYBCCEygMexqpYpbG0QzGy2fvE2MTQ227+i7FKcS2NYx62PtTg3DOsGgCM37X/W13pktxgz2SlBo1NCsxlOBwhrex3g0hHW/F4dSax9nIrbJxOpCJL5yHE4032kvDgH1+8/JW5NkNS6Rhq8Xkwjxoy8PnRqKKZjeC0D1saTX1zPal9HqtMcvHNkf37snUdGY5ArZy8lzR8iLhrFH+cCr4NaU6frxhqGj0qknzPCuCPcfP9fN+vXh+nWK45r/pKLN85qgu7ftSlwwPpva4uMTBcZmVbSOa4rWC/Plo7svuf3evQ6NYZ1Uomi0jaoG3crBxUhRGfgTeBMYJKUMiyE+Act37/3mJTyBeAFuxn4XuBjII9temPZNgFZQghfs6SxYG+OvwvrgVellI/uYPnDQEesJvViIUQiVgLaDl++yiFB18n42/EtZsX9dihxvx1Kwtoa/EM+IFpeiyfXS0ViHIFaL3m1m6g0OuGKOnDFTEp98RRmpNCruJr0KMzNz+WcOb9w0fLF/Ou4owAYnRDm/lNTGNnHzZb+gUOOTsE0TXV7HEVRVMLYxiVgFSTKgYgQ4gjgYmDZr92hEGIo4AHmACGgHusev9jHMbCad7fcVmcWVhL3NyHEn7H6Bd78a4+/G54AXhFCzAJmYpUvBgCaXQVNwqpSVgshEoBH9mMsitKqvF1T6L/pMkKF9XgKktA8Dqae/CWrfywjOdyAO+LEaUTpVNXA39/8DgDZpwvLuuYwP78zV0+Zwtm3HUbnw1PJT47f7jFUsqgoe85ohzUKNeilDZNSLgPuAT4DaoC/AO/s5W4TgSeBCqwR0scD59vHC2CNTn5HCFEjhLhDShkFTsUaEFOGVY3ck/6Le0RK+Q1wNfCoHWMx8E+s5Bms65Flx74QK6mM7a94FKW16T4XcX3T0OOcaLrG6C9Ppja1K6FQKoam079uHUmhcNP6fdZtBqDeG4d26yiOGp1GfnL7+3BTFGXf0kzT3PVaiqLsK+oFp+x3tT8Ws/ykL9H9IVb364RRG8UdsRoKStOS+G54X86d+y1ZT5/L2FHJu9iborRr++W/pfMuW9/ivf69V/Pb/H9lqsKoKIrSziQf3RFRegmHFV3K+bNPxF0QpTHBQWa0mLMLP+HVd+5idudcMnoltXaoiqK0EaoP4yFICDEJ6+bV/0NKmbC9+XtxrIYdLJompTxpXx5LUZStHAkuHAnWaORzvjyN2Y++QkliNv+qPIpZ3ixOOLEzA7PafNFDUQ5KapS00i4cyERtXyegiqL8CglxlInO6MDDE4a2djSKorRBKmFUFEVRFEXZh9rLt7s0p/owKoqiKIqiKDulKoyKoiiKoij7kLoPo6IoinLQC66upfLd1YTW17d2KIqitBOqwqgoitKONM6r4Kfjv2Jq324YL1cztK8DdzjMencCjQEPKbFSRp2e3dphKkq7Fmt/BUaVMCqKorQn1Z+t4/Nh/SgoqyRjcy09f1pDVkMt3eITeX/EaP77cjGJTpPDT+nQ2qEqitKGqG96UZQDS73glP2mbEYpv1w7A8/6KjrU1uMhSBJbb4VakeDm7aGjiOKjtnc2p5+bwbhjElsxYkVpdfulFnjKVUUt3uu/eCm3zdccVYVRURSlHTBjBp/8djZ6VMOZmkI0rBGOTyE9Vk/X6lKKkpKYcO75bE5MIrvRz10//sLyqU6qjunAeU8Pau3wFUU5yKmEUVEUpY0JNUTZtKSOtM5xmOEYU76qYfaPNXSLxsA06bi5gXX56aDDJlIpi0/kp9w0NidaXwVYGu9jk8PFOQtXw9I1rDeqmONJoW5pOQnHdOWsP/fA4WjzBRFFaTXqm14URVGUVuWvCPLFsd8RKw9SnZvEV/kd6eRwkuIPY2gazpiBqekt7oGxPi2L3MayFvvJagg0TVc9txijVyeMZDe5z01kUbczOPy8rgfqlBRFaQNUwqgoinIQCwViLP2xisiiCgryPaz8oAjv2mo0E5IX+Onr8RDokI7pcFDcuQOpFTWE3EECXg9xwRAA1SlJlGXkMbSmhlA4yonL13DM2o2Y6IBJfUeYPqA/AItyu3Ph/T9gzJsNq0uIDO/P56NHEE2M4+yeGi5VeVSUXWqP92FUCeMhRAiRC2wECqSUha0czkFFCLEaeFBK+Wprx6K0H6ZpYmysRc/wofncO103HDUpbjDJSdSINEQprjdwNYb58pE1bC6OANB1xQp8DQFiyS4A9IhBbmk1vyQn4HU5CMTHEYzz0JAYR8jhAocGukbQ66Q4OZnOgJsYhZ0zeT3Oy+XzppDXWMKkrJEA9C7awJA1q0irreatrxL4z9BjKZhVxrfVdfQsLqRuykqMJC8bx3Tikle+w5nkYdXz5/DX6lQOC1Ty0BkpOBM8VJUH6UwILSeFYHWAkqIGOro13M4YWn4GOB2YpbXg1NHStw66KW00wTQJxjQ6JWAlpxsrIDUeEuL26NqXNJp4HJDqbX8f3IrSGlTC2E4IIUxglJRyemvHcjARQkwBJkspH2ztWJRDixmNUT3hbcJfrUbL8JH23aW4Dtv+rWxK6k2OfjnIqkqTMxrKCRQH+Co/B4dhcPPcGjq5TXz+APH1AaKurW3Nhksnwx9k7ILVbMzLxtTBbcbQTZO4SJS42gYcMYOa5HjWZGaRFAyRGgxhaB6+GZTDqE1FzHcPpueKIsq8Gzn955k4TJOVmRlcds7vMHSdqV37ce1PX/P0xJdpIIlFHAE1YZ4eOJzLflxI2hnv8PfsMo7YsI5ZDxZw0nV3UYeLc+Yv5MHwUo4rOJGNyekcsWEV3738AHH9cuD0o+DeT8ChY75wOdoVo/nrzBh3TjOspnRNo1eqyfyvnsT74QxI8sF/74Cj+uzWtb97eowHZpm4dHjtJJ0L+qjvqFAOrJj6LmlFURRld4SnFBL+ajUAZoWfxsdm7nDdl3+JsqrSugtHnwVFfJPXCYCYrvPayD7krSkjo6zWWnk7t0JzmCZ1KQk4MdHt5ZoGMY8bb9AguTZEVnk1KXYTtQ6cumoTPwwZwpwBPfjsmOFU6xoOe9uyxAQMfevHQ7UvHoAE6sigmMw6PzN6dQYgPVTH8A3FmMQxeEMZ3Yo2A/DB4UN40MxnY3I6ALPyevBpn6Ewfx088Km145gBd35EJGZyz3TDusGJ/UHrXbzeShYB6vzw8Ee7dd39EZMHZlnnETHg7hnGbm2nKMrOqQpjGyOEuBG4GcgA6oDXgPH24m+EEAbwrpTyKiFEB+AFYDRQCvx9N4/RBVgHXAb8GcgHpgIX2o+vAAzgASnl0822GwU8DPQFqoFngMellKYQwge8CYwAfMBq4M9Sym/tbS8D7gSeBP4PiAfeB66VUsZ2Ee9xwKNANyAMzJdSHieEeAoYBRwphPgLsElK2UsI4QIeAS6yz+Ofu3Nd9oX6+noSExPV9CEwHdimBVXP8O1w/cz4rdWIgNOJNxrD77LenpMCYUqT48lobMBhmjijJpppoMVMwl4HaBqV6UmEvW6ifp1IzGROxyyims7gTWXM69MNw6GTWlOPHjMxHNZ+w+6tb/8NCT5m52QzvKiQQRs3MnT9eo5eu5wfu/YmKejnxplfNa0bwsMbowcwfM0mwCRVL20aEuoyDEYUrmZebh6OWIyO9bUtrkGGvx4NMBO8UGsPuslIJNDYQIrXS2Vw67rVvngMh44esxK+SHIcLnvZzq5/XHwCyR6oDdm7jzs4/h7U9ME5vb+0x1HS6sbdbYgQoicwHxgqpVwihEgBekspZ22vSVoI8R1WUnkZEAd8CIxkF30YmyWME+1tNWAa1j8YjwKvAOOAz4FuUsoNQoh+wCysJOwLoAcwCbhHSvm6ECIBOB34DAgCNwF32duX2wnji1hJ7f1AZ+Bn4AYp5Vu7uC6bgTuAVwE3MEJK+YO9bArbNEkLIe4CLgZOBjYBjwNXAb89AH0Y1QvuEOJ/5mf8L/2Cs08GSc9NQE/0bHe9mGHyx68i/Lg+xslJQdw/l/CGlkaCP8x5s5fz2HGDGbFqE1dMW4jDMIn3h/nn2CGctLCQ0u5ZNKQlgKbRubCM9wcUsC7Fun1OcjDMEX5/03EumP09Szp1pcKbSI/iMn7p1d0OIMbcrHR00ySnpoa/TH2N/uVrWJ6RQ0K9D81VTX5dGZO6DeKy824gMdrI/CfvxJ2VSMUfzyDzprfQTRND1/jz/X9iaiiJG5b+zLkTsrjpFydzSOX05Qu4Y8E3OH9/LObxQ+DWd8DjgqcuRuuXy4wig1u/N9jsB58bTi7QeHTTdPQnvoD8THjud5CZvFvXfcoGg79MM0h0azw9VqdnWjv89Fb2lf3yxzH2d5tbvNd/93ynNv9HqCqMbUsU64+7nxBivZSyBitJ+x9CiBxgDNBdSlkL1Aoh7gO+2YPjPSClrLL39wUwXkr5or1skhCiGhgEbACuAT6QUn5mL19uV/guAV6XUjZgVRi3eFQI8WdgKPClPS8A3G1XFFfbCa8AdpowYlUVuwHZUsoS4IddrH8J8Dcp5Wr73G4FrtzFNoqyx3zXDsN37bBdrufQNZ44ecugmDi4MJW77UeGkYt7apCfNnTFcVEmkf/7kb+cOJyfu3ZidX4GpfFxdPaHGLl6E/3nb+DpoVv7+UV0Ey0Ww3Q40EyT+KCfi2dOIhj1EiGBjtXV+D0evu2aizM9hajTSRCd0pyedK+pp3OZxvrUOAZUr8CM99J4+ihuy6jl6t9k4XvkFQA6AebwfMyZq3GO6cPjAzvbRz8NgBcu3RJNd+AswP6Ennk3zY3M1fnpkm17SY2Gi0bv+kJv45g8nVkXqh5XSuuJqVHSSmuSUq4VQlyIlZy9JIRYCNwvpdxeEphr/17fbN66PTxkcbNp/zaPt8zbUtcvAMYIIc5stlzHGpWNECIOq3o4Hqs53bC3zWy2ftk2zc+Nzfa/M6cBtwOLhBDlwAtSyid2sn4uULjlgZSyUQhRtuPVFaX16LrGLcduad9OoDLpCHqc/jFBHMwf0IPNySmEHA4SGhvYlJfA4UUlTO+ex02zv+WWnycTdLr499FnsSC3O88dPZ4RqxZy4ZypVJFAr6JNAHQorsA1eT4Bt5PAmHyOn3slZvQyzE01HJaVAOEoeN2c7XFtN0ZteFe04eq+jYrSnqmEsY2RUn4MfCyEcAO/Bz4TQqTzv02dm+zf+cAae7pgP4a2HnhZSnndDpbfgtWXcixQaPdrrGAfNAdIKRcA5wkhNOAorL6cC6WU32MlptvaBHTZ8kAIEQ9k7W0cinIgpJ+YT+KSywnNLWHA8I6s3xxjwXeVlL9XhqlrjF+2lsM3F3PLgskAeKMRzpk/hYW53Qm63UzqP5QjNy6hU0kdARKo97goSfcxYFMpKQUdyH/RusWO5nSg5VsDVojbflO6oijbF2t/BUaVMLYlQoheWEnfj1jNt7VYiaIBlGD1G5wOIKUssvvv/V0IcTlWH8a79mN4zwBThRBfAV/ZcfUEMqWUU4EkIARUAm67OTplbw9qJ84XAP+VUlbYzeQGVvM9WNel+zabvQH8yb4+m7Eqn+3w5a20V+5uKbi7pQDQMx96HpnGF10SWfT0UsyYSWl6IuHFTtwx62UQcrrIrqlDi8UoTknCE42QQQkRnNx2/FW89clQNIdqwlUUZcfUO0Tb4gbuwWoargFuBM6SUgaxBn3cL4SoFkI8b6//G8CD1Sw8DXh9fwUmpVwMnII1mKUYKMMahLKlyflxO+bNWBVPP82ahffSeVh9JhuwBuLcI6X80V72T0AIIWqEEEvseQ8DX2P1/1yH1QdzPYrShp1yUQcaRndjeNFKOpfX8kX6sXybfBQL0nowse/R5FZWk1NTx6D1myjS89hAF5Z4+nH9A/1Usqgo+5ihaS1+2gM1SlpRDiz1glP2m2jE4Ofj3qFqYYyY3YAUdjlYeHgXkv1bvzt6YGaMbukaObcNxmNXKhXlELVfsrmR15S0eK+f8WyHNp81qn8rFUVR2gmnSyfzrydgaFvf2h06bOie3vQ4LtXFqNePputLY1SyqCj7SUzTWvy0B6oP4yHKbp7N386i9VLKfgc6np2xR4Y/v4PFv9vVfRoV5VDS46gMgg8OZd3988AE8c+hnHlBV957ZiXhKp0zrzkSb+L2RzsriqLsiGqSVpQDS73glAPCjBmYJuhOq9o4ceJEACZMmNCaYSnKwWa/lP/EtaUt3uvlM9ltvsyoKoyKoijtkObQ1dB/RVH2GZUwKoqiKIqi7EPtpd9ic2rQi6IoiqIoirJTKmFUFEU5BFR/rtF4Z5jVJ35KpNTf2uEoSrsW1Vr+tAcqYVQURWnnXnl6M9/X9aTGH4f8JcKyCye3dkiKorQxKmFUFEVp576bF0YsWEtOSTXxgTBrf25gweKG1g5LUdqtKFqLn/ZAJYyKoijt2OLXV5FeUkVcMNw0z2GanPxUPYP+VsPyGeWtGJ2iKG2FShgVRVHaqA11JqurTUzTJLy0gsjGOoKLK4hVBwGYffUs6m78iqMXLSOkGU03AV1c0IFOGqwtN/jbY6V8ddGP1C+uxogYrXcyitKORLSWP+2Buq2OoihKG/TszxHW3TGVgopqPijIImttDQOKNtChqhrD1PB2jLEmJZuOXo17x49mcW4WSY1Bjt1QThIafRoCHF5SweHrilgfjNI44muSExwcNXc83o6+1j49RVEOMiphVBRFOciZ4ShmdRAtKx7Nvr9b1Z0/8MfJ04inhugCnUY9EU/MqiHGgEtOOpdv+vTDE44QwgFAXbyXubkZHFtUCVhNTHowTM7aOlwRA6Meph3/HeMWqW+DUZS9EWmH92FUCeNBTAhRCNwppXxTCNEFWAd0llIWtWpginIIM/1h8DjRHPuhR099ABLjrOM0hDAaQtT8+Vsi7y0kaOh4M+NxXXA48RWb6bMmRioluAiBCb5YI3VkE9EdYBp806cfmmlyWGkNyY1h1qTEsTkxHsytSaUZDJFcFySQ5iIYM/HWRDDX1PLSkV+T6tHI6+Ql57TOJByfy/cfluL0Ojn6+FQSs9xNiauiKIcGlTAqiqLsiGHAi9/C+nK4fAz+278m+OEKtEQ3CV9diWtEvrVedQP8+0twOeCGk1ka9PLGUoPuqRpX9NfQ3p8B89bBmUfAsB7EDJPnZYRNU9dwZeVS8lcWYny1GC0QwtErnaCRgbZqI34tmbk5BVz455upSEzgbx9+wXHPLSAnWMqqI0/AufaHplAjuFmQk8tjxx+HpmnkVdYxck0xE35ZSWKslhM2fI9uGNx8wvl8cNhIzlq8mu7VtVR1SCajtBYH8PWwAvKrqrjvuBFc962k4adyVk0rwe+dT9TtQDMMPr0rQmKKi7GfjCVh5XrMH5ajje2DPq4fpmEQe2EG5oZqHJcfgd4ja/89N9OXwRcSjugJpw/ff8dRlF8h0toB7AcqYVQURdmRe9+DBz4AIPbUZIL1HQAw68MErv8E1y83Weud/CDMWglA2c8bOGrsDVjjTkwqpq/jz9c+bq33r//Cgse5vTibv8/RQevBK650Vnz5EYmhIBF8xFZUodHI3I69+MfYcXx62ADQNEYtX8eZs1cBUE8GpfFuInhwEyJAAqXubM6/8gIqEhMAGLukkJs/noorZg1kqSWdDMq4YNkiQkndSLGbr6NuJ2Gvi/zCKs4rXc7MHjn8691vCXq9uKIxDE0j6raatE1dJ+Rx4qwMs+CaqRz5zadgmph//wptyp+IfruK6INfWfv9z094V96Nlhy375+XBetgzD0QiVqPP/o/KxlXFGW/UQljKxNC/AG4BsgBqoG3sJqhY3uxTxO4AbgM6AMsAM4FzgFuAXzAc1LKO5pt0x94DBgC+O047pZSRuzlrwDHASnARuBBKeXb9rJjgMnAhcBDQAbwNXCllLJ+F7HeC4wCJHAFVreqvwIfAa8AQ4GVwEVSymX2Nk7g/+zzywKWADdKKefay8facfQEosB39vIye/kUYC7QBTgeKANukVJ+tqtru7fq6+tJTExU021kOjp9adObpFbfCJhg31NNC4Ws9WtrSbQTOYAVaxuoHtn0kJllzZqug2ECM5fyk3dr5a04OY31KZn0L92IgxAREilOSmJVZjafDjysab2Ay7V1P2hMmDePMAnE8DAtpxePHj+Gf73/OSNXr+PHHl35pP/ApmQRoJFEFvTI48UjzwCgzusl3h8gLhIhq7QBp2ElkCNXbWJ11/SmJBFMqxnbboLW7KHWWnFdU/M2pknwx+XoP23YGmJZPeaaChp6pOzz5yU4fQneLckiwE8r4MwjDoq/GTXdtqb3F3877LKhbqvT+oqAk4Ak4DSspOmqfbDfi4DTgUwgCHwPpALdgDHArUKIEQBCiCxgKvAx0Ak4EhgH3NZsf9OBw7ESxvuBV4UQfZstd2AlXwOxErVBwI27GevRwCqggx33o8B/gOuANGAZ8K9m69+Pda1OBNKBl4GvhRCp9vIQcL197gPsc2q+PcClwONAMvAU8JoQYr8PDW3+JqWmD/5p55lHNk3reanEO8rRCePUg/geO9laPzkZJoim9QaKTLokNT3ktO4a6PZbbXoiceMGcVq3rW+9fUs20r2yBIAocWjEWJWWz/zcXJqrifdg2J9BfreTHH85oFHtTuSpESPpXl7F2OWr8UZjHL9sFf3KSvF7rCTTBHRXmPmdejbtz9Q0VqanINNSKfN5WhzLGwwTdejUpiQQczgwNB3NMPCGwiQ2BkkKBel/Y2/w2Ol0nBvvhME4ThvQtA+tVzZa7+z98rx4TxSQZL9cnQ4YP2Sf7l9NHzrTyu5TFcZWJqX8qNnDeUKIN4CxwPN7uevHtgyOEUJ8CPwNuFdKaQALhBALsKp3M4FLgAVSyi3H3CSEeBh4BCs5Q0r5n2b7flcIcStwDLC02fy/SCkbgAYhxKeAYPeslFK+ZE9PEkJUAl83qyi+jVXxRAihYVVPx0sp19rb/EcIcRMwHnhTSjm92b5LhBB/x0oqm3tPSjnD3ucLWMljD6xqrKJYrj8ZenWCDRVw+nA8myrxzF4Fo/pA72YJ3Qe3wvszweUg6ZwRzApoTFxj0i0Fjs3rCt0fgoXr4fiBkJPOH3OgfwYUTVnNmcmbcd97PpH5m9F6dcb5G8GxczbyydJ4+lSUUZyQiFi/ltfefIU408n61Gz+dOo43nn/CXS8JIdjlCV6ya+vaxF6YtTkyTPHMG7hUhKift7oewx+p6NpeWGcm587d8c04ZO+3Xjh1a/Jq6oj4HaR6vfjWxNiTYdMpvfryqBNJazNSeNIVxlj+6aReOFAPH3TMYffhTlzDdpRPdD6dsI5sDNa72yrD+Pph6H53PvneenWAeY+Ct8vAtENBnfbP8dRlF8p0P4KjCphbG1CiAuwmom7Yj0fbmDWPth1cbNpP1BmJ4vN5235N6sAGCmEqGm2XMOqGiKE0IF7gfOwqoAmEI9VwdsiJqVs/pURjc32vyexbolt2/i37CsDSAAm2k3vW7iAXDveIVhN0gOxmt81e5vtHlNK2SiEYA/iVQ4l4w7fOp2eCId1+d913C64aHTTw+x4uOqwZp8Yw3taP82cUKBDQU+sgnzL5h5X304823zlr2LQbyycPpyUrBTev/sHSj2p9A4UAjDpjSd4buDJLOmQRY/yShbn5jK9Zy+iDgercjvh1kAzDHxRyCraTJXDyftHDsDUNTBN/Lj4qWcO8ctjGL3TOHPmidRvaKD7t5s5t2cynUYN2u6l0frnovVvWQl1jOuz3XX3ue4drR9FUQ4IlTC2IiFEZ+BN4ExgkpQyLIT4B7tfmdtX1gOTpZTjd7D8Aqxm8uOBpVJKQwghoVW+ILMCKxk9Tko5ZwfrvAt8CJwjpawTQpwCTDxQASrKPnfiYOsH60WX+o8TCHy2lNIaAx9+GmLZXCHnYQIbUjJ4e9gIYprOgDVFuD0ONMAXDlPncTN4WSEfDOxhJYsAmoaOSfeyGgAOu6QLAIl5CfS5sue2kSiKshvC7eT7o5tTCWPrSsAqLJQDESHEEcDFWH32DqTXgT8KIa4A3gbCWANCekopv8LqXxm149SFEJdhVe++OMBxIqU0hRD/Av4hhLhKSrlKCJEAjAQWSSk32/HWAvVCiDzgLwc6TkXZ3zotuR7zqUlodX68p40g+NkaIutqyd/s5zfJpcwSKQz8opCVvXMJ+DzopklSXQO+QIh+myua9qOZJmcvWkNmmpMhDx1J53MLWvGsFEU5WKmEsRVJKZcJIe4BPsNqiv4BeAdrcMmBjKNECHEsVj/Hh4A4oJCt/ShfwxoosxqrefgNYNqBjHEb92ANqPlMCJGLVXGchdW3EeBqrBHfdwLLseIduZ39KErb5Xah3XIqYPXHcA3Ka1p0kv3zefbxrHm7jIzGRlwNfk6fvpBNmcmMW7oOTJO5BZ3Q4zz09cHJn4wmNWc/3AJHUQ5F7a/AiGaa5q7XUhRlX1EvOOWAaigNcN+Vyzhi4Wq6byzF0DSKMpNp7JLO2FdHEt8xDm+CC93ZDj/hFGXX9ssfvnZzVYv3evOfaW3+BaYqjIqiKO2YO9mDxzBZk9eBvJJK3JEo3qjBke8fQ0b+fr+TlKIcmtrhfRhVwtgGCSEmYd3s+n9IKbcdDdyqhBCjgEk7WPyQlPKhAxmPohxqnG4NX5JOLfFMPFYQFwoz6JI8lSwqirJHVJO0ohxY6gWnHHCbV/t5+x/zME04/+aBdO59UP1fqSitaf80Sd9S3bJJ+vHUNl9yVBVGRVGUdq5Tdx+9xlcBqGRRUZRfRSWMiqIoiqIo+1I77MOovktaURRFURRF2SmVMCqKorRzkUAM09j1eoqi7CPaNj/tgGqSVhRFacf++9gqpn9VSaoRT8FZfsy6INHvV6N3TcNxWKfWDk9RlDZCJYyKoijtkBk1+Pn+eTxblEm0S2ec0RiRD1ZSfstf8YYCoGvEvX8xrrMOa+1QFaUdaidlxWZUwqgoitKOmKEoRlWAlY8u5PU1iUSzHFzw8wzE+rWUJyQRBtyahm6Y1L08l/hTB+B1tb8PN0VR9i2VMCqKorQTkaXlLD7hY4INMX7q34du4XL6b1jHhIVz+WzwSFbk5KEZBp1LSzhzwQwWLwhy/x/Wc/ZFncjyaZzR34lHfUWgouy9dvgyUgmjoihKW7emBB75hJk/xrE4PQ/SIX91Kbkl1eRSRElyGity8gAwdZ3S1HTeGjSSaq+L7I1l/OGzNACOzY7x/S2prXkmiqIcpNQoaUVRlDYsFDEoHPkAyz9cyDozCYDkmgDZJQ1EcFFNGu5oGK3Zt3rppkFSrIJXRh7OZ316NM3/odTBpz/UYYajmCtKMP2hA34+itIuqFHSiqIoysEgEjN5Z7HBG9/VEB3zO3psqmJ4cQ0A3mAEQ9OoSffSr2IlWqPJiQtmM7XXQHQzxuDCBVx40W+o8SVAfRjCMQA80Sg/PjCLo+Z9R3JNPeH4OBaPP5pNHi+DnHXk+DRcOT7MlES00wehdUxpvQugKMoBpRLGA0QIUQjcKaV8UwjRBVgHdJZSFrVqYPuZEGIS8IOU8u+tHcvOCCGiwHFSyimtHYuibFEXMrnrR4OSRpNbhuoMjQ9Te/sPhL9dwVVHjOWrbt2IehJhQG+W5Ddw+n8+oSyWRswVY1XvLAIJbrQKEw04fOMakuqr6Vm/DK/RiN99uXWQBBfUGuTU1PDdW8/Qpa6GiKbxTX5nAo5ETnp/Cr2I46GjRnGLnMhzg8awKCuFLh9P5acBhzMo2sBf104lqaMP7cEz+LAigXcXRRnUUef2UU50vZ2UVxRlj7S/v3uVMCr7lZTypNY8fvNEvTXjUA490eoQq8/+hsa55aSd3528x49k7QXfUT91M0njcokFYzRMKyb5pDy6vn4sAVPnuA9izC4GjwPeGq/x83/W0f+DhQwPRFmpazSkg78oQIwMFiVnkdnop9hjNUOXJyWwpFMmXYobGVBRxJfDBQAyrydDNqwk4nDyTdde5P5STRxr+fcHb/Kv0RPYlJJIQXkl58+fRUKdh2Jy8ZmNjN5UyOf9hnPs5TczZt0y7pz+BdXeBH7s0oMfuvfGV9vI25+8zomFK9AxieDAeF3izO/BsxvX8Fn/o7i1oB81DgcLemXx8tXJDOzkwDBNrv7G4MOVJkO9fj587B6Sa2p59q+3cVewgKw4eG+CgwGZ7e8DV1HaMpUwKr+KEMIBmFJK9f0RirIdxY/Op+77TQCUP78UYgY1nxcCUP3hWrb0KKx6dzXJx+fySr+ezCq25gVjcNXHYZ58Zx7uUAyHYa1dUww4XLgDUV58ehLvHtuXl8cdDkB8MEyqP0xcNEqdkURCQ4CGhDgW5nRjcXY+oHHk2tWESGJq0vGUpvRnwtpSNKMYX7CBruVBwngBaCSJ1emZrMzOpDElkSsW/IgvGsbXEOa5L9+j1zV3cc0vMzi5cIV9FlZyp4djnLxqGbVxPlbk9EaPGKRFDPJWVXL9J26mXZfAZ6tN/rPIOp/JIR+P5w/juqKvub4yH0OHygDc+L3BD+c59uOzoyj7WTv8f0cljPuQEOIPwDVADlANvIVV3YrtxT5N4AbgMqAPsAA4FzgHuAXwAc9JKe+w1/cBbwIj7GWrgT9LKb+1lz8InAoMl1IGhBC9gdnA2VvW2UEcXbCa0a8C/gh0A/KFEMcAtwEFQCPwOXCLlLLR3m4KMFlK+aAQwg08BZwOeIES4HYp5Yf2uqOAh4G+9vV7BnhcSrm1t/72YzsfuAfIBfzAJCnlZUKIiUAe8JIQ4jlgppTyeCFEoh3HBKAeuHtn+9+X6uvrSUxMVNOHwHQ40HLAiBnd8Z+xGTPxB0OAa+s800Q3t7+NNxBDB86fshQXMeq9bsbPXo03FgM7Fe2/dBPz++UQ8riJOZ2gaczp2QvX0mWsy8imMdFnHUfXibg8aC5fi2P8t28/Hho3BoATf3cTC/9xL95oFIf9HYOOnXzXoKlpoG39xNRNiBnW9YkZ8S3WjWk6hq7R/Exj9nkfDM+jmm7f08ruU6Ok960i4CQgCTgNuAIrwdpbF2ElWZlAEPgeSMVK2sYAtwohRtjr6sDHQA8gHXgH+EgIkWkvvweoAJ62k8sPgSd2lixu4zf2MROBcqDWnpcCjLJ/7tzBtpcBQ4E+UsokYCywFEAI0Q/4EnjUPs/xwPXAxTsLxj6HN4DrpJSJQFfgPwBSygnABuAqKWWClPJ4e7MnsK5PX+AwrOfqgJQzmr9Jqen2PZ1321DiRSY4NNIu6E7ev0aSeGwncGgkjcslYVRHcGgkn5xHxsU9uXm4l37p1rYODZ481cOAuw8n7HEQ1TUMXSP7pBycLhPD7heom3Dmj8v4zZTFpNWG8DVEcdXbCV3MIKWyAXco3JS89SnaRHZtHSMKV5JWW9cUa355KbP69KI0JRlD01ial8vrR4qm5evSM1mR2YEqr4/rTzgHXDrPHX4k0zp1IaZpQIyw04mZ6MU8qjupoQaOrVoKOtS5HCzPT+Wfp3pJTEzk9B4a5/TUcGgw3Ofn5sVT6RAL8kjCOjwOyEmAx0Y7DprnUU237+n9p/0Nk1YVxn1ISvlRs4fzhBBvYCVFz+/lrh/bMjhGCPEh8DfgXrs5eIEQYgFWIjZTStmAVWHc4lEhxJ/t5V9KKWNCiN8A84AZWFW++/YglvuklCXNHk9qNr1aCPEMcMkOtg0DCUBfIcRPUsqNzZZdA3wgpfzMfrxcCPGUva/XdxFTBOgthJgvpawCpu1oRSGEDlwIjN9yHvb1OWMXx1CUPeLKiqPfnLMwTRPNTth6f39qi8fNp5OBxZc7W8yjX0/6X7X1tjdb5gfX17PwqplUL6nGGa7GWe0krHmsfaIRA1bnpPLZEX2IeFwcsaGMVL+fvhutMXbeWJTj58zl+8GHkVNTyZhlv1CUnsFrx48B02TAutV021hMUarVP7JDXT1vDB7LtK55BDwJnLu+nNOTijnmMAPtxMPg0UtJTNv6IWyaJuM1jZPtSqHWrNro1DXeP9Vhn2cSXPsMmCZ/0jRubX7uiqIcVFTCuA8JIS7AaibuinVt3cCsfbDr4mbTfqBsm76DfqyKH0KIOODvWBW6DMCwl22pMCKlLBFCvA/cCIzZw36Ihc0fCCHGYTXp9gY8WJW6sh1s+yaQDfwT6CGE+A74Pynlaqwm7TFCiDObra8DG/93N1tJKf1CiJOxrvtfhRBrsRLst3ewSaYdZ/PzWLezYyjK3tg2AWr+eHvJ0c7W38Kbn8iwb08AIPJzERtH/JuV9APAZcaIag7uPf9Y1nawbshdmJHCb+Yut5YTxkkUX6COP8x4gUY6YuLiwhmT+erwITT4Ehl9lM41G//LO/5qNuXlcVFsObMv6k7H5Ey6hiN0zMhg5Ih8NO3InZ7zzpK/Fst2Y31FaVPa4Z+yShj3ESFEZ6yE6EysPnRhIcQ/ALHzLfe5W4DRWJXNQimlKYSooNmfrxBiNHA58DJW0/TQLX0Od0NTcmn3SfwU+D/gZbtP5PXArdvbUEoZBR4BHhFCpGD1I3wZOBpYb+/juj041y37nQJMsQfinIrVBD9bSrmmeby2cqxKZxdgjT2vYE+PqSgHC9ewXLq+NYH4qz9jVV130HQ2dEpqShb/9OFMJsxeScDrZnFuDkcUbRmoohMiGdNVyXdpo5k5bBDDI8Vc9u4IEpKdwMn8pukoeZx+wM9MUZSDiUoY950ErIpYORARQhyB1f9u2QGOIwkIAZWA225uTdmyUAiRjdWv8Q/Aa8BXwLPsuBl5Z9xYg1eq7WSxL1a/w+0SQozB6vO4EAhgDZKJ2oufAaYKIb6yYzKBnkCmlHLqTvaZDRyFNbCmVghRYy+K2b9LsPorAiClNIQQbwP3CSEW23E8vEdnrSgHm/OOIvu8o4g9OIf6u6YQCOocXrgZv9PDhNkrAYgLhgn741pstjapA1O69uS0qkpOzViE44HT0JLVx4Ki7LV2WGFUg172ESnlMqwBJZ8BNcBfsBKzA+1x+/ibsSpofuzmV7v/3lvAN1LKV+ym6IuA44QQV+7pgez+ktcAfxdCNABPAztqCgarOfoNrBHQxUA+8Dt7X4uBU4Cb7GVlwKs0a0rfAR24DigUQtTbMVwqpSy0lz8IXCSEqLZvIg5WsrwOWA4sAiayNcFUlDar051DyXx1PL2Ozebu/07j+skzWyyvjY9neWYWAOU+Hy8NHccpWoCc1dfhfPkytBz1PdKKomyfZu7gtg2KouwX6gWnHBAP/m0Tg576lrQKP/VaPHWJcbx39GFMyU4lt76OzMZKPjnbge/cIWgOVTtQDln7pRao3dbQ4r3efDihzdccVduDoihKO3TTjR15veMEprxbSI9VRaTV++nftYQMDwyJFHLVmalw+tDWDlNRlDZCVRhbmd1MOmp7y6SUCQc4liVYzcTbWi+l7HcgY2lOCHE7cPsOFp8kpdzhbXQOQuoFpxxQ4WI/NZM3ISsWEevuYsKECa0dkqIcTPZPhfH2bSqMD7X9CqNKGBXlwFIvOKVVTJw4EUAljIrSkkoYd5NqklYURVEURdmX2uE9RVVPZ0VRFEVRFGWnVMKoKIqiKIqi7JRKGBVFUdqZyMSlNF7xPuEXZ7d2KIqitBOqD6OiKEo7Epy+nuBpr6KZJtFX5hAyNRJ+O5RNGxIJhxz4/TF8Pkdrh6ko7Vv768KoEkZFUZT2pPDjNXRsdveLX55fwaIN6ejv+0ltDPH65Nlc/PQA4gsSWzFKRVHaGpUwKoqitBPLvytjepGXkzxe3JEItXE+piTnsmiDRtLgbnTZWM6Ib1Ywp8dy3Od1I5bspt+1vUnrr74SUFH2rfZXYlT3YVSUA0u94JT9YuP8Gt67fh6mCZGYxvR+3TB0nc7VVcTHDHI3VdKxpBI9apBZ2YhumKwsyGDawAJG/bkvvx3swKG3vw85RdmF/XMfxjv9Le/D+KCvzb+41KAXRVGUNs6s9fPz5ZM5Q05n6OKlLOyaS5Y/QP+iEoYtLCTOH0IPR6n1xZFTWk9cOIYnalAWH8cPfQu4bVKYG74zWvs0FKX90Lb5aQdUk7SiKEobVbepkbu/CjL8g285ZvEifNEwAZ8L3eUgjIPNWWlk1DRQ6/GyfHAf8jZXMnBFMQAxTaMiN5tjCivANFlS4YZxua18RoqiHKxUwtiGCCGeA6JSyutbO5b2QghxEfCglLJLa8eiKDsTiZk8OzdGhR+uHuwg+Y25VN/wDTdjMq1rV5484kjiolEGlVa12E526cTKtCQKAmHK0xLxe934gmFqkn1UpCVZK2ka8Y0GN/xrI0f0TkGrCjBuyRJ8cTpx1w9HT/a2whkrShvWTqqKzamEsQ2RUv6+tWNoK4QQxwCTpZTqb1w5OP24FM5/AvxhqscMxjd5EWail+kP/Z4uE/riCUS4+zM/n681aNA0YjGTDoEGBteW0rOgF98/PZO5h/Wme1kFfxt9BEs6ZAHwt69+JLG2nvrkRBp1nR86ZVDvclLvcHA4MHtQPimNAUxNI7W2nupka7T0mKWryfy6jA7FAVxmFL9RikmYZf+Yw8hbriMlUacBB0d0gNuGa/xQaPD1WpPF1dA1WeM93yIG/LIAzjqSWV16sb7OZEAGLCiHnqmwpgZyEzWK6gyu/dZAM6FrusaSCjgsEz45Jkj29PlQkA3DeuzRpVxVbSJLTEZ00shPboef1IpyEFAfpgcBIYQGOKSU0daORVGUA6AhACf+FQJhAFI+mYaGC+r9DLv6H4z4w0N0qwzzfWICjR4nZsQANDbFJfLnGZNZ70jjzOsvojglCUfMIOaPQdTqg1jhi2dqejKr01OIgfWdtqZJ0IgxdMUa0uoaiDkdaJj03FjMnMR48kvKmN0pld/PXo/TMDFxUEI6BRSTV1PL6FWL+bbHYeA2+X4DfL86Bobdp1+H9aEIzn+9DOWbefXHOi4/rzsADg1iplVs2TICQMPExIqposSat2B9EPPI22DjJive12+Ei0bv1qWcV2oy8p0YgSgke2DORQ56pKqkUWlt7e9v8JBLGIUQhcBLwFhgKLAOuBDoBzwAZAIfAL+XUkaFEK8AxwEpwEas5su37X1dBdwHDJJSlgkhsoD5wJ1Sypd3EYcJ3ARcbB/7WCFEPPAQ0BOIAt8BN0opy+xtXsVqkr7KTjIfBC4HEoFK4DEp5b/tdfsDjwFDAD/wFnC3lDKyi7heBRxABDgTaARuBZYBLwK9AQlcKKXcbG/jA+4HzgKSgZ+B66WUq+3l5wO3AQX2/j4HbpFSNjZ7Tl6wn5PhQCFwtZRy5i5idQNPAacDXqAEuB2YCUwCHEKIBnv166SUrwkhhgHP2OcxH/hmZ8dQlP1ifmFTsggtP1oCbjd9NlcQcicTdTms5KqZxZkdqE6OpzjFak6OOXTSI41Uam4ANsb5MNCIaS23694YZHnXPAYtW407GrOOa4LLNJmZn8XsLp245pP5TetvTfAMzlg2x0oYAQy2Jov24/7lG+lTvhmAdw8f2bQoZrbclzVtx9UsvsM3FdJh4yZ7BRPen7HbCeNnqw0C9r/atSH4ap2pEkZF2Q8O1VHSlwLXAqnAAuAT4FhgIDAAOBU41153OnA4VsJ4P/CqEKIvgJTyJWAy8JYQwoWVlH27q2SxmSuB84AEYB4QAq7HSloHAJ2Af+1g23H2eQyXUiZiJVozAOzEdSrwsb2PI+31b9vNuM4GPgLSsJLoF+1zPwPIxnr/v7fZ+i9hJWBHAB2A2cAX9jUBqAV+g3UNR9k/d25zzCuAG7ESzm+B13Yjzsuwkv4+UsokrIRzqZ3IngTEpJQJ9s9rQohkrETyQ/vcbsb6Ozhg6uvr1bSahu4dIN7TNG9FRkdCDhfrU9Ko8bgp9fnwmCZ5gTC4NLBvdzNy8youXTyHWpcLR2zrqOZbp3/DoxO/5P6Pp/G77+ZjaA6choHDMBi6voQTlxWSbyeJ63I6ENV1DE1jfcdMum4uJaJBwOPiX6cNI+R0EPA46EgZOmES2cQvnQrQNdP+xDBbZrgarE3LotYbB8DgonXsqc0dsjGSfFtnDO6629ezT1KwWSgmh2dpu72tmlbT+007HCV9yN2H0a5mPS2lfNR+fDLwXyBLSlluz3sf2CSlvHk720vgZSnlM/ZjHzAHCAMuYJiU0r8bcZjApVLK13eyzin2sbLsx6+ytcJ4DFbicxEwRUoZbLbdrcDJUsoxzeadBTwipey+i7heBTKllOObnV8jcK6U8gN73rXAb6WUg4QQGUA5kC+l3GAv14FqYLyUcvp2jnE9cImUcpj9uJCWz0k/YDGQIqWs3UmslwF3YCWbPzVv0t9eH0YhxIXAw3aspj3vr1jV0i47uy770KH1glN2bO4aeHUKdM3mrt7H8cMX6xm3YiGNOTmI/xtGUnmAD2cGia5cia+skmMKlzK4rII1ad2pdBtM7DmANDNA/5Iirp71I3UOH3PcwwlrGldfeTITFq5i9OqNTZ9VXxwr2PKFgFFN46zPfibkg1x/FWuz07jm0lMJul24wxHCbifHrFnC9T9+izPsZdroUTSc1APN6ybRAzg0phbG0DUNr1cjzW1w3XcTGfPTTKKnDuPJ8Wezrl6jbxosroTcBChutPow9k4z+aYQ+mfA2lorF/6/oTppy9bCK99Dtw5ww8ng2P2vL3xvucGPRSYnFmhM6Hao1kGUX2n/3IfxnkDL+zDeF9fm08ZDrknaVtxs2o9ViSrfZl6infjci1UF7ID1YR+PVQEEQErpF0K8BDwOXLE7yWIzhc0fCCGGYDVJDwR8WH/ICdvbUEo5RQhxO1al7n0hxE/AHVJKidX0O1IIUdNsEw3Y3Xfgputjn1+LedjXx54usH8vtNfbwgV0ts9rHHA3VhXSY8dRtqNjYiWo2MfYYcIIvIlV8fwn0EMI8R3wf1uawrcjF1i/JVm07Xk5RFH2hSHdrB+sMn7NqB7U1HclL9uJrmtAIicekwhkQlEFBIdSn5VFfH2U7AydkVMLiZ37PF1qKzCA2045A/FLA41piXRq8GNqWotPQm+9n8bkeAAanU7qklyE43U+7T+IRWk+Fj/8MPNG9eDfx4xnc1w8NUP6sPb0Htwwws1pSS7+1zYfH2edDZyNE7hlF6d+6vb+bR3czfr5Fc7rrXNe71+1qaIou+lQTRh31wXAVcDxWE2dhl1hbHofFkL0xkoqnwX+JoT4SkpZvL2dbce2d8p9F6tqeI6Uss6uME7c0cZSyheAF+wq4L1YTdB5wHqs6tr43Yxjb6y3f/fYJukGmvoZfgr8H1a1NGBXGG/d2wPbFcVHgEeEEClY/RlfBo7mf68twCYgXwihNUsaC7aznqIccCkJOikJO6iO5WYA1n9QiUnW/335x/fgmXfuZO4rC6jKzsBf4eCijdP52eVi/Jq5PD/oKI5ZtaHpzWrIsrX80ruAjOoGum4uxx0LE9bicGs6d037mvgkOOuLCznb0TwGD4qiKKASxl1Jwhp8Ug7odhPoQOALaGqu/QB4Qkp5jxDCA7wthDhOShn7lcerBeqFEHnAX3a0ohBiKNa7+Rysvo/1dqwArwN/FEJcAbyN1VzeBegppfzqV8S1Q/Zgn7eBZ4QQN0kpN9nJ27FYfRHBGpBSbSeLfbH6ae41IcQYrOu1EAhgVSa3XIMSrEEvBVLKLVXEL4AngT8JIf6J1U/0CqzrpyhtzrUnpcBJ1uCQ485fDkBWnZ+L5/wXQ/dT2DmHLhutYr7pcXPGlPmEXdbbfkyD0jgvQZ+bxkEFpH54BppDNecqyj7R5hug/5d6d9i517AGcKzGqk71BaY1W/40VjJ5n/34eiCdlgNC9sTVWBXNeqxq4Qc7WTcRK/mpwBohfTxwPoCUsgQrYTsdq9m7GmtgT9dfGdeu/BZYAUwRQtQDi4BzAFNK2QBcA/zdHrH8NFYSuy9kA29gnV8xkA/8DkBKuRJrNPTPQogaIcTFUsoaYDxWF4NqrOv37D6KRVFalf/wLP42djDF8XG4oiYPTPmIU9Z9SUOOg/kDu1GWmdKULAKgaRjxLi5bLTn+87PwxO1+n0FFUQ49h9ygF0VpZeoFp+wXi4ujXPxKPRvKo9w2+VtuWPxfNExmZQ3js5FjARg4bw2J9QEAMrRG+mT4Sfn4Apx9Mne2a0Vpz/bPoJf7gi0HvdzjbfM1R5UwKsqBpV5wyn712ocVXDbXw/iFK8mta6AqPwNcXjrX+gmbJt07wgQRR5eLuqK7VVVROeSphHE3qT6M+4kQYhLW/Qb/h5RyuyOfDwT71jLP72Dx76SUbx3IeHZFCLEEq6l5W+ullP0OdDyKcrC76JRUFn24iJnxieTWh/n3JSks7NGRhyZuIMvn57HL++B2tPnPLkVRDjBVYVSUA0u94JT9LhaMUS0r8OXG4+ti/X86caJ1w4UJEya0ZmiKcrBRFcbdpCqMiqIo7YzD6yDjqOzWDkNRDl1tPj38X2qUtKIoiqIoirJTqsKoKIqiKIqyT7W/EqOqMCqKorRzjSUBosWq+6yiKL+eqjAqiqK0Y3P+NIeFn2wEwJUL5smG+kYXRVH2mEoYFUVR2hkjalD3ySr8X6xl6ZQGcFn3W4wUwSVn/cLv7+nLxjUhenTzMGSQr5WjVZR2qP21SKuEUVEUpT2pXtfAvdcvYo0njmEbDI5sqCE5HCTkcLIqPYtj1q7jrmc6YmqQEq7jT9dkMGJ4fGuHrSjKQU4ljIqiKO3I009u4MlBAwGYXpDHL/Oex2UYAHi1CD+l5qFHQtT44vHrDpYuD6iEUVGUXVIJo6IoSjsyo0KHJA1Mk+yGhqZk0UGErjUldJ1bwonLlvDb8y8m5HLxzaQKJm408OgRbp01g/6jOxD3h5FoTvW1gYqibKV6PiuKorQD0fowH5w1le+75IJDA6dOzOXC77GWO4g1rZvub2RwcTFDKmtIMzU2bjb4wJ/K80Y+gT99yZoJ77XSWShKO6Ft89MOqAqjoihKG2YYJqufW0HhjT+zunc6yQUhnnjpC4IpCazplsObY07kiNXzSS9tpEddCQBrMjvgdHlxRSLENI2hlbXkl67n1hmTqEr0Uja/hMgna+jeUI1ZG8B1kUBLiWvlM1UUpTWp75JWlANLveCUnTNNWLqRQHIiqzwpFCSDS4fZmwwc9SH6RwJsyE6m0dT568R60j5aSVJ1gCNXF9Ox1k/IrZMVbuDbUQMBjUCch6jLQdTfgFi3kajTwfqOHahKS206pBaJ8Mdv3mZxbk8CLg9GtJGUYIhBxdbteKKJHjYN6E7dOSMRlxbw6eQyJpPKoII4LnFXEXK7ifg8ZOWppFJpc/bPd0k/GGr5XdJ3etp8nVEljAcxIYRLShnZ1TylTVEvuANo0lqDv88x6ZQA/zpWJ8O3f9+zf5jlZ9K0BgYXF3PU3CW4OyeS/uRxONJ2nkhV+E1u/N6gaGkjPeavI29DCS+PGsSG9DQ0TDTAQIOogTMUJS5q0KG+ntN/WsnAzZUk1gRIaAg37S+ZGmK6k5jhIeLSmT8kn+NXfMe3XY8FrD/Cssx0wh43mCbj5swlkORkSaduAHgiIU5eMJ3c+mr8uodl8fkYOPA7HfRiHXnVZVR54rn+5HMpScrkdwsXUOtLJPv0npxza5cdnmespIHqP3yDUe4n6Y6ReMcW7Pa1fWiWwVeFBqNzNe4fqaNpe/9c1oVMbv7BYE2NyXWDdM7ppXppHYJUwribVJP0fiCESADuBc4EMoENwO+AX4CH7flxwHTgRinlBnu7KcB8oAswBnhICNEbcAFh4DTgPeCanRx7in2cAuA4oAy4GutF8QSQB3wHXCKlrLe3SQf+DhwPeIEfgBuklKX28j/Yx8wBqoG3gDullDF7uQlcB1wO9AaWAJdJKZfv4jodA0wGLgEeADoAHwHXA48BZwN1wM1Syo+bbXc6cBfQDSgGHpRSvmUvywVeAoYAbmAhcJOUcq69/F5gFDAbuMre5bNSynt2FqvS9pT7Tc783CAY3TLH4K3x+28gx4biCI+9XEV8Y4Ar3/uGcMwgDKBrZL1+yk63vf47g29+CdKnxM/y5GymjMxnQ3oCACZai/8yok4n9U7QjHg6mhE2dc0gc3MtCasrmtbJpJhNRncAXBGD4+fOpCqzWUURiAUD9Cgrp0fRZrKra/imYGDT8pDLQ0lyJrn11dTrCfSp3wxAuTsRNAdRPCSGDF775F3qPR6SQ34MND5tHE31JR1JzfJs9zyrfz+JwGcrAaj4eTOdNv8BPWn76zb38UqDO6Zbg3emFZl0TzG5tP/ef/7ePs3g5cXW1Z2x2WBItkbXlDb/ua4cDPbBPzQHG/Xv1P7xH2A4MBZIAk4HSoB/AkfYP/lABTBRCNH8U+wK4Ekg2f4NcA7wFVby+cfdOP7FwCNAClaC+QZW0ng0VjLaC7gBQAihAZ9iFR3623HVA283218RcJJ9LqfZMV5FS5cBZwEZwEbg37sRJ4ADOAYYAPQBTgRm2TGlYyXYLwshfHa847Cu701AGnAp8JQQ4mh7fzrwjH0eHbCS54+FEK5mxzwaK4nvBEwAbhdCjNzNePdKfX29mj5A01VBmiWLUFRv7tfjVtfGMEyID4VxxYym5dGi+l1uu6nBxBPduo272XQLzT6E6uM8BHxWslXRIYmGJA8aBh4i+GhosVlKpIZuNYXohjXwJWbCW727EdN1Nmak8fgpJ7CgU8em9WOmyYKO3ZjepT++WKhpfma4Hm8shNnsoyMxFARAx2RA6Tri4p07PN/whpqmabMxglEb2uE1aXl9Wl6GNZWh/2/vzsOjqs4Hjn/fSUJCEkAIBEFAQEBZBH54sO4bv7buS7UudUPbqv1pbW21WmzV6tNiRduqrUXrvjzuuxXXVutaOaK4AMoimwIJayAs2c7vj3NGL0NmMiGTmRDez/PkYe5+3jsT5s177rk35frpvl6w+psPSF0DLFvf8n3q623rtUqfdklnmDGmHFgGjLDWfhqZHwOqgaOttS+HeaXASuBAa+07oTo4z1p7dmS7u4F+1tpD0jz+a8Cn1trzw/QwfMVvT2vt1DDvOmCwtfY4Y4wB/gN0tdZuCsvL8MlsX2vt4kaOcX1o04lh2gEnWmsfDdNHAPdba7smbpuwn4Pw1cxya21lmPcIUGKtPSJMF4fzNtpaO90Y8xzwnrX26sh+bgY6WmsTk1iMMZ3wVcrh1toZocL4fWvt8Mg6U0N7b0zV3gzRX7gscc5x8nMNPPKZozAPHjs6xpG7tN7fyLV1jt/+ZTkfzdrIOa+9yci5C5GifHo+cSzFh+2Scttn5jRwylN17LZgNUV1DXRbW02vVRXcu+9oNhXkgwjS0EBJ1QaqC4twMeHID2ZzwNJKXHjM366ff8HgpZXU04HZQ7pSUVhO7yWrcAU17CSzacjL44HRR7DH7AXU1OXxZWkx68pK6bOmivcHDmRKeTeKN22itK6OyoICLv9wBj3XreCgmdOJOd8ZVS/QSZbT4ArJC98dtTGhsMEnXlXnjaPn349LGuf6x2ay4gdPQW0DxeNHUnbXUWmd28r1jn0frGf2KujXCd76QR59OrW8gvOfRY7Dn6inuha+21947nsx8mPtrzKkUmqdLuk/1GzeJT2hwzb/wdIu6czrH/79PGF+D3x377z4DGvtOmNMBdAXeCfMnt/IPhubl8qSyOv1SeZ1Cq8HAIXAMp87fm0jvvt6sTHmFOAXwED8Z6YDvgqY7JjVkf03pT6eLEbaVhWfsNauD+2KtvdgY8wvItvkAW8AGGO6A3/CVy13AOKlmh5J2trc9qpthIjw0JExrtoHyoqgvKR1/78uyBd+f1F3vlxWxw6dT6Ro0SryyjqSV970TbGPHhRj3k8KWLq2OyUba+i+Oo9OA/pwUW0By9Y1ILEYI2QjndfV8nl+AfaOeey07BN6z3qfmV1HsmlTCSOXzqA3i/kktidTBw2nprCA2YN6Iw2O9Yxmadcd2GPOXKoLOtJQGGPwmipGf/gpMeCAj+bwxDkns7zkm8cE9l+1iNLaGh7aZxzH/fdNdqhfS8eOm6j7+eFUzVxN0dJVFO3fn7W7lFP/zjw6796T8p8dnDLO4hOGUrhfXxpWb6Rgt+5pn9sexcL0M/KYtwb6d4aSDH33HtBXWHBOHsuqYddukKfJolJJacKYefPDv4OBGZH5lcAmfMIzF76uMJbju3DjGuuLStI/lREL8AlTN2vtFscxxvQF7sdfdznFWlsTKowmcd0sWQDcba2dlGT5RKAX8C1r7ZJIhVG/CbZDIsLQsuwdLy9P6Nc7XP0wNP2ECKBnidCzRPB/Vxb5XQBDu8eroqVAKcOB4deOAEbQ0HASu9XVM3fybFZd+hkDNs5miJtGyYY9qCns4tvUUM8ei75k1OuvU9WhiJm9+gDQo2rd1x3LHWtqOXjxEp7r75eNXVpJzQl7MWtONbuVOXr+/QIKh3cDoEMsRvTp08UA5+yV/jnasZS8HUubdW4AOhYIw5t3StNS1lEo08HdSjVJE8YMs9ZWGGMeA24xxozHJzjx/qh7gWuMMTOA1fiBHbOA93LQ1DiLH2hzozHmKmvtCmNMD2CctfYh/LdUDJ/w1hpj9sJfIzkzR+39C3CXMeZd4G18dXF3QKy1Fn+d5XpgVUjI/5ijdirV6mIxgQ75DL5wKHPH9eOFU+9l4II5DPvqM6YWjsblCQUNDSzcsSdLyrphZszyt+0Roaq4CFb4/dTHhCMXL2LksgrWdShi8OoqDr95HCXdmx6QopTaPuigl9ZxNj4Jex0/gORp/ACMi/AJ2lT8oIte+Gsa6xvfTesLVcVj8Z+F940xa/EjiA8Ky2cCV+JjWA1cBjyYg6YS2vMSfgDPJPx1lkvwg4niJYsr8VXbFfgR0m8DOTu/SmXLLsNLOOTxE/j13t9j9g6D6LpyFSUbNhKLX2tYUMCUsWMYtWAhAyoq6bN6JUu6dWFG/z78a+xIRnRZza7r1zFs7Vr2u3CIJotKtUQ7fNKLDnpRKrv0F061nvWbeHj/yXSeVUxFj26sKO/Mmm5dQIT82jqKNmxi0Nyv2GVlBfUxYX6X7lSM2Inxz+5PYbE+O1ptl1pn0MvEhEEvv9ZBL0oppdqK4kJOvPMYxl+5jP2mLaS0qpqCmlqqu3Qi1tAAMWHugB2JSR3r84pY27GQoZeO1GRRqYzb5vPDLWjCuI0xxkwAJiRZfJi19o1stqcpxph1SRa9Ya09LKuNUWo7IKP6c+d9vfnwpEpWTlvB6sJCFpQU48II4B3XrsYULefliWcycmgxe43SER9KqaZpl7RS2aW/cCprajfW88BFn7Bk5lryGurpWrOW73RezU5//jb5w3vmunlKtQWt0yV9be3mXdKXFWzzJUetMCqlVDtVUJTH6TftzoqFG3h72r/JK3LsfNRpuW6WUmobpKOklVKqHcsriFG+Swl5RVrcVkptPU0YlVJKKaVUStolrZRSSimVSdv8FYtb0gqjUkoppZRKSRNGpZRSSimVkiaMSimllFIqJb2GUSmllFIqk/QaRqWUUkoptb3RhFEppZRSSqWkCaNSSimllEpJr2FUSimllMokaX8XMWqFUSmllFIqy0RkvoiMyHU70qUVRqWUUkqpTGp/BUatMCqllFJKtQUicoaIfCwiH4nIkyJSHua/IyJjw+tbROTT8DpfRJaLSElrt00rjEplkYi8CHTPdTsyKT8/v3tdXd3yXLcj09pjXO0xJtC4tiVtMKYXnHOHZnqn7uL8ZtcYQ/f0tcAezrklInINcDNwEvAqMA6YCuwHbBCRXkB/YKZzrjpTbU9GE0alsqg1/mPKNWOMtdaaXLcj09pjXO0xJtC4tiXtMaYMOhh43jm3JEzfCkwPr/8FTBCRB4AVwOv4BHIAPplsddolrZRSSimVewK4hHnx6beAMcAR+AQxXnEch08mW50mjEoppZRSufcqcLiI7Bimfwy8AuCc2wRMAy4L894F9gVGhtetTruklVItdVuuG9BK2mNc7TEm0Li2Je0xppZ4RUTqItMTgJdFxAHzgHMjy14FxgLWOVcnInOAL5xzNdloqDiXWP1USimllFLqG9olrZRSSimlUtKEUSmllFJKpaTXMCqlUjLGFAN3AXsAdcDF1trnkqz7Y+BS/Gi/KcCF1toGY8wxwBVAYVh2p7X2hmy0P5kMxbUTcD9+9OLsXN0uxBgzBLgHKMPfcuMMa+3shHXygJuAQ/EjL6+11t7e1LJcyUBM3wH+AOwO3GytvTiLzU8qA3H9FjgZ/5mtAyZYa1/MXgSNy0BcZwEXAQ1AHvAPa+1N2YtANUUrjEqpplwMrLXWDgKOAm43xpQmrmSMGQBcCewNDA4/p4XFS4GjrLUjgH2Anxhj9s9G41PIRFzrwrJTs9Li5CYDf7PWDgH+hr9/W6JTgUH49u8NXGWM6Z/GslxpaUzz8KNMJ7V+U5ulpXG9B4y11o4CzgYeNsZ0bPVWN62lcT0OjLLWjsb/H/FLY8zI1m60Sp8mjEqpppyE/zIgVAwscFgj650APGWtrbTWNgD/CNtirf2vtfar8HoNMBPYOQttTyUTca2x1v4HnzjmhDGmHF/hfDDMehAYY4zpkbDqSfiqTYO1thJ4Cvh+GsuyLhMxWWvnWGs/wFfh2oQMxfWitXZ9WO8jfNW7rLXbnkqG4qqy1sZH4RYDBWx5T0KVQ5owKqWa0g9YEJleCPTd2vWMMbsBe5Glm82mkNG4cqgv8KW1th4g/PsVW7YxVRxtLcZMxNQWZTquM4C51trFrdDW5shIXMaYo40xn4Z1JllrP27VVqtm0WsYldrOGWOm4f8jb0zPDB+rF/A0cH684thashmXUtlmjDkQuAb4dq7bkinW2meAZ4wx/YCnjDHPW2s/y3W7lKcJo1LbOWvtmFTLjTEL8d3HlWFWP+DfjawaX4/Ieosi+ynHP6FgkrX2kZa0OR3ZiqsNWATsZIzJs9bWh4EFvdmyjfE4pobpaLUn1bJcyERMbVFG4jLG7I0fbHVMG0moMvp+WWsXGmPeA44E2kJ8Cu2SVko17VHC0waMMYPxTxp4oZH1HgeONcb0MMbE8AMOHgnblQEvA3/N9ejbiBbH1RZYayuAD4FTwqxTgA/CNWJRjwI/NsbEwrVlx+Jja2pZ1mUopjYnE3EZY8YCDwMnWGunZaPdTclQXLvFVzLGdAcOBrRLug3RCqNSqimTgLuNMXOAeuAca+1aAGPM1cBX1trJ1tp5xphr+Oa5pi/hqyDgn386BDjXGBN/1NWN1tq7shbFllocV6ikLMDfLqiLMWYxcLu19qrshsJ5wD3GmCuAVfhr2zDGPA9cYa21wH3At4D4rU6uttbOC69TLcuVFsVkjNkPeAjoDIgx5mTgh23gFjQtfa9uAToCtxrz9V2cTm8D1/u1NK5zw62QavEDef5qrX0pmwGo1PTRgEoppZRSKiXtklZKKaWUUilpwqiUUkoppVLShFEppZRSSqWkCaNSSimllEpJE0allFJKKZWSJoxKKdUEEekvIk5E+rTycc4Tkfsi01NE5FeteUzVOBGZIyLj01w3K5+PbBCRQhGZLSK7Nb222p5owqiUyhgRGSgij4rIUhFZJyKLRORJEekQlo8XkTmNbJds/mnhi/iKRpa9JiKbwnHWiMgHInJ860TW+kSkBLgauCo+zzl3mHPuupw1qgnhvdkv1+3YHrTGuRaRg0SkLjrPObcJuB5/n1KlvqYJo1Iqk54HlgC7Ap2AvYEX8Tfi3RrnACuBH4lIXiPLr3HOlQJlwIPAwyIyZCuPlWunAR875+bmuiFqu/cgcIiIDMp1Q1TboQmjUiojRKQMnyhOds6tcd5i59zkULVo7v6GAvsDZwK9gMOSreucq8M/ASMP2L2RfV0gIh8kzBsgIvUi0j9M3xUqomtFZIaI/CBF264SkVcS5r0mIr+JTI8QkRdFZLmILBSRiSJSkCLkY/GPT2x0n5FuzzND+6pF5HkR6Soi14pIRajsnh/ZfnzoWr1URJaEdW6ItqOpuEVkpIi8ICKVIrJSRF4O86eHVV4KVd5GH/koIsUicmM4xnIReUpE+iXEeIOIPB7aMFdEjkl2kiIxXSQii8M214tIWdhHlYjMilbjRCRfRK4QkXkhhldFZERkeYGI/ClyDi9t5Lj7i8ibYfu5IvJLEUn7DyEROV5Epodq+HQROS4xpoT1746f02TnWkTmh7jeDPOtiIxtbB+RefPFV+57A1OAvLDtOhE5E8A5V4V/3vPR6can2j9NGJVSGeGcWwF8CtwuImeIyLDmfKE24lx8xe05fOXynGQriu/yPh//WLHpjazyADBUREZH5o0HXnPOzQ/TbwKjgR3wXcN3i8iwrWm4iJQDrwNPAL3xldZvA79OsdkYYEYauz8e2A/oB/QH/gvMDcc5C/hLNCEDdg7rDgztOAq4OLI8adwi0ivE8Xo41o7AHwGcc6PC9t9xzpU6536UpL1/BvYKPzsDy4FnZfOK8ZnAn4AuwF+Be0SkOMU52Dm0d2A4Fz/FJz+TgK748x597OQl+EfVHY7/4+MN4GUR6RyWXwYcCewDDAix7hzfWESG4z+Dk4AewBHABcDpKdr4NRHZG/8ZvAxfDZ8APCgi30pn+ybO9XnAz4BuwGPA85G4Uu3zK/wfYfVhn6XOuXsiq3yM/0wqBWjCqJTKrIOA14CfAx8Cy0TktwmJ4wARWR39wVcHvyYiRfgv4zvDrDuAw2XLQQWXh+0XA8cAxzvntrgW0jm3Cngan1AR2nNmZP845+5wzq1wztU75x4CPgrxbI0zgOnOuVudczXOuS+BiWF+Ml2BqjT2fY1zbmVI0J8Dap1z/3DO1TnnpuCf4/s/kfUbgEuccxtCd/d1hPMATcZ9OjDHOTfROVcdYtmsspqKiMTwMf/GOfelc64a/9kYCuwZWfVh59xbzrkG4DZ84jg4xa43AL8L7ZmO/yNhqnPuXedcPf5Z34NEpEtY/yzgj865WaHafTX++eFHhOVnhOVznHMb8Al19Lm5PwEedc49Hc7TLHxim+r9jDoLeNw5NyW8T/8EngTOTnP7VO5wzr3vnKvBJ/Mb8MlvS1Xhk1ClAE0YlVIZ5Jxb7pyb4Jwbg68A/Qq4gkiCAnzhnNsh+gP8X8Kuvg+U4r/4wVd3KoDEKtbvwz7KnXP7OOeeTdG8u4BTQzXykNC+J8AnNiJytYh8FroMVwOj8NWkrTEA2DchKb4TX6FLZhXQZGUIf41o3PqE6fi8TpHpCufc+sj0fKAPpBV3f+DzNNqUTA+gCJgXn+GcW4d/L/tG1lsSWV4dXkZjSFQRksu4xPMQjze+j74JbWjAn4d4G/qE6WgbKiL7GwCckvB+XomvVqZjs+MHc9n8HGyt+fEXzjkHLCS8vy3UGX/9sFKAJoxKqVbinFvvnLsbX7Ea3czNz8Vfj/iJiCzFVxC7AT+Uxge/pOMlYCO++jIeeChUkwBOwSejxwNdQxI7neSDddYBJQnzekdeLwBeSUiMu4QBOsl8AGxVF3gTyhO6d/vjzyc0Hfd8Ulf6XIplAJXAJnzCBYCIlALlwKK0Wp8ZixLaEMOfh3gbvgzT8eUl+DbGLQDuTHg/Ozvnhm/N8YOBkeM39XmC5Oc62m7BX34Qf38326+I5LN5XNGkO9EI/GdSKUATRqVUhogffDFR/GCPgjDQ4Hj8F88bzdjPMGBf4Dh8ohn/2RNfoTt8a9oXqkr3AhcC3yPSHY2vptThE5yYiJyNr7QlY4ExIrJHiPMCNk8I7gWMiJwtIkWhkjdQRA5Nsc+ngP9tdmBNiwHXikhHERmI726NX6vWVNz3A7uKHzRTHN7XcZHlS0mRUEbO+TUi0jskrjcAs4D3MhRfOu4GfiUiQ0KF+XIgH/hnWH4fcImI7CIiHfHd9tE/Fm4BThaRoyKf7WEicmAzjn+8iHxXRPJE5DD8ZzB+neUH+MT+yPBZOQ44IGEfyc712SIyRvxApkuA4khcFhgnfoBXIfB7IDrwail+0MtmyayIdML/vj2TZnxqO6AJo1IqU2rw1Ysn8F1ZlcBvgJ865x5txn7OBaY55551zi2N/HwEPBqWb627gAPx3eLRhOUe/OCROfhq0zBSJLnOudfwic8L+K7QnsBbkeVLgYPxI5/n47ubn8RXlZK5DxgVkrpMWoCP6Qt8jC/gEyJoIu4wMOIg/ICdxcAyIDqC+HLgahFZJSK3Jjn+RfjEZSq+u7QXcHS41jBbJuFvFfMSPoZD8ANI4teMTsTf/uld/HlaiD9vADjnPsFXpn+Of78r8ElgWpcsOOfexl8zez3+s3AdcJpz7t2wfC5+4Mpt+N+dQ4HHE3aT7FzfBtwU9nsScIRzbk1Y9gA+6ZuG7wJfiH+f4+36HJ8Mvxe62uODeE4B/u2cm51OfGr7IP6SB6WUUrkmIucB+zrn0hp9m8b+xuMHnOj99NohEZmPf3/vb2rdZuyzEPgEn9TPzNR+1bYvP9cNUEop5TnnJgOTc90Otf0Ko8hTXbeqtlPaJa2UUkoppVLSLmmllFJKKZWSVhiVUkoppVRKmjAqpZRSSqmUNGFUSimllFIpacKolFJKKaVS0oRRKaWUUkql9P/B6cZkSSl2PgAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "display(HTML('

Shap Summary, Test

'))\n", + "result['test_shap_dot.summary_plot']" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "

Shap Summary, Test

" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "display(HTML('

Shap Summary, Test

'))\n", + "result['test_shap_bar.summary_plot']" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Scale to 100K Samples\n", + "\n", + "The maximum number of samples that can be computed in a single 32G V100 GPU is 4096. To compute 100K samples, we use Dask to distribute the workloads in multiple GPUs.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "7929c9ff8b2342c88c74ec7d559ce399", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "GreenflowWidget(sub=HBox(), value=[OrderedDict([('id', ''), ('type', 'Output_Collector'), ('conf', {}), ('inpu…" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "taskGraph=TaskGraph.load_taskgraph('./10assets/parallel_xgboost_shap.gq.yaml')\n", + "taskGraph.draw()" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[10:43:39] task [xgboost.dask]:tcp://127.0.0.1:41915 got new rank 0\n", + "[10:43:39] task [xgboost.dask]:tcp://127.0.0.1:39245 got new rank 1\n", + "[10:43:39] task [xgboost.dask]:tcp://127.0.0.1:37343 got new rank 2\n", + "[10:43:40] task [xgboost.dask]:tcp://127.0.0.1:36079 got new rank 3\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 10.9 s, sys: 712 ms, total: 11.6 s\n", + "Wall time: 1min 5s\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAowAAAI4CAYAAADgaLi1AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOydd5wkRfn/39Vh0s5svMTlIx5JBAoBEUU4zICifBH1K4j8/IpizogIiIpiwISCiqiAAUExAApIVEEKyUHS3XH5Nu/sxA71+6N6d2f39u4WuLu9UO/Xa3a7u6qrqqvDfOZ5nqoWWmssFovFYrFYLJb14Ux2AywWi8VisVgsWzdWMFosFovFYrFYNogVjBaLxWKxWCyWDWIFo8VisVgsFotlg1jBaLFYLBaLxWLZIFYwWiwWi8VisVg2iBWMFovFYrFYLFsYIcQSIcQ+Y7YpIcQRQojzhBAnTqCMc4QQ39h8rRzB2xKVWCwWi8VisVgmhtb67Mluw1ishdFisVgsFotlK0IIcbkQ4oxkuUUIcY0Q4gkhxC1CiF+MsSrOEkJcn6T/RQiR2xxtshZGi2XLYl+ttIPypz/9CYBjjjlmkltisVgaEJun1ONHP+v1teur53dCiGrD+u7j5Dkb6NVaLxRCtAP3Adc0pEvgIKAf+CvwTuDHL7Dl68UKRovFYrFYLJbJ4W1a60eGVoQQapw8rwY+BKC17hFC/GFM+l+11n3J/vcAu2yOhlqXtMVisVgsFssmRYz5vOjCNuSdarRQRmwmY6AVjBaLxWKxWCxbL7cCJwMIIdqA4yajEVYwWiwWi8VisWxSNqmF8TxgmhDiUeAK4B+YeMUtio1htFgsFovFYtnCaK3nj7NNJou3NWwuASdpratCiGbgLuDnSf5zxuw/an1TYgWjxWKxWCwWyyZlkw6+bgNuEEK4QAa4Smt986asYCJYwWixWCwWi8WylaK1XgscONntsILRYrFYLBaLZZOyeaZ3nEzsoBeLxWKxWCwWywaxgtFisVgsFovFskGsYLRYLBaLxWKxbBAbw2ixWCwWi8WySbExjBaLxWKxWCyWHQyh9YZeT2ixWDYx9obbAVEXPcp/fvQkcQyhgEItAjSHfu8Qdj9mzmQ3z2LZkdk8pkBx4uhnvf7NNm9ytC5pi8Vi2Yz8Vv6R/r4Q7QpcrYlTKXqbm8gOVvjXh+5h19fOxEm5k91Mi8WySdnm9eE6WJe0xWKxbCZ0rOnvD4nSHtpziXwXv1ZHoKk05xjM+vz17Icorq1OdlMtFotlg1jBaLFYLJuBsBRy5+n/IHIbHrNCUGrJE6TTEMWEuQyP397DpW/+B30ryhstc9VzFW78QydXXtXJs8/VNmPrLRbLi0OM+Wz7WJe0xWKxjEGHMcJz0EFE+cG1aOERdJcpP9lH0BeSKTh0nLgr/owCAHEY43gjwrDWU+OPu15DsS1H2OTjRhECiIUgSpnHbphJ07qmh3omRTWf5cGrl/Gqj+5BvRrx96tW8tzSOnJRO02tLj+5ZA3FtTWIHfqyWVw0f7l+gADw2zwW7pJm/q45TliUJ5uxdgCLxbLpsYNeLJYti73htjJWH/cb6n98HBAIBDEOIQ4CQR0PEAS4FMkiAI3AQeMQECEoiSyx6xLHQBzD1BTlekx/W57mYo1iIU3nTm14YUjouwiRCDqtaV3dCwJ6p7VSyqQIUil8rRFCUHddYpONnmyaTKwRcUzoe5RTqWG7xXOpFIuzKSpCUPR9grRH7AoOmyf4xptyHDDbxkdaLBtgMw16eceYQS9XbfNmRisYLZYti73hthBxqYpI+9QvuJHwpqfRL9uZ7GdeTe1LN1D+9WPU1oa4xHiY/zEOJZqokaaOT4SLAHxCNFDHJ8CjlojIFAFVXIp+FhwBWpOrB7hoQkewZmoTfqTRQOgJIkdQzfgU2wvErkNmsEKmXKNzRjuDrc2gNU4c46BBmPLcKE5EKnQW8qTDgIFMhmo6PXycIZorO9pMPgFTHEFXNo0Ta+IwwnU0s9Kahz/XQsYXpLxt/nvLYtmUWME4QaxgtFi2LPaG2wB68Rr46h9g1+nohXOgOYsIQ2LHR2Qc4q4y8bnX4vQXEfUysZcnjjz0c91oXELSaGI8NIIYlzohHgF5Uz562IoY4SMwQrBGDtAECCJS1HERw98jGhqWa3jU8PGI0Gh60sYt7YUh2SgaPpbu1iyR5xC4gsh30IB2xHCJ1ayPE8Qs22UWseuCEIg4Jh2GRI5IWgqB6+LFERXfpzvfxIDrkBUjbucYeCif48FMmrY4preQHU5LxzE13zVmSo0Rto4AIcg4ETtPc+kuawppwXv3Fbx9H4dLH4K5BTh8rsveU0bqqYYx/+3W7NwqyKcEQmzz338WC2w2wfjOMYLxym3+hrGCcRtCSvkjIFRKnTHZbdkQUsqngfOVUpdPdlu2Ql7cDadHrE+j/o9HrQ7p1Mj/OIYoNvv4HtQD879Ug6wPnQOwpg+mNMP0VugdNGk7tcJABeohZFPQXoD+0kj9A2X0YA2mtiAGS+hf3Al9g4h8GnaeDnJX9C2Poi+/DZ5dCbGGQg4n7aCXdo3qmCE3a50cIa2AwKOIzwCQRuOjcYEIhxIhKWIKOIRoHGpkEMR4RDhEgEOZAj7hcB1GLHroJIRbAyXyxLhECKqkiUcFqhuZCZocNTxiAhx6yKNxEWhiBEWRIqtHBGNfPk0t4xGkHBACDUQOw+ermvGp5DOE6RSxEBTzTThxjBfHRI5DzffoLBSIHYd0GJKu1xnMZXmgJc8egxXc5HroS6UIXYebcxnyQtDdlB6uoymKKOVSEMSQccF3jMKsBOA54Dhm6KNOrq0whpQLbsM11Xh5DZ3zoZ6LBQjw45ip5RrNU1PM7PDIZ+C4XWBBC/xnLRy7i7nEMi5MafLQWlOqx7iOQGvNcwOa3dsdHGd0/GU9jPBcB0eYfOOJ1PVt31ja82VTlmXZqrCCcYLYQS/bEEqp909m/VLK24CblVLnT2Y7dkgGynDsV+GOx2B2O6zsNZYigC+cAF/4n9H5Dz8T7npiZL05B6WqEYybmBifgFbAwaMLl2hUeqMQHKZkppEx21xM/KCRc8aJm8EjMO5c8ngUk/w1wEGTQZPDp0RIxrhxCfAZJCaFRuBiRh17ZIZrGopBbEQAWUrEuBRpSrZpRmSRGHZNe5j+84nJUadEFo3AJyKv60S4yVEIMoMRge8OizcBCG3cxrEQhJ5D6PsAOFqTrVRJBQF9+SbwXJa3NNOby4LWtFeMNiu5LhXPY00mRS4yrm+EoA4EQuBozbRKncB1CD2HYnsWygGEEVQ0eCkjBtNu8tNFQ5icocGqEYtxDDl/9A+R8ZY1w8IycFxWNudoXtbPHeUCoevwx2cZ/kHzyTtosHKGY66OIWJ8YjIp+NEiwcdv06wpA0ScsAdc/6xp3pVvcHj9zkZYXvpgzEf/HpNPwW+PcThirtneXdG88doItRrespvgV29y8JwX9n29pqR5w7URD66Fty8U/OINRsBaLBtm+7tG7HC6rQAppZBSWvFuWT+X/A1uf9R86S7rNsIviMzn7F/DkrUjeW97ZLRYBCM4N4NYBAjJMvQoccaIRdjYY9NpyDHkrk1hRCSJUCsjcBGJw9ghQFAdlhqCCCPRouGSXAaT9Yg0vcN5IxwEGjdxJ5PU6BGSpkYzA3gECEhEqE6sjesKzXjM+tDDtPFoQleMkkS1jEcl40OsqWXTI6IfSNfrOHFMXy5DJBx6s5mkIEF/xlghS57pl37PQ6AZFIK1rsO/mzLErkMsoCwEg55L0RHQU4VqZHRZGMNg3ZTpOUPq2bQ01lBIQ0vG/B9ql2D9Fuxxtj8xtZlwzDRCo5Y3ItoCoFiH9/51SCwarv4vlALorcLpN5vruBJoPnBTTCWEzjJ86JaR6/ui+2LuWQWRht89qfn9Uy/csH/hvTH/WWPKuvJxzfXPWq+cZcdkhxMpUsolwE+Ao4CDgMXAO4G9gS8BU4GrgfcrpUIp5c+ARUArsAzjar0qKes04Fxgf6XUWinlNOAB4Cyl1GUbaYcGPgr8b1L3q6WUTcBXgN2BELgF+LBSam2yz+UYl/RpUkoBnA+8BygA3cA3lVLfS/LuA3wTOBAoA1cCZyulgo20axFwIbALUAceUEotklJ+HzgcOFRK+VlghVJqDymlD3wNeBfG2fXtDZU/pq4lPI9zkewzF/gWcFhSzJ+ATyilikn6V4C3A9OANcD3lFIXJWnzkzreDXwOmAP8CzhZKbVqou1+MRSLRQqFwvNfdtf/204LgUjSi8Uihay/OQ9hHRqtcQ0qZIKMzWvsc6PLjxE4o7abbVVi3MQtHDEk1RyCUeV6VKgl8jFG4+IQ4RIjEif0aJFn4h9DYgQeMdVh+6WLJoVPxCApimQSB7kmFA6BHjlHGijnPQZaM7hRjKM1oe8SJFPqxPUQIQROFBELB6E1geeyprVAOgYhBF4cE7pGIPpRTOg4TCtXmV6qEDgC4bp0AAOOwwPZNLkoZlq1zrMtTQQCo3BgtGiLjAgmjEd3s9CQHvN1sCGxuB6e79lfHxvSla4w17mfzeM6MBQ2OrS9UCiM8qgD1KsVSKzHz/cejII6MHJPDZX9gu9lu7xVLW8uxvNkbOvsqBbGk4EPAG3Ag8DvgVcD+wH7AscCQz6+u4CXYgTjecDlUsq9AJRSPwFuBq5MhNOVwE0bE4sNvBc4EcgD9wM14AyMUNoXmAl8Zz37Hp0cx8FKqQJwMPAPgES43g5cm5RxaJL/cxNo0y+A7wItwCzgy8mxngHcCXxJKZVXSu2R5P8s8Cbg5cACYD4wbyIHnzDhcyGlzAB/Bx4Ddgb2AmYzuo8eA16BEdH/D/iqlPK1Y+o8EXhlcnxNmPO6RWh8SD2v5fe/Fo6R0JKDPWZBIQu5NLTmEN9+D8yZMpL/4D3ghENHq6D50yCfWKxcsUmfXh4lBHUEIRF+YpcbXwquKyY0JBZCEuukQ5hYCEMc6rjUIbELmj0ENQrU6CCgQEQqOUgnkW+CmMxwfTXaGDpgj5AaaUI8aokr2xlWTpoAl1oiJj1CnEQM13Go4lMmwzLa6SMPuMS4hDiUSLFqRiuVrE9vm3mDSznrJSOdNU6kiYfi87Sm2JojM1gh11ciXani1wO8ICItXFKxac+83n6a6nXytTr5ep2K71EIAlqCAMdxhk9hcxzzqoEyL6vUmDlkRY4benoo5lBDoRaMuIaHEIBwRgTm2P03htYQa5pqAS2VYPT2xuUk34Zo9mFWHn71JsEuLSPNO+OlMKMJ5jXDZa9zKRQKZDzBz17nMC0Hu7TCJa9xh++Xj0mH18wXtKbh1H0EJ70kN1zH870Hv/CKDK+eY8o6fT/B6xaIF1SOXd46ly0TZ4ezMCZcqpR6HEBKeRXGqnWIUqoElJJYvYOAq5RSP23Y79dSyk8CR2CECcDpwL3AvzE/Q497Hu34hlLqmWQ5wojTIVZLKb8OrE981oEMsLeUslMptQZjUQNjQXtQKXVJsr5CSvlVjCVwY+KojrEuTldKrQZu3Uj+dwMXKKWeBkj6570b2aeRCZ8LjDAVSqmzk30rUsovAP+UUv4/pVSklLqioey/Syn/grFg/rVh+7lKqa6GOk97Hu2dHHJp+OOZE8//2089v/KHBs9EkRncojV4LqT8kXStTSxc4zYhELWAVD0E34WUB3c/adKi2Ahc14ErbkcMVGBtP9z7NDgOeuEsuO8ZM9hmjI3SoYJDBRIxqNGJGHSICREEGJHpEOAAGRyCZI7EgIgMghwRPhEpBBE+4bBLGhwGyeEQ00wvJM7ubjpwMDdjiEuGWlJbCoAIjcPQL21jtfSJSeuIjs5BHpLzCH2XPe9fRj3tkq5HZGtGCKfrFfoKKdxI49XCYetdqlynnkuPWDqFINYaH5hTLFH2PXoS97SznkGKHfU63V6WuutQizV4YrQoTAy0xYwPpQjSzkj6kJDTjjlnQ5bFoRjHoX/r+ZHh6GQ8TcYn68Ix82D3dvjoAYLVFZiaEcRaEGiHqYluGzt4ZLwBJcfuOrqe7y1at+537OXwjr3WtXu0pAV/fdummX+yPSv4+4l2LkuLZUcVjI3uxzIQKaU6x2wrSCkd4ByMRWoG5rHZhLEAAqCUKkspf4Jxk56qlNr4+71GWNK4IqU8EOOS3g/IYR7R+fF2VErdJqU8EzgL+K2U8l/A55VSCmPpO0xK2dewi2AoMGzDHAecCTwspezECLqLNpB/duNxKKVKUsq168++DhM6F8nyAmDumOMCc15mYITxhzGWxdkMjWcwYnN9dZYayt9xGfqydl3IjnOZCDO4gtQ48Wlp33yGePnCdfe/4N3rFjleOyo1eGyZ0StdRThib+itQFsW57ku9NOduH++F3fJWvRuM6GvBnOnEZ53IzEpXOqJbTANODjJmOgYhwo56qSGoyZdYnppY4ACLgEab502aUQiEUdaPZ5bRiNwI41fC0lX6uRLdQaafdw4sXKmPTOauB6BOzrSU4CZALwpg4hjtOMQeiODZXJByGAqJnAd6q5LOopoqtUppY2IdeMYP8m70vOM+KtH4Ajaowg8hx4/BSIGtBGLnmB+k+bcwx2+crcxOv/tRJiSc7lnZURL2mG/6aOvgyjWlANNIT1xx9SumYnls6OPLZatnx1VME6UkzDWp9cAjymlYimlouG7Tkq5ECMqfwhcIKW88XnEw40dhfBr4HfACUqpASnlmzAxeuOilLoUuFRKmUvacC0wF1iKGc38xgm2o7HMB4ETkxjJVwB/k1I+pJT6+zjtBViBcUMDkMRhTnu+9U6QpcCTSqm9x0uUUh6GsaIeBdyjlIqklL9j+wgf2THIpuFAY1oaPmnTjTBi15mIXWfC6/YblZ4G0ue+Zdzi4t4ytd8/QnT3UnLHv4T21+1B2DnA4Pt+R+G6xZR0nEQsDg2FcYZHQseJUzxNSJjEsA25uR3iZPS0Jkysk7ErmPtcJy0DJUq5NC19VQab0xRbMlSTuFInCElXQzOpdjLFjoiho7tIz5RW0vU6XfkclVSK1rpx7+qhCcF1jAaKrkvV98iGEb7WxEBnxuXRtM8qv/GRrunNpdAxtIiQJZ8v0JpdV+y9+yWj1185d3xB6DqCQtreShbLxNj+7hUrGDdMM2bwSSfgSClPwVj//gyQCLWrgYuUUl+UUqaBq6SUi5RS0XrK3Fh9/UAxGdzx2fVllFIehPmuvBcT+1hM2gomDvETUspTMda1OkbU7a6UunEDZaYwIvkvSqkuKWUvRiQOlbsaGOMo4pfApxLX8Urg62y+O+XPwPmJZfV7wCAmRvNlSqnfY/ovwpwvLaV8I/B6zDmy7IA4bTmyp76M7KkvG97mTW2m9fenDq+H/VWW7/ZD6p0lUqSok04csTHlxCLpEhDhEuDhEtNEhRiHAJcqHh4RUQR+2aHjQ/uy9trl9PseXj2k2jCYJPZcYicCrYkdQSWfZfrqAfwgYsraXnqmt9FRqlCtBYS+TywgcBxqroOjHeM+dh18YCDlsaKQIxNEVNxkEqEhoy+akw5M8Y1jc3Q07aih6haLZVNiBeOG+TlwJPA0xjX6S8zAjyF+gBEn5ybrZwD3YKx9X3gB9b0PM7L5LOCJpL7D1pO3AHwD2A0jkh7GjA5GKbVaSvlq4AKMizuLcRtfMm5JozkR+GYywGQt8EWl1B1J2reBnyUu4RWJpe+rQDtwd9KOb2MsgZucxP1/VFLnE5g+WAn8BjNY5q+YPvs3xhB0XbLdYlkvXkuG+Ws/Nm6ajmLiWkg4GKJLAfWVJXQQkd21Bac1i5cff0T6Pt+CKxb8Dh2b1/tFjnHvumEMQhD6Zr21t4wfmN+Wex3expEXH0pYj1mqeujqDJn70hYEmjv+sJZ/PVyjp+SQwvyKq7kefi1g39mC157QyhRHsM9eWdwXON+gxWLZdGyPo6Ttm14sli2LveF2IJ7+1TPceeaDkISA5kpmHsTe1gzEMW19NVwNdd/lrY8eR6otvcHyBrpqrFpSojNKsesuGWZMsb/5LZYXyWbRcrE4edSz3tE/3+Y1o33aWCwWy2Zizhvm4H/6P3iRxmuYOF2EMdpzqKQd9v70S9j/tN1wsxt/HDdPSdM8Jc0eG81psVgml21eH66DFYybCSnlDZiJrtdBKTXuyOctgZTynazfNf1/SqkrN2FdP8JM6D0eeymlnttUdVksWyPplhTu/DzOk33Drxisew5CCFLVgMAV7Hfa7rjjjUy3WCyWrQjrkrZYtiz2htvB0Fqz9OZV/OO8u2ApiHpM6DvU0g7H/XER0/ZqnewmWiw7MpvJJf2eMS7pn23zJkdrYbRYLJbNiBCC+UfP5OFqFoBjjjlmkltksVgszx8rGC0Wi8VisVg2IWNHSW8PWMFosVgsW4DqspjK4y7PpJczY592mmbmNr6TxWKxbCVYwWixWCwvkn/v8muiZ7sJhEekXUq+Ry3roz1BND9PTw1ygwGCgDv+cg/VtEd+Sop33fE6+1o8i2W7ZPu7r61gtFgslglSvuFJet7+W/oG0lRJE+LSn0kR+R6l9la0I3CiiFwlxkOztpDnrjk78+oH/jv89eHGGlyXYm/ENw67lSjtEjelebY5TxhAfy7N/N4iU3XIlEM6oBrSNK/A2oqgteBx7DGtdHSMP2G4xWKxbC7sKGmLZctib7itGF0PiVcMENy3nNoHf4teWyLAJ8ahmV4iHFYxiwiPDvqokqGfZspkKJMmEA5B8hYXP4p4aPeZ7Lqsi3rGIfIcAt8hdgSl5ixaQzWXJhICxxH0ZNP8dr/daAojTnh0MQ5Q9n16c1kiz6PsuaxJp2iOInJBiBvHzN2/wDmfnTW5nWaxbNtsFlNgKN476lnv6Z9u8yZHKxgtli2LveG2Uup/eYzKm34MxKSo0cdUKuRwiZjCCrqYQQ8dxLgIYqazijItDH3fdNNEr59DO8m7m7VGiJi+tiy5qnn9X+QIOqc1Ucul0I6DiGKqTRlwzHuiU9U65VwW3JH3Py+d0k53JkPJc+kS8OpVa8nGMQO+x8pCgTW5NBXP4eovz2Buu53P0WJ5nljBOEGsS9pisexw6DhGP7UWXQuIv/QH9O/uJcLHJUudLH00UyaPQBPh0cs0BmkhxggyjcNappMhSCbk1mSp0ytGBrJooJxLka5Hw9vcWOPXAsqtTWggyKSJhcDRGpG8Y9qJY+JEMGqgJ+WzIpdBC4EXa6qeS7Ye0xyEPCYES/I5fK05+SOL2eutMzluL5/X7G5d1hbL5LLN68N1sILRYrHsUOhKner0T6CLASFpYlyaCHHJUqSZQVqSKTE0LhE+EQEpHCKMhDNfBCbHkLATaAS5IKDi+cRCoH0HX5tdNLBibju1bIpUtU4MFJty5Ko10lGEBmopH51K4QchRBFaCNCaou+bZUA7ggHHpY3AlNmcY2nezO/4bCHLU3dVuOfGXk51fUopF5118VIOwnX4wGE+5x654XdVWywWy/qwgtFisewQBO+6BK78B4IADw8XjaZMPx0UmUGeHmpkG+ZPMyIwRlAhg0CTpkadFAKNSzy6fDw8rXHRRJ5L5I1YGARQyWeIfJdqLk1XczOh71EMQmZ0dZmBMEAtkyF2ArK1minTdZnT3UPfzBmQCMiO/kHWtjTxz6nt/LetMFxHjOCY5zrxtSYQgj/u1EFX5FGvO6DhvJsCzrspgKyL4wtOWAgvm+mybxukwpgFsxw816XZh3zawWKxvHDsPIxbEVLKVwB3KqUm5axIKWcDy4AFSqklk9EGi2WHJY6hp4juK8Ov/4m4/h7oLkE1QJeq0D04KnuUCESIEICghkbQyW6UaAOgTIEmeqkznUZ30gBZqnhMoZ8IF524pQUanVgcAxxKTgo/1qA1TUGVKj61lHEN132XyDMirJxJE/rm0Rv4HqVsluZSeTj2MfA93ChCaI0XReze3cfU3gHWNheY0TuAyKS4buZ0WrVm/95BnmjOUfQ9ZlRquFpTcRxum9FOT1OGuhAQAw6QciHWUI2IPZ/fPOXwm2eMCCUUEERABD6gBZm0oCMLP32tYH6rQ3sGmlKCrCfsVEAWyw7INisYLRbLVsozq+HmB+GAneGG++HxZXDWCdBbgh/eCH0l46NtyUKpBg8ugTAEz4P+QaiERrw8jwF5I47iIVfxyDKAS0Qv82hhFQ61JE0jCIfLqJNlGsuo0kSNJgQaB00XzezBsqSsAIEmxCdFQJEs/TSxakozIMjUAloqFZqCgKawRo+TYyCToZZxccOYyHfx6gE0jbQ9FIK+bAb8kbjDWjaNWw/x4phICFZMbSddC1g7pY2c59IEZBOr5H69g4BmRsUc113T23i6OalAJz7x5jQ4SW/UIyMcY8x/F/AdIyorEeDiC41fClld93jd1RriEIYsppoREeo0CMdIgyNIeZB2oBZBqAX5FBwwDa45zuGyR+C+1ZqPHCg4ZKYRyH96JuaSB2JWl+AjBwqKdbjkQU0cwyn7QkfWIe/DW3c3dV39X811T8WgIe1DqCHlwOoyTMvC2gq8aWeHI+YIbl+uOWQnwX7TzL5/eCrmG/+O6arCy2dCxoNrnoRZTfCaBXDtU1CNYE4efBdO2EPwwf1dfvtExLfv0xy6E+w/3eGhLs3cAlQDuHcNvHdfwWsXrN8q+2yf5qalmv2nCV6209YhtmOtueZJTTmAExcKMt7W0a6JsmpQ86dnNLu1wavnbo0W8W2rPyfCNjtKemMWRimlr5QKNmP91sJoeSFsmzfcRFm8Bvb/BPSXRys314Eo3tCeL4pGwTgeER4aFweNQ314n15m04eZlkYQMYXV+FQo0UotiWx8jqnszoqGsgQRPjHQRQsVMqyaWqCpWE8Gr0BTWGPZtBZqKQ+0RguHyHWo+S59U1vpa20mdBzcOOaPs3ciFrBH3wCuhv27ugl8j8hxyFZqrMw38diMqcP1zyqWeLolPywYAaZUq9zV0YrWMZHr0pdLGYuiNiIOf2T0dL4S0FQJWNOcNWJRYNzdYESf1uAK00FBUocnzLbhDk8CM51xel3rkfIacITRpyRVPniyw++fgi/+c2LXxYcPEOQ8uOBfsRGriYveFLhufb4DQWz+3/52lyd7NKfc+PyvwWN2hj89u/F8t5zgcOS8dYXL0n7N/r+M6K2aPrj+eGeD4nJL8YGbIn74oOm/o+YKbv6fbWeEfW9Vs9/PI5YVzfrlr3M4eZ8X3KebRdkF4n2jnvW+vnSbV5AbtTBKKZcAPwGOAg4CFgPvBPYGvgRMBa4G3q+UCqWUPwMWAa0YQXW+UuqqpKzTgHOB/ZVSa6WU04AHgLOUUpdtpB27AT8GDgSeBX42Jv22pKz5wJHAV6SUVyRtPxBIAQ8BH1VK3SeldIEu4A1KqX9JKXcGngHOU0p9MSnzceBspdTVUsoZwKXAq4A1wNfH1O8BZwKnJMd+P/ARpdQjUsopyT5zlFIrpZRHATcDpyqlfpbs2wMcpZS6V0qpgQ8C7wEWAo8CpyilnthIHx2RlPtuzLmZAVwDnAF8E3gbMAB8TCl1bcN+bwa+AOwCrMKcsyuTtNnr68Mk/RzgcOAe4LSkyB8O9eFG2nsb8B9gAeaaWQu8D3MDXwTMBW4B3q2UKib7dGD6/jVABrgV+JBSak2S/hHgdGAW0Atcibm+oiT9BfWtZYLc8ZgRizBaGm9GsQgbf+K7hECYxCSmEcSApkA/IVnKtCDQ1MiQo0gbXUT0sJK5zGElveRpY5AYQZE8ER4QE+Mg0LT0VvAczWAqA0DN9QhcI9gi16GeTQFQz6SoNWXJBua3rFcPmDpY4pgnF5MOQ+6evROR4zCYyeBqTeD7BN7ox/TyfI6q49DlwCrXZWatzuKWPF1pY6FMRzE0+SNiTusRYVUNqZcC3DAmVQ+oN6XGdFTiwhYCwnikc90xPSwafw2MPRnjn40GfYsG/viM5o/PTPz305+e0TQPNXeojg24xoN45P9fF8fcvnzCVY3ilucmlu9XT2iOnLfu9jtXaHqrZjnWcP1izWsXvLC2bEoa+/6W5zSVQJP1tw1N88BaPSwWwVwbJ+8zee0Zj+0xhnGikvxk4ANAG/Ag8Hvg1cB+wL7AscD/JHnvAl6KEU3nAZdLKfcCUEr9BCNorpRS+pgv85smIBY94E+YL/dpGOHz/nGyngp8F2hJ/jvAxcA8jHj6D3BtYn2MgNuAo5N9jwaeHlqXUs4Edgf+nqRfCUQYEfNKjDBs5FMYofYGYCfgTuAmKWWzUqoLI7QWJXkXNdYFHAyEwH0N5Z0CvBWYghHe39tAFzXiAkdgzsuewOuAu4E/AB3AV4HLpJS55DiPBn4KfBRox5zr70spX5mUt94+bKjzlcBzwEzgGOBMKeVhE2zv/wJfw1wvvwF+iRGNr8SI/z2ADyVtFclxaGCfpE1F4KqG8pYDrweageMw18RpjOYUXljfvmiKxeL2vSx3QafG+R06CTFv65ciaTQ+IVkGmUaVZpzk8Z6lRIRHQAqXmFa6AYEgoocCPbQRkkLjEOAjgBQhuTAgdBoep0IgophsJcKLGlsyuh+cOOZNTy4mE4Q4Gl6+bBVrCwVK6TRl30cDhTAkHZmpeULgvymfTK3OUt/jJcUSx3X28Lbla3nlmh7SUUw+jtZ9sBfrpHoqUAqoI+j3XOrl9bj9h5o4nvVwuHMTl/bYbc+Dw6ZWePnMiV8XcmrIq+aMEaqNYngMoiHffm1VFs19Xs0b5qVTwo1nQnPMLuZYxt4XB04XpBuMd4fOFJN/nwIvmzZyXPt2xMNicWto28aW9+wQtKZGzu8BHfUXXKZl4kw0hvFSpdTjAFLKqzAWxkOUUiWglFiKDgKuUkr9tGG/X0spP4kRMI8l204H7gX+jQmvPm4C9R+MsUJ9SilVAZ6SUn4TY/Fr5HdKqSGBV8aImOHfh1LKs4APA7sl7bkZOBEjbBcBFwDfkFK2YMTcA0qpbinlLIzVclelVD/QL6U8F/hbQ93vAb42ZKmSUp6HESpvBH6V1LUI+EXy/yzgu4kIWgTcqpRqfARfqJR6LinrcuCKCfTTEJ9XSpWB55Jz06SU+ktS1i+AHyZ98CDwEeA7Sqk7k33/nVhm3w3ckbRhQ30I8KRS6kfJ8j1SygcACfxjAm39rVLq7qTsK4DPJcfek2z7M+baAmPlPBBYpJSqJemfBrqklLOVUsuVUtc0lH2/lPKXGOv4JQ3bX0zfvigKhcL2vbz3XMSt58GfFRy4C/zlPhPT+MX/gYEKfPUa6CmaeL2sD7UAlnRCmMxVWA8n5LQfyeJixgeP3inGoUIHOTpHSTQTtzhARIo6U0gRUKCLCnlcNBWa6GYnQNBEH4MUqJNNptRxhjWSRhPhJvMyCjw0qXpIVXjgOkSOoJ7xyQ7USFcjKjmNdgSpao1UtUY9ncKJYvwgZHF7K/+cPws31hz51JJhoRa6LvUwBMdhn+5eIsfh2qntzK7VmVepcl8+x/7F0vCx7T5YxndcPKBYrnPPvDYixzFBebGmPl6/xkPu53HcyA4Ioc2UPnFs0ofcwBoQevS5imNwHIQwXyxB0uO+Y2IEf30M/OIxwSNdmk9IhyN2yfOKBZrd2jTfvz+mvwYnLYTnBoxVL+XCyXtDky8opAQf3D+N78Ce7fDThzS1UOMIgedCRxZWlyDnmZjGN+8qOGyWw1+XaA6fLXjDzk28BaiEIT9/FMohvGQKFOvwcBfkU2b90W4T4pnzIe3CSXsKvvyKNF+5O+ZHD2p2b4M37iK4dzXMaNIUa4InezUn7+Ny7K5Gpo+9L/YEbjvR5Y/PxBw4XfDW3R1g8u/ZK49J8/37NeUQPvhS93ntO9nLM5oEd73D46rHY3ZrE5yyT/YFl7n52P4sjBMVjKsalstApJTqHLOtIKV0gHMwImwG5nHShHFbA6CUKkspfwJ8C+OSLU+g/tnA2jF5F4+Tb0njSuIK/hZGsLYy8pt4qD03A9+WUhaSPB8BjsdYTxcl6UP1AyzdQP1zMK5yAJRSceLOn9NQ12VSyjaM5fJa4GyMlXYRo61kMLrPSzQ+YTbMeOdmoKFdZSklDeUtAF4tpfx4wz4uxkI6kT4c29bn296x19Z42xrbmgbWJMcwRBVj+V0upTwJ+DiwM+b6TmEsrOur8/m01TIRXr7QfADeeujotDcfvEmqEIDuL8G7vwe3PYwOI+JqDHFEhCCmkNgFU7hJzGKMg0ucaBxNin4EEWk0EVk8IgZpYuhBX6KFOikTykcKnxiPIUvfkE3SSNUiaeLYIV2JiFMxUdpDJJYvL4pp6y4z0JxhoCNPtlojV60ReMZl/c/5s4gdh9iBO3eZy76D5jYIBawt5NFCkApDppbKdKV8ejT0Og67liv0ey65urkluzOZ4Qd6oR4ys6dMLYa1KX+MGEwiPtOOiS3V2vhtPWfEqhjFIGBak+ZbixwCLZiShv4qyJmCfNplRhM4z9NyfPDM0eueI/jQAYIPHTDx+LP3v9Tl/S+dWN4jxlgVzz/c4/zDJ1zVMJ8/1OXzh2483/o4ZKbgkJlbV4xg1hd86mXbrqjZe4rgy4dvXX26vbOpR0mfhLGqvQZ4LBFNigapLaVciBGVPwQukFLeqJQaKzjGsgKYJqXMNYjG8aJAxjpJvopxDx+slFqVCMOBofYopf4rpVyNcceuSeILb8ZYF49kxO08FPE+DxPnOF79yxq3JeJ5frId4A6MS/gMzGCdIKnrLRgL6qkb6YPNxVLgcqXUhetJ32AfbmGWYgRe+xhrLABSyjkYa+HxwA1KqbqU8hsYa6dlO0O0NMF1nx1edxv/aw2re6EjD44Li9egT7+c6JZHMLGMGVwqaFxqFPCIhoXkcPmJOIxwcIhxiIbnZRTEuATEONTxiIedwILQcahnHdp7ysPT59R9l75prWjHWOjMtDlQyaRxGry7no5J1+s4GgZT3vCE3XXP467WFurCAQFLM2l2q9ZY0ZzHGyzjaM2yfJaOejh8FK39VQIh6Gr1iB1hBKHWZgCLI/B9QU6EzGoWHD5LcPyeZjTvS6cJDplt3xRjsbwYtscYxk0tGJsxYTadgCOlPAVjQfszQBI3dzVwkVLqi1LKNHCVlHLR0KCE9XA3RixcIKX8DCZW7mMTbE8Z6JVS5jGxcmO5BfgkcFnD+jkYS9ZdAEqp5Ylr9+tSyvcAWcwgkUYuBz4tpbwDY+n8DKZ//5KUUZFS/iup6+yGun4JrFJKPTWB49kcXAT8TEp5N/BPzPftvoBQSikm1odbCoUZ2PQdKeU5SbjAVMxgoV8DeUzMZScQSCkPwcRIPj5ZDbZMEkLATu0j67vNxLv5TCOYVvVQfsW38RevRKDxqVNP5okROKQoIwjJ0UedPL1MwUse/mbeRY0H5OmmSCs1pwUdN/yCEpCuhcNiMQZ6puZxoojI8YatfUJrsvU6B69czf3Tp+LFMYeuWE25UECEIalw5JEYA9OC0bF0IcZt/UyLMZBXHEFFQNVxWNqcYU3Gh8hMMJ5xHN76Eo/Pvsoj7Qrmtzj4YweyWCwWywbY1GP7f44ZLfs0xiq3F4lrM+EHmC/zc5P1MzBWt3M2VKhSKsQMrNkPM5L2WtaNXxyPL2IGyXRjBp38ExgrTG/CiKKbkvWHgQrwjyRecoh3YETksuSYfjGmnAsxsYp/w4yIPhJ4jVJqoCHP2LpuA3KMuL63OEqpv2EGmVyIGTW+Cvg2RnzBxPpwi5BYFd+MuW7vk1IWMdfbEUn645j2Xgf0AZ/FnBOLxSAEzOwg9+z5OHd/kfiGT1PfdSo+/UCMR52YNBE5BCma6SdNdWR3wCMiAjqZTZU82TiCrMYTITmqTKsU6egv4wURsYDe9iypekCuWCJVriCimHSlhh+GpOoBC1d3cvwTT3Ps00uYWqkyrbdv+L3RraUy+WqN1lKZOfWABVUz12IuipgRRnhxjNaaEHCimPn7ZvjEic2s+lor+rw8+ssFwi83UzkvzxVvy7DPVI/d2l0rFi0Wy/Nmm52H0WLZRrE33FZKcNMTlF/zI1KUcdE4xKxmJiF+MqzFQRDRSx6fiBoj72WOXEFTNDK/Yz85NILVbTk6Z+RHxRBmywED7U3E3kj8VS3lo12z7gYB3S3NpBqezTXXpb/JTMZdE4LIdRDCTA70ZNa8OeaTJxV4++ENM4JbLJaJsFl+PdXE6aOe9Wn9w23+V5p904vFYrEA/tELyS8+m+pFdxDNaqb3038nxKPAABqPCJcQjzwVKvgIYjQOkQPOqNhHGBpY0lKq06VBJ18VbhjhhxHZUo1SSw4wbmWdiL841nS3t1P3XPxqdXju89BxcKOIwDXvhRaJVbGvJc3dF8/GYrFsXWyPMYxbjYVRSnkDZgLodVBK5cfbviMipRxcT9KdSqnXb9HGbAQp5ZmYyczH4/UNU/nsSGwdN5zleaPrIWt/8hhrz7g1mVkmJkLQ52VpCiPy1BFADZcyZgLvwaxPd3OGes4ndATpeoibzEYz2JQh9BzqKY/BtgLVXJpAOwgNxUwaF01ORHQsyFFszfLUqhi32eH9/zuVWe0uU/OCQpMdJWqxvEg2i7Krig+MetZn9MXbvILcagSjxbKDYG+47ZBbpv4Sr6tKhhAHqDkOfbkMwtEMtGaJQkhXYTDvEqY9At/FAd7/6DGT3XSLZUdnMwnGD44RjD/Y5gWjdUlbLBbLi+Sozv8dXg56q3itaURD3KKONb8++0/oHsFOYQez929nv//bYzKaarFYLC8IKxgtFotlE+K3ZdbZJhxB/mBBHnjTMS/f8o2yWCxblO0xhnFTT6tjsVgsFovFYtnOsBZGi8Vi2Uxorfnda2+i/ES/eY/1oS7YsEWLZQdg+7Mw2kEvFsuWxd5w2wEf/r+nea7u48WalnKF+Wu78OMYLQRVz2X6NI/Tf/UyfvCSv9DaV0ZriFIeXj3EDWH6Aa2kW9N0/m0lqWKdTByBiNjtAsmcj+8/2YdnsexIbBZlVxEfGvWsz+rvbfMK0gpGi2XLYm+4bYww1qzoCjn3R108tSwEDVPrAS1BSNV18aKIXbt6cGPzjmi3XkdoDWHMlK4BUkFEOZdmsCPPzNU9zFvWTaQFPX6GplqEk8zy2EKJQTJU8cjNzPDS+44nPcNOxG2xbGY2i5Ariw+Petbn9He3ecFoXdIWi8UyhijWPNMZ8PKvFam6LtOrAfOrEaFwAE0VQXe+iYGUj6ONlXFGuUIkXIT2iHyfts5+mqrm/c/NxSqZoM4eS9aMVFKDAB+PmGYqaBxCPDQepZUBD825nAOK70M4DkKA8O2cixaLZfKwgtFisVgauOexCv/zo0FAsHu1RlMY8WQuQw1YUK3jAHUBz3kus2rGmri4pZkZ5QoaiHwfgCDlsWLeVHKDVdq6i2Rqwah6tC/QAbRRwiMGoJ1B1tAKgBvFPJH9Ph4hOQZJv/NApv749cQ6Qi/uRezcgZtNbbF+sVgsOzZWMFoslh0erTWPrQw48HsViGK8lM+ulTqR5xEBLVFEzMi0EikNO1drNEfx8P4a0EKgtZlQY7DFuJPL+SxuEBITUer2aaoHRELQn8ngOhqnNuK5cpOIhbQISGnz6sGAFCEp6lc+RvHKR3CISRMSAy51Cq+ZiX/gHPxz3oCT8rdUl1kslh0MG8NosWxZ7A23FfHBG6pcfD8QxRBgFKEAHEEWzR5rS6SjmHy9zpPpFK8slgFI1QPSUUTN96h75nf3vM4u0nGMiGKcOAZnZNay7ECJpmKJ3GCNtoEakeMYcSlgVm8vzboGQGc6T5+fpblepaNeTvbW+EQMhVr51EgRojHu8TQlcgwkjdc4X3gTqTcuRHQVcV6zJ8K3dgGLZQNsltjCkvjIqGd9k/6OjWG0WCyWrZk1gxFn/yPm3ys1D6+KiWONDjFfE1kPUgK0Bky8IYPGdVxxBUvbsuzWVaI5CChmUgxEES1RyLRyFQBdq7GmkCcWglythhvFOLH5nghSPghBDOSKZbx6hBaCmu8htCZ2BOiYuvAY1BDhkKsFVPBJR3VIbJo+ATASvxjhJe+xdtBoHDKUEWQoAQ76S9cTf+lKNFlA4FBGeICch3vNRxE7dYDY5r+7LBbLFmaHFoxSylcAdyqlJuXpKaWcDSwDFiillkxGGzYHUsqzgEVKqSMmuy2W7Yu1AyF3r4aUB2o1FKtQC+Anj0SUYgER4AgjBjVGCEbaCCRXgO8aQRjE4AmTF0x6yh0WiwBEmuZ6nQjoSqc5uFhhaUuBvXv7h7MIIBVGzO7qwo9i0CPvd/DrAXfuPJPVzU188NnVZKqm7MgTuBG4GsChs6OJQzufIsClmxbSYQQRuET4lClQpkSBgBTG2lglRZ0Al1QS+wgeISlMpCWEtODTj0cFgDgUOHc/jp51BgFpquTxqeJRwaU6fCw4QFsBMVBCuy56r/mI5jRidY+xwi7thHoE+TTsOhMOmA97z4U3HwwtOWjKwN1PQkceOpphZvsmPf8Wy7bD9vejbIcWjJbnh5TyFOAspdSuk92WHY3HujQfvCWmGmoufJXLK2ZP7GF0+SMRn7hNE0Rw0p6CHx7t4CTWpZuXxpx5Z0xLWvDDRQ67tgnqkea0v8Zc86SmEoLnwJkHC17nV/njn/toa3M57T1T+PWTcOl9Ie1ZQX8tpjntcP5RHhfeB8/0aaaWqojOGo+lsgzgQKwJXQeBpu67aASugPktsKRfEw7pHjH8ZzRjQ2caLWRaQ5Ssu6IhTcNwfKAeSQ9iIxRdx+w7lF8n6Q3s2Vei3/MZ9Dw6U2aAybKmHHNKZQTGBpivVkmF0UhzGNGrj81op7UWmGl2MM0MfYemhvxRYj30ichRxYtCmqgjEIBLlSwpqngEuMQ4QIyXWB4bX9blYBQzCGI8KsM96aKJSaHJ4CJoYhCH4nA7h486BrqLpreCGOc/T409E4bBGjyw2HwAPvHzdbKMjb0Y1bOOgMQSSzYF01ugGsAes+Di9xlxesaPIYjgm6fAoXvAQBne83245SFozsK5b4f3HGXKeGI5fOBSKNfg6++GV+5Nz7NF7vjyI0S1mEM/tpCZB3aMfywWi2VCWMG4AaSUvlIq2HhOi2Xz8s7rIx5Ya5bfcl3E2g+4iI24FZcXNafeqIe/uC99SPPymZqT9xHUQs1b/hAnBjXNe26MuPMkj+/9R/PLx0a+6oMYzv2X5uEnu0jXYpYshQsu7+PCvqZEww3ljTn22ojuwAgYEaeYqmFtav2jeEMNT/cBiI3/GN/QsQphrIVjGatYYm0EoQukPbNfoMHREEOqt0wmiEh5Ai0EC4tl8pFmwB1dVFcmzX1T2snW6+xSquAIwUAuR0u5DEJQyqRZUchy97zpVH2PY/75KKlaAFpTzqXQrkO2WsFJCs1FtZFDISZPjUYhKAAHB4d4VDdpHBwiNIIYB58qGnc4z9geMfmraBw0KUxHRON2/aawjWywjLihRyt1WNJpllf3wTsvgjCCR54z297yNVh9GZzzG7j2brOtvwynXQyH7wW77gT/+x1Qz5i0N38Nui7nls8/SOdjxhp8w8fu49TbjkY4m+LILJaNsz2+S3qLCEYp5RLgJ8BRwEHAYuCdwN7Al4CpwNXA+5VSoZTyZ8AioBXjsj1fKXVVUtZpwLnA/kqptVLKacADGMvXZRtpx27Aj4EDgWeBn41Jvy0paz5wJPAVKeUVSdsPBFLAQ8BHlVL3SSldoAt4g1LqX1LKnYFngPOUUl9MynwcOFspdbWUcgZwKfAqYA3w9TH1e8CZwCnJsd8PfEQp9YiUckqyzxyl1Eop5VHAzcCpSqmfJfv2AEcppe6VUmrgg8B7gIXAo8ApSqknNtJHbUkbj8RcH8uA0zEBXj8CUlLKwST7m5RSt0kp3whcCMwFbgOe3lAdDXWdAxwOKOBUzLfkl4FrMOfmIOBJ4F1Kqccb+ujTSR9NS47rw0qp+5L0o4CvALsnbb4lSV+bpN8G3Ic5x68B1gIfV0pdN5E2v1iKxSKFQuF5L3dVRsrorUJv/yDtrRved01vCU1mVP1dFZNHp/KjvK9D27squXHbXcUhnbg/O0t6HYMfQDkcWXY1hJP95SwYMfWBEYuxhrQ/yqrolQKyxSrTdUynFni1mPnVGqs8j86MS8oR9HsuLfWQ0HXx4pjIdelKpdgtiWUsZzOUc1nQELsOrWHIKfc8RqpSxwsDuqYVmLK6ROw5IAS9rWmypQCBpqM8SCBcIm1GRKcp4ybxlAEezrDbebQ10ByagyBCEGEEYJjkcwnI4VNO1s14a9MlETEaGsrdmog7+3Gihrb1DEIcE6zqZtQY8FhDz6C55ruKI9v7ShBElHuqw5vqxYA40riOeMH3oF3ePpctE8fZeJZNxsnAB4A24EHg98Crgf2AfYFjgf9J8t4FvBQjms4DLpdS7gWglPoJRihdKaX0gSuBmyYgFj3gTxiBMQ14G/D+cbKeCnwXaEn+O8DFwDxgBvAf4NrE+hhhBNLRyb5HY8TS0UmdMzHC5e9J+pUYn9Fc4JUY0dPIp4B3A28AdgLuBG6SUjYrpbowYnVRkndRY13AwZhvi/sayjsFeCswBSP8vreBLmpsQy453lbgeGC5UupfmP56VimVTz63JSL5WoxIa0367P9NoJ4hXgk8henbd2GE508xYrcdeBz4TkP+84DjgNcBHcBlwF8ToQtQA87A/AjZF5g5Zn8w1+K3MOf4+8DPpZTjK6VNTOND6vksn3+Yg5fcrecd5gyLxQ3te+DcPCfvPVL3/GY4eW9BoVCgOS343MFGeqRcU2ahUOD0lzrsNOblIi+bAce+zAjPTEbwkePyvGE305hc8g3uu/BJ6dCcGBTz9ZDpvRW85It/6H+mHo4qe5M9gMZTsKGJKUzrGFKOEYyhHp1fa1LVEEfD6pSPEIKS43B3Lsuz6RRPplM8kvJZ5jg8kk2zwndZ67vc3pJjIOUx5Fg245NJBrJoUlVjNQxyaSqFJtLVAO1ociWj0mPHwY81fgyrslP4b3Y6AxQokqWOj5PYAUFTJEc/OQJczCyQIS4BgogMJTKUyVFBJ7JQMyQsXSBFRAZNdpS9Q2DE6oS69vmchxdbjuvgfPmdcP47TMiAEHD+SeA4+J99q4mTHOL4g0HuYq75L50EXjIw6NwTIe1zyBkLcRLL80Gn747rm6vthd6Ddnn7XN5caPP2+OHP9sCWdElf2mAlugpjYTxEKVUCSonl5yDgKqXUTxv2+7WU8pPAEcBjybbTgXuBfwM+RkBsjIOBBcCnlFIV4Ckp5Tcx1rRGfqeUGhJ4ZeC55EPS9rOADwO7Je25GTgRI2QWARcA35BStmDE3ANKqW4p5SyM1W5XpVQ/0C+lPBf4W0Pd7wG+NmQFlFKeB5wGvBH4VVLXIuAXyf+zgO9KKUWyfqtSqtFscKFS6rmkrMuBKybQT3WMENsDuF8p9eRG8p8E/FspNVT236SUfwBmTaAugCeTHwEAN0gpu4G/jrlWrkyWBfAh4I1KqWeTfX4qpfwopo+uUErd1VD2ainl1zGispHfKKX+kZR5KUY87ob5IbNVcvI+DsfsIghimN408YfP5a/3uODwmGId5rcI/IYYva8c7vLhAzQZF1ozZvvcZsHi/+eyrKgp1WPSnsPCDgeYygnHt5HNOmSzDn/eW7N8QNORFRTrRnS2ZQWfPlTTV4O2VJaBchpiTV0IlnVr/tsd8erdPfrrAkcYi+S+UwXPDWj+u1rTV9GsjQRZD9rTMBBAaxru74QFBXimH659MmbVoKCWyA+BmfeQUBuBgTbT2YQxBDHt9ZC2IOSZTH5dURnFNPWNiNrYEfQX0qQG66PzDQclaipCUEx5HFyssFM9Ynkuy6xSiVSswXUhNmW5YTQSMiAElXyG2HNIlet0dJbQzsiAG0dD0c/j46JxWE4an5A5dFKkKZk+B8po5rCMCs1mP8JE9CVhAMRJhKNIhGwaCHGSqMeR2Eo9vD50eLCuC7nROBszYrBdB19ALgNzp0BzDgYrxsWcTqEPWwiFHMxoRrzzVdA1YM5Paw6eWg1RBMcfYlzRQkBTGtqTL/M3H2zSp7Wa9f0WwMqfwrIuyKVhdsNo73e9Ct54INRDmG7y73HMbOa9ajpxEJPrSI/XcovF8jzYkoJxVcNyGYiUUp1jthWklA5wDkaEzcA8s5owFiMAlFJlKeVPMF/0pyqlymyc2cDaMXkXj5NvSeNK4gr+FkawtjLixxlqz83At6WUhSTPRzBWuVdjRNzNDfUDLN1A/XMwrnIAlFJx4s6f01DXZYk1bXeMZe9sjJV2EXDVmPIa+7wETORn1YUYEf5zYCcp5Z+BTyul1qwn/2zG9BnmuCYqGFeNWS+z7rUy1O4pQB74U+JyH8JP2oGU8kCMtXM/jKVUJPuMW6dSqiSlhIn1zaTSnn1hv1Jn5B1mrC9tHPGZ9gS7tpnIuVH1t488LoQQzGkx++YawhTzKUE+WW9Kj0wFM6/d5RW7jd+GvaaYz/p4R8PyN49cfz6A258LeaALdm9xuGeVoKfsccdyTWu/pj8QaFfTaBasN/k4pTqx41BrTqNLAbOjiBVCUHXGDIoB8lFETbjsNGQp9TyyoZkup7Wzl51WrkU7goHmJqLsiEhxEiEphEB769pVnTgeFoYgqOPRSWvDoJWYuCE+cYSRLRqHGA9BRDOrcRNRqBHJwJk6IpuCl++OePPBiFIVMbcNcexBZnTzOKwvHnKibHC/l+48sjx36rrpHePckrm0GRgzHm1jb3PINNuJzC2WTcXWOOjlJIxV7TXAY4loUjQ8e6SUCzGi8ofABVLKG5VSY4XHWFYA06SUuQbRuGCcfGMDe76KcQ8frJRalQjDgaH2KKX+K6VcDXwUWJPEF96MsS4eyYjbeUXyfx4mznG8+pc1bkvE8/xkO8AdGOvfGZjpgIKkrrdgLKinbqQPNkpi8f088Pkk5vIKjIh8N+MHPa0AXjtm23j9uinowgjfRUqpe9eT59fA74ATlFIDUso3YUIRLDsAr5rr8aq5Zvn1u4yfJ9Zm1HilHvHqi2o84GcgBr8a0FKpk9Oa/eoBxDGFKOKBpixdnkfKExy5up/lmTQR4MUxM4tFtOMgtGanlWuNFS7W5Itl+jMpY03TGhGZ3zepWji2MTixxquOWADBjJgWo8QgtNBPiItDQIRPhIseHk1thr64BHiiTjRjCro4iJ43Fef7p5A7YuGm62SLxbJDsjUKxmZMLF4n4CRTuewH/BkgiTW7GrhIKfVFKWUauEpKuSiJKVwfd2OsexdIKT+DiW372ATbUwZ6pZR54Gvj5LkF+CQjrs9bMII2jYnHRCm1PHG7f11K+R4gC3xhTDmXA5+WUt6Bsdp9BnOO/pKUUZFS/iup6+yGun4JrFJKrWcOjIkjpTwGExv5JDAIVBme0ZjVGNHdrJQaSLb9CjhbSnkS5rwcgQkRUC+2LWNRSmkp5XcwLv/TlFJPJefkMOBhpdRKzPnqB4pSyrnAZzd1OyzbNo4QpD1Iex73n9kyvP0X91c49/IqtVhTEALHcVjblKZvRjN4Lq19Fa6bNY3XrelmSrVOJorQrktFOGTrdbQjEMnoXy3EyJtehCBI+Ti1mMFClo7uQbQjcMKYQk8dF01KR4nbVxONY0lspkgTZfpowSckQxUHKJEj9ASFdEDh0U/jzrNTx1gsWwPbS9xiI1ty0MtE+TlwD0a0rAD2wgz+GOIHGDF5brJ+Bsbqds6GClVKhZiBNfthRsZey7rxi+PxRcwgmW7MoJN/MuLUGuImjFC5KVl/GKgA/0jiJYd4B0ZELkuO6RdjyrkQI8D+hhkRfSTwmgZxNl5dt2FcrzezadgFY5EbwIjWCiOi6+9JvYullH1SylcppZ7BDCA6G+jDiPCfsPn4InAdcJ2UcgAzYOb9jFzL78NYqIuYc3z1ZmyLZTvi3ftneewbHczfN8PqXIo1KY+UjsiFMTsNVIgqAZEjeLTQhB/HwxecdgSh67Bq5jTqvkctnaJnevuoQR6Ojgl9D+055PoD8r11WrrrZvJuLRBofGI0gll0M43eJBJRAxF9ZOjzW/CmNpF6y56U95jHwJydyJ5+ILM7P0fr4NesWLRYLJsV+y5pi2XLYm+4bYDrHqxx7vVVnlsTktExnWl/+J3R+/YVObS7H7/h2VkYGCROjwRzOlFEoVQmU6nihhGpSo3Ic6nlcrSs7mfBkl4aI/zSBMnk2jCdfjSaXprITxGkF05h+jdeSf7g9UWiWiyWF8FmMQUOiE+OetY3629s8ybHrdElbbFYLJPKcfulOW6/NMVSxImXDHBbl5lcPBvHzKvUcIMQnUzj4kYRThih/RiduKHdKCZdrZEtloe/jbwwoq8pg9MRMNg1QK4UIzTD0YgaKFCijkOJNLO/cjAzPycnpwMsFotlDNuVYJRS3oCZCHodlFLrDqHbQWmYeHssdyqlXr8J6zkcuGE9yV9RSn1lU9VlsWwOCk0u13+8bdS2oJ7n0+96nNTAIH4UITRE6RReECIEaK1JD5Y45MSZPPKj/6JdIyJrmTQIQX6wivahlPdwADeE1kqIg2ZVupXD/3Msub2se9li2ZbZHmMYrUvaYtmy2BtuO2HxY0WeemiQfIvH7vvn0Rru+eMa4lLEYSfOpGNWlseuWcqdn/sPpdY81VyWtF/lEzct2njhFotlS7FZlF2/+NSoZ32LvnCbV5BWMFosWxZ7w+2g/OlPZnanY445ZpJbYrFYGtgsQq5PfHrUs75Vf32bF4xb4yhpi8VisVgsFstWhBWMFovFMgnEUUwUjDcXvsVi2fYRYz7bPtvVoBeLxWLZWqlWNEtuy/Lot26jdcUgDy6cQ8dAkUw94G3n7s7Coyf6Nk2LxWLZ8lgLo8VisWxmnv3Ro/R/qk7TbRVSxYCHF85m7touZnf2MKW/yI2ffoizLunCxpRbLNsHesxne8AKRovFYtmMaK2547xHEJ4gTPl0d7SS0dBcGnkJ1IqWJr7RnSdzQZ29PtbJrY+VJrHFFovFsi7WJW2xWCybkMr9K7jn4D9Tc33cuE45k6XFcenM+nRP68B1BE1BQKkpR3PRTIn6y1e8hFrKPI6fmt7MD7/wJPX/m85rXzNtMg/FYrG8QLbHeRitYLRYLJZNQNRT4omO71IVWbSTI61DZsXdhGWH5S0d9IjC8CTe6VpArlwnV6wReQ6RGPlyCT2Xqw/dk0f+0sk1e9bYc056sg7JYrFYhrHzMFosWxZ7w21nrD765yy+p4+OYoUInxxlavgMeBlWZaayelYz1SbznulyNkOQSrH7Y8/hRjEaqKUd7ttlJhe/7iBqngsN4tHtLrPmrCwdTf4kHZ3Fst2zWUyBPeJzo5717fqr27zJ0VoYLRaLZYL0zfw47qoeUtSoMI0ITZkOmmlikGYAKmQpMECv30LkiGGxCJAfLBNRw43MdDoCcCPNnqt7+PitD3D1Pgt4eubIawGj5jQ7f7nMvZ/IsXuHFY0Wi2XysILRYrFYxkGf+A2i3/4LQYoYEMQ0kUPjU2IqDgECnzxVyhRG7VslSzoKqbgp/GrArGIvrtYsbungD3IvvH0jXnfff5nX2cfFh+7Lsmlt7FwLeHr66PdWO45gULi8+iv9nHyQz1fe3rIFe8BisbxQtscYRuuSngBSyiXAWUqpK6SU84HFwByl1PJJbdhmRkp5A3CrUurrk92W7Qh7wzVSqsLDS2GXGTB1AmJoyVpYvBrSKdhrDmR8+PvDJu3IfeHpVbC8C/2z24hbW4k1uNUK4sAFcPODRI8sQ6zoxUk5iDAirgVoBAJNQAFNBoiSR31IREREMwEFXCoUWE6EzyAzAE0v0+imjVaKDNKExsElxCcEBL1+jmZdojU0I6KfnDqVz7ztOAC8MGT22m5umD+Tsuch+wcp59M8NrN12C2dL9fJFOt0tefAgebBGl4QEqddUhmH3WZ4HL9TxCG7eKgBj52cmMPnO8xoczftebJYtl82i7LrFmeOetZ36K9s8wrSWhgt60Up9frJboNlO6avBId+Fp5YAa1NcPuX4CXz15//t/+Ad3wbEncuO7VBLgXPrDHr7XnoMaOOI9JUmA44OFTI/fLvCBoeeIGxADiARhOTJqaAIMRnENA8yr7UaaaJMlPoJ083DpoibfQxFY1DhRTNFGmnl1b6qZDBIaDLaycdatqDEjmqw4ewe2cnXhQRui5CCF5SqTDzmef44W7zqboOvmBUDKOINV0dueFtA/kM9FbBccFPwdIq9/99LUoIbl0wldX5NPN7ivz8HVleua8dLGOxTBbbo4XRzsO4AyKldKWU9txbJpfr7zNiEYx4vOyWDef/7l9GxCLAqt4RsQjDYhEgoMDQ480hHvfRLRJjrwB0kjdFLy51XAL25kF2ZRk70YODRhARkqKTBUSkiPHIENBBr4lFJCZPmTQ1vEgPvxAsbnjMLm9pIRYCR2v27eoBYEo9oC0MeWRaK0uzaRjy+mjNzFIVp9FOMVRUJYIoZm0+Q3c2hac1u3cXQQhWFTL85vYKFovFsimxFsYEKeVHgNOBWUAvcCXGDR29iDI18CHgFGBP4EHgf4ATgI8DOeBHSqnPJ/lzwBXAy5O0p4HPKKVuStLPB44FDlZKVaSUC4F7gLcN5VlPO+Zj3OinAZ8AdgHmSSmPAD4HLABKwB+BjyulSsl+twE3K6XOl1KmgO8DbwYywGrgTKXU75K8hwNfBfZK+u9i4FtKqQ26YJM6/pO0YRGwFngf5rv2ImAucAvwbqVUMdmnA/g68JqkLbcCH1JKrUnSN3guk/PyQeA9wELgUeAUpdQTG2rrpqBYLFIoFOxysUhh/pg5BhdM33D+BdPhH6NPkWbEn9S47BAO54nxRqWNh0uVkACIG7ZFw6W6xFRpI03vqJI8AjxCAtKUyAHGkT0i8jQRmpVtrfRnmljW0c5xjz5FtSmDnwjDvpRPX3MTuA59hayxJmrNwcu72aezSGst4J5ZyUCYyshxIQRCa9KReUQNJvM4poKYmR3u+H1ol+2yXR61bJk41so0wnLg9UAzcBxwKkZgvVjehRFZU4Eq8HegDSPajgQ+KaV8eZLXAa4FdgM6gF8B10gppybpXwS6gB8k4vJ3wEUbEotjeEdSZwHoBPqTba3A4cnnrPXsewpwELCnUqoZOAp4DEBKuTdwPXBhcpxvBM4A/neC7fpf4GtJO34D/BIjGl8JzAf2wAhvpJQC+APmm3wfYB5QBK5qKG8i5/IU4K3AFGAZ8L0JtvVF0fiQ2uGXX74QLvsgvOEAOPt/4IzXbzj/906D9x0Ne82Gg3eDC9+NuOpjsPN02Hk64psnw9sORbc24dOHTz8uFVIUwXHXeVWX+YhhQZmiE+OgNvQzhaFHpMlVp8R0sgxgbJIBGSpUyNJPC3Uy1MkQkCfEIUKQo0wzZXbrXc1OfT3keus4aDLlGk49xK/UuXbBLALXAVeMuKOFIHCN6JtaqpltOsaphKZJOQ/QtJVqlLI+3XMLPDe3mZlOyKd3j/jYW5om//zaZbu8DSxbJo61MCYopa5pWL1fSvlLjCi65EUW/c2hwTFSyt8BFwDnKKVi4EEp5YMYIfZPpdQgxsI4xIVSys8k6dcrpSIp5TuA+4F/YKx85z6PtpyrlFrdsH5Dw/LTUsqLgXevZ986kAf2klL+Sym1rCHtdOBqpdR1yfoTUsrvJ2X9YgLt+q1S6m4AKeUVGKvnhUqpnmTbnzF9AHBg8lmklKol6Z8GuqSUs5VSyyd4Li9USj2X7H85o/vdsqV4z1HmMxFam+CS09fdftLho1aHXMGZCTZBAGhNfOsj6A/+lDAMcZb3kq/2ERAR4RPj0c9UemiliX48+tFkiHGI8Ue5nR00DhqNQ4oAgE5a6au0MWtFkXQlpNhmptqJheCkWsj3jpREkaCWctCOQMSaWQPGrbykKWPEZDniJ8e4/O8hWTxnyMqZwtyWjUz0yC0Wy+Zie4xhtIIxQUp5EsZNvDOmX1LA3Zug6FUNy2VgbSIWG7cVkjZkMa7WN2IsX3GSNmRhRCm1Wkr5W+DDwJFjytoYSxpXpJRHA2dj3LJpwMW4hMfjCmA68G1gNynlLcCnlVJPY9zJR0opj2/I72AsdxNhbB+Nt23oJ+GCpK1rpJSNZVQx7uvlEzyXjeWXGsq37IgIgXPkvvD4RTSOL3bjGP34Siqf+g3pG5aSx6dGM3kGaGYNNbJUSOETEGBEYIBDhTQOmm5aaKeftbSbaoCWYm1YMAL0tzcT10OaI025HjGY9XFqIQ9nM5TzWdY2pTmcInecPXrKHYvFYtmSWMEISCnnYATR8cANSqm6lPIbgNzwnpucjwOvwljDliiltJSyi4agKSnlqzCxd5dhXNMHDcUcToBhcZnEJP4B+DRwWRITeQbwyfF2VEqFGLfx16SUrZh4xsswbuOlSRkffB7H+kJZihF47eOJ5a3oXFq2BxwHsfdsctd/ghzQGsfE/3gKXUgTPdXDmuv+S+bKx0kTI6hTJUNADjdxbNfIsMpxIB6JoowbRkF3N+dR83ei4jpUhpRqJSBCsCRrLIX7Vsvc8ckZW/CgLRbLi8VaGLdf8hiLWCcQSCkPwcTVPb6F29EM1IBuIJW4o1uHEqWU0zFxjR8Bfg7cCPyQ9buRN0QK47vqTcTiXpi4w3GRUh6JiXl8CKhgRNtQBP7FwO1SyhuTNmlgd2CqUur2F9C2DaGAB4DvSCnPUUp1JzGeRymlfs3Wcy4t2yHCcXAP3wMA76Xz2fmEA+AK6L5IseKzf+eWhXvx+gefJmpwUa9omsrKuR3Me6oTjeA/C2dSLKQoZVL8e7fZ/GduO5mBOtUwJh/F1D2XOpCKY16eq3HreVYsWiyWyccOegGUUo9jBpRcB/QBn8UIsy3Nt5L6VwLPYFyxSwCSaXCuBP6mlPpZYl17F7BISvne51tREi95OvB1KeUg8ANGDxwZy3TMYJRejDt3HvB/SVmPAG8CPpqkrQUup8GVvqlIjvvNmGv3PillETNS/IgkfWs5l5YdiI6PSg6qfprTrj2cZ6a1oJPBM2XXxa2H7LpiNX4qpNbksveyNRzw3xU8PXMq9y6YRuR7VDty7EnMkX0lXtPZxSuKRXZPR9x63vTJPjSLxfKCEGM+2z72TS8Wy5bF3nA7AMGaEk+97xbyezZT228nbj//aaav7iPSI18cNxyykEuPfMnw+u5r+knXIqpZnzY/5J7zN/nvLYvFsi6bRc2tFWePetZP0+dt86rRuqQtFotlE+NPb2Kv644dXv/NZZ3053Ps8pQZaxU5gj3WdLLX6h7+O7WVOf0lcoM1uly44cMt7DPLvqXFYtmW2R4tA9bC+CJI3rV8+HhpSqmxc11s7rY8inETj2WpUmrvLdmWRqSUZwJnrif59UqpO7dke7YC7A23g/KVw26htbtCthbQ01HAizVEEctmdLBkeoHf/WLhZDfRYtkR2SyWvzVjLIzTtwMLoxWMFsuWxd5wOyh/+tOfAHj9a97ARcf/i2hNmcFcmjd9cR8OPqpjkltnseywbBYht1p8cdSzfoY+d5sXjNYlbbFYLFsQL+3yyb+8YrKbYbFYLM8LKxgtFovFYrFYNiF2HkaLxWKxTJgfX7ycu2/vZ25Os9cxDhnfzDUflAJ0PSbVZge3WCyWbQMrGC0Wi2Uz8Mb3L+HGadOIF3aw/5puqpeW2bWyjF+d/GvyQUA6DkFoMqcu5JXffflkN9disWxStj8Lo52422KxWDYhcaR5z1sf4t+FFl7S1cdpjzzD/GKZQGseq05lTrGf2YP9TCuX6ChXGLjyaW6edtlkN9tisVg2iBWMFovFsokI6jHvfdtDPN7WSns14E2LV7JTuco+PQPkw5hDlywj8gV1z7xtuoqLV42oVAXLL7xvsptvsVg2ERox6rM9YF3SFovFsol492n/5XcH7E7oueza1T/qa6KpVKO/kKWnrQkRa6asHaSno4kp1UGmDA7S/blb6T33LvYd/Miktd9isVjWh7UwWiwWyybgS7dW+Pu0qYSRhjDmmY5mOnNmUIsTRsxY0U3kmUeudgSrZ7fSomscsHIZcwd6aYtqiFLI4+ICuo//BfV/L53Mw7FYLC8CPeazPWAtjBaLxfIi+OqddW796XP0pVLs6vjsPdDHsozPM1PyVFJpihEc+PCT9OZzpKgNWx21ELRWKsPlCCBNhEdM+PunWPr7ZbSzEm/XqeTv/yxuPjMpx2exWCxgBaPFYrE8b869s8537qgzWI3pqIXs43j4jk8uNraE+dWAKcu7yGioZNL8Z98FLN5pKi19A8xZ08m+K1ay39PLqaV8IgQuGg1EuMN1lMjRzx7MfnoVuvApMpQQlHF8D2/lxYgpzZN09BaLZWNsL3GLjVjBuAWRUv4ICJVSZ0x2WywWy8Qo1TUX3x/xnzUxDywJWLw6pNacgcgDX1CPBBU/tc7Xw9ximaGpNTo7WolqNe6YOZVo9nTe5moOXrqETCVk0Enhx5oYB41DhGYJ0xkkR4YyESHNDACgcYiDiHjqqZiIopDyogNwX78f2Q++FpFObcmusVgsOxD2XdIWy5bF3nCbmV89HnPjYs2r5ghO3dfhzDsjrnxMIwQcPQ/OPcxldUnz1uti1pSgNQWrKg0FDD0TG89UYjnEERBEiO4yOtZM1ZpyIcsu/SWINW1hhKshU60xMwhwk91C4MFMirXN+eEif//TX9JRrlDFp0QWlxiHGI+IEmlcwCFiAY+Rpww4hPjUKACaNH2khoXkxhFjV4Qw/z3X/K9HJm2XnUDuDPOmwVlvg6bEFR5G8NGfwvX3w0G7wM8+BLmGiccvuwVufxRetz+cdLjZ9v3r4aYHoVyDA3aGL5wA+ewEWmuxbDE2iylwuTh/1G05W5+1zZscrYVxEyClFICrlAonuy0Wy47MLUtj3vEX8zaVXzymUatjfvjgSPpPHoYH1kY82g2V5G6tVMYUIpLn+nCwoQbPMaJRAwM1oymFoFMIdusv80xrjlQUM+fZVey+ths/5dPd1kIMOFqTimKa6sFwFekgJBOE1IVLRWcAQYSLIMZtcEzHuKxiZ2aznDQl6jQlDRPUaMOn+MIm7dCMCONozGPrqZXmA7CmDy5LHCLnXw0/uNEsL15j+uPqT5n1a/4F7/2BWf7FbTCtBZashQ/9ZKTcmx+CFT1wxUefb2stFstWwDYnGKWUS4CfAEcBBwGLgXcCewNfAqYCVwPvV0qFUsqfAYuAVmAZcL5S6qqkrNOAc4H9lVJrpZTTgAeAs5RSG5xJV0qpgY8C/5vU/WopZRPwFWB3jFHhFuDDSqm1yT6XY1zSpyUi83zgPUAB6Aa+qZT6XpJ3H+CbwIFAGbgSOFspNfKtM367LgdcIACOB0rAJ4HHgR8DCwEFvFMptTLZJwecB7wVaAH+DZyhlHo6SX878DlgQVLeH4GPK6VKDefk0uScHAwsAd6nlPrnRto6H3P+TgE+A8wDbsecz88ApwIx8CWl1A8a9jsc+CqwF9ALXAx8Symlk2O5Ang5kAOeBj6jlLop2fcU4Czgu8CngSbgt8AHlFLRhtq7KSgWixQKBbu8mZYf7W4a1d//WbPuOXi4C2rP50wPCcjxzHha0xSE1B2HNz25jNZ6SDGXZVU+h075zKgHTO3uo32wxNwg5G9aU075vFE9xeqwlT15hmliFb26nR7ayVPFIaKEZkixekTE+FTJo7f0xBaPPAck/fzgktFpDy8d6f9Hl41Kqt73FJnVA+sUFz20ZFgMby3XjF3esZc3F9tjDOO2Oq3OycAHgDbgQeD3wKuB/YB9gWOB/0ny3gW8FCMYzwMul1LuBaCU+glwM3CllNLHiLKbNiYWG3gvcCKQB+4HasAZGNG6LzAT+M569j06OY6DlVIFjND6B0AiXG8Hrk3KODTJ/7kJtuttwDVAO0ZE/zg59rcA0zFffec05P8JRkgeAswA7gH+nPQJQD/wDkwfHp58zhpT56nAhzGC8ybg5xNsKxih+gpgLjA/qf8ZzLG/B7hISjkXQEq5N3A9cCGmn9+I6fP/TcpyMP22G9AB/Aq4Rko5taG+eUk/7IL50XEC8Pbn0d4XTONDyi5v+uVjdhZMSTyezSn49MscvDHP7VP3EbxkKuMzkRCdQpr2eoCvNfODkMOXr+K4/z4HmSyrWlu4a94snpnSzrOFPMtch9ZqldhzcbNp/u/OBznzD//goP+uZheW0aaLpHXADNbgU2OAHALIUyZFjQJFOugBIMQDQgQREJNmXUG2yTnl1eaQCwX4wOtGxDPA+1870v9vPQSac2Z5SjOZE14BJx4G2dExle57Fw0vby3XjF3esZctE2ebszAmXKqUehxASnkVxiJ1SGLxKkkpb8MIgauUUj9t2O/XUspPAkcAjyXbTgfuxVjVfOC459GObyilnkmWI4w4HWK1lPLrwPrEZx3IAHtLKTuVUmuAIXvIu4EHlVKXJOsrpJRfBb6GEX4b4+9Kqb8ASCl/AfwQ+KVSanmy7XfA/0uWpwAnAfOSNiClPBdjPT0YuEspdUND2U9LKS9O2tjIJUqpR5P9fwJ8VErZopTqn0B7v6SU6kn2/TPwRqXUj5O0G6SUvcD+wHOY83W1Uuq6JP0JKeX3k/b8Qik1iLEwDnGhlPIzmOvh+mRbBWOtjZLjuQWQmB8Mlm2YBa2Ch09xUas1+00VzGkWPH0aXPm4xndAzhC8eq6D1ppvqxi1RvPymQ6/fiLmsW6YnhM8168pBzEgGqKbhInhEwI8hxNXrGROfwkB9GVSNIcxpTSszvijRJUYoz9D36O12E/ZSeHoeHQaLhVMvOA0euighksNJzFtFliNSw0wg196mUqWLCnKiZPamOMFDNsnNSA8ByftwZRmyPiQy8DUgsk8tD3lwX9XQNqH9xwJrXnjVj5wl5EGHv1SeOy7xv38yj3h8L1H0vaeC49eBA8sAbkLzGiDBdPh0e/Ag0ugFsDO0+Gg3V7gmbVYti22x2D1bVUwrmpYLgORUqpzzLaClNLBWNJOxFjONMYFOWxfUEqVE4HzLeBUpVT5ebRjSeOKlPJAjEt6P4w71BgLxkEpdZuU8kyMpe63Usp/AZ9XSimM6/cwKWVfwy4CGubc2DDD/ZMc36htJP2TLC9I/j+U5BvCB+Ykx3U0cDbGCplO2rF2fXVi3NYkdUxEMI5t26ox6WPbe6SU8viGdAcTboCUMgt8HWN5nIL5WizQcM6BtWPcz6WG8i3bODOaBG/aZUS0zWtxOPOQ0XmEEHz8oJHb6YwDJuJsMQZ3eUmJqxbO53VLV+FqzdNT2tm5Z5AYGEh51LUgFWtiwItCRByjHQe/FjJ9dT/1lEeAw7PMpjkaJE1AJx1UMBa6CEE6EYYRKTxKCGJCMol1EeoImq98F97LFsCuM4dbONEHxAtm4Sz4/NvGT5s9xXwaWTDdfCwWyzbPtioYJ8pJwGnAa4DHlFKxlFLRYDeQUi7EiMofAhdIKW9USo0VLOsjHrP+a+B3wAlKqQEp5ZuAP61vZ6XUpcClSdzdORhX6lxgKXCzUuqNE2zHi2HodRK7jRHdAEgpU8AfMPF+lymlKlLKMzBxkZPB0qQdH1xP+seBV2HiKZckcY1dbKaRcJYdD/V/TUAT1aCFW54J+MiPBpiRyVATUAhj7usokIliYmDRs4PUhUOhWGbmyn5KGR8dCQLfpR42c13TIey8to8An3QUAZop9I66WAU1HGqIqWnqbz4O94xXkXnJ7Mk5eIvFMiG2xxjG7V0wNmMGn3QCTjLgYT/gzzA82ONq4CKl1BellGngKinlohc4AKIZY1ErJjF3n11fRinlQRhr3b2Y2Mdi0laAXwCfkFKeClyFcV/PB3ZXSt34Atq1XpLBPlcBF0spP6qUWiGlbMXEhN6UZMsAvYlY3AsTMzhZXAzcLqW8EbgRYzXeHZiqlLodcw5qmEFEqcQd3TpJbbVsx2R8hzcuTHPEBe0c+dHVZCLNgp5+2soVKimXnUpVZpUqFCpVcB3WTm9m/uNdCCBDCBqaBqEv1YR2BRWtgZiZZTHsWhbH7kn6p2/BtZN0WyyWSWZbHfQyUX6OGUDxNLACM6r2zob0H2DE5LnJ+hmYgRLnvMD63oexaBYx1sKrN5C3gBmp24URN68hGXihlFqNEWxvxri9ezEDe3Z+ge3aGP8P+C9wm5SyCDyMGQiik5jA04GvSykHMX121WZqx0ZRSj0CvAkTY7kK4xq/nBGX87eAPmAlZuBMmTGhAxbLpqQp43LPj2bx5+/sxN9mdDCvWEJ29jOjVMWLRpwQbhivY3MQgBtpEILIcYgdwez6Z5miv0qH/irt151sxaLFsg2ikwmvhj7bA3bibotly2JvuO2YL12ylh89Kjh2ZSdeHLFT3wC5Yhk3jomAnZ4boKW3Ygaj6GSgiqepZTxcHXHAh2cz6/wjJ/koLJYdis2i5paIr4561s/Xn9vmVeP27pK2WCyWLcYX/m8aB1y7ku9el6aYTnNQrMlkMqTqAXs8uox6zqOvKc/U1X1UHJ9a2qWecZmypsii+qkIb3t3+lgslm0VKxjXg5TyBsx8g+uglBp35POWQEr5TuCS9ST/n1Jqq5oaRkr5KGbew7EsVUrtPc52i2Wb5o3Hz6SruorFly1BCwe/HpAtV1EH78E+Dz9DoatMf1OGzil5UvWItq4ie15ymBWLFst2xTZvUFwH65K2WLYs9obbQbjtxi7++q1nyQYhA4UmvFzAoSeuYPUXXGqeS6ZcI18q8brrX0v7flM2XqDFYtkcbCaX9AVjXNKf3eYVpLUwWiwWy2bgiNdN4YjXTaFzdY1U2uGOu24EHP7vkTdNdtMsFstmZnu0DFjBaLFYLJuRqTPSk90Ei8ViedFYwWixWCwWi8WyCdleptJpxApGi8Vi2UxorbnktX9ndc0nG+URQcyhrSuZcvjMje9ssVgsWxF2WJ7FYrFsBm644FG+ftAtlAagpR6QimJ8obnphLtYfOkTk908i8WyGdkeJ+62gtFisVg2Me9764Pc96cu4nwGnIYvCyHIl+v8+8z/TF7jLBaL5QVgBaPFYrFsAoqliCPeu5h3vvNphJuiVsihXYfmrgpO8orAbLFKjCZTjvj34b+f5BZbLJbNhbUwWiwWi2Udjv/yamZ/aYBVHS30NaWppVI8194K1ZDcQJ2+TJ6aTjFtaT8DzSkqeY+ee3rpfqIXgKirRFSqT+5BWCwWywawg14sFovlRXDYx1fQHXq8stxPfybFTTtPQy7rQXW0EO4+m8P27uLA7gEAIlfw0ocWE/pQKaR4fJ9fMSdaC7iECJoYpGPVmfgzmif3oCwWy4tie5yH0VoYLRaL5QVw74qA7Kd6eSJMcfSKLub2llgTCfyuEqqjmcB10EJw18wp1BwHJ46pFjKsmNVCf3OWYiHD6mktaFKAi4/GI6Rnpy/SIz5Cp/gIpXuXTvZhWiwWC2AtjBaLxfK8+Owtdb72jwBCQQeCIzp78LXmjo4WnizkklwjMUsOMOep1SxY1cvama349XA4reKnhpc1LikC0tSJEZTJE7/sm1QpoRftTHZ6Ht6/CF5hX8FusWz9bB9xi41stYJRSrkEOEspdYWUcj6wGJijlFo+qQ17EUgp3wWcr5SaP0n1vwK4Uym1/V3JFgtQjzSuANcZfYkP1mPqoSafdki5Jm1xX0iTB71V8F1YVYRiTXPvGlgzCLcvjXh6AKqBhiCGWINwIO2B7+NFAX05n39PaaV1TQ9Vt8FhUwvJ+sbC+JpHnuNlDz4HwNS1RZ7ZYwrZagWA9vLg8NeKR500Jo5RoMlSAQQxTXg3P0XMIMGV/0EQ4lFBAwIBaGJ8QtJ4beC8ZB7sOoPYz+D0DSDeewTs1I5Y0wdhDPvMAc+DQhae64K2HHQ0m7SUB6Kh7wYrEMeQ8iEzIm7XIYogSvJZLJbtkq1WMFosFsvz4bv/ifn4rTFZD357jMPrdzYC7g3XhNyw2ORJORHfPVLwgZs18dCOWuNUAtzeCghB0JGDlAvCAzT4QEoYwRhqI6iimDBvXvm3LOPzVxyagwAn1sSOYOdiiWNXdvJUeyuHPL1qVDvr6TRxysElZtbSFdTw8QjxiRMRSPJ3RLgF5EgxSJoyAWki0njUAE2dLF3sjsbF660y7fYncG5/dKSEX99pDpON2DwEMK0Vrv88HLALnP4j+NHfRtI/8Dr4wfvW3e+mB+Bt34BSFb7+bvj4sRuqxWLZIdheRkY3YmMYtyKklPbnucXyAqgEmo/dGhNpGAzgY7cZOfhQpx4WiwD1GD52W4NYTHB7KwgNItaJVkse9kKMLDsCBKSiGKfxyek5lDMeKQ2Hru3hA88s4/iVnfjAvP4B8GLioSKIOfihp2gvVth92Ro8oE6KMjlCfEo0E+IS4wwHzWsgwsMoVw+POj61YUEYk0LjAhCSoUrBNH3MMW7060sDa/rg81dBPRgtFgEuvhHuf3bd/T5+OQyUjYXxkz+HYmVjNVkslm2QSbUwSik/ApwOzAJ6gSsxbujoRZSpgQ8BpwB7Ag8C/wOcAHwcyAE/Ukp9PsmfA64AXp6kPQ18Ril1U5J+PnAscLBSqiKlXAjcA7xtKM8G2vIy4GJgIfAA8Lcx6UuAy4BXAy8D3iulfBz4LrA34AJ3A2copZ6RUk4B1mBc8yullEcBNwOnKqV+JqX0gB7gKKXUvVLK3YAfAwcCzwI/G1N/DvgqcDyQBe4CPqyUek5KeSBwG9CulAqklO8FfgIcqZS6VUo5HVgJ7JT022Lg3cDngDnAv4CTlVKjzSvr9tEpwFnAD4BPAC3AJUm7LgWOTuo5TSl1V8N+/w/4SFLXs5hz9rckbb/19WGSfnmyvYq5LkrAeUqpSzbU1k1BsVikUCjY5U287DqQdjWV0MiijJPMezjOEy7lwAYlzVg1OYQ2YvIla/pZlU+zoq0JABFGnLB4BU2xpiwEXqx5trmJtlqdOZ29TB/op3tamkw9JnbAG4wQcUx+sNpYOALd4GaGgBQOMTXS5OgZzjlW+Lk0TsejE8vjiyCXBtdBO8II6EayqXX7P9vgqk554DmTfj3YZbs80eXNhbUwbnqWA68HmoHjgFOB0zZBue8C3gxMxYiCvwNtwC7AkcAnpZQvT/I6wLXAbkAH8CvgGinl1CT9i0AX8INEYP0OuGgCYrEFuCHJ3w58DPjAOFn/H0bI5oHrML/zz8GI6PnAIEbQopTqAh4CFiX7LsII3KOT9YOBELgvEY9/Ah4FpgFvA94/pu5vA4ckn3nJcf5JSukC9wM14ND11LUIeEQptbahvBOBVyZtbwLO20AXNTIPaAV2Bl6BEfw3ABdiztu1NIhdKeX7gM8A70zSPw9cK6XcNcmy3j5s4G2Y/mlP6vu+lHLeBNv7gml8SNnlTbeccgVXvdFlQQu8ZCpc9npjrN+tTfCRA8SQcZBdWuEvxwta04wibMuiHYF2BQhtxOHYTxBDMaApiNhvbZGXrOxjt7UDHP3MKpoSYeUIwc8XzuPaXWZx+cJ5PJdLI2KNryHyHbTrMJBLsfNza9ChJsJYHXNUcACPcHiqX4eIPtqokKdGbtjiGOMRYkSaBnwqNLOSDL20sxg/iW9stFA2rq+LANeB6S3w8j3gm6eA6yK+f9pITGNLzmxfOHvd/v/x6bDffJg/Da74CGTTk3492GW7PNFly8SZVAujUuqahtX7pZS/BI7CWJheDN8cGhwjpfwdcAFwjlIqBh6UUj4IHAT8Uyk1VkxcKKX8TJJ+vVIqklK+AyOg/gGsBs6dQBvehLFcfU0ppYF7pZQ/xYicRn6slLo/Wa5gBOEQNSnlucDDUsompVQJY1FcBPwi+X8W8F0ppUjWb1VKxVLKQ4EFwKeUUhXgKSnlNzFWO6SUDsYieKxSakWy7aMYC+XLlFL/klLeCiySUt6JEdofBj4JnJnUdfOYYzk3EbVIKa9i4uK/kuzbeH7uVUrdnZR1BfA5KWWLUqo/acd5SqkHk/2vT9r6dsygoo31IcDflVJ/TJavlVL2AS8F7Dwm2yhv3s3hzbut+xv4oiNdLjpy9LbeD43N5WMM5VAJYlIu3L4s5uE1mqseh3+viSCIaInqpEJjgpxTrNLrOkQNloQVTVn6k8EhkeNw+27zOPyhZxPrpMmntcBN5FuESytFvMSs2WiV8AmYwnJiYtJUgIg4GfIi0ISkoT2NGCiT3a9A/uAFOC/fA162O+w2ywxWqdYRucwL69DTX28+G2O/BfDAt15YHRbLdsr2OA/jZLukT/r/7N13fCRl/cDxzzPbN73cJdc73HF0HnoVAQug0kSkI/4QlSIWVJAmiiJ2QUFEQYoFUARFAREBBeGhHOV6yfW79GSz2WTLPL8/ZpJswpXcXcol932/WDI75Zlndm9nv/t9nmcGL7s23a9LGK/5cEflN4O2A7V+MJI/r8ivQwy4FTgRqMRrkCrCy04CYIzZoLX+A16gcmyfsjZnIrDSDxa7rNjEejX5T7TWM/Ayawf79ejavhIvAH0GuEdrXQbshpd9uw7YBy+IezBv/7XGmPbN7H8MEMVrzu06zjatdS09TcrPAOcDjwDNeNnSn2uty/EC+0v6HEv+6570698fm3p/+r6H+OW14AXCt2utf5K3ThAvY92f17BvXbe1vmIUi4W8oPPYKQ7HToErDgIvoAQooCNTzNxvt9LU4dDiQnl7msJ4mlg2x7imFgJuNTm/k2OBaxnb2Ekom6WtIIzjWsry+vgpIEGcQlJYFCFCBMnhkCVEGwGyXhD5nbNQnzsWFQsTDgTeU+f3zgEcB7Y3WBRCiD6GrUlaaz0JL7N3MzDOGFOC149tqBv+rwKOxguASowxpXj9KbvrobU+GrgQr7/h7Vrrgn6UuxaY4mf+ukzbxHp9g89fAAlgb2NMMXC4P7+rnOfxms4/j3eJnAxeYHcKXoDUlfVbC4z1m9E3tf86vCbn7nla60K85uvV/qyn8TKtpwJP+31LX8BrWq/26zIcVuL12yzNexQaYy71l2/tNRRiu0VDAZZdX0bjLSXMrFR0xMMsKi3h6fJSZjS2cOEbizhgXR0fXryS2fUt5IBAziXWkaUo0YHrOnnNy9BJmGaKaaaYBsppppB2HFL77I7quIegvY/g1SdCYQw2ESwKIXY+o/Fe0sOZYSzEC1jrgIzW+hDgXGDBENejGC9wagDCfnN0addCf3DHQ3gDLO4F/g78HK85d0uewBt48WWt9Q+BvfD6aG6tR3oxsARo9ge59OoH6A+8eQmvafg6f/Y/gd8C640xS/x5L+MFVt/xj2k8Xj/KrnJcrfV9wDe11vPxMojfBxYCr/jrLNdarwauzDvefwLfBF7Ka94daj8EbtBaL8Eb1BTFG9hTb4xZyFZeQyEGyqIvF3PkzXW8Fo5RXZfgrbIS9m5sYbfGFlylcKzL6mnluCEHN+DgZF1c5bD7wnVEMhkaSqMUZzsY09xOiAwhkoxr+RrB4vjWdy6EEENo2DKMxpgFeANKHsMLVr6KF5gNtR/4+18HLMNr/qyB7n5+DwBPGWN+7TebnoPXr+9TWyrUGNOM18x9Jl7G8id4gebWfAE4EmjFy+Y9sYl1nsYLiroG3jyH1wGru0+hMSaLN7p7H6AWr+n6rk3sywCvAqvwRjx/pM8o9Wf8sv+V97yY9/ZfHDLGmF/idSP4Nd5ruwr4Bj3thv15DYUYEC9cO4azJ2bJFYSIKhfleo9gNksw55KOBXH9i3q7QQerLEtnjSMTglNrz+H4pk+zr72CPe2XmGlvkGBRiFFgNGYYlbWjsWumEDst+cCNUtZarrttNctMO1MbmxnT5iXgA+msdw1HbyXCyQ4ykRgnXTGJaRfOGcYaCyEYpK5K89WPep3r97BXjviocbgvqyOEEKOCUopvfnkyD/5+NmrfUpLRCJlAAHKWUKqTQDpLJNlBKJ1lyqJ1EiwKMYpZ+nNJq5FlxN0aUGv9JF5z43sYYwqHuC7v4l1DsK+Vxpi5Q1mXnZXWejIwfzOL7zfG9L02pBAj3re+N5sVbzZx35XvEAgqSppSuI6DAqJtaY55VW6fJ4QYWaRJWoihJR+4XcxTN85j8e9rKGrPEO7McMbyMwhu6hY0QojhMChNxe+oH/c61+9prxjxTdJy1hJCiEF0wvX7cML1+/D4448DEQkWhRAjkpy5hBBCCCEG0GgZGZ1PBr0IIcQgcjM5nr9xHo1/kd4IQoiRSzKMQggxQLINSdZd8iQNj6xC4dBcEGdjSSmNZQWkwyFaX4W/PvYiJ959xHBXVQgxiEbjz0MJGIUQYgCsOvBO2k0DcToJUEaripPqjFLY0Ek4lSXY6dJUHmHVyxnq322icm7ZcFdZCCH6TQJGIYTYQcv2uoPqd15lAm20MoYNVNNGGGUhkLWEUjmSpREaq8vZWBzjumtq6IysJdTZzievm8NR+xcN9yEIIQaQ9GEUQgjRS8djb1H8zkIKaCFAjiCdlJFglt1IpdsKgLKQLIpilcv4uiYmb2hEqRAdheX8+ts1HHHuEmrWdAzzkQghxOZJwCiEENvJWkvLx+4jTjsQBSK0MZaAn18ot0lCNkPcpilsT1HQmiSSzlDenGDSuo0oIBGNcmhLksuvXsWF31w3vAckhBgQo/Fe0hIwCiHEdrA5l3bnfOKkKCCFd/1fB0ugZx1gvNtEQbaTzpB3unWVojMWIeBaXGuJd6ZJh4JMyuRoXdDGIVetIZdzh+WYhBBicyRgFEKIbWSb22kNXooiiu3TFTyL033/2CwOdZTS5sao2NCBBZrHltNSWYaNRVCdGVYXF5EIhQCozLkkOoPsfvkG9r5yHYmO0TjWUojRT+4lLUYUrXUNcK0x5n6t9VRgBTDJGLNmkPd7BPCCMWZ05OGF8LmvLKH5sB+Qy8UIEifrZxNTFBEhSTtFJCjD4hAgR7OKkbXeOtGOLKGsQzbsBYcKiGYzrI7H2BAJoxyIKVhRUYxjLSWJFOU3tWFDAUKOxXw2wtwxcsoWQgwPOfuIfhvKoFOIAdHaDr/9N7QkIRiApjZoaYe/vwGREIRjUJ8gd8BU3OcX4STaUK5LDoccEbLECJEiQCeWEIo0BYRJoXCJE6ATlyCdFLGQPXBRxMjiosgSJGB75xYc64K1oLzfUk2RCAA5C7q2icpMlsnN7dQUF7KsJEY24gWXOWDPu3MQsJBzoTMLkSAE/N9kfnl07U8p72EtuJZQJkcmFAQsBBxiASiLQDLrZT+KQ97qp8yCHx4bwFGKZNpy77uWWBDOnasIOvL7T4j+Gi39FvNJwCiEGJ2sheNvhFeWbGaFEF2nwMC6VwjkNRw5uITIYkl2n/YtWRQQJIVDjgAJHCwuihpmUEkDxbSRoIhWinFxAEvOgaaKKK7jkAgHUekMrdEwK0pLeGNMOQAHNTQzpd0bJb1HUwt1sQhBN9pT1bADfh9InIAX3QU30aNIqfc+V/jBIoAXRKZyilR7z2qtae/vT96A12tzvHBWkBMfzfFv/2fhv9cofvOhAEKIXZcEjCOc1voK4FJgAtAEPIDXDJ3bzvIUcDNwIVAENADfN8b8FJjnr7ZIa22B7xpjvqm1ngX8EjgAWA78up/7OgZ4BjgP+CZQDTwCfB74PnA60Ap8wRjzaN52HwO+AcwA1gM3G2Me8JdNBO726xIG3gKuNMa85i+/ATgS+B9wsV/kz40x1/f3NRIjRHNyC8Ei0CsDsOleRmoT0+0U0Uo11awFvGEuITLUU0UxCVwcImRwUbQTor46RqIoSs5xqJ9Ywf1zZ7K8tIhoJsuh6xqpSKcZn+rglfIS3i0uoLojTaFrqU520BoJknMcCPYJBLcl27eNHahe3widWdsdLAL8o2a09MISYqiMvgyjDHoZ+dYAHwKKgY8CF9ETCG2P44HzgYONMUXAwcB//GX7+H93N8YU+sFiEHgceBcYixfkfWYb9hcAjgH2AuYAHwReBv4MVAC3APdoreMAWuvjgV8BVwLlfl1/prU+yi/PAe4ApuAFoK8Dj2qtQ3n7PApYBYwHTga+rrU+fBvqvN0SiYRMD9V0aQHsO43Ns5uY2twaPdMtVJEm3mu9FDE6iNJMCVnCOFgsijhZ0hEvM5eOhFlaXsryUu8i3R2hILVFUSakOllcUsAzVRWsj0V5o6yYmniE96+t5cIFNcxsSaDcvJpYCx3ZnubnrdnG7609KyESVBw4tmek9hHjst3TO837K9MyPQDTov+U7e9JR4wIWuvbgMnGmI9vz6AXP+v3MHAO8JwxpiNv2XvK8AOtZ4EyY0y7P+/TwF1bG/Ti7+tfwFhjTJ0/7w9AgTHmRP95HEgC+xpj5mmtnwBeMcbclFfOT4GYMeY9gbLWuggvSznXGDPfzzCeYYyZm7fOq8D9xpgfb6m+A0Q+cEOpqQ3ufsb7GwxAYxsk2uGpeRAOQlExNLWRmzsJ979LcNqTYC0uAbJEyBEjTJIgHVgUKWI0MIl2KimhnkJaaKSc9UwkSoI9eQ1FjiYmUMtELAFWVZSwprKUbDDA67tP5Vd7z+qu3pzGVvZsamNdOMh/ykq654/PpDlnxToySvHshDHMm1rpLXAtZF3vX1FAeT+Puvor9tXdhxFC6YzXLK0UBBRhx+u32J7ziiwMgePAidPhlycECDiK1k7LL9+yRIPw6b0V4cDoy5gIwSClAl9TP+91rj/AXjriP0DSJD3Caa3PAq4CpuO9n2G8DN12McY8p7X+OnAt8Aet9UvANcYYs5lNJgK1XcGib8U27DLXFSz62vECvK76tGutwWseB5gGvE9rfVXeNgHgBQCtdSXwA7ysZSnQlSYZk7f++j51SOaVL0aTskL48se2ulrAf+Q/D/VdyVoKXl9G+sBbcW2QTmJESQEORbQxgzcJ0cFyNYslag4KqHDbmNzQwsbyErJKsefK9ZwcDvFGVQUF2SxVGUtTNEoIS1VHmo3RMLFcjmwowD8nVLKmME57NEhRS4r/XBplrwnh7Xwh3nM0W1UcUXzxwBH/HSeEGCASMI5gWutJwP3AqcCTxpi0n2HUO1KuMeYu4C4/u3cD8CgwmZ7gK99aYKzWOp4XNG6pHXBHrQR+Y4z53maW3wKMw2tSX5+XYZRvPrFjlEIdMJNy9y7KWttpKf0iMZuliATt1BElSZowi9UeoJR3zUUnzthAM8FMBhUMUNSc5Nxn3+QcR/Gno/ejvrgQgCCKcCzEFJtjQ2mUuqylrSDEgitjTC6V07QQI81obEqSM9HIVojXKFUHZLTWhwDnAgu2t0Ct9YFABHgV6AQSQFcHpjq8oHEWXt9J8LKZK4HvaK2vxusX+IXt3X8//Aj4tdb6ZeC/eMmgvQDlZ0GL8bKUTVrrQuC7g1gXsYtSxXGK2n/EhqKvUB8az9TORSiX7huBdV1Sw7XQqArpCIUIuC65oGJDVQm1VeXEoPsSOy6wvjiGVXDouo089+OJBDY1CloIIYaJnJFGMGPMAuB64DGgGfgq8NAOFlsE/ASoxxshfQLwCX9/KbzRyQ9prZu11tcYY7LAR/AGxNTiZSPv2sE6bJYx5ing/4Dv+XVcD/wQL3gG7/UY69f9LbygcrtGjAuxJYFohPGdP2JyajUxNwNAiAwT7GqUtTjWJezkaI3GsHmjmjuiIZJFBRSl0+C6pBUUpTo4YclaLu6o44XbJ0uwKMQINxrvJS2DXoQYWvKBG2USd77G8s88yzhqKKGVNMXUMoGVRWPIZIMEMlAztQQ34N0ysDPnUFdaxBuTxvLKrIns3tAC2Sx/unUclWNjw304QuxqBiWae1X9ote5/kD7mREfNcrPWCGE2AFFlxzAuH0tzYyniQl0UIKDw/hkM+moQ8B1mbqyhaLmTlTWpX1MIY8cPAczcwJTm9u47CDLC7+ZLsGiEKOI3EtajApa6yfxLl79HsaYwk3N34F9tW1m0QvGmA8N5L6EGC5j3/gKuVm3ElqaJOMPuI+4OXZrqWV+6QQc1xLN5AgnXCLpRl57JEZsXAneQH4hhNj5SZO0EENLPnCjWHreOlZf+CSpt+oJuYqUCrExWkp7LIrFkgkoqk+cwNH3HLX1woQQQ2FQmopfVnf2OtcfYi8Z8U3SkmEUQogBEt5nPDNe/1SveW4mx1s3vsmS+UuJfjLK0adLsCiEGHmkD6MQQgwiJxRg35sPIHphHCcip1whdgWjcZS0nL2EEEIIIcQWSZO0EEIMkucP+j3BBbUoXJKFlUS/P6BjyoQQO6nR2FldMoxCCDEI3rnsOXLLW9kwrpKKbIr9m1bTfF2WVf+rH+6qCSHENpOAUQghBlimOYX9+SuUphMcuGQRTdFCXpo1h0RlEX/95EvDXT0hxCCTPoxCCCG2amX595iUa2BqYiPJQJx4cxb9zgp2W7GR9VPHsHF1+3BXUQghtokEjEIIMYBWXPYshbYThywbQiWkbaT7RDuxtoFINsu3z3+DpfNbhrWeQojBIxlGIYQQW1T8s79RQiOtFBLMOGRdhQVcIOM4jK1rQhUUcM3NtTz2cO1wV1cIIfpFAkYhhBggy4q/S4ROGhjD8qJJvDtxGp2xMOuLimmMFoALemENU9bXUpzN8sxvVnP8mQtoSbnDXXUhxACSe0kLIYTYpLrJ11OU6GR1bCxrC8fxt8MPJhcIEOlMc/ArCyAC7eEwDVUlLJs+iQiwpKKcf5eXsPtVG3GjDvOuLWdcRWi4D0UIId5DAsYRQms9EVgNTDPG1AxzdYQY/ZIpcm+vouWyBwmZRUTI4uCi8JqXsxTgkCNDEEuMAMU0hwtpCBezpnAMVRuaWTe+nM5ImA1jyqje2EQqFOLN2dO6dzEj1cHqtiArK4pJhYPMvS1JNu2yx7paOoujLBlTRiYaBOsyNgpJN0AsqphaGuBHxylmlimaU5ZcTjFzrJzOhdhZjJZ+i/nkDLMT0Fpb4EhjzIvDXRchdmpNbXDBT2HhWrj4OPjyx7z5qU64+A54dSmcdijcco43P5GCi34Gb6yA9k5Y39SruPc2FTnQHRJaHCBOIQEKAUUnDg6dBOkgShKIEcaSo4MsxRSlM8xKN1DVkmL9ikqWzhjHq/tNZ/GEMdQVFTB1YwO5gOq1fzcSIukEIGtpUkECEZfq9g6KGls58/VF/PSo/VhXVsyarANZlybXYV07HHS/7elUpACbgaz1pgNb+LJ6z6L3rts1p+v1mVgEH5uheGqlZY8KxU2HK678l2Vdm+WK/RVPr4S36y0XzHX4+iE9PZ1+8lqOr71gscCXD1TceHhg8/XajFfXW059LEddCvYfC4+fGqAiNvq+jIXY2UnAKIQYOW74PfzlVW/6K/fBsXvBATPgh4/Dgy9487/zKBw5Bz58ANzyCDy8+eseqvc8c8jvdeSicAj5yyxx6lH+Mi+DEPDXVbiEsDgooIR2Wulg0up6njhsLumSIgA2jCtjclMzy8ZUUBeP8r+xZXS6vcPWHA6PzZgCrmVWUwtR10LID7TCAT+mVZBzvb/d1VdedRS952+HvoH0mgT87E1v7uImyzv1lqXN3rLPPmO717/mRZdjJikOm6BYm7Bc+a+eZTe9ZDljN8ueY7atbqf/JceaNm/6pfXwjRdd7jh+2wNPIYaSZBjFDtFaXw58AagEWoF7gRP9xU9prV3gd8aYi7XW1cBdwNHARuDWfu5jKrACuAC4GpgC/Bs4239+EV765JvGmNvztjsSuAXYA2gC7gB+YIyxWus4cD9wGBAHlgJXG2Oe9re9ALgW+AnwFaAA+APwWWNMbiv1/Q3e11wGOBVIAl8CFgC/BGYDBjjbGLPO3yYO3AScBpQArwCfN8Ys9Zd/AvgaMM0v7y/AVcaYpL+8Bu+1fT9wMFAD/J8x5r9bfYF3UCKRoKioSKa3d7ql9/UL29fXE2fGe+anNjQQg/fM31aWAAqXrkBS9QqleqYVOfqGWRbIRBXpcM9pti0aYW0syj0Tq70ZOQsFEcjkNhnkLSkroSq8mcrtYFC4I5KZnum+wWVLpyWRaCOVLXzPsg3N7ew5pgDo//ueSMd6ldHcaYf/36FMj5pp0X8ySnqIaK13A74DnGSMKQLmAn8xxuzjr3KCMabQGHOx//wBIAdMBo7CCwC3xWnAEf72U4H/AcuA8cCFwI+01pP9us0F/gZ8DxiDF8R+HjjXL8sBHgVmARXAQ8AjWusxefubAlQBM4ADgTOAT/SzrqcDjwDlwDfxAsWbgFP8Mi1wQ976d+MFkocA1f6xPaG17hot0AJ8EigFjvQf1/bZ50XA5XgB59N4wfugyz9JyfR2TF99Cowv96ZPPYT4hw/0pi/7MMwc500fsyexTx7jTX/xIzDF/2ca2Nrpriez2BXoBMjSQQhFBouik8Jey6HTn3YIkMFicYFW4oBiSqKW0kSye+0xiQTLInkRoAVclwlNCQI5/7eVteBnHYszGWpL4t3Pybk969g+4Zi1XgCay1vWd53NzeuH/au8vxOL4LajHUoj3vNz91BM8t+ek6Yrjp+qKCoqYmaZ4uw5PdsfN0Xx/pnx7uf9fd9/eKzq/qIqDsPXDw4M/79DmR4104NFRkmLHZHFayyaq7VeaYxpBl7e1Ipa6wnAscBMY0wL0KK1vhF4ahv2901jTKNf3hPAicaYX/rLntRaNwH7AauAS4E/GmMe85cv1Fr/DDgPuM8Y04aXYezyPa311XiB4d/8eSngOj+juFRr/U9A4wW+W/OsMeavfl3vA34O/NYYs8af9zDwaX+6EjgLmGKM2ejPuxG4Ei9b+KIx5sm8spdqre/wjyXfncaYd/3t7wau1FqX+K+32FnNmQgr7/QyhxV5J/2JlbDwJ9DcZ/70alh2hze/NA4L1no/f9I5iAbhydexyTTsMw1V14z99zuwtgm3vBD7vyXYVfXEqSdDFIdOAmTJEMTFQZFFkaPVKabDLaaENhSQJE6aEJ0EqLLtfPcPv6OhoJDnZu9FJhKiULn8Y9qk7irObUzwbnlxT52VJRJxcC0kigsobOsg7rpsLIx5QW8m662GJew4dOIQVor9x1qmFoHZqBhXCBGVY9+xineavBbtshDklOKM3RVmIyyqhyklMK4ASqLQloG9xsLcCkWnq4gGLGsSltKoorrAIR5SNKYsxREIOorTd1ckM1AWVWRdS0sn7+lbeP+JQX5yrEvWhbEF25efOH9ugDN2s9S1WyYUKYLO6GvqE2IkkIBxiBhjlmutz8YLzu7WWr8F3GSM2VQQONH/uzJv3opt3OX6vOn2Ps+75nV9s04DjtVan5q33MEblY3WOobXJH4iXnO662+bn2Gs7dP8nMwrv991Nca0a603Vf/8ugK85a/XJQRM8ut7PHAdXhYygtfk3fcKyfnld6WAivCyk2JnFgz0Dgq7BPoxf8/JvZfNntSrp5G66Dhvk75FbKE6Ff7fV2PforKjkySFZAgxngaCeBnBMckEs2vX8sb0mRQCJ2+oY2lRAdNSnUxv76CkM81bxYV8fE+HX15YguMMbuPPR3fv33pjC3o/L88LCMMBRdh/YYKOoqJ3y3HeNjt+LPGQYkqJBIpi5JA+jGKHGGMeBR7VWoeBzwCPaa0reG/Geq3/dwpeMzL0BEqDYSVwjzHmc5tZfhVeX8r3AzV+v8Z6NjW8cvB1BdGzjDF1fRf6r+2f8fpS3mOMSWmtP4/XL1KIQXNg6hreVt+ljVJCZEgTIkpPZz+b1+dwXCbHxOYEClhdEOUjHy3jPx8p3kSpQgixc5CAcYhorXfHC/qex2u+bYHuO4ZtwOsf+CKAMWaN1vo54Fat9YVADPjGIFbvDuDfWuu/A3/367UbMMYY82+gGOgEGoCw3xxdOoj12SxjTK3W+kHgDq31lcaYtVrrUuB9eH0RAaJAkx8s7oHXH1OIQbdH+1W8WHI3kWwO1zqkCZEMB2mOFPDWBC+72RyPkYxGiCVThENZ/nzv7GGutRBioI2Wfov5ZNDL0AkD1+M1hTbjDbg4zRjTAVwD3KS1btJa3+mv/0m85tTVwAvAfYNVMWPMO8BJeP0A1+M13/6GnibnH/h1XoeX8WzHG1k8XD4NLAKe01ongLfxBtlYv7/lpXjBdhtwO/DgsNVU7FICsRDV+ygca1E4rI5X8FbFVFYVjmHsuiYWVI1ldWUFJS0JDpytuP33+2y9UCGE2Akou50j5oQQ20U+cLuAl9QPKXRgZWk5bZFo9/zG8kIaS4uYdmo1Z1+12zDWUAjhG5SuVf9Uv+l1rn+/vWDEd2qUDKMQQgyw2Y9+kFXxMtZVVXTPcxVEOzqZO28VZ105cxhrJ4QQ2076MI5AWut38QbE9LXSGDN3qOuzJf7I8Ds3s/gSY0x/LrsjxIhSdsoconoxrIOGyhLCnRmCHRmi7Vnin5wx6KOghRDDazSOkpYmaSGGlnzgdiEPTf4dq6qqyIaDjK1touDULJ/87qlb31AIMVQGJbJ7Rt3b61x/nD1/xEeQkmEUQohBctaqnpsdPf7443iXCxVCjHbucFdgEEi7iBBCCCGE2CLJMAohxBCwWUugIYO1FqVGfOuUEGIL7Ci8haUEjEIIMQiu+eYqlr7bRtpxmNDcRlVtIeXNbTx5xW+Y9cDRzPrY9OGuohBC9JsEjEIIMcCuvnYpJc+vY59gAKsU6wvi/PnAPXAdh+qmVj573vOUvO9lxjz6CVRAegYJMdrY0ZdglIBRCCEGUmfGpfntNgqVQ0NhARGgANi3oZnCtnamrVrPO7tNZM7f/0M6dC1ZYHLnjTghGRAjhNh5yU9bIYQYQBd9ez1HvLOCE5+fR2Emi8K7bkdlRwfpogJKXZcj3l3KU9Pnkg0FyAZDNIe/RNt3nx3uqgshBoh1VK/HaCABoxBCDKCq5xYxd/k6AMKZbPd86w90SYbDrCkvoyzh8lLlnuQCAd4pm4H96mM03/bccFRZCCG2SgJGIYQYIOdeupC9mpaS9e/kcuhriyhKtJN2HNrDYQK5HBPW11HVnGTKxiYqWpJsCFfSSZhWSmn8ynO42dwwH4UQYkdZp/djNJA+jEIIMQDWNWWYn43y1w+fyZWx1zho/iqaohH+WV1JZWOSE95cSUcsRFGyk+L2NGCZna2liARxWnBwabNxloduYOqCSwnOHj/chySEEN1GbcCota4BrjXG3K+1ngqsACYZY9YMa8V2gNb6HOBmY8zUYdr/EcALxpjR0SHDp7W+GwgaYy4Y7rqIkennD9dz/UtQN20cX3r+TWLBAG/uPY1Xqyo5dslKDn99NY5/o7Cg8pqpQ2QoIkGEJI5/X4hC2nEJkZvzFVIBRUHbPeTa0oQqC4br0IQQ28EGRtXXJDCKA0YhtNY3AEcYY44b7rqIncvKdRlaEi57zAjxxArYkITqAsu79Za5lYr5DZb/rYe3ai0NSUi5EE8lKUomWVta4V0zw1EoYEJzglhTmobyQm9wS7KDjOMwf+I4iIRZPHMKB7y7gXhHBgeXnHLIWZdAyOXZsXPpCIbZs2k5e7TWAJYIbSwrmElENVNR/CnimTY6gQAKJ+9W5ApQCiiOQjINkSCUFsDHD4PPfhgWroEn34CxpXD1xyAa9jZMtMPP/wEzquC0w4b2hRdCjFgSMI4iWuuQMSYz3PUQYmf21H+S/PDeZqyFZbuXs/Q993e2edM9WYLWWCGtsULIul7v74AXvq0pL0aFMlgUdLq8NLmK6a0pUhEvQEvGo7w1eyKHvrmMIC7efwGWVIyhLRIDYHHxePZsnYdDlgBBJiYVBTQToBMXhSKEF566QN5H3AItHd50Nu0Fjj/8q/dA4VVUwc/+Aat/7q03+RJoTnrT5x0D916+4y+qEKIXdycbGa2UOh74BDDWWnuyUkoDxdbafl+eYUQHjFrrK4BLgQlAE/AAXjP0dvca11pb4DLgAmAOMA/4OHAGcBUQB35hjLnGXz8O3A8c5i9bClxtjHnaX34z8BHgYGNMSms9G/gfcHrXOluoy0HAHcBs4E3gqT7La4B7gPcBBwGf0lovAH4CzAUCwMvA540xy7TWlcBGvKb5dVrr9wPPABcZY36ttQ4CjcD7jTGvaq1nAb8EDgCWA7/us/84cAtwKhADXgQuN8as0lofADwHlBtjMlrrTwF3A8caY/6lta4C1gHj/NdtBXAe8DVgEvAScL4xZv1WXqOpwJ3AwXhfn8uBTwL7Al8HHK11m7/63saY5Vrri4BrgDHAY3jfrFnELuGv/05iLWSV2kSw2A+uhXCg53na9YJFAAuPTZ/E1NZ29k+kuldJlIZpKwhTluzonpfLO/3u3/w2Af+foCJLlDSdjCFMA0HS9ASujv9w+1HRrgv6APUJeH2Fl13sChYBHnlJAkYhRjml1GXAFXjfwaf7s1N4sUK/mxlG+tidNcCHgGLgo8BFwMUDUO45wMfwAooO4FmgDJgBHAt8SWvd9SI7wKPALKACeAh4RGs9xl9+PVAP3O4HWA8DP+pHsFgCPOmvXw58AfjsJlb9NF4gW4gX/FjgBrwgeirQhhfQYoypB94Cuppoj8MLcI/3nx+MFzi95gePjwPvAmPx/pF9ps++fwgc4j+m+Mf5uNY6ALwBdAKHbmZfxwHvGGNq88o7EzjKr3sBcNMWXqIu3wZWAVVAJXAh0GyM+b2/7DljTKH/WK61PhK43T+WcuBpf79DIpFIyPQwT0+s8gK1gLWEcv0JvPpSXpax+2mfTELWUhOJsCgWoSUcpKyllcqmFlLhQHeY5wLlje3Esp0o61Lc2d5nDxaw5IjQO+PJJp73r8pt5VGYMyE/aQrVpTvN+yLTMj0c04NlJxslfSVwnLX2O/T82lwI7L4thShrt+Pks5PSWt8GTDbGfHx7B734GcaPG2P+6D//LPAdoNQY4/rzXgEeMMb8eDNl1APnGWP+5j+vxgugNgANwAldZW2hHmfjZe+mGGOsP+9bwNldg166MozGmM0GVlrrPYG3gUJjTFJr/T2gyhhzntb6VeA2vF8Z1cB1eFm407TWh+MHysaYdr+sTwN3GWOU1toBksBH8rKphXgZyqONMS9prf8ILMALmjcAlwNfMsYcqLX+NdBojPli3vtzkDHmVb+szwEXG2P228rr9Bu8QP0rxpgFfZbdQJ8+jFrrXwJRY8y5efP+AywZokEvo+cDN0K1d7jc9+dWmlpd9jm4kG/Mc2hMeV0A2zJQFIZ1bdCatvhxW9f/UNZiXRdyXh/GokwHN/3jT3z9/aeSVkEKOzK0KP/bIeQwO5HgY28vZ0lZCR96fSHj1ieJdObIKUW5bWWSs4YCN0WADCGaCZDBJUqOQrJE/AxjCksAupuke04dm2z0Cig44zBYvAHmr4F4FO66BE47xFt+/3Nw3e+hsgge+yqMKx+kV1qIEWFQ2o7/UvJAr3P9R1rOHrY2aqVULTDOWptTSjVaa8uVUlFghbV2XH/LGelN0mfhZdem4x1LGK8JdkflN4O2A7V9Arx2oMivQwy4FTgRL8Pl+su6MowYYzZorf+AFzAdu7Vg0TcRWNkVLPpWbGK9mvwnWusZwPfwsoVF9AQolXgB3jPAPVrrMmA3vOzodcA+eFm/B/P2X9sVLG5i/2OAKF4TcNdxtmmta+lpUn4GOB94BGjGy5b+XGtdDrwfuKTPseS/7km//lvzZeAbeJnNAn8fXzPGtG1m/YmA6TNvU6+rGKXiUYfPfKK0+/mH99n2MlxrWVifY2NzjD/vdSqxlzKMDWQ5dG0Dfx1bQWJsIYQclhSF+IMTJJyxLD2hnANr1nL0a8sY19BOK4U0uJWsjwXYEC+hnQi7t69kYmojijRBkmRRZAmS+snFlF16LKAgGNhq/bbonGO8hxBi0Oxkd3d5Hvgq8K28eZcD/9qWQoY/UbqdtNaT8JpabwbGGWNK8Joah/pdugo4Gi8AKjHGlOL1p+yuh9b6aLym0nvwmqb7c42MtcAUrXX+8UzbxHp9g89fAAm8TGExcLg/v6uc5/Eycp/Hu0ROBi+wOwUvyHwmb/9j/Wb0Te2/Dq/JuXuen2EcC6z2Zz0NHIjXx/Fpv2/pC3hN69V+XXaIMabOGHO5MWamf6zHAF/xF28qMF+L11Sfb1OvqxCb5SjFHmOCvG9WmB+fWkzD9yrYL9hByHU5qbYOQt6pNRdwqCv1PkKdoSBNsTDjG9pRQDHtlJGiKtXG3Mb1dMZDLCiYQasTpGnWNOL2V0Tt/UTtHyi77AQIBnc8WBRC7IouA05RStUARUqpRfSMy+i3ERsw4vXZc/ACl4zW+hDg3C1vMiiK8QKnBiCstb4OKO1a6A/ueAivw+mn8fpd/rwf5T6Bd4xf1lqHtNb74/XR7E99kkCzP8ilV3O1MSaFl/37El5AB/BPvD4O640xS/x5LwMrge9orWN+5vILeeW4wH3AN7XW4/3A8vt4/SJe8ddZjhc8XtlnX18GXjLG5PW+3z5a6zO11tP8wLoFSNMzgGUDMFlrHc7b5D7gdK31+7XWQf/algftaD2E+NPN41kWi1LSkcFxexoGCjq9Uc3KWvSS9X7/RIjTMwAmaF2KMimKOtspuPlEpiz+6tBWXggxoKzq/RjWuli7Hi95cybeoNDzgYOttRu2pZwRGzD6/dWuxxvo0YyXbn1oGKryA3//64BleM3VNQB+P78HgKeMMb/2g6xzgOP8UcObZYxpxmvmPhMvY/kT+hdofgE4EmjFy+Y9sYl1nsYLLLuCuOfwRip3ZRcxxmTxRnfvA9TiNV3ftYl9GeBVvIEn4/D6NOaPUn/GL/tfec+L8/e1g/YD/o03uOdd4HW8fpkAf8QLWDdorZu11tOMMc/j/dq6G6+/5QeB3w9QXcQu7tHvjkO5LiWpzu7+j4l4iHP/+xY3/P5ZjplfQyaqKKGFQN7lcTKOQwaHPTqXUf41uWyoEGJgWc//rLV/tNa+bK3d5hF/o2rQixAjgHzgRrlPnfI6f9x/Ngn/QtnKWv70vT9SVe+NzGwoiTEtu5rpyXVkCJF0YjRHI4xJ1VPh/mw4qy7ErmhQ8n9/qnyo17n+lPqzhnPQy2o2891jrZ3c33JG9KAXIYTY2Vz5nd1Y/N31vDh7MijFMQtWUZjqQGGxQEF7J/MqZ1AXKSWa62BK60bGP3QaxR/Za7irLoQYnc7p83wcXje5321LIbtcwKi1fhKvyfY9jDGFQ1yXd/GuX9jXSmPM3KGsy85Kaz0ZmL+ZxfcbY/peG1KIYbXX7oVEW1dyyv8W0FlcyOSWdv580GwOXryGZDDI2pI4EeWSa+vkgLUJyl/+HOGDNnUaEEKMVO5ONEjaWvvvvvOUUs8Bfwc2eXnATZEmaSGGlnzgdgG1LS4XXfAuuXCAmrJiVpQU0ek4VCVTXPLqu0wmw6deOmG4qymEGKQm6UfG9G6SPq1u+JqkN0UpVQbUWGtL+rvNLpdhFEKIwTa2xOGJP/U0Mb/0VC2/vquGKWsS7L13ESffJQPzhRjNdqbrMCql+t7cIw58GO9ucv0mAaMQQgyyQ08YS33n/wA4+eT3D3NthBC7mEl9nifxrvDy220pRAJGIYQQQogBNNzXXsxnrb1wIMqRgFEIIYaAm3FJf6aZ55ruwB0b59i1Fwx3lYQQo5RS6tj+rGetfba/ZUrAKIQQgyyXs2QvaSHW6rC2qhqr4OXwD5n93GmUHtbvy6AJIUYIq4Y9xfirfqxjgen9LVACRiGEGGR37/sXqpMOtVOLSRZGAHi7aCbZY/7MEenLh7l2QojRxlo7baDLHLG3BhRCiJHg5sOeJdyWoTzTTkcs1D2/IxpibWUF717z8jDWTggxGFzV+zEaSMAohBCD5NMffo3Stk4CriWazVHZkOheNqGpgXQoQu2PXxvGGgohRjulVLFS6gdKqdeUUiuVUqu6HttSjjRJCyHEIDjqnCXsFQqyYvoEFJAsLeLAt1ZQ0ZKkgCRTEhvpjHSSyhWQ/N4zFHz5uOGushBigOxM12EE7gAmAjcB9+PdKvDLwCPbUohkGIUQYoBdeNwrFIfC2HAIpRSuUiyePoGa6SUUpdpoTUUJqDomdK5karaGuq/8G9KZ4a62EGJ0OgE4zVr7GJDz/54JnLsthUjAKIQQA+DVBW1UXbaRqZespXniWIpdl+ZYlGQoSCoUoiMc5qXZc2h0S5iRXcpYW0uIDDFaiJFkeeSr4LrDfRhCiAFgVe/HMHOAFn+6TSlVCqwHZm5LIdIkvQvRWk8EVgPTjDE1g7yvc4CbjTFTB3M/Qgwlay2PL+7gsYXw6jrL/NocubQl2JEj4FpygSBlIUWsI+1toBRZxyHo31XWsaCwOPQODAtopZgMjYHPkUEROHNf4h+aQ/wTB0EkMsRHKYQYZeYBRwP/BF4AbgfagMXbUogEjKOE1toCRxpjXhzk/RwDPGOMkX87YkjUtVuufdGlLQPXHuLw9xWW/6y1nDRDcebuiuv/61LTAp/dV3HM5J5Gk0ufznH/fEsqY8mlLTgQCirmVCqWNlna23LgKAj727guoLx5ANZCpwuuhYDyHkEHbIB4Z5a5tQnGlMVpjIVIo8h25MBa2pWLS0/zTWcgQDCbA6CqtoWwm6OGGVRSSyGtZIhRSCOgiNHG65V70vZCC4f94cdkL7A4WDIqiINFWUsgL9h0AVc5uMoh7GZ7XrQbzkRdf6Y3/eMn4IX5sOdkmFcD766GdBb2nQY/vgimjB2Ed02IXdtOcB3GfJ8Guip0OXALUAqcty2FyJe+EGKnds7fXJ6q8VJ0Ty7P0dTpzX9kieWxpfDnpd7zvy63LPu0orpA8WOT4xfz/LRe2v8bdMgAb9UDKAg5XhDYdWJ3nJ5pgLQLOX/brPWCReWtv9fGBBtKomwojnnLI0Fo6IBQgCQRFlrLzLZ2rFIkwg6F6QwB1+IGIUQOcJjH4cRIsg//pedcDijFO5V7UJRpY7+6t73ibU8waPPWDgAB64LtnbG0N/wezj0aXloEV97jv2B9Lt+zsg6Wb4C3frTV90AIMaKttNbmAKy1dcDF21OIBIwjjNb6cuALQCXQCtwLnOgvfkpr7QK/M8ZcrLWuBu7CS0VvBG7t5z7CwM+AjwFRYAPwdeC/wJNAQGvd5q/+OWPMvVrrg/BGYs0G3gSe6ue+LgCuxUuRfxEoAe7E+wV0F3A8sA64OD97qrX+NHAF3k3VlwNXG2Oe8pftA/wEmIv3nfoy8HljzDJ/+W/8+R3AGXg3Yr/JGHNnf+q8IxKJBEVFRTK9DdOLG23369cVLHZZUN+Ty2vPwpoEVBfAq+szdJ/erO3JGuZzVO8AsW9GwFo2J+haOoKB3ttGgl40B7xdVsiEjjQKqA841BUXcNy6WprHlGD0TKat3Mi0ulpCZHFxgCxeY7VlUekM73iC8c3uf2sUwJL1dL5dwxYbtBevH/b3V6ZlejinB8tOdu3FDUqpPwIPWmu3uxVSBr2MIFrr3YDvACcZY4rwAqK/GGP28Vc5wRhTaIzp+vXwAJADJgNHARf0c1cXAAcCc4wxxcD7gfnGmHXAh4Ccv59CP1gswQskHwbK8QLaz27DoU3BS49PB44ALvPL+x5QBjwK/Drvdfg/4GrgbH/5NcCjWuuuDrwWuAGYAEzF66txf599ng487tf3MuBnWusp21Dn7ZJ/kpLp/k1/dt+e09TJM6DUj4AmFMKXDgoQ9BcfPgH2HuNNf+mgMN3hXEB5mcK+AWDab27u0nd5OJCXylM9Z0trWVxZyKSmdgJdg1TSuV5luUqxpjjK8uIo86Jh6oJB3IBXQG11Ka8dMIMgWVJEeStwMBmCWCzvlu9GU6yceCbJ3IYFXfEnmw9dN80GHDhmTyIXvB/KCr2Z0dB7V/zcB4f9/ZVpmR7O6V3ECXjfgw8qpWqUUrcopfba1kIkwziyeGkImKu1XmmMacbLnr2H1noCcCww0xjTArRorW+kf5m/NFAI7KG1fskYs3or65+El6X7rjHGAq9qrX+FF9D1Rwq40RjjAvO01vOAV40xL/vHcj/wNa11iX8sl+NlBOf52/9Na/0v4BN4A23eyiu70z/ut7XWBcaYpD//WWPMX/zpR7XWzcC+wMp+1lkMkS8f5HDCVEVbBg4bD7XtML/Bsu9YRVlUccwky9o2OGQchANehLdvlcOK/4N733Vp6nBY3WxZ0Ain7W45dEKAeXUu72xUrE1YXqmFVBZy1kLWBeWHZy7eGTLgeMFkxvVGrVhLXTxEQ6yYcEcWN2uxGett53hBYWEuxzsVhbhWMaMxwUdqGyhMtNNWXABANNVBiyrwdpUL8QZHU0oroXSCjy59gopUI65VPFc5l/0bFpF1okRVlmi2A+VXzYkEoDBKa2kF6rDdKWpohAWrYL+ZqAcuh0gIZk+EBT/x+i3uNQkWroPaFmhugz2nwMG7DfXbKYQYYtbaN4A3gK8opY4GzgL+qZTaYK3du7/lSMA4ghhjlmutzwYuBe7WWr+FFzhtKgic6P/ND4BW9HNX9wNVwA+BWVrrfwJfMcYs3cz6E4GVfrC4rfsCqPWDxS7teEP+858DFOFdGmAacLvW+id56wSBNQBa6xl42cmD/W266lWJF9jSp3z8+bvcz86RYp+xPe07VQVQVdDzfGaZYmbZe7eZVOxw7aGbbkT5wLSBa1ypTWQZf2Mr8VQaVRCl1YX2eAjXv5bGsvIiWldtZL+1G9iQrUBZS1Ei1R2XArgEiJEk2NZGVcOtOOXeP8X39WP/JVtboarUewCMKd22gxNCbJedbNBLvkXAArwrpszalg0lYBxhjDGP4mXEwsBngMe01hW8t9Vqrf93CrDMn+7XzciNMVngu8B3tdaleP0Z78Fr1t7UheLWAlO01iovaBzwG5/nWQlcb4z542aW/wKv3+PexpgGrfWewNv0GlkgxMAYWxQke1s5AImOHEd9bi3LomV03QTQcS3xTAaFpbqhidZ4nIpEgs6QQyTjYvEGwhQ8fgHlJ23TZdGEEGKr/OsungZ8EjgEr6Xxu8BftrDZe0jAOIJorXfHC8Sex2vGbcELFF28gSmzgBcBjDFrtNbPAbdqrS8EYsA3+rmfY/2y3/L3k8RrDsffT0BrPc0Y05VFfAJvkMmXtdY/BPYCLgL6DFEYMD8EbtBaL8G7vlQUOACoN8YsBIqBJUCz1roS73ZIQgy6omiAN341mdPvauaF5R2kgw5HrakjiqKpuIiq5lZmN6wjEY+wW2YJa5iMAiK0SLAoxCiyE1ysO986vEGrDwKnWmtbtrL+Jsmgl5ElDFyP15zajNeX7zRjTAfewI+btNZNWuuu0b6fBCJ4qecXgPv6uZ8q4LdAk7+vKcAlAMaYxXijoV/RWjdrrc/1+1KeiHeroSa84PHnO3SkW2CM+SXeiO9f+/tbhRcMd/Xq/wJwJN4o8hfwAlohhszD/1fKU4c0csj6ZnavbaSioZnithQby0qYP3kC5bkG4nQQwKWzqJM5yS8Pd5WFEKPXDGvtcdbaX21vsAig7BYuHSGEGHDygduF/OLGRfx7keKY1xYxtqGVskyKkOtS0tZOlgApggRKsxzUdNlwV1WIXdWg5AJ/Pf2RXuf6C5eftnPlHLeDZBiFEGKQfOb63TnCbaSwvYNcIEBjOE5zKEqLipHFoTYW5sDGzw93NYUQYqukD+MuSmv9Ll5Tc18rjTFzB3A/k4H5m1l8vzHmMwO1LyF2Rp/73SH8+KAWJqxsBKCkM0m5TdKBxR44GbXzjqYUQmynnawP44CQJmkhhpZ84HZRj0++k3EbExRkcrREYjTPqOSD73xyuKslxK5uUEK7e2b0bpK+aNnIb5KWDKMQQgyF28ezri3H8QceQ2xm6XDXRggxiHam6zAqrxnjYrwLdldaa/dWSh0FVFtr/9DfcqQPoxBCDBFVGJBgUQgx1G4CPgXchXerYPBudHH1thQiAaMQQgghxACySvV6DLMLgJOstb+jp1vUCmD6thQiTdJCCDEEsu3w2u1F1Nzwd9pDYV4dV84fHtkHxxn2LxMhxOgWANr86a6AsTBvXr9IhlEIIQZZJp1lzW1hLv7vfzjt9VfYf80K5iRSfODsRcNdNSHEILCq92OYPQn8QCkVge4+jd8EHt+WQiRgFEKIQfadj73MnutWE8zluOvYY7njhBNYOL6acTi8/+zFw109IcTo9gVgHN4tf0vwMotT2MY+jNIkLYQQg+jeGQ8yKRKkuaCA5WPHMm+Kd/nTbDDIumiYSXVNw1xDIcRAsztJVxOlVAA4HW+EdDFeoLjaWrthW8uSDKMQQgyCXEeO+8c+RCAbIOnE+e+s3VlXUQF5174tSWdpCzosXt05jDUVQoxW1toc8ANrbYe1ttZa++r2BIsgAaMQQgyKP41/gGxBiJwToDDZwcS1tTy9+2zmRcO0KMWGgEO9o0jGo9xy0SvDXV0hxADayUZJP66UOnlHC5EmaSGEGGD/jX2fZNXkXreQiHV00hgMUBMOMSGbY3wuRxZwlUNhNomZ14Lep2S4qiyEGL2iwMNKqZeA1eTdccxae15/C5GAUQghdlQ2R+JzD9F81yusLpjCutJqMqEATs4SsBYLONkcczc28EZlGWNzOcA7AdfFItx+zDHc/qhL2Z+aWX1NCfHQsGckhBA7YGfpw+h7x3/sEAkYRTetdQ1wrTHmfq31VLwLe04yxqwZ1ooNMq31RLxfXdOMMTXDXB2xLTJZSKSgvGjTy62FuhZvuiQOze2Q7PAeIf/0984qSHZCcRTWNEFDK0yphKUbsM+/g0ql6QwXkDErCWVSuIRQZHGJoHAAlwgpYkQIUERDMkhFugMno0jFwlibIxULgVJM3lDPKQUx1lZV4lhLxnFoiIa9LxcnQGMuTPU1LRTkcqQKwrSEgoAlGnSZ3tZKSyTCnjMKOHfPAGtXtbM+FuekGYrxpOkMBmnOKWaUOyTTkHMtOA67lyuCjiLR6VLbDpOKFR1Zy/o22K1coYa/uUwIMYistTcORDkSMIpRTWttgSONMS8Od13EAHtjOXzgJqhrhXOPhnsvh/zgpy0Fx1wHry3znjsKXLvpsvqwgPIfrZQQZzURcv6ynN/UnMUFEtECYh0uDinqqKSNAkIZy9iGdrLBduorY1Q2JWkPh2koLKCwo5MxyXaUUrSGgiwqLfACWwvxbI5EPEIi4FDQ1sEeiVbmjy2lIxhifukYUIq16yxPrbX86J7nmGHhpLOOoyMehrTr1dxxIaC841UuBSG45kC45jkXC8SjipSrsEB1HBZ+KkBJRIJGIQbUTvRDTCl17OaWWWuf7W85MuhF7FS01qH+zBOCmx/2gkWA3/4bzNLey3/3Yk+wCP0OFoFefQ9DZAn6wWLfZS9M25+SjmT387Zg70ynVTB34wamNzRQlWyjIJulvaigO6tXnMkSzmS9ullLezDYvYNkQYSq9g4CjvK+fLq+gJTCOg63nHYUhy9ezcmvL4Gsm3ec9Fo/mYFrX3C7Oy21d9ju6Q3tcMcbedsKIUajX/V5/AX4O3D3thQiAeMuRmt9hdZ6odY6obVepbW+RWsd2MEyx2itf+WX16q1fk1rvbu/rEJrfZ/Wer3WeoPW+l6tdXnetjVa6+u01v/SWieB07TWz2mtf6S1/rPWuhX44lb2f7nWeoV/TGu11t/258/zV3lKa92mtb7bn1+ttf6L1rpFa70Y+OCOHP+2SCQSMj1Q0yXx7nkoRVvA9l6npICB4G7hNNkSL2bB2Jndz9dOLKMrHLOAyigyNsjb4yfy5tQpNJQVE8pku9fPWcv0tXW9LrXTHc0FFNWJJAF30wFdxC+nIxTsHcVuat0tfMILVM8lfYb9PZVpmR7i6cFiHdXrMZystdPyH3gX7/4W8LNtKUdZ2/9f3WLk01qfBrwO1AD74v3KuM4Yc+f29GHUWjvAi8B64LNAHbAnUG+MWae1/juQAbpGYt0PYIw50d++Bu8+lx8B3sQbzfUksD/wMeBfQMwY076Z/e/mb3egMeZdrXUpMNsY87K//D1N0lrrfwKteDdkjwEPA4czNH0Y5QM3UGqb4cKfwbKNcPmH4bMf6r3cWrjyHvjNs14GryTu9WdM5zZZXK9N86YzBEkTJ0YbDi4uXr9ChUsyHONbx1/OnhuW0hkMs7J4Csc88xY9sasi50BHKEQuoFgzrYz2gggbqipZVRjn2THl1EfCBIBcPNS1CQQc9mxs5phl67hv7xkkCyLkAj2Ba0FHmlvve4oNpUV889SjvE9Qxt9pwM8uOuA4oKsUtx2l+MRjORpTsP8ExYpWRWMHHD8FHjslgLMTNZ8JMcQG5R//z/d+ote5/tK3TtqpPmRKqSCwxlpb3d9tpA/jLsYY80je0ze01r8F3g/cuZ1FauBAoNIY448u4C0ArfV44APAbsaYJn/eVcBCrfU4Y8x6f/1fGmPe8KdTWmuAh40xXX0rNhks+rJ4H/i5WuuVxphm4OXNVlbrCcCxwEy/vi1a6xuBp7bloMVOYGwp/PXazS9XCn78Ke+xjfLP7GH/gbWQThOYv4bOGx/BeexlIukOvvGPH/PU7KOJZYLsPf8ZGp1xBHK57lJyygv0AjlLUXMHnQVhStpTPD5zMqmgdwrOWUtFW4qOSIhkNEgwl8Zmk5QfE2fxxTHK4gHCgfxMZwi+cQoAN/XzmNZetkMNCUKIbbATXHtxa47H68DSbxIw7mK01mcBVwHT8d7/MFsIsPphKlCbFyzmm+T/XZE3b1nesq6AsWYT225q3nsYY5Zrrc8GLgXu1lq/BdxkjNlcADjR/7syb96KTa0oRC9KQSQC+80g8uevdM8OA6f4050r6lg8/U4SqoyYzWGxbAiUda+biQRYUF7K+tJiJifbWVRSDMC4tnZSJVFuPSXEZ3XUX3szI7+FEGIbKKV6XXsRiOO15n1uW8qRgHEXorWehNckfCrwpDEmrbW+DS9LuL1qgLFa62JjTGufZav9v1OBrhEJ0/ssg03/yun3Lx9jzKPAo1rrMPAZ4DGtdYXfjN23CXit/3cKPcHrtP7uS4gtiUwbw172Wl4/6jeUvLyGgkyacDZDk1NEa2GU+w/Zg2eneb9ZSjrTfHj1etbFotSHg2y4sZjIljobCiFGDKt2qiEi5/R5ngQWW2v7fmdvkQSMu5ZCvIFOdUBGa30IcC6wYAfKNMBreNm9zwP1wFx6+jA+BXxfa30+Xhvd9/GC1fWbLXEb+INrpgHPAymgBS9I7Ao4NwCz8PpZYoxZo7V+DrhVa30hXh/GbwxEXYTosv/zF/Df+PchUkJ7KExtvJSN4yp4p6qye52WSJhnqytxLRy5ZiORyIRhrLEQYhQ70Fp7W9+ZSqmrrLU/6G8hO1UILAaXMWYBcD3wGNAMfBV4aAfLdPEGrKTwBp80A7+mpz3tHCABLPQfzfQMgBkIYbxjWu+XfTlwmjGmw19+DXCT1rpJa93VT/OTQAQvy/kCcN8A1kcIAA5r/yINkTBJJ4qrFBurK9ittecSPMq1pJWiNJPlbw/tPow1FUIMtJ1plDRw3Wbmb6ET+HvJKGkhhpZ84HYxCx5YzCM/XUNzdSUO8E5pEc2hIC+VFhGwoBubefmeqcNdTSF2VYMSzf1s/7/3Otd//vUPDnnUmHfB7seBk+h9rNOBb1hrp/S3PGmSFkKIQTTn7N2Y9K9G1jUHieVyzGlpozUSog0oS2eZWSW/IYQYbXaSUdK/8v9GgXvy5lu87lqXbUthEjCKrdJaPwkcuallxpjCIdj/L3hvp90uexhjVg12HYTYEefffQgvnjKPjlgMiyIRDDA30U55Nsntt+4/3NUTQoxC/kW6UUrdZ63d4a5g0iQtxNCSD9wu6vHHH+f+P04l0BlibFMrc95XziVfm7n1DYUQg2lQUoE/1f/oda6/zHxgp0g57gjJMAohxBA554waTj755OGuhhBiF6KUKgZuAI4GKskLkq21k/tbjoySFkIIIYQYQFapXo9hdgfe7XZvAsrx+i6uAn64LYVIhlEIIQZZJmd59oFKCjZmmB1by6zj5JqLQoghcwIwx1rboJTKWWsfU0oZvNHT/Q4aJcMohBCDyFrLZae8QdH6NG2Owx03reCB8Q9x69n/G+6qCSEGyU52HUYH76YWAG1KqVK8axdvUydqyTAKIcQg+ubXFnLw4hoOXLSKWopxUWQdxfTfvc5r503lgA9UDXcVhRCj2zy8/ov/xLtZxe1AG7B4WwqRDKMQQgyi5jeSzFhXT70qJEqGcbQwwW1FAYvPe2a4qyeEGAQ7WR/GTwM1/vTleHdmK2Ub77omAaMQQgySKy9ZSE1JjEvPP4nTv3oGNmbJEiBNiJAL0+oTvHb3O8NdTSHEKGatXW6tXeZP11lrL7bWnmmtnb8t5UiTtBBCDILGjSkSG9qZkbMc+NYyJq3cSCBrcfMu+xZyLakvPAUX7zmMNRVCDLSdIKvYTSmlgIuBs4BKa+3eSqmjgGpr7R/6W45kGIUQYoB1Zlw+/NUNNBcWUNqRZs7ydey5cgPRTM5fw7umbzrgUNJmqVE3Dl9lhRCj3U3Ap4C7gK7rLq4Brt6WQiTDKIQQA+yIi5fRWFrC2MYsAMFsrnuZAhLhMDjQHgvSaS2VzfVsVFdDJEvBURMp/OtlEJLTsxAj1c6UYQQuAPaz1tYrpX7uz1sBTN+WQiTDKLZIa12jtT7Hn56qtbZa64lDsN8jtNZDchs9rfW1WuvnhmJfYvTK5CxXP9zECRevojIUIRsN8b/qCpqiEd6eNZmOsBcArq6uYMnkStZVFVGQSzO2OQkEiJCmoDOL+/RK1odvYKP6Kkl1Lh0fvQ2bF3AKIcQ2CuCNioae29MW5s3rF/kJK4aU1noq3i+bScaYNYO8rwuAa40xcsPeXcTvF7osaYJPzFbMLPN+4Wddyz1vW+raLaEAWKu4eG9FRaxn+Q9NjrvfBmshEoQgluUbM7QFggStJdiSJpDJ4oQDZEKKYMZlYnOKqmQHb5YUkLGKymyOyZ2dpGJhWkIhxiTSYC3/njyeQzbW8+gHDiGSydIeCTFt+RpyYQc3ANNa68gRIUgCBQSwxJx20m6IJOOJ/+VdwqGPY1EowBLEEsbFARSWLA4WhcUGwTl0GpkZ0+mcMYv4eXvjlERo/OpzZFe3UvLFg4lMLiDzuzdxZlQQ+sR+/Xth1zXCvf+C6lI4/33gSK5BiC3ZyTKMfwN+oJT6AnT3afwm3oW7+00CRiHEqPCT112ueNYF4Mevw/wLA4yJK6541uWON/OT1ZYHF8Kb5wVQqmt539IUOCFAkW7PkM4ABCGroDjC4as3snt7BwAljW08VllKeyDAuKxLW0BR1JH1i1FkFTwyfQIoOGxDI3ut3kAw52UM45kMm/pa2VhSjgo2M6tued5y69csjcUBwrgEcYAAKSCHyubghflEXphPB+Op/cUb2MII6UWNgCL1t+WUlHYSbEoA4K5rJXLV0Vt+YTvScOQ1sHyj93zROvjOuVveRgixM7kKuA/v4t0hvMziU8hldcS20lpfobVeqLVOaK1Xaa1v0VoHdqA8pbX+ltZ6nV9mjdb6Mn/xPP/vIq11m9b6G/42s7TWz/nrzwN0P/dVprX+o9a6QWvdorV+R2t9pNb6UOAXwHR/P21a62P8bU7UWs/35z2BdzP2IZFIJGR6kKafWZ7pnq5Pwbv1XoD17Mr3Nue+VQcr673WmOdWb6bnQ1eGIOP2zHMtZFwm+8EiQHk2Rzzn4ipFzoINBcgvcWVxjPWFMdYXxPjL1HGEG5I4rldmBkUWhcUhSSEdwRANBcU8sc/hmMn7bjKY9CtCVwBpCWBxgd7HGaGV7NoEmUUN0FWShUxTtnud3HPLtv7arqrvCRaB3D/f2vL6Mi3TI2h6sOwM12FUSlUDWGtbrbUfwxvwcggww1p7irV2m14ICRgFeKOlPgQUAx8FLsIbgr+9jgfOBw42xhQBBwP/8Zft4//d3RhTaIz5ptY6iJcafxcYC5wOfKaf+/oyEAem4F2I9FRgjTHmJb+M5f5+Co0xz2mtpwOPAt/21/8J3kVNh0RRUZFMD9L0ibNC3dPjCmDvMd5J+kPT3/vb58BqmFJZCMAHpm7mZG79sC+cd5oMKAg51Id7GmdaAg6pgENxNkd5NsvMphTryiJUdHQyLpnCsT3hYybgcPehezFtSQNT19ZjMwFeqZ7G+ngh6Xgrt374bH5y/MdZX1pJVaIOoPsyPF2leI3PQSzecXkhp0PfBqMOSghOKyW899ierR1FaEyke53gB3bf+ms7ZQzM7rn3deDDB2x5fZmW6RE0Pcr1vZPLL6y1r1prN2xPYdIkLTDGPJL39A2t9W+B9wN3bmeRaSAKzNVa1xljNgIbt7D+wcA04MvGmBSwRGv9fbxLAPRnXxXA7sAbxpit3eroLOAVY8z9/vOntNZ/BiZsfhMxElyyj8OkIljSBKfOUpT7fRS/f4yDrrY0pCyRAGRcxbl7KJTqWT63Ised87wYMRqCoILFazLUESQcdwh15nCzLkEngNPcxrzqIqI19cxsaKXTCTAjFiIVCpNxHAqzWQ7Y2MJuzf6Pd8fy5OQqco7DwWtrOWpRDRMCDcRbMyxVVdTHilhbUMFedW9y0csP8tqkfRibqOOYxS+SxaGVKqJkCJLGoQOXIMrrsQhkcMkCDgoHG4vhnDCHzIzpBKZMo+rjc1BFYZq/+SLZVQmKv3Ag4XFxMo+87fVhPGmPrb+wkRC88C146AWoLoMzDhucN1CIUWQn6cPYtxLH7EhhEjAKtNZn4fVxmI73byIMvLy95fmZvK8D1wJ/0Fq/BFxjjDGb2WQiUGuMac+bt6Kfu/seXp+Me4FxfhPzV/wgdXP7qukzbwUSMI4KH57+3kYTpRSfnLP5k7dSik/tHeRTe/ddkn96jPRdiPc7pYe1lovvbGDeG1Ccy0EuB4EAs5rb2K2uCazLjFXrcVzLCzN2Z3yyhTlr11IfKyJgXTooY0btKmbWrqSZCpKUESBL6Z2n4ly8bQNNIn1qXP6dY3svv+LIfpcFQGUxXHbitm0jhBhuA3qlEQkYd3Fa60nA/XhNuU8aY9Ja69voZx/CzTHG3AXcpbWOAzfgNQNPxut81ddaYKzWOp4XNE7r536SwDXANVrrav9YvofXmXdz+/pAn3n92pcQW6KU4lef8brDHn5xDWtiYd4cW0EiEuSC+SsobWnDcf1+h0qxpHo8GysrGLOyEaIuLcRonTCXqrtOp+LD/cj8CSF2WtbZKTKMQaXU++jJNPZ9jrX22X4XNsCVEyNPIV5f1jogo7U+BDgXWLC9BWqtD8RLcLwKdAIJoKunfR1eIDcLr+8keNnMlcB3tNZXA+OBL/RzXycDS/H6arQBHXn72oAXiBYbY1r9eQ8B1/lZ1T/ipeg/Cmwu+ynENvvP3VM58dxlrCmJkwoGaQ8GKQgFsfScqbOhIBuKCpj6Ri3xcBtT7beGs8pCiNGnFrgn73lDn+eWbbh4twx62cUZYxYA1wOPAc3AV/GCqh1RhDeYpB7vH+gJwCf8/aWAbwAPaa2btdbXGGOywEfwBsTU4mUj+9N/EWAG3oCZVrym5pR/DADPAk8DK/x9HW2MWYY3qOY6vOP9AnD3jhysEJvy8O2TiViXExatpCSZwg2HaKkopb0gRmtZEZ3xKKWtCVSojcM6Ltt6gUKIEWNnGCVtrZ1qrZ22hcc23elFWTugTdxCiC2TD9wu5MtXL6X0pXV0xqJUNLSQiYQpbmyjMxTgj4fvwSn/fYNTL5jAlC/sUA8QIcT2G5Ro7rvHvNDrXH/1c0fuFG3UO0IyjEIIMUi+992Z2JwLjkNZQ5KZC9YydmMLk9Y0EujsZNaSBiZfccDWCxJCjCg7Q4ZxoEkfRrFdtNZPApscammMKRzgfW3ufpcvGGM+NJD7EmKgrdl3LHZdjvKyQopbvDFd6aDiC39+ngm/fh9q5+gcL4QQWyRN0kIMLfnA7WKstZz58QW8W17K3HUNhNvambuujqmHlHLWvUcMd/WE2NUNyi+2W479T69z/deePXzE/zKUDKMQQgwipRS/+/0crr3svywoK+Rz39idow86eLirJYQQ20QCRiGEGGSOozj0g40cSiNHH7TP1jcQQoxoo6XfYj4Z9CKEEEIIIbZIMoxCCDEEsm0uS38QofGqP5KKRRlT18Cp687vvqe1EGL0GI0ZRgkYhRBikD3+48Vkv9vJtECGeXt518qtGzsGxv2K0zZcPMy1E0KIrZMmaSGEGCTz327mjFPf4n+/W4dyLEtmVHcvS4dDpEoKWfLLd4exhkKIwTAar8MoAaMQQgyCRG2Sb16/himNbUxsamH1pEocN9e9PJbuQK9fxOvfeR3rytWWhBA7N2mSFkKIAfa939fxwL/SdFSVU+I4vF1WyMwNdZS0t3H80ldoKChh7vrlONkcB9e+was3zOagmw4c7moLIQaIHR1JxV4kYBRCiAF0yW3r2PBuhtmuBWtpD4foCMWpbmr1Vsi6HLX0DVwUz0/Ym1RHnNIf/Q8kYBRC7MQkYBRCiAGib2vGLrHM6mpiVopMIMC6SJjk9MlUdnTg4rKocDLh9gwtwRjxWBYSQebtfy/7vH7+8B6AEGJAjJZ+i/mkD6MQQgyA2HUtBFa001gYI5v3ZbEgHuM/xQU8XVqEzbmsr67mzblzaC4qprAzAzlYMb6SmvU5Xg99B7czM4xHIYQQmyYZxlFMa10DXGuMuV9rPRVYAUwyxqwZ1ortZLTWzwAvGmNuGO66iJ1bJufy4LwswZDiqYUZfvuui81CKKzIFsZ5pbiAwtZOnouEmJZIkXAUi4MhlLXMTaZoD4dIZ3OEg5AoihNPdTCpvoVFE8dQX1BKJqQoj15HmAxRWnELIqgPzaVgz7GE3zeL3F4zCJXGvMqMwgyGEKPFaMwwSsAoRi2t9W+ArDFGLnS3C3Kt5XPPuPxlmeWw8Yr7PuQQCymeqnG59GmXjW2WWCbL/+0X4KNzgxz3sEsi7W9sLWQBLAQU5J/7rQIXZjd0cFhHJ4vLC6mLRboDuFxQ0RAM0RANEe3IYtM59mpLckAiCUB7OESgo5NYeweVLUkcmyXoZgmqDB9a/08KSNE9ZjqpyD7cQO7hQrjhIYLkyB9PbQlgsTi4/vPeVd0ctdt4OPEA+MN/YEIFNCehKemVMK0KHrgSZo7zVn7+Xfi/X3ivyc8vgWP32vY3Qwgx4knAKIQYlR5eZPnFPC+8enix5aBqy5cPUpz1hEtjB4AiaYN8+99pfrVIkUjnhVpdV79RCpw+IZhr2a0xwSHrG8k4CjOhvCfbl7Okunr6uJaxqU5CWZcx6WzP9koxYfVGZq7eyOqqUrKBcuY0L2JMup6CbMpbBcgQJESGIJ0oQmQpJkxTr6oocrg43UFiv3Mai9d5D4C1jb2X1bXCFb+Cv17rPT/7R7CmwZv+5A9hwz393YsQuyxXMoxiZ6O1vgK4FJgANAEP4DVD57a44ZbLtMBlwAXAHGAe8HHgDOAqIA78whhzTd42ewLfBw4A2v16XGeMyfjLfw0cB5QCq4GbjTEP+suOAZ4Bzga+DVQC/wA+ZYxJbKWu+wE/BfbC+5pfCJwIfNovD631J/zVSwAX+CrwOf847mUbvmd3VCKRoKioSKaHYDqVLej12rdnobU1QUc21jPTf+fTORcI9H27Nqusw+tn2Blw6AzmbZfJ+9g5ijWxCCesr+ftwjhTUh04SlHakmT/+atYX1FENuCdgheU7s7M1ct77SNFESEaUVj6nzscIO3pntczle6Zn0rvNO+vTMv0QEyL/pNBLyPfGuBDQDHwUeAiYCCaYM8BPgaMATqAZ4EyYAZwLPAlrfVhAFrrscC/gUeB8cChwPHA1/LKexHYFy9gvAn4jdZ6j7zlAeAEYB9gN2A/4PJ+1PN24CmgHKjCC2jTxphb8YLWe40xhf4j5x/XF/Beq2qgHjiqfy/Jjss/Scn04E6fOVtx3BQvyNp3LHx+P0VxcRE/e79D2MELxFJZPr5ngF9/OEggPx7rOjNaC10jnm3XyGdYURInp6Agk6M6kepZntderKzliIZWMsEga6MRpr2zgpOefZ1TnnqVolSagkxH3rou6UCY9cwgQTkbmYbjF+Y1O4dw/Kbq3g/lr9PzyLfZ58UxOOkAb7q6FKIhL5OqgMpi+M45Pa/nzz4N0TBEQvCzi3ea91emZXogpgeLRfV6jAaSYRzhjDGP5D19Q2v9W+D9wJ07WPT3uwbHaK0fBr4D3GCMcYF5Wut5wIHAf4HzgHnGmK59rtVa3wJ8Fy84xBjzq7yyf6e1/hJwDDA/b/5XjTFtQJvW+s+A7kc908BkvME8NcDLW1n/POBOY8xr/rHdAnymH/sRI0w0qHj6jACpjCUW6jlhX7iXwzl7KBwFmVyQqL8s+0VIpl1c15J2FUHHkkorAo4XM6Zzinv/k2T5MzVsiBXw58mVlLrQbi3kctDZEzCGc1mmt3ZQkcligbJMluWlRXzwnRWAt9qc5mW8WrgHgVyOackaVhTNZGq6lqbsWFZVVjCnJYHNlNJIOYWlHRSUFJI+5UBCYwrIVZcTilicmdXYlg6IhnDGl8OMauyqOoiGUPWtqLICMskcgapiFC4EApDJQmmhV9GOtBcM5nLeQboWwsHeA2o+cQScfqg3Hex/FlYIMbpIwDjCaa3PwsuqTcd7P8NsPWjqj/V50+1ArR8s5s/r+pk2DThca92ct1zht/FprR3gBuBMvKyeBQrwspddcsaYurznybzyt+RC4BvAi1rrDHA/cKMxJruZ9ScCNV1PjDGu1nplP/YjRqj8YLFLyE8nBvq0sRSEe88oifZefu2JJXDiPpvcj7qxHXDAgXQ0AslOOpUiai1HtSZZO2Us85eXsf+69RTSTrgzxEnLn+c3h55CS7KE0975B20qTOFPzuCIyw7tLndTH4JQ3nTfEE5NGetNVJW9Z933iIb9QgJbbpGXQFGIbSKjpMVORWs9CS9AOhV40hiT1lrfRv8ycwNpJfCMMebEzSw/C6+Z/ARgvh+kGQagU5YxZgVeMzxa673wmqdXAPcA7iY2WQtM7XqitVbAlB2thxD2+jjjvljHhqpScBRrS2MEO7J0+FHpIW/XUpZNUU5r9za1wUlMW1BPYTJFY6iK3VPfGKbaCyHElknAOLIV4vW2qgMyWutDgHOBBUNcj/uAL2qtLwIexGsmngrsZoz5O17/yqxfT0drfQFeX8UndnTHWuvzgaeNMeuAZn8/XdnFDcAhWmsnLzv6W+BWrfWfgLeBL+FlPYXYYeu/P4Y9rq8j3pQliOLNgjidfsC4Ss/ifTVrSau1hG0OgA2RCoLZLJWZJnZ3JVgUYrQYjRlGGfQyghljFgDXA4/hBUtfBR4ahnpsAN6HN0imBm+09p/wmsnBG4n8P2ApXoZvD+CFAdr9scBrWus24CW8gPUBf9ndeE3fDVrrZq11AC+4/SnwOLARGAs8P0B1EYL5N46hOA4zGxK4ed8Z2YBDJhhkYcFEVkYrWRwfR0u8gFgyi3vKbsNXYSGE6Adlbd9xdEKIQSQfuF3Eu/PrOOtHaRaWFeECRzS0cNSy9ez3xlIC1lKeraOyPcWyggmc2HbecFdXiF3VoKQCrznpjV7n+m89sd+ITzlKhlEIIQbB3D3GcMURaY5dtZbf/+FR9Pp6aqtK+e/hsxkfWcZh7S8QJM2E7x443FUVQoitkj6MuyCt9ZPAkZtaZowpHOLqbJHW+kjgyc0s/rYx5ttDWR8htsWnzpvGJz5h+eKFWVRbjt3XLuXc1x+msr2ZhCrhnTHT+Njn5gx3NYUQA8yO+Hzie0mTtBBDSz5wu6iHfvUEC34VZM7K9cyob2R1SRWnbjwbNQo7xwsxggzKB/DrJ/dukv724yO/SVoyjEIIMQQKx1oO/FqGk0++EICDhrk+QojBMxrvJS19GIUQQgghxBZJwCiEEEOgvSlH28OdJFY0D3dVhBCDzCrV6zEaSJO0EEIMImstP97r7wRViPqx1Sz4zGKmrlnPRe9+dLirJoQQ/SYBoxBCDKLv63/iRAKU1rVR0ZQkF3BYObWaXDZHQO7RLMSoNFqyivmkSVoIIQbJn36+lHVjiqmqbSbgeoMmAzmX8evqmDflrmGunRBC9J8EjEIIMUje/c1K3jf/XeorS3tdTykTCJJoc5HLmgkxOrlK9XqMBtIkLYQQg6Clw6WhopRXyopJxmO0x6NUbWwkFY2wZNZEXps+gWD4Ng7PfHm4qyqEEFslAaMQQgyCb5z/OmMyWdqiUQBWj69kyaQqHCwhC4l4lCXjxlFVfBMzW68b5toKIQbSaLzTizRJCyHEIFhPAQoIZ7O0BoMsKCtleUkxteEIc5fVUN7USCIWxmmHt4pvGe7qCiHEFkmGcYhorWuAa40x92utpwIrgEnGmDXDWrFB5t+3+l/GmFuHuy5borXOAscZY54b7rqIkSubc/nAj5tZsDLHwbEYa4pyTEi04XZku0dNtsaiVNc18dHXXialwhTaNGWJehaUf5l1BUUcumYZgQsPJ/TDs3FKCob5iIQQ28MOzh0Hh5UEjGJQGWM+NJz7zw/Uh7MeYuexJmF5cIFlfKHlqAmKN+tg/yrFxCJFZ9Zy79s5HlsG6Ry4FsxGSGQs1rVgLd6tZy3kd2TP+cuUAgopKE3zRHkhrlPNoSs2cOSS9SwfVwFAMJejqqWVHCGKbZK4aiRiO9mtqYlJTQ0sZB/m/vo1sr82BEgADhaHHA4OaRw6sUCOGC4xAiQIYqGyAJXOQWcnKhzATq/G7jkDF4eW/9UTDucoHK9gWjUcMYfUxg6y61PESy3BAyZigw68sw70TNTRs7f8Iq7YCG+vhEN3hzElANiNLfC/5bDPJNSUykF454QQw0kCRrFdtNYBwBpj3OGuixD9tbDBst99OTpy3vOgsmQtlETgxU84nPuXLG82qt7BIAAKnC1kDJQfMDpeL59kKOpHnPCfadWMae9g1ur1VKRSHLpkBdUtCUJkKKKVsM0CAVwCxGlnN5ahUIAiRzEBEmQpwhLABUI0EyRJgBTtFJFhIjE2EKxvR5Hx6tOZgXk1uPMaWMyetOMFcFPmz2cM82j55Su0UckE1gJgyaJI+9Mh3C9+DOe2szZ9rK8ugWOug/ZOGFcG5nvYrMUeeCPUtkJhFJ7/Gmq/Kdv+BgkxSoyWkdH5JGAcQFrrK4BLgQlAE/AAXnYrtwNlWuAy4AJgDjAP+DhwBnAVEAd+YYy5xl8/DtwPHOYvWwpcbYx52l9+M/AR4GBjTEprPRv4H3B61zqbqcdUvGb0i4EvAjOAKVrrY4CvAdOAJPAX4CpjTNLf7jngGWPMzVrrMPAz4GNAFNgAfN0Y87C/7pHALcAe/ut3B/ADY8wWrz2itf4EcD0wEWgHnjTGXKC1fhyYDNyttf4F8F9jzAla6yK/HicDCUBGHOwi/rzUdgeLAFn/X1ZLJ9z7ruXNOiC4HSf6TX05KC8TqYBUYSHBVIrD3qlhztr1KHLkgopEtpROorQTZiwbiAVcArm+p4sI5DVv5YgSJIkCIrSSpIgscYI09t490EmYdgq75zVQzRjW0kA1E1ift24Q/IARMvCbF2FzAeMf/usFiwDrm+Afb0Da8YJFgLYO7MOvSsAoxCgjg14G1hrgQ0Ax8FHgIrwAa0edgxdkjQE6gGeBMryg7VjgS1rrw/x1HeBRYBZQATwEPKK1HuMvvx6oB273g8uHgR9tKVjs45P+PouAOqDFn1cKHOk/rt3MthcABwJzjDHFwPuB+QBa67nA34Dv+cd5IvB54NwtVcY/ht8CnzPGFAHTgV8BGGNOBlYBFxtjCo0xJ/ib/Qjv9dkD2BvvvRqSW24kEgmZHsbp6QUpNufgcYri0GYXb51SfpM1lKTSlLSniWZz7FOfYGp9Ix94ZSHTVtcRJEspCeLZNEFcQmSIk2YjE9gQH0s9ZYALWByyfqjYk8h3ugM7yBEGXAJk6Hs6t0CIDAGy3fPitAEQo412CvLWzW8oCMCeEzf7GqZmjO3ZzlGwxySYO6HXnS06ZlRscluZlumdbXqwjMZ7SSu5cOzg0VrfBkw2xnx8ewe9+BnGjxtj/ug//yzwHaC0qzlYa/0K8IAx5sebKaMeOM8Y8zf/eTXwBl6GrwE4YWtNy3l1PtoY8/wW1vu8v6+D/OfP0ZNhvAC4Bi+QfskYk83b7mdA3BhzUd68LwIfMsYct4X9xfEC4C8BvzPGNPZZXkNeH0attYOXhTzRGPNPf94sYDHwviEY9CIfuGF257wcP33dMjYOJ05XvF0Px05WnDfXYUG9ywV/zfFGPbgoXOu/YV3nSdd6qbv8LwBrUTlLUSZLazwC1rLX2maUA7ttaCEVj/J/f/434xu8DFwJrZTR2r15miA5QjSrAiY7iyjMpbHk/EDRwcXFksMlQoA0DkkcvGCxk3KCtBOiDQigcMHf1gI2Vki7W0R9ZwUhUlQHVuIURrAzJ7KxqYhIMkk8niW6d7l3GZBlddhD9kB963TUmOLNv4g//zu8sgQ+ehB87GDvZXj4Vexf56EOm4n69DED8VYJMRQGJZq74vT5vc71P354jxEfNUqT9ADSWp+F10w8He+1DQMvD0DR6/Om24HaPgFeO17GD611DLgVL0NXiZeaKMLL2gFgjNmgtf4DcDlw7Db2Q6zJf6K1Ph6vSXc2XttZAKjdzLb3A1XAD4FZWut/Al8xxizFa9I+Vmt9at76DrB6S5UxxrRrrT+M97p/S2u9HPi+MebBzWwyxq9n/nGs2NI+xOhyyT4BLtln08vmVDr87/zta3h5aWGWs++tpWRjBzEbYOHkSi595L+UtqepauzJaLQRp4QEDtYfvBKggxAq0k66M07G74eYJoxLgPCehcSeuQZVVdZrf0G2fAJX/qPQf/RdNm4T8/L/btGlH/Qe+duffiDq9AP7s7UQo95oySrmkybpAaK1noQXEN0MjDPGlAC3M0i/XrbgKuBovObeEmNMKV5/wO56aK2PBi4E7sFrmt6Wa3d0B5d+n8Q/A7/Dy6QWA1ezmWM2xmSNMd81xmhgCl6ge4+/eCVwjzGmNO9RbIyZu7UKGWOeM8Z8BC9Avhm4X2s9o299fXV4nbWm5s2btrV9CLE1h84uYPkt43njnunc9oVy3LYO3phaRUFHmtXjeppoOwnxcuVs1sYqSBKlgGbi1FJ9xmTG5L5P1P6KqL2XYvtLSu0viL9923uCRSGEGGqSYRw4hXgBeB2Q0Vofgtf/bsEQ16MY6MRrag5rra/G618IgNa6Cq9f4xXAvcDfgZ8D523HvsJ4g1ea/AE0e+D1O9wkrfWxeH0e3wJSeINkupql7wD+rbX+u18nC+wGjDHG/HsLZVYBR+A1e7dorZv9RV0jBzbg9VcEwBjjaq0fBG7UWr/j10OumiwG1GF7F3HcqnksnTWBtzs7eHvGRA5dWEN5QxsNpXFqplVz0vOvkcxFWBCp5EOtlw53lYUQA8gdfQlGyTAOFGPMArwBJY8BzcBX8QKzofYDf//rgGV4Wbwa6O6/9wDwlDHm135T9DnAcVrrT23rjowxbXijwm/VWrfhZVQ31xQMXnP0b/EynuvxsoyX+GW9A5wEXOkvqwV+Q15T+mY4wOeAGq11wq/D+caYGn/5zcA5Wusm/yLi4AXLK4CFwNvA4/QEmEIMiJtvmIrNZAnn0pQm2tnr7VVMW1nH/m+t4pA3FlHZ2Eosm+LoZecPd1WFEGKrZNCLEENLPnC7kE+e8jZHLF0JGdhnUU9X5LbiEIWtbez5wimUHDFhGGsoxC5vUHKBnztzYa9z/e2/nz3ic46SYRRCiEFSFlO0RMIUJVO9fim4achGlASLQogRQ/owDjO/mfTITS0zxvQd3DjYdXkXr5m4r5X9GXwyWLTWXwe+vpnFHzLGvDCU9RGiv25/cE++dUQ964sKKS3pJNqZJR1y6FQB3l/7meGunhBikLij8F7S0iQtxNCSD9wuZs2SNu7+5Cvsucq/2pRrSQUV567/xPBWTAgBg9QkfemZi3qd63/++91HfAQpTdJCCDGIJs4q5IZXj6VxapB1xTGSBQ5nLD99uKslhBhEo/FOL9IkLYQQQ2DctREATj75zGGuiRBCbDsJGIUQQgghBtBovA6jBIxCCDGINq5u5+envUTOKaAz6HDEQR2UVUWHu1pCCLFNpA+jEEIMou+f9Soz1zcwZ209+6ys5f73PcXyf64Z7moJIQaRq1Svx2ggAaMQQgySZ/7TQGlnhg3VFWwcV06irJDdNtaz+uQnkCtUCCFGEgkYhRBikPzxllUsmTmFjpI47UVx6saW8fcjDqCpsoSXoncMd/WEEINkNI6SloBRCCEGwbrmLJlIBGVd2kMh3pw4ntcnT6Q5FuW5feYQDMjty4UQI4cEjEIIMQiO+uIqmuIRGmNRVpWVkg0EAGiOxxlb20RjaQGPlfximGsphBgMrur9GA0kYBRCiEEQDoZpjEZwHYe2SLhngbWUN7ewe8NKdm9tYM0fFwxfJYUQop8kYBRCiAE28/KNNIcjtDleVtFVipJEGwXtHey7aAWxdJaiXIoYOVo+/iTrf/LyMNdYCCG2TK7DKAac1vpuIGiMuWC46yLEUFhSn+bwuzuoS0F5R47OghhVTQnejUZJZBwOWLWBQ5bUUJJIUd7aQXEmicpZOgiTJsi6K14iccXfqWQ1atYEip+/kkAsDCWFw31oQojtYAfnFtXDSgJG0W9a6xuAI4wxxw13XYQYSH+4YznXryqiKRymvaKAiUWwpAmyFsBC1xVwrAUXcCGYyxF0XabWNrFw4hhIKMhZGoNBCDg0FkTJKYexG5s56a3FYC0TNyYIuhYI8WZkD9JOkHgqQyEpchRgiZNd0kbjuG8RJUUTYcZQh6OyZAKWgmx2i19DWRQtoRIygRDlnY2E7SYG1oSDUByDZCfsPh4++0G44Q/e/N9eDkfs0bPuHU/C4wYOnw3XnA6jZLSnEGLbScAohNilLX5sFZ/dWElDZRyAaDLDgkwobw1Fd5SmFCgLOUvWCZB1AiycPBZSWcj5UWXWQsShOR4FpZje1AqA41o/WPQEcy4bKqPE1mYpo54prAagjjGsZwJjaKSEBmKkwEI4y1ZzFkEsFZlmyGxhpXQW6hPe9Js18H95A2+OvxESD0IwAE+9CZ/7pTf/72/AuDL4lPxWFKI/RsvFuvNJwDhEtNY1wN3A+4EDgRXA2cBc4JvAGOCPwGeMMVmt9WTgB8DhfhGPA180xiT88r4NfAIYC2wEfmqM+ZG/bKpf/nnA14BJwEvA+caY9Vup51TgTuBgvLzKcuCTwL7A1wFHa93mr763MWa51voi4Br/GB7D+17L9uM1+Q0QwPt6OxVIAl8CFgC/BGYDBjjbGLPO3yYO3AScBpQArwCfN8Ys9Zd/wj/maX55fwGuMsYk/eU1wF1478PBQA3wf8aY/26tvgMhkUhQVFQk0zvRdOuadpoKqrvfo5yzla7dStGTcvQn+343OFCZzlAfCfP2uAqOX1ADAYe2aIjCDi+aay2MgAKrYJzt+VhWUsd6JpAiSpyewTJD8vXTkYG2DigtoGPhKnrdwHBFLTD875dMy/RATov+k0EvQ+t84LNAGTAP+BPwPmAfYC/gI8DHtdZR4FlgPjAd2AOYCPw4r6z5wBFAEfBp4Bat9Qf67O9M4ChgAlCAF2htzbeBVUAVUAlcCDQbY37vL3vOGFPoP5ZrrY8Ebgc+A5QDT/v77a/TgUf8bb+JFyjeBJzi18ECN+StfzdeIHkIUA38D3hCa92VEmrBC3BLgSP9x7V99nkRcDlewPk0cO821HeH5J+kZHrnmN7tI5P44JKV3fMd12WTuu7MkutzhxbXQjjgPRwgEoBQgFmtSeKZLBWBEDe+T3PPfrvzxY8cxpLqUlZXFdFaGKG4OU3OKtJEuotLEwYUITIESfTsZtO16l3FPn/7paq0Z/r4faC0AIDoWUfD9Cpv/phiOO8YYPjfL5mW6YGcHiyj8daAkmEcWncZYxYAaK0fxMswHuJnv5Ja6+fwso9pQBljrvO3S2mtvwH8V2v9aWNMzhhzf165z2qt/4qXNftH3vwbjTH1efu7uB91TOMFYtP9ur61lfXPAx42xjztP79Pa31JP/bTXXdjzF/9Ot4H/Bz4rTFmjT/vYbyAGK11JXAWMMUYs9GfdyNwJV628EVjzJN5ZS/VWt/h1zHfncaYd/3t7wau1FqXGGNatqHeYpQonlTAo9+fwj9MglfdOPtNDjO5SPHqBpf/rIO6JCTSlo4Ol5VtLrY5hcpa2sJh4ukMGdclGY9B0GFKuoOiRAd1HSESkTAnrq0naGFSZycFQYdULMID++7O1596hWI3xbLKsUxtq2U505nCKkJ00kwRlaykgnWASzthwqQBLxAM5Fe+shAiIci5UBRD7T2VVFrRGQhTEs2hmtogFobKIsjmvG2O3QvGlcPCNXDMXjB7Ajz+qrfeB/fvKXtMCcz7AcxfAzOroVwyMkLsyiRgHFr5zcHtQM4YU9dnXhFec+pkrXVzn+0tXjC3Vmt9OV4gNRGvtSoGPLiF/SX9srfmy8A3gMe11gXAw8DXjDFtm1l/Il6zcb4V/djPe+pojGnXWveaR89rAt7rAvCWv16XEF6zO1rr44Hr8LKQEbzv19rN7RPvdcHfhwSMu6hIcZiPHBvmI3nz9DiHS/fb1NqxLZQUY+LV9SSyLhvLi9itqY3ijk4WlRSCgg/MX8Vh/1lKhjCNhChs7iAHhEkQm381sTlV/fqQbklsKzXsdtw+PdOnHLLpdQpjcNCsHayRELue0XKx7nwSMO6cVgKLjTFzN7VQa3048F28jOL/jDE5PxO3w/9E/QD2cuByrfV0vD6JX8ELwjbVKrYWmNpn3jRgyY7WZRO62g1n9Qm0AdBah4E/49X3HmNMSmv9ebx+kUIMiTXfreTuZ1u45F85GsIhGgIORekMS4sLeHCPaRz+n6WAd9mNtqIIueZ29nW/Mcy1FkKILZOAcef0BHCz1vrrwE+BNmA8cJAx5k9AMZAD6gCrtT4R+BDeoJkdorU+E28gSQ1exi1NzwCWDXiZz7AxJu3Puw/4hz+A5d94A3EOYhACRmNMrd+0fofW+kpjzFqtdSleP9CuJvEo0OQHi3sAnx/oegixNRcfW8I3Hl5PPJNm/7pmAParb+b+mZPy1rLEnRT7Zb8+LHUUQgwedxReh1EGveyEjDHteNnDPYCFeIHbP/FGKoPXT/G3eIFdPd7AkT8N0O73wwv82oB3gdeB2/xlfwRWAxu01s1a62nGmOeBy/AGozQCHwR+P0B12ZRPA4uA57TWCeBt4AzA+s3mlwK3+iO5b+e9zfRCDIlxcZjWkux+roAZrUle3n8y9dUFtFcEmHzWBJytjcoWQoidgLJ2m8bTCSF2jHzgdiGfPeUtyjsz3qV4rOWtyjKaY1HOMG/hZLJ87q2ThruKQuzqBiUVeOYFK3ud63//mykjPuUoP22FEGKQ1IVDKGtRrktaKZpjUSLpDBuKiphxfOVwV08IIfpN+jDuYvwLgs/fzOL7jTGfGcB9nY13EfBNucQY88BA7UuIndEffjebW498lvZIjBVjK6loS1LZ2kY0leKD35e7pggxWskoaTHiGWNWAYVDtK8HAAkKxS5LKUV9NMT0pqb/b+++46uuzgeOf86d2YMMNoThAhXEgwv3VoraKlpbq5baVmu1rV1qrVpttc4O2/601lp3rbtY0brrBA8KqICyNySB7HnH+f1xvgk3gQwkN5eE5/165ZXv/c7nfG9u8uQ559zLgNo6atLC+BrquXrOyakOTQghdogkjEIIkUS3vXIk8Xic5x6dSSC3kWnTpqU6JCFEkvWXT3dJJGMYhRAiyXw+H4Fc+XUrhOi7pMIohBBCCNGD+uP7MErCKIQQSfTY0IeJBtKwSuGPxDhp5jJ8UcX3vprPtBPzUx2eEEJ0i/SRCCFEkjxT8FcWjBhCRn0TBVtqaMoMkdugqA6GufbZRk6/eHmqQxRCJEFMtf3qDyRhFEKIJIjXNvHC5HGMX1tOdVaYdUPymL/nSCxQ1BQlM2b5PJCZ6jCFEKJbpEtaCCGS4JOTH+bseZY1RXnUDsgmGg4ycvMWTnvnI9KbIjx99GReHDWUprpmwpmhVIcrhOhBMktaCCFEt1SaBhrTA4RjMSasWMUBS1eQ0dTM2kEFZDU0ceRHi8mJRDnza4tSHaoQQnRJKoxCCNHDKp5YSH0wjcqMTCZsWEtmJAJAdn0DL+qJNARDNAf9hJuaWD6kmPfe3sKhhw9IcdRCiJ7SHz/pRSqMQgjRwz75xotEMnwUNZWRFWloXf/S5ImsGDqID/bbg/l7jWJ0c5RI0Md1f69JYbRCCNE1SRiFEKKHNFz+EKt9P2RsbDmTqhayd/Xn5LIJAAssHzywdV+rFDG/n0M3VzN/cD7+n1UQjcVTFLkQoifFUW2++gPpkhZJobWOAscbY95IdSxCtLIW1m6GukbIyYB4HIYVQkUtNDZDzEJOOjZmsR+vQjXFsE1NKJ8PVmyC52YT/XA11DUQ8QWpbVJkx+oJEAOCxMllIHF80Rgq2kCMJsLUk8kW4vggfhr42/7abfL7KM8JE1c+0m9pJupTtPx9Uc0xbEAxKEsxIAx5aT5G5UFRhmLqWMURw/w0xaC6GYZlu4Nq6uM0NVsK8/xtrmM2xMlLg7H5HdcJSussfh8UpPePP3BCiJ4jCaPYIVrrlcA1xpiHUx2LEDskHodz7oAn32u7/qjx8N5n0BwFFDaUjm2OEScNH434aMLicrhmQoRoBiBIE+kEgTRc/bCRIOWUUUKUIBlUk0MDljRKs/JZMHB/NoXCZAJBa4l73480Szj11XncePYRLBuYD37Am2Fp013St7HJfbElzrubFCjF7+dBmj+GUtAQhW/tp7hwYIRf3VtBJArTj8vk0rNzADj44ShzNrrmfv8Ay13HtU0mAW6ZHeeqt+L4FNxzoo9v7ScdUEJ8UTGZJS36Gq11sDvrhOj35i7bNlkEePNTL1kEsNjmGNb7X9pHE9Ba8GtNFt2eCmh5O5ytyzmUMpgl5LKJOFEayWBL/R6ULKtjxJYq8PmI+P3E/H5KVm5i2IYt5NU3cc7bn7acuGN+1ZpMAjTGXLIIcN/Hlj/+p46I9/iJV+vYUh1jRWW8NVkEuHv+theIxS3XvBPH4oqs17wtXeNCiLakwriL0lpnAdcDXwGKgNXAd4EPgZu99enA28DlxpjV3nFvAPOAEuBY4Cat9d5AEGgGTgceBy7p5NpfBa4DhgH1wCxjzIVa65nACOBvWuu7gXeNMSdqrbOBPwHTgBrg2h1opwUuAy4E9gHmA2cD04ErgAzgbmPMLxKO2Re4AzjQi+8R4FpjTMTbfj9wPJAHrAF+bYx51Nt2NPAK8HXgJqAQeAn4ljEm6TMPampqyM7OluVULA/IxipQ7fMlRbskTQFxQLVWFlu0f9x2jSWOnxCNrVv9RKmgkEDcJWCTl6zixcKEjwO0Wy/cEGr3f5y1bZLDroT8UJihKPUep4UU0eY6cjOz2+yX5t/+/RmQBqX1bp/C9F3g+ZJlWe6F5WTpj7OklbWd/TsrUkVr/TgwBDgfWAmMxf11+ikwEZcwVgJ/ACYDk4wxMS9hnAScAbyOSyr/AnwN+AbwJBA2xtR3cN0MoAo4yRjzmtY60zv3W972lbTrktZa34dL9r4CNAD3A18GjulqDKOXMM4GzgK2AM/jEtV/Ar/2zjvHO9e7WutiYBFwtXedIuA54N/GmBu8c34LeNa7P9OBB4GJxpiFXsL4OvB34AdAJi7p/ocx5jedxdpD5AWXSg++Dtc9DhU1kBaCgXlw0fEw08DKUsCHHVFEfGUFrNgC8Rg+Gmh52poJE6TZSyUBAlhCWHzEUcQIEaIGn1eJtPgoZRhljAKgIRjkT2edQGMohD8ep6C2nj0+XUVleojfTz2Iiux08IE/FiMWcN3GylqsUi6ESMxlhgAKjh2hSA/Axjq4+mAfhxXEufORaqrr4nxzWhYH75sGwJ0mzvXvxAn54V/TfBw7ctvOpffWW37yRoyQX3HXsT72LeqHf/GE2FZSftCP++76Nr/rX71nSJ9/QUmFcRfkJUVnA/saY1Z4q5dorX24BPI0Y8w6b98f4hKtg4CW/rYnjTGvecv1WmuAt40xj7es6yKECLC31nqeMWYL8FYnsfpw1bqpxpiN3rqf4xLG7rrDGLPWO/ZJ4LfA9caYODBfaz0flxS/i2v/fGPMPd6x67TWNwO3ADcAGGPuSzj3P7XWPwGOBhYmrL/SGFML1GqtnwX0DsQr+qrzj3Ff7V02tXVR4YYRbk+4/YrmCPHbnyHyiycAHxaIkoWfRiCOjwiFrGFhzl7E/GlsKM5nRPkWtuTl4rMW5ffx6FH78VFRPvGAoriqFp+NcdFxWRSkNXPpYWkE/YnRdDWaxMetl2/7fo5XaB9X6M5HIB06RPHO1+RPghA9IdZPZkYnkt8Ou6YS7/vn7dYX4UbYL29ZYYyp1VqXAsPZmjCu3M45t7duG8aYeq31qbju4N9orZfjErpHOzikCPd3NPH8K7a/a4c2JCzXA6Vespi4rqX/YBQwRWtdmbC99W+8l8BeD5wDDMLVZTK9OFvEjDFlCY/rEs4vRPeFgvivPhv/1We3rvrsoLtIW7CGwc1riCg/z42YRlU4h0gwQGNWBuFoFH9Cz05NOEjMWs7dM8ZDX8/f3lWEECLlJGHcNa30vu9B26pYGdCES5qWQetYx2LcWL0W2xux3u1R7F438htaaz9wGvCU1nq2MWbZds5ThhsbWdISkxdfsqwCXjHGTO1g+7nARcCJwEJjTFxrbUhSt4MQ7e015zLezb+ZGl8enw8YTFXYzVQORqLEmprBpyioqGJJYT5LcrLYFA4TikclWRSiH4n1w784kjDugowxpV7X7F+01hfikqQx3uYHgRu11gtxY/TuABbjxvntNK31QOBwXFJWlVDJi3nfN+IS2ZZY41rrR4Ffaa0/wY1hvLknYunAg8CPtdYzgEfZmqzuaYx5EcgBorhE1ufdvwm4sZFC9IrJq39CWc61ZNYVUZ61dX1zIEBcKdamBXl8xGCG1tYTbI5Q/duijk8mhBC7AHlbnV3XDNxs5zdxM4+fw3Wx/ggwwAe4mdODcWMaY9s/zQ7zAZcCK7XWNcCfgQuMMSu97b8GztNaV2itZ3nrfoDrhl4MfAzMZGuC2aO8cZLH4Cb1rAQqgGeA0d4uD+Am0SwF1gHj6GQMphDJEMwOUhYIc0jle+xd+Tk5zdWk0UBdThYLCvN5aeRQxm2pZK/yCgb4YgQC/bAcIcRuLK5Um6/+QGZJC9G75AW3m6hcXkHemG+1Pm7whXlg7FdpzE4jEg5R5/fzWXEBjz05PoVRCrHbS0o2N+WSjW1+17/zf4P6fNYoFUYhhEiCvNH5lAaKWx+XhYrJr6unORiiLj2D6oJ80vwdzccWQvRlMaXafPUHMoZxN6S1vhr3Pobbc0rLey720LVmAUdsb5sxJmt764XoL+ZOO42i1z6ksLaeqkgxvgBsKMikNjOXGHDSjOIuzyGEELsC6ZIWonfJC2438/xJM1m/POrefPsUuOiO01A+hc/XP6oOQvRxSXkh6u9tavO73vxlYJ9/wUuFUQghkuhLL00DYObMmQD4AzISSAjR90jCKIQQQgjRg/rLuMVEkjAKIUSS3XXwLFapLOJZlgMPqGfIsIxUhySEEDtEEkYhhEiiaye9xMlLl3B0UzM1aWGeP7GaQTcfzGmnD051aEKIJIn2vwKjvK2OEEIkywt7/4Njli2lND2XxXnDWJE1iOLyKlZd+UGqQxNCiB0iFUYhhEiS0ctX8Mj+hzF+fQV/OVGzrjiX9KYI0+cs7PpgIUSfFU3O5OuUkoRRCCGSYM65zzEwEufYZUv5xYnHcsyS1Qyd24BVMGfMUG4+5AWuev/UVIcphBDdIgmjEEIkQcbTH1JDPh8VD2UQjZSUV+OPuo9Yn7R8HU256TRUNpKel5biSIUQPS3S/wqMMoZRCCF62vI/GgLNaTSQxuCqJpYOHtKaLAJkNDSTUdnIbV9+j4aGaAojFUKI7pGEUQghelC0romKn71Jk8rA4mPuuBKG1zRRFw617tOQkc7ykYNYOnAQv5r2bgqjFUIkQ0SpNl/9gSSMuzCt9Uqt9XneconW2mqth6U6LiHEtmqe/pDP/T9jac4dVPjyWJudhwVqM9OwPh//m7QPS4YNpKwwj80DB5AVjRP1web8TP5v0kOUf7Qu1U0QQogOyRhGIUT/8+z78McXYFgBjBsOz7wPAT/E4nDoXjBvBaSH4MAx8N/5cML+xD9aR3zuWvBFiJVuJhiLESdADUU0+/xkU01dWoDKtHRyG+opaKhO+GBwRRqKACPZqDKpTw9SVFXPimH5jNpQxupBBdSlp7FyyEDGVFa1/qe+5+ZqyjIz+HRQMbNvqaA+XEdFsJYzF8zhjI8+YfmAQawZmMHsEWOYvGYVX16/hDsevwUVDLDX7AW815TJiccNZMr7i7GbG0i/eDL+oTlf+LY13vQykec+JnzqnoSu+9JOPglC7L4iqQ4gCSRhFEL0Ly9+CF++tePts5dsXZ71EQDxOSuJkA8ofNQTxo0r9BEhizKIZxKkiYz6Oorqq7yDY5CQMgKMYgmFtp650f1YNLqYprQQxy9YzB7rSinNzKW4opq1JYXUZqXTlBZkaWEBdeEwkEcDUQY3x5g3ZBSXnL0/GfE/cdzcTVz9pem8uc8YAB565F5O+fpvuP/gI/jF4cdDGAb9YCYT5rh2ND66gILFl6OC/h2+bY1/+B9Vv3gLgPo5sxkQ8hG8SmZxCyEcSRhTTGv9A+ASYChQATwCXGOMiXV6YOfntMBlwIXAPsB84GxgOnAFkAHcbYz5RcIx+wJ3AAcC9V4c1xpjIt72+4HjgTxgDfBrY8yj3rajgVeArwM3AYXAS8C3jDE1XcR6PXAEYIAZuGESvwGeAu4HJgOfA+cZYxZ5xwSAn3ntKwY+BS43xsz1th/nxbEnEAVe9baXetvfAOYCJcCJQClwhTHmua7u7c6qqakhOztblpO5/N7nO/CMOHGC4L1vmo+2k1ACRLBEaJ8cuv3tNmviPstnwwdhfa6OmBWpZtLGUlamD+fjfUaAz5JZX08kmO0lix5fEIiR1eyu/+7IvZg6dwXj15W3JozvlYzh9E8+JOrbOprowNVbu7JjyyuoXraJ3L2HdHx/OliO/DfxvikaX1zUmjCm/DmVZVlO0nKy1PeTcYuJZAxj6q0FTgFygNNxSdNFPXDe84AzgCKgEXgNyAfGAMcCP9FaHwagtS4G3gSeBoYAhwInAFclnO9tYCIuYbwB+IfWelzCdj8u+ZqAS9QOAC7vZqxHAkuAQV7ctwH3AZcCA4BFwB8S9r8Bd69OBgqAvwMvaa3zve1NwPe9tu/ntSnxeIALgDuBXOBPwANa66R/wG/iLylZTtLyKQeAb8d+WftopiX5ixNqkwZGSKOZMLR5I17LtgmkW1Pvy2xNFkdXrWAP5lLCJ2RlbcJ6cUUCAcINDQSiW5NTf9zS6PexLD8LXzzO1IUfUUs+80YUuRjjcaYums9bJWOJKR/hiOv0em2fsa3nCEweSs4egzq/Px0shy/UrW1SxEifccgXOo8sy3JfWhbdJxXGFDPGPJXw8COt9UPAccA9O3nqO4wxawG01k8CvwWuN8bEgfla6/m46t27wPnAfGNMyzXXaa1vBm7BJWcYY+5LOPc/tdY/AY4GEj+y4kpjTC1Qq7V+FtDdjPVzY8zfvOVZWuvNwEsJFcVHcRVPtNYKVz2daoxZ7h1zn9b6h8BU4GFjzNsJ596otb4Vl1QmetwY8453zr/iksc9cNVY0Zcdshd8eDvc/V8YUejGKT7yPxiQCeU1cMokeHMhZIfhqH3hyffwnTaZ4Pw12JcXobJ81M5dQbiqjnggjcpwEbGGCPnRKKXZ+SwrGMK4jesoaixDYQEfMSzl6QWkNQUJUc+oLWtZMWAYe21Zgs9LwkbVrOBdO5nyAXlU5uaAtQyvqGJhcQE+FE0+y6qsEJNWL2bG7P8xuLSJ5SNyuOrdf/Px0sEcuWopkwf7eOruqzja7+PSjxdhNvs5/MGjyf2wBLu5nvD08Sj/F6sDhKZPZMDzAaL/+ojgl8cTOGNSDz4pQuxeGvpfgVESxlTTWp+L6yYejXs+QsD7PXDqDQnL9UCplywmrmv5N2sUMEVrXZmwXeGqhmitfcD1wDm4KqAFMnEVvBYxY0xZwuO6hPPvSKwtsbWPv+VchUAWMNPrem8RBIZ58R6I65KegOt+V94x272mMaZOa80OxCt2dRNGwf99d+vjEye23f61I7cuT5sMgO/MQ71/j9r+IAxKWC7xvtrz48rYc8feRcGyDeyzvpyiTRGWDBgMtRkEaaaocS1+G3XJIoBSNKaHWTwwm4mrNvLCI3t7ZxuGK9BvlTj95NyWhX3GM6Fledje9ITg1H0JTt23R84lhOhfJGFMIa31cOBh4CvALGNMs9b6drpfmespq4BXjDFTO9h+Lq6b/ERgoTEmrrU2kJIPyyzHJaPHG2M+6GCffwJPAtONMdVa6y8BM3srQLH7OnDpZQCsUT9FRbOIVw5ijfd/1bLgHsRUCF88Ttzrso4Dhy7dwGP/2idVIQshkqC5H36WtIxhTK0s3HNQBkS01ocA30hBHA8CWms9Q2udprX2aa1Ha61P9rbn4CaPlAE+rfUM2Frc6E3GGIsbj3i71noPXOBZWuuTtNZDEuKtAmq01iOAK1MRq9h9Zbz3A9YUZpPRHGtd10QajRkhCiqriFhLLBZjs43w6OM9Ux0UQohkkoQxhbwxetcBzwGVuMTmsRTEsRE4BjdJZiVutvYzuG5ygAeA2cBSYB0wDnirt+NM0HLPntNaV+MmzFzM1p/n7+AqojW4iTxPpCJIsfsqOGQY0aCPLdlbZ0FXpweIba5lTVqYYz6eR6ChgUceHofqh7MphdjtqXZf/YCydtuZfkKIpJEX3G7ipW/8l9J3q2iMwIQ15YRw1cayARm8v+9YtgR9/O6Vw1McpRC7vaSkc+pHW9r8rre/G9Dn00apMAohRBKc9NCJ5JfWMqqyujVZBLBxRbkKcOfLU1IYnRAiqZRq+9UPyKSXPkhrPQv3ZtfbMMa0nw2cUlrrI4BZHWy+yRhzU2/GI0RvGnT+KJrvXkRdOEhmU4SoT7FpQDYq3ihd0UKIPkW6pIXoXfKC2838qeRpBlc00Jgfoj4tyILBRfz68QPILU76+8QLIbqWnC7pKyradknfmd/n/0OULmkhhEii76/8Cjm/PYiFY/OJfz3AXa9PkWRRCNHnSJe0EEIk2QmX7EHjsMWpDkMI0Vv64ZATqTAKIYQQQohOSYVRCCGSLNYYpfKqLTSqbB6+/EmCzRGOuvcgBp06JtWhCSGSof8VGKXCKIQQyfb0/veyNrsEf62frKomBmxp4JOzX091WEII0W1SYRRCiCS68/vzqBm8L8fPWYg/FqcilEFlVjq5dQ2pDk0IkTT9r8QoFUYhhEiiZZ83c9KcTxjQWE9upJHBDVWkRyL4VZxPDrg31eEJIUS3SMIohBBJFAYym5tbH4fiMepDfuozgywqT0tdYEKI5OmHnyUtCaMQQiTJ5TPmM39gAWd943R+OvUoakJBKtPSKK6tY8OAXKqz01j16upUhymEEF2SMYxCCJEE8Xic1VUBXhtTCCg+Lx5AJBDggtmLKaqpASAUr2f5Rc8ycsXlqQ1WCNGz+klVMZFUGIUQIgkOuGAl/xk5hMS/HOWZ6fjjcfx1PjJrGnlj7J74q+Is+unM1AUqhBDdIBXGfkJrvRK4xhjzsNa6BFgBDDfGrE1pYEL0c9FYjNLqGL+bVcNnS+uYWx4m7vNTN7KIKIpQfYTmgB9lLQ2BAIFIHAUMLq3hq7PnckjFPHy3z6bh9kdZVDyaEaVrSKMRde1XiX3nODIb6/APGQDhEPjkf3wh+ob+V2KUhFEIIbYjbi2T/hFj/mYLwGljFC8st0TjQNyCL/EPggJyGF5pCVlLPA7N9REIBgjF4oRjLklcn5dDZnWELGoYH11IqLwOi49aBhIgxr6lawlSB1jsDQ/DDQ/jA2ybyJTbDlil8ClFU0YxsaLBpD3yDfyHlngNiMPF98C/3gE9Fp78KeRldt7oxmY49054/RM4cSI8/AMIBXf+Zgoh+jz5d1X0GK31Nn9ZtrdOiL7g7g/jzN8MLdMc/70Mola5z4j1+9z3dl/ZTTHiSmGBGq8aGPcpfN5ZBtXW05QVoiC0mTQqCFBHkBqyKKMuGMBHBIVF4X45t/yCbjvhcut2v7WoeJxw7Ubsis00fedfWxsw08C9L0NVPby6AG5/rutG3/syPDvHHfPEu/DAGz1xK4XY/fTDWdJSYexDtNY/AC4BhgIVwCO4bujYTpyzCPgtcAKQBywBvmaM+UxrXQD8ztumgJeAHxljtnjHrgT+DhwDHAR8S2t9MTAPKAGOBW7yzt/R9VcCfwOOAybjutK/DowHbgSKgCeAi40xUe+YEcCdwBTvNDOBHxtjarztNwFfBYqBTcBdxpjfe9tKvGucD1wFDAfeAy4wxmzYsbu342pqasjOzpblPrAci7et63VHMG7BD41KEfHW1Qf9hKNxJlTVMMPMJ16oWMYgRi/7uPU4P00EbBOJf1ksO/53xsbiW9sSi7fZ1tTQQNhb7qjtjXUNtHmjH+8cqX4uZFmWk7Usuk8qjH3LWuAUIAc4HZgBXPRFT6a19gHP4RLFyd73bwI13i6PAPnAOGAfoBB4qN1pvg1cAWR558KL649Arve9KxcA3/OuNR94BpeETgD2A04DzvZiTgNeAxYCo73YhgF/SDjfQuBwINuL72at9UntrnkOcCQu+c4EbuhGnDst8ZeULO/ay5cc6GfPXAvWApZjhoFPeY/j3vd2XzXpPvKjUZT1krVYHCyMqm/gkKpalpSMZOKyFeyxfiMNDKKJAiw+4gQI20qiZBLH79UQXdLYna/m4AAozCL8pzO3tuX0yXDOFFcNPWgPwldN77LtaZd9CY7dzx1z0kS48Jhd4rmQZVlO1nLy9L8So1QY+xBjzFMJDz/SWj+Eq8zd8wVPqXGJYqExpspbtwBAaz0EOAnY0xhT4a27AlistR6cUI271xjzkbfcoLUGeNIY85q3rr4bcfzVGLPIu8ajuArjIcaYOqBOa/2GF+ejwJcAZYy5NuGavwTe1Vp/2xgTM8Y8nHDu17TW/8Hdp5cS1v/KGFOecM0vnHiL/ingU3z27SDWukqjUu6XfjzuksEtdXGUAmoaeW294vq3YqhoI5vT0sn0+ci0ceqUj/zmCFMqqgFoDvix/iiDG8pxncshmskm7qvHH1NY6qkjRIAGGDeShlsvIKuxCV9eOuqgsfgzwuDzEY/H8SVMgAkBYdXuj5LfD//8sUtm22/rSGYavPqrHTtGCLFbkISxD9Fan4ur5o3GPXch4P2dOGUJUJqQLCYa7n1fkbBuWcK2loRx5XaO3d66ziR2BdcDMWNMWbt1Lf8SjgJGaK0r253DAoOAdVrry3GVxWG4f+3ScclmR9esSzi/EG2odolTS6JWmO0lbFlZTB8M0w8EV/x3xs9YwYZB+RTGIRy3xIGP8nJ4bewozvtsWnwl0AAAJ5VJREFUY+t+iwtGEztoMJNe2PZ/lvQOYvL5/W1j7LwBnW3tuWOEEFv1w5eQJIx9hNZ6OPAw8BVgljGmWWt9O65K+EWtBIq11jnGmOp229Z430uApd7y6HbbANoOlOp4XU9ZBXxujBm/vY1a6ynALbiK4mxjTExr/ST98uUrdmWf/n0Ux395Ae/sM4pnBhW6uc1KMbt4DMd/toRiNlORlsXSnGLO3E6yKIQQuxJJGPuOLNyY0zIgorU+BPgGsGgnzmmAucDftNbfB8pxk03KjTHrtdb/Be7QWl+AS7juwCWrSZ8c0onngV9rra8G7gJqgSHAQcaYZ3AlnhjuPlmt9VTcuM8nUhSv2I19PiSfQDxOYzCADfnIamjixHkrWclIVjICX6ie4749uusTCSH6ln5YopBJL32EN8bvOtzEkkrgSuCxnTxnHDehpAE3s7kSuJ+t3bPn4SbALPa+KnGzi1PGGFOPqx6O82KqAl4FJnq7vISbmDMHlwCfhZtEI0SvW/3n4RRX1xLJD1NZmMna4QN4dsre3lZFuD5O3lUnpDRGIYToDtUyoFsI0SvkBbebmTF1DvcfM6n18dDyah665VlIi5Gb1sSkiu+nLjghRFJqgeqq2ja/6+3NWX2+5igVRiGESKLDD0inqKau9XF+JELzMEtOvFaSRSFEnyFjGPs5rfUs4IjtbTPGZPXC9e/GdW1vzzhjzOpkxyBEKs349X7kjnyAfx0ykbjfzyWvvcfETUuZmz421aEJIZKlz9cTtyVd0kL0LnnB7Yaa6iOYIX9lcG0lfqKsCxdQ8tRUhpw8KtWhCbG7S06X9NXtuqRv6vtd0lJhFEKIJAtnBNny0Ai2MIJp06YxMtUBCSGSqx++l6mMYRRCCCGEEJ2ShFEIIXqBjUPZI1He/aXBxmVkghCib5GEUQghkmz1p5vZckUzmW82sfShVfzxgFnEY5I0CiH6DkkYhRAiycwJL5BZF2FDbhazRw4mWN3I49NfSXVYQohkUe2++gGZ9CKEEEnU1BwhvTbCm/sM5/ZTD2L4lipm7VfClbPeSHVoQgjRbZIwCiFEEj00fiZ1BQX87eQDiWcE2RDM54E/P8mm7IxUhyaESJp+UlZMIF3SQgiRRE3RAIsPGMv0xes5+5M1KAX/3n8cBy9Zzy+/9WGqwxNCiG6RhFEIIZLkxoP+TXNOJgRdZ05+Y4RxZTVMWLmJ+ngGw15bmOIIhRBJ0Q/HMErCKIQQSfDDI1+mZHMTVdlhwk0RMusbAThh7hIOXrweH1BY6eOG8U8in7glhNjVScIohBA9qLmuiesOfIyTzBqyShuoAb42823Off5djn7/E+L+OJeedxxbskL4Q4oDlzdwzaTnaFxXlerQhRA9pR9WGGXSixCi//tgCSzbBCdNhPwst+6thbChAg7fG95aBCXFEA7CJ6shEoMh+Xw2YV/e+uM7jHrpXe466GTGbahiUN1msjasozktTMTn57AlSxldWUGAeupCaXyWtid5wydSF6pkeUkRp3+wGL/3Rt1jV5dSVpjFpv2yeODw8Vz94mxWFRdQVlTA377yFKcs+YTFuQXMLRrN9I8XkNEIadSSTjUqCwIqQEVgANHiXAqPGo4vECYwMBMWLMc3MBc1Mg/V0ATTD4Nxw9veg5fnEftwDfFhgwlMHY/KS+/d50AI0adJwiiE6N8e/R+c9wewFvYaCuZW+Ptr8IP73Pa0IDRG3LJPgZfczR06isMvvZHGAYfjO+cwznvnI/6+/0Q25Wbji8eJK8Ub//crDqxcQoQgQSJElJ+fTz+HL89Zzr9POYCmcIhRZeWMXl8OQMynKM8IUxUOEVeKuIL9qz5i+sufYQGFZUzFSp4bMYl10T0IEydIIwfwDvFaH0HqGUIFtgLql6xGxaP4qMFHjDad2r9+Al67AY4Y5x5f/TDc/DR+IE46dXvvT6b5ISoz3BvPgBC7oX5SVkwgCWM3aK1XAn8DjgMmAyuArwPjgRuBIuAJ4GJjTFRrPQK4E5jinWIm8GNjTI13vpuArwLFwCbgLmPM771tJd75zweuAoYD7wEXGGM2dBHnhcA1wJ+BHwO5wD3AzcBfgROA9cBFxpi3E477NvAD71rLgZ8bY/7rbZsA/NFrqx94H/i+MWaZt/0f3vpGYDpQB9xgjLmnp++rd0xK7q3owx5/xyWLAJ+tg3kr4Z9vb93ekixCa7IIMHOcpjEYcqt9Psqys9iUm936uLimkqNWuEkrzYQJEuHOg8+gMTuTJaMH0hQKktPUxAcH7EFx4xb2rVxMdUYarw6fwpDKGqbP+5y3xo/kx5+4N/BO/PNy1JL1hKMulghpVFBEHuUEiLXuG47X0ejLIhyPbXM80Tg8M3trwvjY1vYGaaBh8UZi89YTmDJqx++nEGK3JGMYu+8C4HtAPjAfeAY4BpgA7AecBpyttU4DXgMWAqOBccAw4A8J51oIHA5kA98GbtZan9TueucARwJDgUzghm7GORLI8659OHAZMAu4zYv9aeD+lp211t8Bfo5L1PKBXwBPa63HertY4HovjhKgFni43TXPwiVuA7zr/UlrPbKb8Xbrvnqxpvre7rSamhpZ7uXlpvFDW5dtTjqMHQSTRreu66gQoNcu2/rAWoqrawjEYq2rNmdksyanAIAIrlKXEWmmLCvM+2MHktvYSCgepy4jzIS6j8mNVzO8tpTHn3uAMZs2Mz42h6u/ehTlmdltrtvkD/K/kpKENZYMarGoNlXEOEF88Tg2oQFtqoyTRm+9DwntjRGA7DR8Ywu3uVeyLMu723LS9MMxjEpm53XNq4T92Rhzm/f4VOA/QLExpsxb9y9gHfAOcIsxZkzC8QcC7wIZxphYu9OjtX4SWG6M+VlCFewgY8wH3vZLcVXBA7qI80JcNTDPGBP31s0BPjDGXOo9Hgd86u1TpbX+BLjVGPNgwnlmArONMb/ezjX2BT4GsowxdV6FscgYMzVhnzIv3ue6iHcl3byvxpgfaa3PIkX3tgfJC663xWLwp1mwdANceCwcOAaaI3DnTFi/BY7eF17/GEYNdN3Tc5a4quOeQ3hyyjG89sinDF+zhsf2P4oDV26iIivE8Mr1lOVlU1hXzYy336Jk82YayCHuU5zxnSv4aPRApi5awYi6OL54jDue+h0+73dtdTiD8lAmwXgz74wczl8POobr33iaEeVV1KZl8c7AUazMLeLcuQsJNPnJZTMD2EQ61VQzgLg/QCwYQg3MJDfkg6wQgQ0bURlh1JAsVDwG3zoeZhy39R7UNmBveZbYW0uJlpQQvPwY/JOGpegJEWKXkpR0Tl3X0OZ3vf1Vep9PG6VLuvsSuyzrgVhLUpOwLhsYBYzQWle2O94Cg4B1WuvLcdWvYbgf1nTg0U6uV+eduztKW5LFhLjax453viov3j9rrf+YsE8AWAugtR6Dq04e7B3T8iIo9OJqH+uOxtvd+wqpv7eiL/L74QdfarsuFIQrv7L18VcO2br8vVNaF88CzjppEODGMLgfQYBJCSeb1ubU/357Fb+76g0UfnxZ2dTkZPPiuMM49dN3iCnFx4PGslf5agrrqqjx7c1Rn25gRdoeLDimkMueOZGJfr93ptO3acqAHWh2G1npqBvPJYD80hdCfDHyu6PnrQI+N8aM395GrfUU4BbcuL3ZxpiYVwVL1X8fq4DrjDFPdLD9bty4x/2NMZsTKoypiLev3VuxGxp6+Ehuf2skx09fyF+feZyHDz+R/4yfwjtjJuCLWgJRyyv7HMb0ef8lr7GBhuhmzv9gOsGstFSHLoQQHZKEsec9D/xaa301cBduzN8QXDfoM0AOEAPKAKu1ngqcgpvckQq/A67XWi/BjSFMAw4Eyo0xi714lwCVWutCenG833b0tXsrdmMv/nMf7jxwAuuywxTU1kEszpCNZQSiMZpDQd4bsR819VX85OPzUh2qEKKn9cMyhUx66WHGmHpchWscsBjX7fsqMNHb5SXgIWAOUI7r9Xqm1wP1GGPuBW7FTYSpAFYDvwSC3i4/Ao4AqoG3cElbSvS1eyt2bwG/4rI3T2HCso34m5tIr28kEHXDbEPNEWINPgY0hFIcpRBCdI9MehGid8kLbjdz5aGvs1dNDUsHD2T4htLW9aM3buLE8otSGJkQgmRNevlVY9tJL9el9fmao1QYhRAiiX716hQqg2lEA35KB+TRGArii8P6oi88hUUIIXqdjGHsQ7w3rV7YweaHjTEX92Y8XdFa3w10NEBrnDFmdW/GI0QqhDNCDFm3mXhmiMZwiPr8HCLNUUrjka4PFkKIXYR0SQvRu+QFtxt64ltvs2l2LVVF2cT8PpqUj1/NOohAoM/3UgnR10mXdDdJl7QQQiTZ9PsOp/CsWgINjYTqGvnZ/eMlWRSiP+uHn/QiXdJCCNELMg8MM+7AeqZNm9b1zkIIsYuRhFEIIYQQokf1k7JiAumSFkKIJHvw1P+w8jofS6/3cfckeR95IUTfIwmjEEIk0WMXvkHdWos/BuEoVATz+OsRKXv/eyGE+EIkYRRCiCTKeXkZVm3tngpGYzwxcGQKIxJCJF0/nPQiCaMQQiRRbnMNJLx9Wdyv2KO8JoURCSHEjpOEUQghkuSNUx6nlmwOXrKEkRvKKCitoUEFyPT7+eXU91IdnhBCdJvMkhZCiCRJe3cjE6rXoYCSxk2sYBgbMzLIro+SU1Of6vCEEKLbpMIohBBJMGviAxQ01bQOX/ITJ6Sa2TS0kOcPHkdpbg4/On1OSmMUQiSJjGEUQgjRleUvLmX0J2tJb462rouheOnwScTzMjigbAuLxgzCXxlFPp5VCNEXSJe0EELsJFvbwLrjbqV0QTmrC4eRE8mkctQohm3ewuDKzcT9lmWDBrM5Lw+AoLUMaIqwoTCbY7+5lIKaah59fCKhgD+1DRFCiA5IwrgL01oHjTGRrtYJIXbcgjLLz9+M4/fBHeNr2OuXD8LqcmoXVrK5toAoQbJsOYWsxkecOD4UCovCh6scWoI0kEM5RQxmJUNpZGPaaD4aMR6AlUWDOOHjeeTU1uNvaHv9zVlB/rXfGKJ+HxlNEQZdX8u578xj9p4lrC3IYVNeFuHGZiLKTzgWY1B9PTG/j6lLFjJhSy0fDh/GMwfsxX5DfBw8WPH2OstRwxQ3TPGhVD/pAxNC7DIkYUwCrXUWcD3wFaAIWA18F/gQuNlbnw68DVxujFntHfcGMA8oAY4FbtJa7w0EgWbgdOBx4JJOrv2Gd51RwPFAKfAd3CiK3wMjgFeB840xNd4xBcCtwIlAGvA6cJkxZpO3/QfeNYcCFcAjwDXGmJi33QKXAt8E9gY+BS40xizu4j4dDbwCnA/cCAwCngK+D9wBnAVUAz8yxjydcNwZwC+BMcAG4NfGmEe8bcOAvwEHAiFgAfBDY8xcb/v1wBHAbOAi75T/Z4y5rrNYRf9z+jMxVla75dULGljwxGwA0vHRyDB8xCliFT5cl7EfC8TbnEMRIZN64pQRopG7ppzMB4MPZsL6LQBYpdiQncMqfwGBBsvwFRsoG5RPUzDAvMGDiPrdqKD6cJD6UJC/nHAoBBUoRSgSpSk9BDFoCPtZkRUG4L7cg/jZ6/MYsa6W/dPW82p0GK+tdjG+tdYyJs9y4b6SMAqRUv3wnzYZw5gc9wEHA8cBOcAZwEbgd8Ah3tdIoByYqbVO7IeaAfwRyPW+A0wHXsQlnz/uxvW/AdwC5OESzIdwSeORuGR0L+AyAK21Ap4FLLCvF1cN8GjC+dYCp3htOd2L8SLauhA4EygE1gB3dSNOAD9wNLAfsA9wMvC+F1MBLsH+u9Y6w4v3BNz9/SEwALgA+JPW+kjvfD7gL147BuGS56e11sGEax6JS+KHANOAq7XWU7oZ706pqamR5V1g2VrL+tqtYwfXBjNbl/3E8RHHT6Q1WexKwKs4/vmwk9icEcAfiwGQ3tzE6M0bqcsJsnT0QGzAz+GzP2Payx8yrKJ26wm2c5m4colj+0HzzQE/jUH3v35u47adDcs2N3XadlmWZVmW90H9IpQMuO5ZWutiYBOwrzHm04T1PqAOOM0Y87K3LgvYAhxljHnPqw4uN8bMSDjuH8AIY8yx3bz+G8CnxphLvcfjcBW/g4wxH3jrbgX2MMZ8WWutgf8B+caYJm97AS6ZHW6MWbuda9zuxXS299gCZxtjnvAeTwUeNsbkdxHr0bhqZrExpsxb9y8g0xgz1Xuc4d23icaY+Vrr54E5xpgbEs5zF5BujGmfxKK1zsZVKccbYxZ6FcbpxpjxCft84MX7h87i7SHygttF3PBunOvejaOA2/NWc8Ul10M0Ri3ZrGcscWAon5HNZgCs1yFtSczfAsQJs5KxDOdTzrzwCmbtfQD/uucRRlTWUFhbRXokghk+hk9Gj6EiOwssnPj6POrDQX47/UjW5WSwIj8HgKzGZmpz0gDwx2LElM8VNRUon6tYTlqzka98uoaGgJ/7J+/FxtxMijNhYx0Mz4Z3zvUzPKf/VTeESJKkvFjUTc1tftfbq0N9/kUpXdI9r8T7/nm79UW47t7lLSuMMbVa61JgONDyLr4rt3PO7a3rzIaE5foO1mV7y6OAMLDJ5Y6tGnHd12u11ucCVwCjcT8zIVwVsKNr1iWcvyuxlmQxIbbqlgfGmHovrsR4j9FaX5FwjB94C0BrXQjciata5rG1D7Gog1h3NF7RT1x7mI/zxin8Ckbmjoapf4DqBjLrmygxa7HF2ahVE7EbS7H5GURmzqP547XEq5oI2ig+moA4mwI5+OKbqSXIVS8/S0FtPa+NG8wv/7MCgAg+atOzGFBdw96r1jB73F4sG1HE0LJKjl+2jlnDB7IlGCC7sYlTFy2hJj2TD/YeRkZI8eWJQYYOzyA7EiFQ2URzNMJBUzPJ3TiImpJijiCdCcWK3BAsr4KSHMjs+3+XhBC7IEkYe95K7/sewMKE9WVAEy7hWQatFcZiXBdui7aDpDpe11NW4RKmAcaYba6jtR4OPIwbdznLGNPsVRh1+317ySrgH8aY2zrYfjMwGDjYGLMhocIof0XFNkbnJfxYDM6HwfkoIHTAqDb7KSD80zMIb+cciZ8KfSgwobSGT/f8A27YcYA5Y8azcOQI0uubWF1UyODyLcTjMV6ZOJZPigYwrjjK+zfleWcY2EGkQSBj68N98inC/QfXYnxh1+0VQogvShLGHmaMKdVaPwn8RWt9IS7BGeNtfhC4UWu9EKjETexYDKTy3XsNbqLNH7TW1xtjNmuti4DjjDH/BLJw4wLLgIjW+hDcGMlFKYr398D9Wuv3gXdx1cX9AGWMMbhxlvVAhZeQ35KiOMVuKqM4m8mV1/DPIX9mYvUWtoQy2X/uMvxxS1M4SH1GkBX5GSzKzGbsxs/582NfSnXIQgjRJZn0khwzcEnYm7gJJM/hJmD8CJegfYCbdDEYN6YxlpowwasqnoH7WZirta7BzSA+2tu+CLgO14ZK4ErgsRSEihfPf3ETeG7DjbPcgJtMlOXtch2uarsZN0P6XSBl91fsvk559xuYwr3JqGzEH3fDmcJNEQo3VXPYsrU0F2Rzy/MnpzhKIURS9MNPepFJL0L0LnnB7UbuH/YYxfVNRG3IrbCWAbV11GcHuf7UKbz3yJ6pDVAIkZxJLze3m/RyVd8fXCwVRiGESJJvrj2XvIY6GsN+fLEYufUNpPmiNKTBK/eO6voEQog+qv+VGGUMYx+jtb4auLqDzacYY97qzXi6orWu7WDTW8aYU3o1GCFSoDKQRmNugIpCN2llVFkZHwwbwhkZwS6OFEKIXYckjH2MMeYm4KZUx9FdxpisrvcSov+qyQiwdvBA0hsbaQ4F+d/QQaRvrkx1WEKIZOofRcU2pEtaCCGSaPr68whuqaYyO5ua9AyqYnF+9NqRXR8ohBC7EKkwCiFEEvn9fn624FRmzpyJtXDaadNSHZIQQuwwqTAKIUQvUf2wm0oIsXuQCqMQQgghRE/qh/8cSoVRCCGEEEJ0ShJGIYQQQgjRKUkYhRBCCCFEp2QMoxBCCCFET5IxjEIIIYQQYncjCaMQQgghhOiUJIxCCCGEEKJTMoZRCCGEEKIn9cN36ZcKoxBCCCFEL1NKrVRK7ZvqOLpLKoxCCCGEED2p/xUYpcIohBBCCLErUEqdr5T6WCm1QCn1jFKq2Fv/nlJqsrf8F6XUp95yQClVrpTKTHZsUmEUohcppV4CCnvreoFAoDAajZb31vWSRdqxa5F27FqkHTvlRWvtyT19UvuTwA7XGL3u6d8CB1prNyilbgTuAs4BXgWOAz4ADgcalFKDgRJgkbW2rqdi74gkjEL0omT8YuqM1toYY3RvXjMZpB27FmnHrkXa0W8cA7xgrd3gPb4HmO8tvwZcrZR6BNgMvIlLIEfhksmkky5pIYQQQojUU4Btt67l8TvAJGAqLkFsqTgeh0smk04SRiGEEEKI1HsVOFUpNch7/G3gFQBrbRPwIXClt+59YAqwv7ecdNIlLUT/9tdUB9BDpB27FmnHrkXa0Xe9opSKJjy+GnhZKWWB5cB3E7a9CkwGjLU2qpRaCqyw1jb3RqDK2vbVTyGEEEIIIbaSLmkhhBBCCNEpSRiFEEIIIUSnZAyjEH2c1joDuB84EIgCPzHGPN/Bvt8Gfo6bjTcLuNwYE0/YnoYbWF3f229v0RPt0FqfDlwLhL1tfzfG3NELse8JPAAU4N7y4nxjzJJ2+/iBPwIn42Y+/tYY87eutvWmHmjHL4Gv4p6/KHC1Meal3mtBa4w71Y6EffYCPgL+Yoz5SW/E3u76O90OrfXZwC/ZOgP3eGPMpt5pQWsMO/tzVYz73TAcCOFmBV9ujEkc+yeSTCqMQvR9PwFqjDFjgWnA37TWWe130lqPAq4DDgX28L7Oa7fbb4D3khtuh3qiHRuBacaYfYHDgEu01kf0Qux3A382xuwJ/Bn3/mntfR0Y68V7KHC91rqkG9t60862Yw4w2RgzAZgBPK61Tk961Nva2Xa0JDD3AM8mO9hO7FQ7tNYauB44wXtNHA5UJT/sbezs83E1sMgYsz+wH+6fyq8kO2jRliSMQvR95+B+IeP9126AU7az31nAs8aYMq+qeK93LABeYrUH8FDSI96+nW6HMWa2MWa9t1wFLAJGJjNor/oxCXjMW/UYMElrXdRu13OAe40xcWNMGS4Rmd6Nbb2iJ9phjHnJGFPv7bcAV9UqSHbsiXro+QD39iXPA58nN+Lt66F2/Ai43RizEdxrwhjTmPTgE/RQOyyQrbX24XoPQsC6ZMcu2pKEUYi+bwSwKuHxalzXTbf301pnAr8HLklOiN2y0+1IpLXeGziE5L+p7XBgnTEmBuB9X7+dmDqLu7ttT6aeaEei84Flxpi1SYi1MzvdDq31/sBJwO+SHm3HeuL5GAeM1lr/T2v9odb6Gq31Dn9k3U7qiXbcCOwJbMD1IrxkjHknmUGLbckYRiF2cVrrD3G/TLdnYA9d5jZcl9E6rfUePXTONnqpHS3XGgw8B1zaUnEUvUdrfRTuj/wJqY5lR2mtg7iq9TeNMTHXq9tnBXBv7HwCrir3Ii4RezCVQX0B03EV6+OAbGCW1vosY8yTqQ1r9yIJoxC7OGPMpM62a61X47pdy7xVI4DXt7Nry34k7LfGWz4cOFVrfS2QBuRrrRd4Y4Z6RC+1o6UL7BXgNmPMv3Ym5m5aAwzVWvu9BMMPDEmMydMS9wfe48SKSmfbektPtAOt9aHAw8DpxpjPkh/2Nna2HYOBMcALXrKYByitdY4x5ju9EH+Lnng+VgFPGmOagCat9XPAQfRuwtgT7bgMmOENQany2nEMIAljL5IuaSH6vifwPg3Aqw5OxlUS2nsKOENrXeSNBfo28C8AY8z+xpgSY0wJbpbrxz2ZLHbTTrdDa10AvAz8qbdmGRtjSoF5wLneqnOBj7xxWImeAL6ttfZ547fOwLWlq229oifaobWeDDwOnGWM+bA34m5vZ9thjFltjClMeD38Hje2rjeTxZ76uXoUOFFrrbzK6XHA/GTHnqiH2rECN3sarXUIOB74JLmRi/YkYRSi77sNyNNaL8UN0v+OMaYGQGt9g9b6YgBjzHJcN+H7wBLcx049nJqQt6sn2nElbqzTd7XW87yvb/ZC7BcDl2mtP8dVQy724n5Bb+3TfMiLdYkX+w1eW7ra1pt2th1/AdKBexLu/3692gJnZ9uxq9jZdvwTKAUW4pK2T4H7ei36rXa2HT8EjtBaf4xrx+e4YQOiF8lHAwohhBBCiE5JhVEIIYQQQnRKEkYhhBBCCNEpSRiFEEIIIUSnJGEUQgghhBCdkoRRCCGEEEJ0ShJGIYToglKqRClllVLDknydi5VSDyU8nqWU+lkyrym2Tym1VCl1YTf37ZWfj96glAorpZYopfZOdSxi1yIJoxCixyilRiulnlBKbVRK1Sql1iilnlFKhbztFyqllm7nuI7Wn+f9Ib52O9veUEo1edepUkp9pJQ6MzktSz6lVCZwA3B9yzpr7SnW2ltTFlQXvOfm8FTHsTtIxr1WSh2tlIomrrPWNgG3494XVYhWkjAKIXrSC8AGYC/cZ74eCrwEqC94vu8AW4CLlFL+7Wy/0VqbBRQAjwGPK6X2/ILXSrXzgI+ttctSHYjY7T0GHKuUGpvqQMSuQxJGIUSPUEoV4BLFu621VdZZa62926ta7Oj59gGOAC7Afb7vKR3ta62N4j5lxA9s88kiSqnvK6U+ardulFIqppQq8R7f71VEa5RSC5VSX+sktuuVUq+0W/eGUuqahMf7KqVeUkqVK6VWK6VuVkoFO2nyGbiPNdzuORO6PS/w4qtTSr2glMpXSv1WKVXqVXYvTTj+Qq9r9edKqQ3ePnckxtFVu5VS+yulXlRKlSmltiilXvbWt3zE3H+9Ku92P4pRKZWhlPqDd41ypdSzSqkR7dp4h1LqKS+GZUqp0zu6SQlt+pFSaq13zO1KqQLvHNVKqcWJ1TilVEApda1SarnXhleVUvsmbA8qpe5MuIc/3851j1BKve0dv0wp9WOlVLf/EVJKnamUmu9Vw+crpb7cvk3t9v9Hyz3t6F4rpVZ67XrbW2+UUpO3d46EdSuVq9wPAWYBfu/YWqXUBQDW2mrcZzqf1t32if5PEkYhRI+w1m7GffTY35RS5yulxu3IH9Tt+C6u4vY8rnLZ4Wf5KtflfSkQYfuflfsIsI9SamLCuguBN6y1K73HbwMTgTxc1/A/lFLjvkjgSqli4E3gaWAIrtJ6AnBVJ4dNwn2EW1fOBA4HRgAlwGxgmXedbwK/T0zIgJHevqO9OKYBP0nY3mG7lVKDvXa86V1rEHALgLV2gnf8idbaLGvtRR3E+zvgEO9rJFAOzFRtK8YXAHcCucCfgAeUUhmd3IORXryjvXtxGS75uQ3Ix933+xP2/ylwPnAq7p+Pt4CXlVI53vYrgS8BhwGjvLaObDlYKTUe9zN4G1AETAW+D3yjkxhbKaUOxf0MXomrhl8NPKaUOrg7x3dxry8GfgAMAJ4EXkhoV2fnXI/7JyzmnTPLWvtAwi4f434mhQAkYRRC9KyjgTdwn/06D9iklPplu8RxlFKqMvELVx1spZRKw/0x/ru36j7gVLXtpIJfeMevBU4HzrTWbjMW0lpbATyHS6jw4rkg4fxYa++z1m621sastf8EFnjt+SLOB+Zba++x1jZba9cBN3vrO5IPVHfj3Ddaa7d4CfrzQMRae6+1NmqtnQVUAAck7B8HfmqtbfC6u2/Fuw/QZbu/ASy11t5sra3z2tKmstoZpZQP1+ZrrLXrrLV1uJ+NfYCDEnZ93Fr7jrU2DvwVlzju0cmpG4BfefHMx/2T8IG19n1rbQz32eJjlVK53v7fBG6x1i72qt03ADFc4ocX4y3W2qXW2gZcQp34ubmXAE9Ya5/z7tNiXGLb2fOZ6JvAU9baWd7z9B/gGWBGN4/vzH3W2rnW2mZcMt+AS353VjUuCRUCkIRRCNGDrLXl1tqrrbWTcBWgnwHXkpCgACustXmJX8D32p1qOpCF+8MPrrpTCrSvYv3GO0extfYwa+3MTsK7H/i6V4081ovvaXCJjVLqBqXUZ16XYSUwAVdN+iJGAVPaJcV/x1XoOlIBdFkZwo0RbVHf7nHLuuyEx6XW2vqExyuBYdCtdpcAn3cjpo4UAWnA8pYV1tpa3HM5PGG/DQnb67zFxDa0V+olly3a34eW9racY3i7GOK4+9ASwzDvcWIMpQnnGwWc2+75vA5XreyONtf3LKPtPfiiVrYsWGstsBrv+d1JObjxw0IAkjAKIZLEWltvrf0HrmI1cQcP/y5uPOInSqmNuAriAOBbavuTX7rjv0AjrvpyIfBPr5oEcC4uGT0TyPeS2Pl0PFmnFshst25IwvIq4JV2iXGuN0GnIx8BX6gLvAvF7bp3S3D3E7pu90o6r/TZTrYBlAFNuIQLAKVUFlAMrOlW9D1jTbsYfLj70BLDOu9xy/ZMXIwtVgF/b/d85lhrx3+R63tGJ1y/q58n6PheJ8atcMMPWp7fNudVSgVo267EpLu9fXE/k0IAkjAKIXqIcpMvblZuskfQm2hwJu4Pz1s7cJ5xwBTgy7hEs+XrIFyF7tQvEp9XVXoQuBz4Cgnd0bhqShSX4PiUUjNwlbaOGGCSUupAr53fp21C8CCglVIzlFJpXiVvtFLq5E7O+Sxw/A43rGs+4LdKqXSl1Ghcd2vLWLWu2v0wsJdyk2YyvOf1uITtG+kkoUy45zcqpYZ4iesdwGJgTg+1rzv+AfxMKbWnV2H+BRAA/uNtfwj4qVJqjFIqHddtn/jPwl+AryqlpiX8bI9TSh21A9c/Uyl1klLKr5Q6Bfcz2DLO8iNcYv8l72fly8CR7c7R0b2eoZSapNxEpp8CGQntMsBxyk3wCgO/ARInXm3ETXppk8wqpbJxr7d/d7N9YjcgCaMQoqc046oXT+O6ssqAa4DLrLVP7MB5vgt8aK2daa3dmPC1AHjC2/5F3Q8chesWT0xYHsBNHlmKqzaNo5Mk11r7Bi7xeRHXFToQeCdh+0bgGNzM55W47uZncFWljjwETPCSup60CtemFbg2vohLiKCLdnsTI47GTdhZC2wCEmcQ/wK4QSlVoZS6p4Pr/wiXuHyA6y4dDJzmjTXsLbfh3irmv7g2HIubQNIyZvRm3Ns/vY+7T6tx9w0Aa+0nuMr0D3HPdykuCezWkAVr7bu4MbO3434WbgXOs9a+721fhpu48lfca+dk4Kl2p+noXv8V+KN33nOAqdbaKm/bI7ik70NcF/hq3PPcEtfnuGR4jtfV3jKJ51zgdWvtku60T+welBvyIIQQItWUUhcDU6y13Zp9243zXYibcCLvp9cPKaVW4p7fh7vadwfOGQY+wSX1i3rqvKLvC6Q6ACGEEI619m7g7lTHIXZf3izyzsatit2UdEkLIYQQQohOSZe0EEIIIYTolFQYhRBCCCFEpyRhFEIIIYQQnZKEUQghhBBCdEoSRiGEEEII0SlJGIUQQgghRKf+H4Y2riMLuuRrAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "del result\n", + "%time result = taskGraph.run()" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "

Shap Summary, Train

" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 32, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "display(HTML('

Shap Summary, Train

'))\n", + "result['train_shap_dot.summary_plot']" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "

Shap Summary, Train

" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "display(HTML('

Shap Summary, Train

'))\n", + "result['train_shap_bar.summary_plot']" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "

Shap Summary, Test

" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "display(HTML('

Shap Summary, Test

'))\n", + "result['test_shap_dot.summary_plot']" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "

Shap Summary, Test

" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "display(HTML('

Shap Summary, Test

'))\n", + "result['test_shap_bar.summary_plot']" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We run the XGboost performance metrics again for 100K samples:" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "ef6d3363fec0465282356c59c5c067b5", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "GreenflowWidget(sub=HBox(), value=[OrderedDict([('id', ''), ('type', 'Output_Collector'), ('conf', {}), ('inpu…" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "taskGraph=TaskGraph.load_taskgraph('./10assets/parallel_xgboost_performance.gq.yaml')\n", + "taskGraph.draw()" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[10:45:02] task [xgboost.dask]:tcp://127.0.0.1:36079 got new rank 0\n", + "[10:45:02] task [xgboost.dask]:tcp://127.0.0.1:39245 got new rank 1\n", + "[10:45:02] task [xgboost.dask]:tcp://127.0.0.1:41915 got new rank 2\n", + "[10:45:02] task [xgboost.dask]:tcp://127.0.0.1:37343 got new rank 3\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 4.97 s, sys: 336 ms, total: 5.31 s\n", + "Wall time: 55.1 s\n" + ] + } + ], + "source": [ + "%time result = taskGraph.run()" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train R-Squared: 0.6240418005318643 Test R-Squared: 0.11996625136005122\n" + ] + } + ], + "source": [ + "print('Train R-Squared:', result['train_rsquared.out'], 'Test R-Squared:', result['test_rsquared.out'])" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [], + "source": [ + "train_infer_df = result['train_infer.out'].compute()\n", + "test_infer_df = result['test_infer.out'].compute()" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Train')" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYoAAAEWCAYAAAB42tAoAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAAw40lEQVR4nO3de3Rc9XUv8O+ekWxDAzWIEBNAcUq5BKfmFRdQA0RpIDwKsYvbrJCs2gVjgcEQp7AAr7Q39LpZpg6lCmAgAtvXasnjdjlgJ8GEwEKBhAFssMENToAScBxbgQhcaGNLlrTvH3t+PWfOnDkzI50zZ2b0/aylNa8zo9+x4Oz5Pfb+iaqCiIiolEzaDSAiovrGQEFERJEYKIiIKBIDBRERRWKgICKiSAwUREQUiYGCKEUislFE5qfdDqIowjwKouqIyH/5Hh4IYBDASP7xFap6f+1bRZQcBgqicRCR1wFcrqqPhrzWoqrDtW8VUbw49EQUExHpFJGdInKjiPQDWCMih4jI90XkLRF5J3//KN97+kTk8vz9vxaRn4jIrfljfyki56d2QkR5DBRE8ZoG4FAAHwLQBft/bE3+cTuAvQDujHj/aQB+AeAwACsArBIRSbLBROUwUBDFaxTAV1R1UFX3quqAqq5T1d+p6nsAvgrgExHvf0NV71XVEQBrARwB4AM1aDdRSS1pN4CoybylqvvcAxE5EMA/AzgPwCH5pw8SkWw+GAT1uzuq+rt8Z+J9CbaXqCz2KIjiFVwdch2A4wCcpqoHAzgr/zyHk6hhMFAQJesg2LzEHhE5FMBXUm4PUdUYKIiS1Q3gAAC/BfA0gIdTbQ3RGDCPgoiIIrFHQUREkRgoiIgoEgMFERFFYqAgIqJITZlwd9hhh+n06dPTbgYRUcN47rnnfquq7w97rSkDxfTp07F58+a0m0FE1DBE5I1Sr3HoiYiIIjFQEBFRJAYKIiKKxEBBRESRGCiIiCgSAwUREUVioCAiagK5HLB8ud3GrSnzKIiIJpJcDvjUp4ChIWDSJOCxx4COjvg+nz0KIqIG19dnQWJkxG77+uL9fAYKIqIG19lpPYls1m47O+P9fA49ERE1uI4OG27q67MgEeewE8BAQUTUFDo64g8QDoeeiIgoEgMFERFFYqAgIqJIDBRERBSJgYKIKEKSGc+NgqueiIhKSDrjuVGwR0FE5OPvQSSd8dwo2KMgIsoL9iC6u+3WPR5LxrMLOEkkwtUKAwURUV6wBzEwML6M52YZukp16ElEzhORX4jIqyJyU8jrXxCRF/M/T4nIiWm0k4gmhmDNpLa28fUGmmXoKrUehYhkAawEcA6AnQA2icgGVX3Jd9gvAXxCVd8RkfMB9AA4rfatJaKJwF8zqa0NWLJkfL0BF3jGM3RVD9LsUZwK4FVVfU1VhwB8G8Bs/wGq+pSqvpN/+DSAo2rcRiKaYDo6gKVLbdhpvL0BF3iWLWvcYScg3TmKIwH8yvd4J6J7CwsAbCz1ooh0AegCgPb29jjaR0QTWFy9gSSL9dVKmoFCQp7T0ANFPgkLFGeU+jBV7YENTWHWrFmhn0NEVKmkS3c3kjQDxU4AR/seHwVgV/AgETkBwH0AzlfVgRq1jYioKXoDcUhzjmITgGNF5MMiMgnA5wBs8B8gIu0Avgvgr1T15RTaSEQNiqU34pNaj0JVh0VkMYAfAsgCWK2qPxORK/Ov3wPgfwNoA3CXiADAsKrOSqvNRNQYxpK/kMsBvb12f9489iT8Uk24U9WHADwUeO4e3/3LAVxe63YRUWPr6wMGB4HRUbvt6yu88AezpXM5uz80ZK+vWQM8/jiDhcPMbCJqOm1tFiQAu21rs/uu17B6tS17db2Nvj5g/37v/W45LAOFYaAgoqYzMABkMhYkMhl77Iaj9u0DNL8u0gWEzk6gtdXrUTRyclwSGCiIqOl0dgKTJxfmQLhyGi5IiHivdXTY65yjCMdAQURNxc0/dHdbT8KfA+ES6FpagEsvLQwIXApbGgMFETWNqNVOTKAbOwYKImoa5VY7sdcwNtzhjoiaRqnVTjQ+DBRE1DDKZVu71U6At9oprs+eyDj0REQNoZJs67DVTnF99kTGQEFEDaHUbnHByen58+22miWu5eY2JjoGCiJqCMH9IdraCnsB3d3Atdd6y1+dSi74nNuIxjkKImoIwd3i/DvQ7dsHfP3r1htQtXIc3/iGBZJK5hzGM7cxEbBHQUR1K1i8L7i8taXFAoUq8POfF75XNbxmU/AzgbHPbUwUDBREVHNh1Vv7+mzIx2VTA6UnmN3x558PrF/vleXIZi1wANYzCF70S01aMxkvGgMFEdWEu7jv2QPcdpvNBUyebHMLS5Z4k8mZjD0/f37x5LULKu5i39JixfxcJVhXtsMfcPwX/bAJcZbwKI+BgogS5y7uLhg4g4PAqlWFFV1HR+1xf3/h5LXrGfgv9gCwcCHQ3l5ZTyA4IZ7WEFPY8Fc9Y6AgosS5i7s/SDhbtnhBwlEFNm4Ebr+9uGcQvNhXswy2HoaYgsNfYcUL6w0DBRElzl3c9+4tfP6444CXX7b7IsDxxwPbt1ugGB62C+jSpYXvGe/FPu0hJn+PaHAQuPpqO996TvTj8lgiSpy7uF95pc0ruL0gliyxCWgRm2v44heBKVPsubiGhuIqzRHX57igmc3az+hocRJhvWGPgohqwn2TnzfP6w0AFiT8t+eeC+zaBSxYEP7tuppyG3GV5oizxIe/R9TWZsEy7TmTchgoiChxYfkQgH1DHx72kuSuusqbpN66FZg5s/iCHLVyKaiaY6PE9TmO/99g5sz6n9hmoCCiRPlXPGUywMqVQFeXveafmBbxggRggSMsWW7HDhuyAQq/hZdKpItjlVOSq6XSnjOpBAMFESXKX3BvdBRYvNjrKQSHYa691o4FbM6iVLJcS4sti3UrnpJKpPMHn7RXS6WJgYKIYue/wAa/fY+MlE50mzkT6O21+8Flr8H8ifZ27/WxJNKVy2UICz7BFVgTBQMFEcUqeIG95prC/IlMpvTQTdRFfccOrypscPin2qGhSian456XaGQMFEQUm1zOVvG4TOvBQeC++wqPmTat/Of09ADr1gFz51ovw13Us9nCISen2iGmSoJAvWRx1wMGCiKKRS5nF9OhIe+50VHg7bcLj/v1r+3C/9hj9jh4ce/pAa64wu4/8ggwZ074kNN4ymBUEgTqIYu7XjBQEFFZlVyU+/pspZKfiPUsRIBDDgHeeccr/93bC6xebe9pbfW+1a9bV/gZu3YVX9TDymC4woLZLHDnnd7KqjCVBoFGWJFUCwwURBTKX/rbnxRWKtmss9Mu+K5H0drqLXmdNMlyJvyf09/vHesCBwAceGDh5y5YUJxrsHx54dDRunWFK6uuvjo8B8OPQaByDBREVMT/jV3EuwCH7VXtv9/XV7hqCfAeA4X7WfufByxwuN/Z2gqcfLIFCdcz8F/Ug0NHc+cCjz9euJ1pUpPPjVb5NQ4MFERUxD/Zm8l49ZgmTbL9JM46yy7Gra2WWT0yYiuSnngCuPtu+4xczhteGh729ppobbXXTz7Z7ruhJ6Cw3PicOaWHj0oNHV19tbUlm01m3+s4S3k0EgYKIirivrG7bOovfQmYOtWCxK23et/cXXIcYMFgxQrggQe8C6r/wg/Y+wYHbT/rTMb7HFXgBz8o3KkuapWRC0J+LqhcdZUFn2uvLT/8VK2JumSW1WOJqEhHh00Qu+qmd9xh39DdznSluJLhLhs7uM+Eo+rtdQ1YkPFPhF92md2GVWt1q6vuucd+PvlJ75gtW7zVUYODxcFkvPyVXyfSkln2KIgo1JYtXsE+N2EcTJw74QQr3uccdpjddnZ6QWYs3nuv9BBPcHXV4CBw8832k7Rqlsw201wGAwURFcnlgDVrCoeC5s4FnnzSLswiwEUXAeefDyxa5AWEn/4UuPFGG6b60pe8HkgmY0GnUs88U3qIJ7i6CgAefdTa1t1tgcXNe7gJ9VLnGDYhX+6iXslqqWaby2CgIKIiwW/tp59uu811d1tPY9UqYP16m1fwGxmxeYpMBpg82SrFum0+t22z9z3/fHHQyGYLK8defLENdwUT4tzF/Y47rB3PPw9s3uytyBoYsNf9F/2wb/bBAoNuKKyai3pUj6HZ5jJSDRQich6ArwPIArhPVW8JvP4RAGsAnALgy6p6a+1bSTSx5HLAww8XDhs98YR9Y580yXoRLogEE+wc/4XbFdLzXyiHhoAXXvB6LKq2yul3v7OeS1eXPQ5e8IPf0ufNK3wuuN9FqW/2/gu5f0K90ot6uR5Ds5X/SC1QiEgWwEoA5wDYCWCTiGxQ1Zd8h70N4FoAc2rfQqLmF/xWnMvZ5LB/NZPjajf55yRKyWSKL5D+0hxhx99wQ3H9Jtem5cutKKD/W3pvr5Xz6O72ei2VfrP3X8iDPYpKLurlegzNVv4jzR7FqQBeVdXXAEBEvg1gNoD/CRSq+iaAN0Xkz9JpIlFzKDf84spguAznKG7jIP9QkSMCnHkmcOih9njFCrudNs2GiYLHinglN8qV+s5mveqxLS2Wn1FuuKjUN/vghRyo7qIe/Ny2Ngtm/vc3U+Z3moHiSAC/8j3eCeC0lNpC1LTCdpibOdNWCbmyF4ODXrJaOarAcccB27eHv/bkk+HLYltaio/NZm3Se2DA2ukPYn19wLPPFuZiLFxovYgdO4B77y0/BxD1zT54Ia/moh6173WjT1yHSTNQSMhzJVZdV/BhIl0AugCgvb19rB9D1DTcxXbHjsI6SFddZRdof7Y0UPmqJFUvX6LU62FGRoATT7S5CWd4GPinf/KyvF15EBfY/PMk2WzhjnZr1tjrLS3Rw0VJfbN3nxusO9XoE9dh0gwUOwEc7Xt8FIBdY/0wVe0B0AMAs2bNGnPAIWoG/l6EBL6SjYx4PQf3WrX5DpX0PIJEbOVTqc8aGrJv5qecUhwkRCwJz38B9k+Ep6nZJq7DpBkoNgE4VkQ+DODXAD4H4PMptoeoabjMaHexzWQKS2Y4qrW70FYSjDZtsmWvwSAxZYrVhnLzAH19XmZ3cGtVp1YJb802cR0mtUChqsMishjAD2HLY1er6s9E5Mr86/eIyDQAmwEcDGBURJYAmKGq76bVbqJG0NlZGBhGR4EjjgB27061WWWpFg6BiQDnnGNLZv3zAC6xrtS3+FonvDXTxHWYVGs9qepDqvq/VPUYVf1q/rl7VPWe/P1+VT1KVQ9W1an5+wwSRBW48EJv/gGo7yDhVkCJ2JyDq6c0ZYpNug8MFM4DDAzYxX/ZMm+nPH9dqLDlqzR2zMwmajI33mgVXms5rFQJV302KJu1WzdXMTwMfP7zwFtvASed5K0sCvYg/HkWwd7DRJg3qCUGCqIm0tPj5S7Uk8mT7WL94IOFzx9/PPCJT1jZcUcVuP9+61088ohXDqRUYl1Y72Hp0uafN6glBgqiBhVW1O5f/iXFBpUwYwbwxS9a7sb3vle4Yuq112zuIZMpXknlekNh5UD8opLqGCDiwUBB1IDCitq5vIh6s327BYPubmurPyAMD1sAuO664p6QiJ2XKwcSlv0MTIxVR2ljoCBqQH19XsbyWHIaakkV2LvXKscGVzS5APD3f+89n8kA119vcxptbRZIymU/s/eQLO5wR9SA9uypr4nqSjz3nPUoslmbc5g9G5g/3/Im/HtLqFqQWLrUhqsAYONGC4yVrmJyhQSDu+PR2LBHQdRgcjngu99NuxXVGx0FLr3U7vf3214Ww8NesT9XslzEajz19ADXXGPP+4NiuZId1eRQNNMudElioCCqc8FJ67POqm63uLSIFE5St7ZadvWSJTYU5QwP294TALBhgwWUBx/07gc/89JLoy/qlW4a1Gy70CWJgYKojrn9IdzF7LTTGiNIOC0ttmXqtGnAwQcDX/uaDSEFTZtmVWHXr/eeCwsSU6ZEb28KVJ5D0Wy70CWJgYKoToQNg/T2evtDDA4CTz+dVuuq5zY6mjbNehKlNi2aPNm7+E+a5J1vNmvBYXjYAs7ll3vVY6NUugqKSXmVY6AgqgNhwyDbtlnegZ9/0rdRrFplgSLIleu4/XbvYn777VYG3V/+3A1hVRIknEpWQXFZbeUYKIhqLKzn4B8G2bfPVgO98kqKjYzR8DDwwQ8WP69qAWFgwB7ncrbDnis94obYoirEjheX1VaGgYKohkpNoLa1Fe6v0CxBArDzvOEG4O23gSee8J53eRSdnYX7Z7jeREuLN/Q0nqEhrmwaPwYKohhUejHq7fVW/Ozda8Mpp50GfOtb9ZlVPV6nnmoZ2UDh/EprK7BggTec5HaJc0Hi7LOtaiwwvos8VzbFg4GCaAyCS1YruRjlcrbPs9+rr9pPI3G74pVL+MtkLBi4QODfVc8FCZc4F5xYvvlm799wPBd2rmyKBwMFUZWC31Lnz/cuRoODdpGbO7e40qnbla2RTZ8OHH64ne/Wrd7zYcFjdNQS5rZssclsfyA4+eTCZb+PP57MxDJXNsWDgYKoSsFvqYAt5RwZsYvjI4/Yj1utc9FFNkYfthdDo3n9dfsJ7sN95pnA6acXF/YbGrIS4lOm2BDUli32/P33Fy777e0tnx8xVvPn2201q6aoUEWBQkT+UVVvLPcc0UTQ1mYBQNX7dhw2DONW6zz4YPE+DI0ueL5PP22BotS+3ENDFiTWrLH7wff398c/lxDs+SUViCaCSosCnhPy3PlxNoSonoQVlcvlgEWLbDhlZMS+VZ97rl0AGylbOglDQ9abCJuQd6ub+vut9xAMEtmsJeXFvXUpt0ONT2SPQkQWAbgKwDEi8qLvpYMAPJVkw4jSErZSBrDnXGlvZ/16W8ETtvEOFWZU9/YWv57NAnfdZVVi166Ndy6B8xPxKTf09E0AGwEsB3CT7/n3VPXtxFpFlKJS30TDvg27YRUKp2pDc24Y6d57CwPqRRcBXV12P+7JbGZex0e0gqL2InI6gJ+p6nv5xwcBmKGqzyTcvjGZNWuWbt68Oe1mUIMqVU6jVK0iitbaCvz4x3ah7umxEh0uWEyaxCWr9UJEnlPVWWGvVTpHcTeA//I9/u/8c0RNx30TXbjQVsxs2+Ylf1H1XPkNwHoPCxd6q6b8r1H9qnR5rKiv66GqoyLCpbXU0EplU+dyNp7utu5stJ3k6oUr6jd5cuH8wLx5pecjWG6jPlV6sX9NRK6F14u4CsBryTSJKD5RwSBswnrFCpugZnCojghw5JHA7t2FGdgLFxbnL7geW3Byu5JyGwwk6ag0UFwJ4HYAfwtAATwGoCupRhHFIXjh8Sd89fd7K5j27QMuuQTYsYMBYixEbB7iwguBl17yCv+5gOHmJtats4x1N3ntehVr13qTzlHlNli3KT0VBQpVfRPA5xJuC1Gs/BeewcHCSVQ/VeCNN2revKZx5pnAM8/YiqZgHkUuB/z5n3sJh488YrcDA8VBodxyVtZtSk+5PIobVHWFiNwB60kUUNVrE2sZUYVKDUe0tdmtiP0wzyEZb71lczlh/74vvgi88ELhc+vW2eKAYFAot5yVeRHpKdej2J6/5VpTqply49Du9bY2YONG2wVO1SZN3XBELlfYg2jGEt618qEPATt3lg60u3dbYh1gE9j790d/3ty5pYNC1EZCzItIT0V5FI2GeRSNq9w4dHCDG79MBvjMZ4Bdu2y+ob+/tm1vVq64YVSPzJ+BvW2b9RpOOgm44w77W2Yylni3YIE3R0H1JSqPotzQ0/cQMuTkqOpnxtk2ogKlsqLdt0j3elgPYXS0+Yrv1QO3ZWlYwT9neBhob/d6BC4YzJlTuG9HX58Fe/YGGku5oadb87cXA5gG4F/zjy8B8HpCbaIJLDgO3dbm9TBaWmw3OKq9TAa47jrgttssiAcHIkSsFxcMAi5wcMVSY6u0hMcTqnpWuefqBYeeGk9wxzi3xr6/n3kN9SCbBZ580u67ZMTgXISrEvv4414QcH/XHTu8Ok/ZLLBsGbB0aU1PgcoY89CTz/tF5A9U9bX8B34YwPvjaiBNbLmc7XY2OGgXkeuus7X1YfMQlA5XamPp0tI79al6mxAFexHZrPUIVa134lakUWOotNbTlwD0iUifiPQBeBzAkqQaRc3L7emwaJG318OKFd5uZyMj9njvXgaJerNmjf3N2tqi/zbPP+/1JNx808gIcP753qT4kiWFe31Qfas04e5hETkWwEfyT/1cVQeTaxbVu6glrFFlMzo7vbLcq1YBd94JbNhQkybTOL3yiiXXfexjNsxUajhw82b7O19wgfUkABuSmjbNmxhnwlxjqXQr1AMB/A2AD6nqQhE5VkSOU9XvJ9s8SsJ46+VETUyWqqHkxqn949r791uw4PxD4xgZAZ591u5nMla6Q7WweKILBOvX238Drt4TEP/mRFQblc5RrAHwHAB3WdkJ4N8AjCtQiMh5AL4OIAvgPlW9JfC65F+/AMDvAPy1qj4/nt850cWx+iSqlELwtd5eYPXq0pv7bN069nOhZEydCrz3XnTeRCYDnH22ZVhv2wZcfbW3Gsr1NlwAcctmASbMNapK5yiOUdUVAPYDgKruBSDj+cUikgWwErb39gwAl4jIjMBh5wM4Nv/TBe6BMW5x7CPslrC6MtLPPmsBKJcDHn7YvlG6JK2XXoreAW5oiD2KerNnj008H398+OsilgV/8812sR8Y8AJDJgP88R/b69lscc+ho8MmxBkkGkulPYohETkA+eQ7ETkGwHjnKE4F8KpvJdW3AcwG8JLvmNkAevN7YTwtIlNF5AhV3T3O3z1hjbVeTnC4qrvbK5Hx4IPAD35gAcL/LXT/fm9JJTWW/fuBT3wCeP11b6HBccfZ1qVTpxb2CIL/TXV3e9nZrlwHNbZKA8VXADwM4GgRuR/AxwH89Th/95EAfuV7vBNAMJ0q7JgjARQFChHpQr70eXt7+zib1rzGUi8nbLhqy5bioBCGvYXGNDpqJTfmzSv/30rwvynAVjUNDdkXhZkzGSwaXdlAISIZAIfAsrNPhw05fVFVfzvO3x02dBW8rFRyjD2p2gOgB7CEu/E1rblFFV4L09fn5TS4dfL33Vd8XNRKGKpfLS22l8SuXcCmTd4Q0sBA5f+t+I9bvpzlwJtN2TkKVR0FsFhVB1T1B6r6/RiCBGC9g6N9j48CsGsMx1CEXM7+xx3PmnX/uvnRUeDpp22SMuj3f3/sv4OSJ1L8eM4c22jogQdsyGjKFJtbCG5fWg03FBU2R0GNqdKhpx+JyPUAvgPgv92Tqvr2OH73JgDH5rO8fw3bGOnzgWM2AFicn784DcB/cn6icnHV19myxestiJReqbRnz3haS0lz+3K4oC8CnHpqYYnvOFYlsRx486k0UFwGG/K5KvD8H4z1F6vqsIgsBvBD2PLY1ar6MxG5Mv/6PQAegi2NfRW2PPbSsf6+icC/T8PAgOUtlBoCqDSXIpcrzHXg0FJjyWa9qq+TJgHXXGOF/UZHw3sN1Q5LlhLX51B9qDRQzIAFiTNgAeNJAPeM95er6kOwYOB/7h7ffQVw9Xh/z0QQ3Kchk7GxZ7ehjH8IoFRPIyx49PaW34iG6tOnP21LWIHCv6u/9Dcv5lSJSgPFWgDvArg9//iS/HOfTaJRVL3gPg1uqerChZbw5C4KuZxdPFxA2bfPq9TqDx7d3dYr4eY/9efAA+3vpmqZ0UuWAN/8pu1C5+dfmhpW+puoUpUGiuNU9UTf48dF5IWSR1PNuQlEf4/C1dnxB4ng7nCqljkNFAaPRYtYlK9ezZtXvGx1zhzLe3C9PxEL9ERxqDQze4uInO4eiMhpAH6aTJNoLNwE4j/8A/CNb9gOY6p2v7PTgkRvrwWBYAAYGbEMan/wYJCoT62tXt0kv44OK7DY0mJfEqZM4Wojik+lGxdtB3AcgB35p9oBbAcwCptKOCGxFo5BI25cNN5CfUGLFgH3+GaR5swBHnrIK6eRzdqP20jGlYKm9J10EvDZz9p/Dz/6UeECgkmTbKjJPyEdLMrI+Qcaizg2LjovxvZQQNzbROZytieA38svF+c+LFliS10PPJClvutFNgvcdZfdX7bMW9LqL7J3661ej29wsHA1G+cfKAmV7kfxRtINmciiqrFWy+0WFyzE9/LLhQlXo6PAP/+zN59B6ctkLEh0dHjZzf75JpfH4u/5ZTIcYqLk8RJRB+LMZO3ttW+ZwRFFVSvo5oKCu+CMjNgEKOckakfE5o5uuKE4W9pNQPv/m5g8GVi50noYK1fa/IPbC2LlSvYgKHmVDj1RgqIyWf1JdFu22HPz5pW+OASXs2Yy3qb3v/d7hctn3R7GYdNUrhooxSOT8Woo3XWXLTYAgGOOARYvtoDtT4CL+m9i5kzOQ1BtVTSZ3WgacTI7TNhyVsAu4qWGp4KT2GedZd9A584FvvY14NVXvdeOPNL2Dli/nhnXSWpttRVJAwPVbR1LVEtxTGZTCoJJdM7+/aUDxbx5lhexf78NW+RyNgH64x8Df/EXhYFCBPje9xgkkpDJAGecAcyYEd0DBDgBTfWPgaKOBZPonNbW0vMYHR0WRPr6bOe5Bx+05wcHgYMOAr7wBeD+++25YCYvVeeAA4C9e73HIsCZZ1YWHIgaCQNFHfIPRbhx6rA5ilJDFu4b6qJFxZ990EGlf28mA1xyiS2t3b49ttNpWv4gAVjP7LzzbKtPombCQFFnwnIqwi48YccBhYFj3jzbYGh42Iah+vtty9JSRkftc955J4kzaw6HHmr/PmHDdVE9PaJGxkBRZyrNqQge19sLrF1rQ0zZrE2eAt4Fze1tXQ6LAJZ2wAGWMd3T4/27ZjK2l/Rxx9lyVw43UTNioKgz/o3qW1psT4lcrvgCFNzQvr/fqyg6Ogpcld85hGU5qiNi/+7+0uqtrcCCBV6NJReQMxnLY3BLXYmaFZfH1iFXwG/1aq8W02WXFU+Q+nMsrr3WLl40NlOnAiecANxyi/3bf+MbXib0FVcAd9/tHcvlrNSMuDy2wbiVSy5zemTELlxr1xbWgXKT1suXh+9hTdE+/Wm7nTu3uFewdq3XWwtWa+VyVppoGCjqlBtacitrVEvPWXR22nDJ6GjhnsiAt5LplVeATZuYM+HMmQM88ED4a9zzmagQaz3VqY4O22XObT4E2P1Sq2pcAHB7JPt99KPAM88AH/lIEi1tPAccYBPPUTo6bLUZgwQRA0Vd8+9QJmLzFKVWQI2MWLAITl6LAHv2WE7Fyy8n2dr619ICXHnl+Mu4E000HHqqoWonQYMrm8J2Ngsel8kUBouREWDFiuL3zJkDTJvmTdo2iz/8Q+C112z4LZsFrrsOePdde43Z0kRjw0BRI2PZnKjSsXL/cW1ttiGRWyobJpu1SrLPP18cWBpZNmsrlgDOLxDFiYGiRsa6OVGlK2yCxy1aVDpQjIx49Z6aiar9u3JugSheDBQ1EhxGSrLUw8aNzbsRkX+nt49/3J776U/tOf9+DkQUHwaKGqnVkstczkqHN6uLLgJOPbXw35AJcETJYqCooUqGkUpd9KIuhv7X+vqaa3Lab/Lk8HpKTIAjShYDRR0pNeEdNREefK272y6owRLYjUoE+PznLReEPQaidDCPoo6ETXhHPR/22pYtwLnnAtOn20U26H3vS/os4uPqLP3rv3KCmihN7FGkKDicVGrCO+x5f0FAfw5FT09xCQ//41NOAZ54okYnWIVMxgKDW6orYnt9l8odIaLaYaBIULl5hbDhpLAJ7+DzQPFw05YtwL33Fq92cvWfVO1ifOihCZ7wGB1+OHDxxdZ+wNp59tnAzTezF0FUDxgoElIuwa5UXkWpiVn/88uXF753YABoby+965qI7a/g8gzqzbJlwMyZhRVbGSSI6gcDRcxcL2LHjugEu/HkVQTf6/bTbmmxcuMux2DGDBu6WbnSS7Dbs8f7HBHgAx8A3nwznbyLTAa4/nqvxDcrthLVJ25cFCN/LyKbtQvx8HDpkh3jWf/vn6NYssQ2LRKxPANXGdW9vmhRfSXgcWiJqP5w46Ia8Q8nAcDChTYkVCoQjGf9v3vvokWFdZ3Wrwdefx3Yts2bl0grSBx8sFeQzxGx5bsMEkSNg4EiQhzVXpO8GPb02ASwv1OoCmzdWvi4tbVwD+haaGmxABY0e3Z40hwR1S8GihKSrPYaV/sWLy5f+TWTAe68E1i3Dnj00dK9i2nTrPfz7LPxtO/YY4v3v8hkrPwGgwRRY2HCXQlRSW5RarUzWm9vYS8hkyne2Q6w1UQDA7Yv9OTJdkw2C5x0UuFxb75peQv+HfXG45VXCnfby2RYtI+oUaXSoxCRQwF8B8B0AK8D+KyqvhNy3GoAFwJ4U1X/qJZtrGW112rlcl7OgXP99bYZ0SWXAG+84T2/bZv9TJoEXHMNcNtt1qv4xS+As87yku9GR8eWiHfAAeHlQkZGgMsvt15KW5sFK65mImpMaQ093QTgMVW9RURuyj++MeS4/wvgTgC9NWwbgNoOI5XjX+E0MGDDQ8EhJzdp3N/vPZfJ2BzF6KjNF3z/+96WqUNDtnw2l6t8/sIl7vldfDHwne/Y6i6/WszREFFtpBUoZgPozN9fC6APIYFCVZ8Qkek1a1VAGlVJgxPobq5kcNDLsg7z/PN2679gn3EG8Mwz9l5V4KWXvNdaWuxC/t57lW1ilMkAn/kMsGFD4TzHRz9qeRqLF9vvzmS8JboMEkTNIa1A8QFV3Q0AqrpbRA4f7weKSBeALgBob28f78elImwC3c2VuItzqbSXTZuA554rDCRPPQVceKEtmfW/TwS49FIbkvrmN4s/S8QCSUdH4dBU2O9va7OEuZkz66P3RUTxSyxQiMijAKaFvPTlJH6fqvYA6AEs4S6J35G0sAn0trbK9rVWLT5meBh4++3iIaNsFjj5ZOCqq8IDj3tuxgzgJz+xIOEmpf2fJWJDYQD3hCBqZokFClU9u9RrIvIbETki35s4AsCbSbUjTePNw3BZ1yMjdnEfHa1+U6Innyx+z9/8jZX8iAo+bghr8mRrT0sL8NBDhUFiypT6muQnomSktTx2A4D5+fvzAaxPqR2JccNIf/d3dpvLlX+Pm0BftsxuBwa8YafRUeDEE6PfL2IBxr9MNiywTJ1avi1uMtq159JLvYnwTAY455zKckuIqPGlNUdxC4D/JyILAOwA8JcAICIfBHCfql6Qf/wt2KT3YSKyE8BXVHVVOk2uTqnqsOUEh3CyWe8CvX27TRK7zOtHHik8buFCG1JavNibUwgOO2UyXi9g9Wprm59Icfa0m1RndVeiiSmVHoWqDqjqp1T12Pzt2/nnd7kgkX98iaoeoaqtqnpUowQJwBtGymbHnofR0QFcdpn3eP9+6w388IfFx37sY8Ddd1svxB8kZs+2Eh6ABYm77/aCUV+fzUP4nXkm8MAD4ftS+3s7DBJEEwdLeCQkrjyMk0/27o+O2rwFYJnW/h7FggV2G5znuOEG+/HnYeRyXrAIbo0aVp/Jf04MEEQTDwNFgsZzYfXva+EqwGYy3iojt4fDunUWNLq6vPd0d9txbW1eoOrsDK9dtWBBYX0nF3CIiBwGihqpZgVUcF+L1lZvXwv/EFZXlxcwgjkY3d22Ysp9xkkneUl7/jmTsIBDROTHQFED1VairXZfi+B7hobswu8ej4xYQp5bsRQWcFzCnBuWIiJyGChqoFQlWtfD8N/v6Kh8Xwt/L8X/nmwWOPDAwtwLFyTCdpYbS0l1Ipo4GChqICyRzl2YW1q8rGr/RTpsItwfGIDii/tjj1n58VWrrGxHS4utetq40Ru6ClvWOtalvEQ0MTBQ1EDwwu+/MPtrKPkv0sGJ8OC3/nPP9bZAHRy09y1dCqxY4VWD3b/fNiR6/PHo+ZF6LqlOROljoKiR4IXfXZiDPYrgRdq/+skFl337Cgv9uWWzPT32vF9/f/nVV/VUUp2I6g8DRQo6OmxVkltpVKryqr8X0dJicw5ufwk/EavddN99xSU7poWVZSzRJgYIIgrDQFGlagv9lfoMt3T1ySft2/zSpcXHha1+eu014Ec/KgwILvM6GEDcnhNEROPBQFGFuFYHRU0el1rJ5FY/ARZcBgetJ+E2CQKsFpPLrD7zTOCWW9hLIKLxY6CoQlyrg0pNHocForC5g1LzCd3dwNVXW89i06YxnyYRUQEGiirEtTqo1ORxWCBaurR43qLU0NfAgDeHwWWuRBQXBooqJL06qFwgKjf0xWWuRJQEBooqxbE6qNQFv1wgKjf0xWWuRJQEBooURF3wowJRJT0GLnMlorgxUKSg0iGi4HwEewxElAYGihRUcsGPGp5igCCiWmKgSEm5Cz4L9RFRvWCgqDNuuKmtjSuYiKg+MFDUkbBd6gYGOB9BROlioEhZT49XHHBgoHC4aWAgvAYUEVEtZdJuwETW0wNccQXwyCN2u2eP9SSyWQ43EVH9YI8iRevWFT7eupXLX4mo/jBQJKDSUuRz51pvwv+Yy1+JqN4wUMSsmlLkXV126+Yo3GMionrCQBGzavMfuroYIIiovnEyO2auPAcnpImoWbBHETPWYyKiZsNAkQBOSBNRM+HQExERRWKgICKiSAwUREQUiYGCiIgiMVAQEVEkBooIuRywfLndEhFNVKksjxWRQwF8B8B0AK8D+KyqvhM45mgAvQCmARgF0KOqX69VG6spxUFE1MzS6lHcBOAxVT0WwGP5x0HDAK5T1eMBnA7gahGZkWSj/D2IsFIcREQTUVoJd7MBdObvrwXQB+BG/wGquhvA7vz990RkO4AjAbyURIPCdpfjVqREROkFig/kAwFUdbeIHB51sIhMB3AygGcijukC0AUA7e3tVTco2IMYGGApDiIiIMFAISKPwuYXgr5c5ee8D8A6AEtU9d1Sx6lqD4AeAJg1a5ZW8zsAr5ifvwfBUhxERAkGClU9u9RrIvIbETki35s4AsCbJY5rhQWJ+1X1uwk1FQCL+RERlZLW0NMGAPMB3JK/XR88QEQEwCoA21X1tlo0ij0IIqJiaa16ugXAOSLyCoBz8o8hIh8UkYfyx3wcwF8B+FMR2Zr/uSCd5hIRTVyp9ChUdQDAp0Ke3wXggvz9nwCQGjeNiIgCmJlNRESRGCiIiCgSAwUREUVioCAiokiiWnVuWt0TkbcAvJF2O3wOA/DbtBuRIJ5f42rmcwOa+/ziPrcPqer7w15oykBRb0Rks6rOSrsdSeH5Na5mPjeguc+vlufGoSciIorEQEFERJEYKGqjJ+0GJIzn17ia+dyA5j6/mp0b5yiIiCgSexRERBSJgYKIiCIxUCRARA4VkR+JyCv520NCjjlaRB4Xke0i8jMR+WIabR2LSs4vf9xqEXlTRP691m2sloicJyK/EJFXRaRoD3cxt+dff1FETkmjnWNVwfl9RERyIjIoIten0caxquDcvpD/m70oIk+JyIlptHOsKji/2flz2yoim0XkjNgboar8ifkHwAoAN+Xv3wTgH0OOOQLAKfn7BwF4GcCMtNse1/nlXzsLwCkA/j3tNpc5nyyA/wDwBwAmAXgh+LeAVTXeCKtofDqAZ9Jud8zndziAPwbwVQDXp93mmM/tTwAckr9/fhP+7d4Hb775BAA/j7sd7FEkYzaAtfn7awHMCR6gqrtV9fn8/fcAbAdwZK0aOE5lzw8AVPUJAG/XqE3jcSqAV1X1NVUdAvBt2Dn6zQbQq+ZpAFPzuzM2grLnp6pvquomAPvTaOA4VHJuT6nqO/mHTwM4qsZtHI9Kzu+/NB8lAPwegNhXKDFQJOMDqrobsIAA+7ZWkohMB3AygGeSb1osqjq/BnAkgF/5Hu9EcdCu5Jh61chtL6fac1sA6xk2iorOT0T+XER+DuAHAC6LuxFpbYXa8ETkUQDTQl76cpWf8z7YvuBLVPXdONoWh7jOr0GEbZAV/FZWyTH1qpHbXk7F5yYin4QFivjH8JNT0fmp6gMAHhCRswAsA3B2nI1goBgjVS35hxCR34jIEaq6Oz888WaJ41phQeJ+Vf1uQk0dkzjOr4HsBHC07/FRAHaN4Zh61chtL6eicxOREwDcB+B8tR02G0VVfztVfUJEjhGRw1Q1toKBHHpKxgYA8/P35wNYHzxARATAKgDbVfW2GrYtDmXPr8FsAnCsiHxYRCYB+BzsHP02AJiXX/10OoD/dMNvDaCS82tUZc9NRNoBfBfAX6nqyym0cTwqOb8/zF9PkF+NNwlAvMEw7Vn9ZvwB0AbgMQCv5G8PzT//QQAP5e+fAetCvghga/7ngrTbHtf55R9/C8Bu2ATpTgAL0m57xDldAFt59h8Avpx/7koAV+bvC4CV+de3AZiVdptjPr9p+b/RuwD25O8fnHa7Yzq3+wC84/v/bHPabY75/G4E8LP8ueUAnBF3G1jCg4iIInHoiYiIIjFQEBFRJAYKIiKKxEBBRESRGCiIiCgSAwVRDERkqohclXY7iJLAQEEUj6kAigKFiGRr3xSieDFQEMXjFgDH5PcE2JTfa+SbALaJyHT/nhwicr2I3Jy/f4yIPCwiz4nIkyLykZTaT1QSaz0RxeMmAH+kqieJSCesiucfqeov89WBS+mBZdi+IiKnAbgLwJ8m3ViiajBQECXjWVX9ZdQB+crBfwLg3/KlegBgctINI6oWAwVRMv7bd38YhcO8U/K3GQB7VPWkWjWKaCw4R0EUj/dgW9qG+Q2Aw0WkTUQmA7gQANT2H/mliPwl8D/7cjfUfs40MbBHQRQDVR0QkZ/mJ633woKDe22/iPwf2A6GvwTwc99bvwDgbhH5WwCtsK0uX6hdy4nKY/VYIiKKxKEnIiKKxEBBRESRGCiIiCgSAwUREUVioCAiokgMFEREFImBgoiIIv1/wNHDsrbYDs8AAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "pl.plot(train_infer_df.portfolio.values.get(), train_infer_df.predict.values.get(), 'b.')\n", + "pl.xlabel('true')\n", + "pl.ylabel('predict')\n", + "pl.title('Train')" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Test')" + ] + }, + "execution_count": 41, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "pl.plot(test_infer_df.portfolio.values.get(), test_infer_df.predict.values.get(), 'g.')\n", + "pl.xlabel('true')\n", + "pl.ylabel('predict')\n", + "pl.title('Test')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Hyperparameter Optimization\n", + "\n", + "When data scientists are building machine learning models, there are a few magic numbers that are included in the model. The example numbers are depths in the tree, the learning rate, etc. The parameters that define the model architecture or training process are usually referred to as hyperparameters. They are magical because there is no good theory about what number to choose. Commonly, the hyperparameters can be searched to find a good set of them that results in the best model performance. The process of searching is referred to as hyperparameter tuning.\n", + "\n", + "There are a few popular Python-based hyperparameter tuning libraries existing: Ray Tune, Optuna, HyperOpt. Each library provides a set of search algorithms and schedule algorithms that is easy to use.\n", + "\n", + "Inside the `greenflow` project, we implemented a Context Composite Node that can flexibly expose the hyperparameters that are interesting for tuning. The Context Composite Node makes hyperparameter tuning easy to do by leveraging the hyperparameter tuning libraries. Inside `greenflow_gquant_plugin` project, there is a `GridRandomSearchNode` that can do random and grid search with Ray Tune library for the hyperparameters. First, we need to initialize the ray tune environment." + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-15 10:45:10,488\tINFO services.py:1263 -- View the Ray dashboard at \u001b[1m\u001b[32mhttp://127.0.0.1:8265\u001b[39m\u001b[22m\n" + ] + }, + { + "data": { + "text/plain": [ + "{'node_ip_address': '10.110.106.133',\n", + " 'raylet_ip_address': '10.110.106.133',\n", + " 'redis_address': '10.110.106.133:6379',\n", + " 'object_store_address': '/tmp/ray/session_2021-09-15_10-45-08_945691_30859/sockets/plasma_store',\n", + " 'raylet_socket_name': '/tmp/ray/session_2021-09-15_10-45-08_945691_30859/sockets/raylet',\n", + " 'webui_url': '127.0.0.1:8265',\n", + " 'session_dir': '/tmp/ray/session_2021-09-15_10-45-08_945691_30859',\n", + " 'metrics_export_port': 63946,\n", + " 'node_id': 'cadedc646617252457992a87cec4161ba7922eb6f2968744302dbfe0'}" + ] + }, + "execution_count": 42, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import ray\n", + "ray.init()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Following is the workflow to run HPO. As a simple example, we will search the `num_rounds` and `eta` parameters in the XGBoost model. We use grid search for `num_rounds` and random search for `eta`. Click on the `GridRandomSearchNode`, you can see how we configure the search space." + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "616245b82159476ebae5818eae9b52fa", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "GreenflowWidget(sub=HBox(), value=[OrderedDict([('id', 'xgboost_train'), ('type', 'ContextCompositeNode'), ('c…" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "taskGraph=TaskGraph.load_taskgraph('./10assets/hpo.gq.yaml')\n", + "taskGraph.draw()" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "get best {'eta': 0.1127734673885831, 'num_rounds': 110}\n" + ] + }, + { + "data": { + "text/html": [ + "== Status ==
Memory usage on this node: 18.8/251.8 GiB
Using FIFO scheduling algorithm.
Resources requested: 0/20 CPUs, 0/4 GPUs, 0.0/156.09 GiB heap, 0.0/70.89 GiB objects (0.0/1.0 accelerator_type:GV100)
Result logdir: /home/yidong/Projects/gQuant/gQuant/plugins/hrp_plugin/notebooks/ray/exp
Number of trials: 3/3 (3 PENDING)
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
Trial name status loc eta num_rounds
search_fun_ad0bb_00000PENDING 0.170374 100
search_fun_ad0bb_00001PENDING 0.323495 110
search_fun_ad0bb_00002PENDING 0.438429 120


" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[2m\u001b[36m(pid=31180)\u001b[0m Port 8787 is already in use.\n", + "\u001b[2m\u001b[36m(pid=31180)\u001b[0m Perhaps you already have a cluster running?\n", + "\u001b[2m\u001b[36m(pid=31180)\u001b[0m Hosting the HTTP server on port 34661 instead\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[2m\u001b[36m(pid=31180)\u001b[0m start new Cluster\n" + ] + }, + { + "data": { + "text/html": [ + "== Status ==
Memory usage on this node: 20.1/251.8 GiB
Using FIFO scheduling algorithm.
Resources requested: 16.0/20 CPUs, 4.0/4 GPUs, 0.0/156.09 GiB heap, 0.0/70.89 GiB objects (0.0/1.0 accelerator_type:GV100)
Result logdir: /home/yidong/Projects/gQuant/gQuant/plugins/hrp_plugin/notebooks/ray/exp
Number of trials: 3/3 (2 PENDING, 1 RUNNING)
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
Trial name status loc eta num_rounds
search_fun_ad0bb_00000RUNNING 0.170374 100
search_fun_ad0bb_00001PENDING 0.323495 110
search_fun_ad0bb_00002PENDING 0.438429 120


" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "== Status ==
Memory usage on this node: 25.9/251.8 GiB
Using FIFO scheduling algorithm.
Resources requested: 16.0/20 CPUs, 4.0/4 GPUs, 0.0/156.09 GiB heap, 0.0/70.89 GiB objects (0.0/1.0 accelerator_type:GV100)
Result logdir: /home/yidong/Projects/gQuant/gQuant/plugins/hrp_plugin/notebooks/ray/exp
Number of trials: 3/3 (2 PENDING, 1 RUNNING)
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
Trial name status loc eta num_rounds
search_fun_ad0bb_00000RUNNING 0.170374 100
search_fun_ad0bb_00001PENDING 0.323495 110
search_fun_ad0bb_00002PENDING 0.438429 120


" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[2m\u001b[36m(pid=31180)\u001b[0m [10:46:16] task [xgboost.dask]:tcp://127.0.0.1:40519 got new rank 0\n", + "\u001b[2m\u001b[36m(pid=31180)\u001b[0m [10:46:16] task [xgboost.dask]:tcp://127.0.0.1:36895 got new rank 1\n", + "\u001b[2m\u001b[36m(pid=31180)\u001b[0m [10:46:16] task [xgboost.dask]:tcp://127.0.0.1:40869 got new rank 2\n", + "\u001b[2m\u001b[36m(pid=31180)\u001b[0m [10:46:16] task [xgboost.dask]:tcp://127.0.0.1:33611 got new rank 3\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Result for search_fun_ad0bb_00000:\n", + " date: 2021-09-15_10-46-21\n", + " done: false\n", + " experiment_id: 98260473da2e4fa18b3354361c1356b4\n", + " hostname: dgx-rpd-05\n", + " iterations_since_restore: 1\n", + " node_ip: 10.110.106.133\n", + " pid: 31180\n", + " test_rsquared.out: 0.14195915475865342\n", + " time_since_restore: 67.76179671287537\n", + " time_this_iter_s: 67.76179671287537\n", + " time_total_s: 67.76179671287537\n", + " timestamp: 1631727981\n", + " timesteps_since_restore: 0\n", + " train_rsquared.out: 0.5148968427308512\n", + " training_iteration: 1\n", + " trial_id: ad0bb_00000\n", + " \n" + ] + }, + { + "data": { + "text/html": [ + "== Status ==
Memory usage on this node: 28.0/251.8 GiB
Using FIFO scheduling algorithm.
Resources requested: 16.0/20 CPUs, 4.0/4 GPUs, 0.0/156.09 GiB heap, 0.0/70.89 GiB objects (0.0/1.0 accelerator_type:GV100)
Result logdir: /home/yidong/Projects/gQuant/gQuant/plugins/hrp_plugin/notebooks/ray/exp
Number of trials: 3/3 (2 PENDING, 1 RUNNING)
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
Trial name status loc eta num_rounds iter total time (s) train_rsquared.out test_rsquared.out
search_fun_ad0bb_00000RUNNING 10.110.106.133:311800.170374 100 1 67.7618 0.514897 0.141959
search_fun_ad0bb_00001PENDING 0.323495 110
search_fun_ad0bb_00002PENDING 0.438429 120


" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Result for search_fun_ad0bb_00000:\n", + " date: 2021-09-15_10-46-21\n", + " done: true\n", + " experiment_id: 98260473da2e4fa18b3354361c1356b4\n", + " experiment_tag: 0_eta=0.17037,num_rounds=100\n", + " hostname: dgx-rpd-05\n", + " iterations_since_restore: 1\n", + " node_ip: 10.110.106.133\n", + " pid: 31180\n", + " test_rsquared.out: 0.14195915475865342\n", + " time_since_restore: 67.76179671287537\n", + " time_this_iter_s: 67.76179671287537\n", + " time_total_s: 67.76179671287537\n", + " timestamp: 1631727981\n", + " timesteps_since_restore: 0\n", + " train_rsquared.out: 0.5148968427308512\n", + " training_iteration: 1\n", + " trial_id: ad0bb_00000\n", + " \n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[2m\u001b[36m(pid=31180)\u001b[0m /raid/yi/conda/miniconda3/envs/rapids-21.08/lib/python3.8/multiprocessing/resource_tracker.py:216: UserWarning: resource_tracker: There appear to be 24 leaked semaphore objects to clean up at shutdown\n", + "\u001b[2m\u001b[36m(pid=31180)\u001b[0m warnings.warn('resource_tracker: There appear to be %d '\n", + "\u001b[2m\u001b[36m(pid=31181)\u001b[0m Port 8787 is already in use.\n", + "\u001b[2m\u001b[36m(pid=31181)\u001b[0m Perhaps you already have a cluster running?\n", + "\u001b[2m\u001b[36m(pid=31181)\u001b[0m Hosting the HTTP server on port 40263 instead\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[2m\u001b[36m(pid=31181)\u001b[0m start new Cluster\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[2m\u001b[36m(pid=31181)\u001b[0m [10:47:25] task [xgboost.dask]:tcp://127.0.0.1:43917 got new rank 0\n", + "\u001b[2m\u001b[36m(pid=31181)\u001b[0m [10:47:25] task [xgboost.dask]:tcp://127.0.0.1:45795 got new rank 1\n", + "\u001b[2m\u001b[36m(pid=31181)\u001b[0m [10:47:25] task [xgboost.dask]:tcp://127.0.0.1:41453 got new rank 2\n", + "\u001b[2m\u001b[36m(pid=31181)\u001b[0m [10:47:25] task [xgboost.dask]:tcp://127.0.0.1:33929 got new rank 3\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Result for search_fun_ad0bb_00001:\n", + " date: 2021-09-15_10-47-31\n", + " done: false\n", + " experiment_id: 7a685eec40ae40adb9e7f8de357d3466\n", + " hostname: dgx-rpd-05\n", + " iterations_since_restore: 1\n", + " node_ip: 10.110.106.133\n", + " pid: 31181\n", + " test_rsquared.out: 0.12150225587516547\n", + " time_since_restore: 66.88904094696045\n", + " time_this_iter_s: 66.88904094696045\n", + " time_total_s: 66.88904094696045\n", + " timestamp: 1631728051\n", + " timesteps_since_restore: 0\n", + " train_rsquared.out: 0.6638374727455243\n", + " training_iteration: 1\n", + " trial_id: ad0bb_00001\n", + " \n" + ] + }, + { + "data": { + "text/html": [ + "== Status ==
Memory usage on this node: 28.0/251.8 GiB
Using FIFO scheduling algorithm.
Resources requested: 16.0/20 CPUs, 4.0/4 GPUs, 0.0/156.09 GiB heap, 0.0/70.89 GiB objects (0.0/1.0 accelerator_type:GV100)
Result logdir: /home/yidong/Projects/gQuant/gQuant/plugins/hrp_plugin/notebooks/ray/exp
Number of trials: 3/3 (1 PENDING, 1 RUNNING, 1 TERMINATED)
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
Trial name status loc eta num_rounds iter total time (s) train_rsquared.out test_rsquared.out
search_fun_ad0bb_00001RUNNING 10.110.106.133:311810.323495 110 1 66.889 0.663837 0.121502
search_fun_ad0bb_00002PENDING 0.438429 120
search_fun_ad0bb_00000TERMINATED 0.170374 100 1 67.7618 0.514897 0.141959


" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Result for search_fun_ad0bb_00001:\n", + " date: 2021-09-15_10-47-31\n", + " done: true\n", + " experiment_id: 7a685eec40ae40adb9e7f8de357d3466\n", + " experiment_tag: 1_eta=0.32349,num_rounds=110\n", + " hostname: dgx-rpd-05\n", + " iterations_since_restore: 1\n", + " node_ip: 10.110.106.133\n", + " pid: 31181\n", + " test_rsquared.out: 0.12150225587516547\n", + " time_since_restore: 66.88904094696045\n", + " time_this_iter_s: 66.88904094696045\n", + " time_total_s: 66.88904094696045\n", + " timestamp: 1631728051\n", + " timesteps_since_restore: 0\n", + " train_rsquared.out: 0.6638374727455243\n", + " training_iteration: 1\n", + " trial_id: ad0bb_00001\n", + " \n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[2m\u001b[36m(pid=31181)\u001b[0m /raid/yi/conda/miniconda3/envs/rapids-21.08/lib/python3.8/multiprocessing/resource_tracker.py:216: UserWarning: resource_tracker: There appear to be 24 leaked semaphore objects to clean up at shutdown\n", + "\u001b[2m\u001b[36m(pid=31181)\u001b[0m warnings.warn('resource_tracker: There appear to be %d '\n", + "\u001b[2m\u001b[36m(pid=31179)\u001b[0m Port 8787 is already in use.\n", + "\u001b[2m\u001b[36m(pid=31179)\u001b[0m Perhaps you already have a cluster running?\n", + "\u001b[2m\u001b[36m(pid=31179)\u001b[0m Hosting the HTTP server on port 44369 instead\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[2m\u001b[36m(pid=31179)\u001b[0m start new Cluster\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[2m\u001b[36m(pid=31179)\u001b[0m [10:48:34] task [xgboost.dask]:tcp://127.0.0.1:36535 got new rank 0\n", + "\u001b[2m\u001b[36m(pid=31179)\u001b[0m [10:48:34] task [xgboost.dask]:tcp://127.0.0.1:35221 got new rank 1\n", + "\u001b[2m\u001b[36m(pid=31179)\u001b[0m [10:48:34] task [xgboost.dask]:tcp://127.0.0.1:38959 got new rank 2\n", + "\u001b[2m\u001b[36m(pid=31179)\u001b[0m [10:48:34] task [xgboost.dask]:tcp://127.0.0.1:32893 got new rank 3\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Result for search_fun_ad0bb_00002:\n", + " date: 2021-09-15_10-48-40\n", + " done: false\n", + " experiment_id: 4d81a558d774401d946fb04d25fc2eed\n", + " hostname: dgx-rpd-05\n", + " iterations_since_restore: 1\n", + " node_ip: 10.110.106.133\n", + " pid: 31179\n", + " test_rsquared.out: 0.08677003579494547\n", + " time_since_restore: 66.62945485115051\n", + " time_this_iter_s: 66.62945485115051\n", + " time_total_s: 66.62945485115051\n", + " timestamp: 1631728120\n", + " timesteps_since_restore: 0\n", + " train_rsquared.out: 0.7518223619807083\n", + " training_iteration: 1\n", + " trial_id: ad0bb_00002\n", + " \n" + ] + }, + { + "data": { + "text/html": [ + "== Status ==
Memory usage on this node: 28.0/251.8 GiB
Using FIFO scheduling algorithm.
Resources requested: 16.0/20 CPUs, 4.0/4 GPUs, 0.0/156.09 GiB heap, 0.0/70.89 GiB objects (0.0/1.0 accelerator_type:GV100)
Result logdir: /home/yidong/Projects/gQuant/gQuant/plugins/hrp_plugin/notebooks/ray/exp
Number of trials: 3/3 (1 RUNNING, 2 TERMINATED)
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
Trial name status loc eta num_rounds iter total time (s) train_rsquared.out test_rsquared.out
search_fun_ad0bb_00002RUNNING 10.110.106.133:311790.438429 120 1 66.6295 0.751822 0.08677
search_fun_ad0bb_00000TERMINATED 0.170374 100 1 67.7618 0.514897 0.141959
search_fun_ad0bb_00001TERMINATED 0.323495 110 1 66.889 0.663837 0.121502


" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Result for search_fun_ad0bb_00002:\n", + " date: 2021-09-15_10-48-40\n", + " done: true\n", + " experiment_id: 4d81a558d774401d946fb04d25fc2eed\n", + " experiment_tag: 2_eta=0.43843,num_rounds=120\n", + " hostname: dgx-rpd-05\n", + " iterations_since_restore: 1\n", + " node_ip: 10.110.106.133\n", + " pid: 31179\n", + " test_rsquared.out: 0.08677003579494547\n", + " time_since_restore: 66.62945485115051\n", + " time_this_iter_s: 66.62945485115051\n", + " time_total_s: 66.62945485115051\n", + " timestamp: 1631728120\n", + " timesteps_since_restore: 0\n", + " train_rsquared.out: 0.7518223619807083\n", + " training_iteration: 1\n", + " trial_id: ad0bb_00002\n", + " \n" + ] + }, + { + "data": { + "text/html": [ + "== Status ==
Memory usage on this node: 28.0/251.8 GiB
Using FIFO scheduling algorithm.
Resources requested: 0/20 CPUs, 0/4 GPUs, 0.0/156.09 GiB heap, 0.0/70.89 GiB objects (0.0/1.0 accelerator_type:GV100)
Result logdir: /home/yidong/Projects/gQuant/gQuant/plugins/hrp_plugin/notebooks/ray/exp
Number of trials: 3/3 (3 TERMINATED)
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
Trial name status loc eta num_rounds iter total time (s) train_rsquared.out test_rsquared.out
search_fun_ad0bb_00000TERMINATED 0.170374 100 1 67.7618 0.514897 0.141959
search_fun_ad0bb_00001TERMINATED 0.323495 110 1 66.889 0.663837 0.121502
search_fun_ad0bb_00002TERMINATED 0.438429 120 1 66.6295 0.751822 0.08677


" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-15 10:48:40,271\tINFO tune.py:561 -- Total run time: 208.46 seconds (208.32 seconds for the tuning loop).\n", + "\u001b[2m\u001b[36m(pid=31179)\u001b[0m /raid/yi/conda/miniconda3/envs/rapids-21.08/lib/python3.8/multiprocessing/resource_tracker.py:216: UserWarning: resource_tracker: There appear to be 24 leaked semaphore objects to clean up at shutdown\n", + "\u001b[2m\u001b[36m(pid=31179)\u001b[0m warnings.warn('resource_tracker: There appear to be %d '\n", + "[10:49:28] task [xgboost.dask]:tcp://127.0.0.1:41915 got new rank 0\n", + "[10:49:28] task [xgboost.dask]:tcp://127.0.0.1:39245 got new rank 1\n", + "[10:49:28] task [xgboost.dask]:tcp://127.0.0.1:36079 got new rank 2\n", + "[10:49:28] task [xgboost.dask]:tcp://127.0.0.1:37343 got new rank 3\n" + ] + }, + { + "data": { + "text/plain": [ + "Results([('grid_search.conf_out', ), ('grid_search.test_rsquared@out', 0.15113658175811273)])" + ] + }, + "execution_count": 44, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "taskGraph.run()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In above simple HPO run, we see more rounds in the XGBoost training help to increase the test R-squared score. HPO is a time consuming process, GPU make it possible as we reduce the time to run 100K bootstrap samples from days in CPU cluster to 4 mins in DGX station. Feel free to add more hyperparamerters and increase the number of trails in above workflow." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "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.8.10" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/gQuant/plugins/hrp_plugin/notebooks/10assets/all_feature_simplified.gq.yaml b/gQuant/plugins/hrp_plugin/notebooks/10assets/all_feature_simplified.gq.yaml new file mode 100644 index 00000000..f589912a --- /dev/null +++ b/gQuant/plugins/hrp_plugin/notebooks/10assets/all_feature_simplified.gq.yaml @@ -0,0 +1,145 @@ +- id: '' + type: Output_Collector + conf: {} + inputs: + in1: merge_features.merged +- id: all_feature_computation + type: CompositeNode + conf: + input: + - all_max_raise.logreturn_df + - all_max_drawdown.logreturn_df + - all_data_distance.in + output: + - all_corr_feature.out + - all_data_distance.cov_df + - all_data_distance.distance_df + subnode_ids: + - all_max_raise + - all_max_drawdown + - all_data_distance + - all_max_drawdown_feature + - all_max_raise_feature + - all_mean_feature + - all_std_feature + - all_corr_feature + subnodes_conf: + all_max_raise: + conf: + negative: true + window: 60 + all_max_drawdown: + conf: + negative: false + window: 60 + all_data_distance: + conf: + window: 60 + all_max_drawdown_feature: + conf: + name: all_max_drawdown + all_max_raise_feature: + conf: + name: all_max_raise + all_mean_feature: + conf: + name: all_mean + all_std_feature: + conf: + name: all_std + all_corr_feature: + conf: + name: all_corr + taskgraph: notebooks/10assets/feature_computation.gq.yaml + inputs: + all_max_raise@logreturn_df: log_return.out + all_max_drawdown@logreturn_df: log_return.out + all_data_distance@in: log_return.out +- id: load_raw_csv + type: LoadCsvNode + conf: + csvfile: notebooks/data/pricing.csv + 17assets: false + inputs: {} + module: investment_nodes +- id: bootstrap + type: BootstrapNode + conf: + offset: 0 + samples: 4096 + partitions: 200 + inputs: + in: load_raw_csv.df_out + module: investment_nodes +- id: log_return + type: LogReturnNode + conf: {} + inputs: + in: bootstrap.out + module: investment_nodes +- id: aggregate_time_feature + type: AggregateTimeFeatureNode + conf: {} + inputs: + in: time_features.all_corr_feature@out + module: investment_nodes +- id: merge_features + type: MergeNode + conf: + column: sample_id + inputs: + left: aggregate_time_feature.out + right: all_feature_computation.all_corr_feature@out + module: investment_nodes +- id: time_features + type: CompositeNode + conf: + input: + - all_max_raise.logreturn_df + - all_max_drawdown.logreturn_df + - all_data_distance.in + output: + - all_corr_feature.out + - all_data_distance.cov_df + - all_data_distance.distance_df + subnode_ids: + - all_max_raise + - all_max_drawdown + - all_data_distance + - all_max_drawdown_feature + - all_max_raise_feature + - all_mean_feature + - all_std_feature + - all_corr_feature + subnodes_conf: + all_max_raise: + conf: + negative: true + window: 12 + all_max_drawdown: + conf: + negative: false + window: 12 + all_data_distance: + conf: + window: 12 + all_max_drawdown_feature: + conf: + name: max_drawdown + all_max_raise_feature: + conf: + name: max_raise + all_mean_feature: + conf: + name: mean + all_std_feature: + conf: + name: std + all_corr_feature: + conf: + name: corr + taskgraph: notebooks/10assets/feature_computation.gq.yaml + inputs: + all_max_raise@logreturn_df: log_return.out + all_max_drawdown@logreturn_df: log_return.out + all_data_distance@in: log_return.out diff --git a/gQuant/plugins/hrp_plugin/notebooks/10assets/feature_computation.gq.yaml b/gQuant/plugins/hrp_plugin/notebooks/10assets/feature_computation.gq.yaml new file mode 100644 index 00000000..11fbd194 --- /dev/null +++ b/gQuant/plugins/hrp_plugin/notebooks/10assets/feature_computation.gq.yaml @@ -0,0 +1,88 @@ +- id: load_raw_csv + type: LoadCsvNode + conf: + csvfile: data/pricing.csv + 17assets: false + inputs: {} + module: investment_nodes +- id: '' + type: Output_Collector + conf: {} + inputs: + in1: all_corr_feature.out +- id: bootstrap + type: BootstrapNode + conf: + samples: 10 + partitions: 4 + inputs: + in: load_raw_csv.df_out + module: investment_nodes +- id: log_return + type: LogReturnNode + conf: {} + inputs: + in: bootstrap.out + module: investment_nodes +- id: all_data_distance + type: DistanceNode + conf: + window: 60 + inputs: + in: log_return.out + module: investment_nodes +- id: all_max_raise + type: MaxDrawdownNode + conf: + negative: true + window: 60 + inputs: + logreturn_df: log_return.out + module: investment_nodes +- id: all_max_drawdown + type: MaxDrawdownNode + conf: + negative: false + window: 60 + inputs: + logreturn_df: log_return.out + module: investment_nodes +- id: all_max_drawdown_feature + type: FeatureNode + conf: + name: all_max_drawdown + inputs: + signal_df: all_max_drawdown.out + module: investment_nodes +- id: all_max_raise_feature + type: FeatureNode + conf: + name: all_max_raise + inputs: + signal_df: all_max_raise.out + feature_df: all_max_drawdown_feature.out + module: investment_nodes +- id: all_mean_feature + type: FeatureNode + conf: + name: all_mean + inputs: + feature_df: all_max_raise_feature.out + signal_df: all_data_distance.mean_df + module: investment_nodes +- id: all_std_feature + type: FeatureNode + conf: + name: all_std + inputs: + feature_df: all_mean_feature.out + signal_df: all_data_distance.std_df + module: investment_nodes +- id: all_corr_feature + type: FeatureNode + conf: + name: all_corr + inputs: + feature_df: all_std_feature.out + signal_df: all_data_distance.corr_df + module: investment_nodes diff --git a/gQuant/plugins/hrp_plugin/notebooks/10assets/feature_computation_workflow.gq.yaml b/gQuant/plugins/hrp_plugin/notebooks/10assets/feature_computation_workflow.gq.yaml new file mode 100644 index 00000000..33ff8090 --- /dev/null +++ b/gQuant/plugins/hrp_plugin/notebooks/10assets/feature_computation_workflow.gq.yaml @@ -0,0 +1,164 @@ +- id: load_raw_csv + type: LoadCsvNode + conf: + csvfile: notebooks/data/pricing.csv + 17assets: false + inputs: {} + module: investment_nodes +- id: '' + type: Output_Collector + conf: {} + inputs: + in1: merge_features.merged +- id: bootstrap + type: BootstrapNode + conf: + offset: 0 + samples: 4096 + partitions: 100 + inputs: + in: load_raw_csv.df_out + module: investment_nodes +- id: log_return + type: LogReturnNode + conf: {} + inputs: + in: bootstrap.out + module: investment_nodes +- id: distance_node + type: DistanceNode + conf: + window: 12 + inputs: + in: log_return.out + module: investment_nodes +- id: max_drawdown + type: MaxDrawdownNode + conf: + window: 12 + inputs: + logreturn_df: log_return.out + module: investment_nodes +- id: max_drawdown_feature + type: FeatureNode + conf: + name: max_drawdown + inputs: + signal_df: max_drawdown.out + module: investment_nodes +- id: max_raise_feature + type: FeatureNode + conf: + name: max_raise + inputs: + signal_df: max_raise.out + feature_df: max_drawdown_feature.out + module: investment_nodes +- id: max_raise + type: MaxDrawdownNode + conf: + negative: true + window: 12 + inputs: + logreturn_df: log_return.out + module: investment_nodes +- id: all_data_distance + type: DistanceNode + conf: + window: 60 + inputs: + in: log_return.out + module: investment_nodes +- id: all_max_raise + type: MaxDrawdownNode + conf: + negative: true + window: 60 + inputs: + logreturn_df: log_return.out + module: investment_nodes +- id: all_max_drawdown + type: MaxDrawdownNode + conf: + negative: false + window: 60 + inputs: + logreturn_df: log_return.out + module: investment_nodes +- id: all_max_drawdown_feature + type: FeatureNode + conf: + name: all_max_drawdown + inputs: + signal_df: all_max_drawdown.out + module: investment_nodes +- id: all_max_raise_feature + type: FeatureNode + conf: + name: all_max_raise + inputs: + signal_df: all_max_raise.out + feature_df: all_max_drawdown_feature.out + module: investment_nodes +- id: mean_feature + type: FeatureNode + conf: + name: mean + inputs: + feature_df: max_raise_feature.out + signal_df: distance_node.mean_df + module: investment_nodes +- id: std_feature + type: FeatureNode + conf: + name: std + inputs: + signal_df: distance_node.std_df + feature_df: mean_feature.out + module: investment_nodes +- id: corr_feature + type: FeatureNode + conf: + name: corr + inputs: + signal_df: distance_node.corr_df + feature_df: std_feature.out + module: investment_nodes +- id: all_mean_feature + type: FeatureNode + conf: + name: all_mean + inputs: + feature_df: all_max_raise_feature.out + signal_df: all_data_distance.mean_df + module: investment_nodes +- id: all_std_feature + type: FeatureNode + conf: + name: all_std + inputs: + feature_df: all_mean_feature.out + signal_df: all_data_distance.std_df + module: investment_nodes +- id: all_corr_feature + type: FeatureNode + conf: + name: all_corr + inputs: + feature_df: all_std_feature.out + signal_df: all_data_distance.corr_df + module: investment_nodes +- id: aggregate_time_feature + type: AggregateTimeFeatureNode + conf: {} + inputs: + in: corr_feature.out + module: investment_nodes +- id: merge_features + type: MergeNode + conf: + column: sample_id + inputs: + right: all_corr_feature.out + left: aggregate_time_feature.out + module: investment_nodes diff --git a/gQuant/plugins/hrp_plugin/notebooks/10assets/full_workflow_xgboost_performance.gq.yaml b/gQuant/plugins/hrp_plugin/notebooks/10assets/full_workflow_xgboost_performance.gq.yaml new file mode 100644 index 00000000..bebbefbc --- /dev/null +++ b/gQuant/plugins/hrp_plugin/notebooks/10assets/full_workflow_xgboost_performance.gq.yaml @@ -0,0 +1,337 @@ +- id: load_raw_csv + type: LoadCsvNode + conf: + csvfile: data/pricing.csv + 17assets: false + inputs: {} + module: investment_nodes +- id: '' + type: Output_Collector + conf: {} + inputs: + in1: train_rsquared.out + in2: test_rsquared.out + in3: train_infer.out + in4: test_infer.out +- id: bootstrap + type: BootstrapNode + conf: + offset: 0 + samples: 4096 + partitions: 25 + inputs: + in: load_raw_csv.df_out + module: investment_nodes +- id: log_return + type: LogReturnNode + conf: {} + inputs: + in: bootstrap.out + module: investment_nodes +- id: distance_node + type: DistanceNode + conf: + window: 12 + inputs: + in: log_return.out + module: investment_nodes +- id: assets_order + type: HierarchicalClusteringNode + conf: {} + inputs: + in: distance_node.distance_df + module: investment_nodes +- id: hrp_weight + type: HRPWeightNode + conf: {} + inputs: + asset_order_df: assets_order.out + covariance_df: distance_node.cov_df + module: investment_nodes +- id: portfolio_construct_hrp + type: PortfolioNode + conf: {} + inputs: + return_df: log_return.out + weight_df: hrp_weight.out + transaction_df: hrp_transaction_cost.out + module: investment_nodes +- id: performance_hrp + type: PerformanceMetricNode + conf: {} + inputs: + in: leverage_hrp.lev_df + module: investment_nodes +- id: nrp_weight + type: NRPWeightNode + conf: {} + inputs: + in: distance_node.cov_df + module: investment_nodes +- id: portfolio_construct_nrp + type: PortfolioNode + conf: {} + inputs: + return_df: log_return.out + transaction_df: nrp_transaction_cost.out + weight_df: nrp_weight.out + module: investment_nodes +- id: performance_nrp + type: PerformanceMetricNode + conf: {} + inputs: + in: leverage_nrp.lev_df + module: investment_nodes +- id: max_drawdown + type: MaxDrawdownNode + conf: + window: 12 + inputs: + logreturn_df: log_return.out + module: investment_nodes +- id: max_drawdown_feature + type: FeatureNode + conf: + name: max_drawdown + inputs: + signal_df: max_drawdown.out + module: investment_nodes +- id: max_raise_feature + type: FeatureNode + conf: + name: max_raise + inputs: + signal_df: max_raise.out + feature_df: max_drawdown_feature.out + module: investment_nodes +- id: max_raise + type: MaxDrawdownNode + conf: + negative: true + window: 12 + inputs: + logreturn_df: log_return.out + module: investment_nodes +- id: all_data_distance + type: DistanceNode + conf: + window: 60 + inputs: + in: log_return.out + module: investment_nodes +- id: all_max_raise + type: MaxDrawdownNode + conf: + negative: true + window: 60 + inputs: + logreturn_df: log_return.out + module: investment_nodes +- id: all_max_drawdown + type: MaxDrawdownNode + conf: + negative: false + window: 60 + inputs: + logreturn_df: log_return.out + module: investment_nodes +- id: all_max_drawdown_feature + type: FeatureNode + conf: + name: all_max_drawdown + inputs: + signal_df: all_max_drawdown.out + module: investment_nodes +- id: all_max_raise_feature + type: FeatureNode + conf: + name: all_max_raise + inputs: + signal_df: all_max_raise.out + feature_df: all_max_drawdown_feature.out + module: investment_nodes +- id: mean_feature + type: FeatureNode + conf: + name: mean + inputs: + feature_df: max_raise_feature.out + signal_df: distance_node.mean_df + module: investment_nodes +- id: std_feature + type: FeatureNode + conf: + name: std + inputs: + signal_df: distance_node.std_df + feature_df: mean_feature.out + module: investment_nodes +- id: corr_feature + type: FeatureNode + conf: + name: corr + inputs: + signal_df: distance_node.corr_df + feature_df: std_feature.out + module: investment_nodes +- id: all_mean_feature + type: FeatureNode + conf: + name: all_mean + inputs: + feature_df: all_max_raise_feature.out + signal_df: all_data_distance.mean_df + module: investment_nodes +- id: all_std_feature + type: FeatureNode + conf: + name: all_std + inputs: + feature_df: all_mean_feature.out + signal_df: all_data_distance.std_df + module: investment_nodes +- id: all_corr_feature + type: FeatureNode + conf: + name: all_corr + inputs: + feature_df: all_std_feature.out + signal_df: all_data_distance.corr_df + module: investment_nodes +- id: aggregate_time_feature + type: AggregateTimeFeatureNode + conf: {} + inputs: + in: corr_feature.out + module: investment_nodes +- id: merge_features + type: MergeNode + conf: + column: sample_id + inputs: + right: all_corr_feature.out + left: aggregate_time_feature.out + module: investment_nodes +- id: hrp_nrp + type: DiffNode + conf: {} + inputs: + diff_b: performance_nrp.calmar_df + diff_a: performance_hrp.calmar_df + module: investment_nodes +- id: merge_target + type: MergeNode + conf: + column: sample_id + inputs: + right: hrp_nrp.out + left: merge_features.merged + module: investment_nodes +- id: leverage_hrp + type: LeverageNode + conf: + target_vol: 0.05 + long_window: 59 + short_window: 19 + inputs: + in: portfolio_construct_hrp.out + module: investment_nodes +- id: leverage_nrp + type: LeverageNode + conf: + target_vol: 0.05 + long_window: 59 + short_window: 19 + inputs: + in: portfolio_construct_nrp.out + module: investment_nodes +- id: hrp_transaction_cost + type: TransactionCostNode + conf: + cost: 0.0002 + inputs: + logreturn_df: hrp_weight.out + module: investment_nodes +- id: nrp_transaction_cost + type: TransactionCostNode + conf: + cost: 0.0002 + inputs: + logreturn_df: nrp_weight.out + module: investment_nodes +- id: split + type: DataSplittingNode + conf: + train_size: 0.9 + target: portfolio + inputs: + in: merge_target.merged + module: greenflow_gquant_plugin.ml +- id: xgboost_train + type: TrainXGBoostNode + conf: + num_of_rounds: 100 + columns: + - month + - sample_id + - year + - portfolio + include: false + xgboost_parameters: + eta: 0.3 + min_child_weight: 1 + subsample: 1 + sampling_method: uniform + colsample_bytree: 1 + colsample_bylevel: 1 + colsample_bynode: 1 + max_depth: 8 + max_leaves: 256 + grow_policy: depthwise + gamma: 0 + lambda: 1 + alpha: 0 + tree_method: gpu_hist + single_precision_histogram: false + deterministic_histogram: false + objective: 'reg:squarederror' + target: portfolio + inputs: + in: split.train + module: greenflow_gquant_plugin.ml +- id: train_infer + type: InferXGBoostNode + conf: + prediction: predict + pred_contribs: false + inputs: + data_in: split.train + model_in: xgboost_train.model_out + module: greenflow_gquant_plugin.ml +- id: test_infer + type: InferXGBoostNode + conf: + prediction: predict + pred_contribs: false + inputs: + data_in: split.test + model_in: xgboost_train.model_out + module: greenflow_gquant_plugin.ml +- id: train_rsquared + type: RSquaredNode + conf: + columns: + - portfolio + - predict + inputs: + in: train_infer.out + module: investment_nodes +- id: test_rsquared + type: RSquaredNode + conf: + columns: + - portfolio + - predict + inputs: + in: test_infer.out + module: investment_nodes diff --git a/gQuant/plugins/hrp_plugin/notebooks/10assets/hpo.gq.yaml b/gQuant/plugins/hrp_plugin/notebooks/10assets/hpo.gq.yaml new file mode 100644 index 00000000..bc92c603 --- /dev/null +++ b/gQuant/plugins/hrp_plugin/notebooks/10assets/hpo.gq.yaml @@ -0,0 +1,75 @@ +- id: xgboost_train + type: ContextCompositeNode + conf: + output: + - test_rsquared.out + context: + num_rounds: + type: number + value: 100 + map: + - node_id: xgboost_train + xpath: xgboost_train.conf.num_of_rounds + eta: + type: number + map: + - node_id: xgboost_train + xpath: xgboost_train.conf.xgboost_parameters.eta + value: 0.3 + taskgraph: notebooks/10assets/parallel_xgboost_performance.gq.yaml + inputs: {} +- id: grid_search + type: GridRandomSearchNode + conf: + parameters: + - search: + function: grid_search + args: + - 100 + - 110 + - 120 + name: num_rounds + - search: + function: uniform + args: + - 0.1 + - 0.5 + name: eta + metrics: + - train_rsquared.out + - test_rsquared.out + best: + mode: max + metric: test_rsquared.out + tune: + local_dir: ./ray + name: exp + num_samples: 1 + resources_per_trial: + cpu: 16 + gpu: 4 + output: + - test_rsquared.out + context: + num_rounds: + type: number + value: 100 + map: + - node_id: xgboost_train + xpath: xgboost_train.conf.num_of_rounds + eta: + type: number + map: + - node_id: xgboost_train + xpath: xgboost_train.conf.xgboost_parameters.eta + value: 0.3 + taskgraph: notebooks/10assets/parallel_xgboost_performance.gq.yaml + inputs: + conf_in: xgboost_train.conf_out + module: greenflow_gquant_plugin.ml +- id: '' + type: Output_Collector + conf: {} + inputs: + in1: grid_search.conf_out + in2: grid_search.test_rsquared@out diff --git a/gQuant/plugins/hrp_plugin/notebooks/10assets/parallel_xgboost_performance.gq.yaml b/gQuant/plugins/hrp_plugin/notebooks/10assets/parallel_xgboost_performance.gq.yaml new file mode 100644 index 00000000..01e04c4d --- /dev/null +++ b/gQuant/plugins/hrp_plugin/notebooks/10assets/parallel_xgboost_performance.gq.yaml @@ -0,0 +1,113 @@ +- id: '' + type: Output_Collector + conf: {} + inputs: + in1: train_rsquared.out + in2: test_rsquared.out + in3: train_infer.out + in4: test_infer.out +- id: load_raw_csv + type: LoadCsvNode + conf: + csvfile: notebooks/data/pricing.csv + 17assets: false + inputs: {} + module: investment_nodes +- id: xgboost_train + type: TrainXGBoostNode + conf: + num_of_rounds: 100 + columns: + - month + - sample_id + - year + - portfolio + include: false + xgboost_parameters: + eta: 0.3 + min_child_weight: 1 + subsample: 1 + sampling_method: uniform + colsample_bytree: 1 + colsample_bylevel: 1 + colsample_bynode: 1 + max_depth: 8 + max_leaves: 256 + grow_policy: depthwise + gamma: 0 + lambda: 1 + alpha: 0 + tree_method: gpu_hist + single_precision_histogram: false + deterministic_histogram: false + objective: 'reg:squarederror' + target: portfolio + inputs: + in: persist.split_data@train + module: greenflow_gquant_plugin.ml +- id: train_infer + type: InferXGBoostNode + conf: + prediction: predict + pred_contribs: false + inputs: + model_in: xgboost_train.model_out + data_in: persist.split_data@train + module: greenflow_gquant_plugin.ml +- id: test_infer + type: InferXGBoostNode + conf: + prediction: predict + pred_contribs: false + inputs: + model_in: xgboost_train.model_out + data_in: persist.split_data@test + module: greenflow_gquant_plugin.ml +- id: parallel + type: SimpleParallelNode + conf: + input: + - bootstrap.in + output: + - merge_target.merged + map: + - node_id: bootstrap + xpath: bootstrap.conf.offset + taskgraph: notebooks/10assets/full_workflow_xgboost_performance.gq.yaml + iterations: 25 + inputs: + bootstrap@in: load_raw_csv.df_out + module: greenflow_dask_plugin +- id: persist + type: PersistNode + conf: {} + inputs: + split_data@test: split_data.test + split_data@train: split_data.train + module: greenflow_dask_plugin +- id: split_data + type: DataSplittingNode + conf: + train_size: 0.9 + target: portfolio + inputs: + in: parallel.merge_target@merged + module: greenflow_gquant_plugin.ml +- id: train_rsquared + type: RSquaredNode + conf: + columns: + - portfolio + - predict + inputs: + in: train_infer.out + module: investment_nodes +- id: test_rsquared + type: RSquaredNode + conf: + columns: + - portfolio + - predict + inputs: + in: test_infer.out + module: investment_nodes diff --git a/gQuant/plugins/hrp_plugin/notebooks/10assets/parallel_xgboost_shap.gq.yaml b/gQuant/plugins/hrp_plugin/notebooks/10assets/parallel_xgboost_shap.gq.yaml new file mode 100644 index 00000000..dd7c6a2f --- /dev/null +++ b/gQuant/plugins/hrp_plugin/notebooks/10assets/parallel_xgboost_shap.gq.yaml @@ -0,0 +1,135 @@ +- id: '' + type: Output_Collector + conf: {} + inputs: + in1: train_shap_dot.summary_plot + in2: test_shap_dot.summary_plot + in3: train_shap_bar.summary_plot + in4: test_shap_bar.summary_plot +- id: load_raw_csv + type: LoadCsvNode + conf: + csvfile: notebooks/data/pricing.csv + 17assets: false + inputs: {} + module: investment_nodes +- id: xgboost_train + type: TrainXGBoostNode + conf: + num_of_rounds: 100 + columns: + - month + - sample_id + - year + - portfolio + include: false + xgboost_parameters: + eta: 0.3 + min_child_weight: 1 + subsample: 1 + sampling_method: uniform + colsample_bytree: 1 + colsample_bylevel: 1 + colsample_bynode: 1 + max_depth: 8 + max_leaves: 256 + grow_policy: depthwise + gamma: 0 + lambda: 1 + alpha: 0 + tree_method: gpu_hist + single_precision_histogram: false + deterministic_histogram: false + objective: 'reg:squarederror' + target: portfolio + inputs: + in: persist.split_data@train + module: greenflow_gquant_plugin.ml +- id: train_infer_shap + type: InferXGBoostNode + conf: + prediction: predict + pred_contribs: true + inputs: + model_in: xgboost_train.model_out + data_in: persist.split_data@train + module: greenflow_gquant_plugin.ml +- id: test_infer_shap + type: InferXGBoostNode + conf: + prediction: predict + pred_contribs: true + inputs: + model_in: xgboost_train.model_out + data_in: persist.split_data@test + module: greenflow_gquant_plugin.ml +- id: train_shap_dot + type: ShapSummaryPlotPlotNode + conf: + max_display: 20 + plot_type: dot + inputs: + model_in: xgboost_train.model_out + shap_in: train_infer_shap.out + data_in: persist.split_data@train + module: investment_nodes +- id: test_shap_dot + type: ShapSummaryPlotPlotNode + conf: + max_display: 20 + plot_type: dot + inputs: + model_in: xgboost_train.model_out + shap_in: test_infer_shap.out + data_in: persist.split_data@test + module: investment_nodes +- id: train_shap_bar + type: ShapSummaryPlotPlotNode + conf: + max_display: 20 + plot_type: bar + inputs: + model_in: xgboost_train.model_out + shap_in: train_infer_shap.out + data_in: persist.split_data@train + module: investment_nodes +- id: test_shap_bar + type: ShapSummaryPlotPlotNode + conf: + max_display: 20 + plot_type: bar + inputs: + model_in: xgboost_train.model_out + shap_in: test_infer_shap.out + data_in: persist.split_data@test + module: investment_nodes +- id: parallel + type: SimpleParallelNode + conf: + input: + - bootstrap.in + output: + - merge_target.merged + map: + - node_id: bootstrap + xpath: bootstrap.conf.offset + taskgraph: notebooks/10assets/full_workflow_xgboost_performance.gq.yaml + iterations: 25 + inputs: + bootstrap@in: load_raw_csv.df_out + module: greenflow_dask_plugin +- id: persist + type: PersistNode + conf: {} + inputs: + split_data@test: split_data.test + split_data@train: split_data.train + module: greenflow_dask_plugin +- id: split_data + type: DataSplittingNode + conf: + train_size: 0.9 + target: portfolio + inputs: + in: parallel.merge_target@merged + module: greenflow_gquant_plugin.ml diff --git a/gQuant/plugins/hrp_plugin/notebooks/10assets/workflow_bootstrap.gq.yaml b/gQuant/plugins/hrp_plugin/notebooks/10assets/workflow_bootstrap.gq.yaml new file mode 100644 index 00000000..eda21441 --- /dev/null +++ b/gQuant/plugins/hrp_plugin/notebooks/10assets/workflow_bootstrap.gq.yaml @@ -0,0 +1,130 @@ +- id: load_raw_csv + type: LoadCsvNode + conf: + csvfile: notebooks/data/pricing.csv + 17assets: false + inputs: {} + module: investment_nodes +- id: '' + type: Output_Collector + conf: {} + inputs: + in1: hrp_nrp_diff.out + in2: performance_nrp.ret_df + in3: performance_nrp.sd_df + in4: performance_nrp.sharpe_df + in5: performance_hrp.ret_df + in6: performance_hrp.sd_df + in7: performance_hrp.sharpe_df + in8: performance_hrp.maxdd_df + in9: performance_nrp.calmar_df + in10: performance_hrp.calmar_df + in11: performance_nrp.maxdd_df +- id: log_return + type: LogReturnNode + conf: {} + inputs: + in: bootstrap.out + module: investment_nodes +- id: distance_node + type: DistanceNode + conf: + window: 12 + inputs: + in: log_return.out + module: investment_nodes +- id: assets_order + type: HierarchicalClusteringNode + conf: {} + inputs: + in: distance_node.distance_df + module: investment_nodes +- id: hrp_weight + type: HRPWeightNode + conf: {} + inputs: + asset_order_df: assets_order.out + covariance_df: distance_node.cov_df + module: investment_nodes +- id: portfolio_construct_hrp + type: PortfolioNode + conf: {} + inputs: + return_df: log_return.out + weight_df: hrp_weight.out + transaction_df: hrp_transaction_cost.out + module: investment_nodes +- id: performance_hrp + type: PerformanceMetricNode + conf: {} + inputs: + in: leverage_hrp.lev_df + module: investment_nodes +- id: nrp_weight + type: NRPWeightNode + conf: {} + inputs: + in: distance_node.cov_df + module: investment_nodes +- id: portfolio_construct_nrp + type: PortfolioNode + conf: {} + inputs: + weight_df: nrp_weight.out + return_df: log_return.out + transaction_df: nrp_transaction_cost.out + module: investment_nodes +- id: performance_nrp + type: PerformanceMetricNode + conf: {} + inputs: + in: leverage_nrp.lev_df + module: investment_nodes +- id: hrp_nrp_diff + type: DiffNode + conf: {} + inputs: + diff_a: performance_hrp.calmar_df + diff_b: performance_nrp.calmar_df + module: investment_nodes +- id: leverage_hrp + type: LeverageNode + conf: + target_vol: 0.05 + long_window: 59 + short_window: 19 + inputs: + in: portfolio_construct_hrp.out + module: investment_nodes +- id: leverage_nrp + type: LeverageNode + conf: + target_vol: 0.05 + long_window: 59 + short_window: 19 + inputs: + in: portfolio_construct_nrp.out + module: investment_nodes +- id: nrp_transaction_cost + type: TransactionCostNode + conf: + cost: 0.0002 + inputs: + logreturn_df: nrp_weight.out + module: investment_nodes +- id: hrp_transaction_cost + type: TransactionCostNode + conf: + cost: 0.0002 + inputs: + logreturn_df: hrp_weight.out + module: investment_nodes +- id: bootstrap + type: BootstrapNode + conf: + offset: 0 + samples: 4096 + partitions: 1 + inputs: + in: load_raw_csv.df_out + module: investment_nodes diff --git a/gQuant/plugins/hrp_plugin/notebooks/10assets/workflow_empirical.gq.yaml b/gQuant/plugins/hrp_plugin/notebooks/10assets/workflow_empirical.gq.yaml new file mode 100644 index 00000000..b00fea41 --- /dev/null +++ b/gQuant/plugins/hrp_plugin/notebooks/10assets/workflow_empirical.gq.yaml @@ -0,0 +1,138 @@ +- id: load_raw_csv + type: LoadCsvNode + conf: + csvfile: notebooks/data/pricing.csv + 17assets: false + inputs: {} + module: investment_nodes +- id: '' + type: Output_Collector + conf: {} + inputs: + in1: hrp_nrp_diff.out + in2: raw.out + in3: log_return.out + in4: assets_order.out + in5: hrp_weight.out + in6: portfolio_construct_hrp.out + in7: portfolio_construct_nrp.out + in8: nrp_weight.out + in9: distance_node.cov_df + in10: distance_node.distance_df + in11: leverage_hrp.lev_df + in12: leverage_nrp.lev_df + in13: performance_nrp.calmar_df + in14: performance_hrp.calmar_df + in15: performance_nrp.sharpe_df + in16: performance_nrp.sd_df + in17: performance_nrp.ret_df + in18: performance_nrp.maxdd_df + in19: performance_hrp.ret_df + in20: performance_hrp.sd_df + in21: performance_hrp.sharpe_df + in22: performance_hrp.maxdd_df +- id: log_return + type: LogReturnNode + conf: {} + inputs: + in: raw.out + module: investment_nodes +- id: distance_node + type: DistanceNode + conf: + window: 12 + inputs: + in: log_return.out + module: investment_nodes +- id: assets_order + type: HierarchicalClusteringNode + conf: {} + inputs: + in: distance_node.distance_df + module: investment_nodes +- id: hrp_weight + type: HRPWeightNode + conf: {} + inputs: + asset_order_df: assets_order.out + covariance_df: distance_node.cov_df + module: investment_nodes +- id: portfolio_construct_hrp + type: PortfolioNode + conf: {} + inputs: + return_df: log_return.out + weight_df: hrp_weight.out + transaction_df: hrp_transaction_cost.out + module: investment_nodes +- id: performance_hrp + type: PerformanceMetricNode + conf: {} + inputs: + in: leverage_hrp.lev_df + module: investment_nodes +- id: nrp_weight + type: NRPWeightNode + conf: {} + inputs: + in: distance_node.cov_df + module: investment_nodes +- id: portfolio_construct_nrp + type: PortfolioNode + conf: {} + inputs: + weight_df: nrp_weight.out + return_df: log_return.out + transaction_df: nrp_transaction_cost.out + module: investment_nodes +- id: performance_nrp + type: PerformanceMetricNode + conf: {} + inputs: + in: leverage_nrp.lev_df + module: investment_nodes +- id: hrp_nrp_diff + type: DiffNode + conf: {} + inputs: + diff_a: performance_hrp.calmar_df + diff_b: performance_nrp.calmar_df + module: investment_nodes +- id: raw + type: RawDataNode + conf: {} + inputs: + in: load_raw_csv.df_out + module: investment_nodes +- id: leverage_hrp + type: LeverageNode + conf: + target_vol: 0.05 + long_window: 59 + short_window: 19 + inputs: + in: portfolio_construct_hrp.out + module: investment_nodes +- id: leverage_nrp + type: LeverageNode + conf: + target_vol: 0.05 + long_window: 59 + short_window: 19 + inputs: + in: portfolio_construct_nrp.out + module: investment_nodes +- id: nrp_transaction_cost + type: TransactionCostNode + conf: + cost: 0.0002 + inputs: + logreturn_df: nrp_weight.out + module: investment_nodes +- id: hrp_transaction_cost + type: TransactionCostNode + conf: + cost: 0.0002 + inputs: + logreturn_df: hrp_weight.out + module: investment_nodes diff --git a/gQuant/plugins/hrp_plugin/notebooks/10assets/xgboost_performance.gq.yaml b/gQuant/plugins/hrp_plugin/notebooks/10assets/xgboost_performance.gq.yaml new file mode 100644 index 00000000..0f92ccde --- /dev/null +++ b/gQuant/plugins/hrp_plugin/notebooks/10assets/xgboost_performance.gq.yaml @@ -0,0 +1,251 @@ +- id: '' + type: Output_Collector + conf: {} + inputs: + in1: train_rsquared.out + in2: test_rsquared.out + in3: train_infer.out + in4: test_infer.out +- id: performance_diff + type: CompositeNode + conf: + input: + - nrp_weight.in + - hrp_weight.covariance_df + - assets_order.in + - portfolio_construct_nrp.return_df + - portfolio_construct_hrp.return_df + output: + - hrp_nrp_diff.out + subnodes_conf: {} + taskgraph: notebooks/10assets/workflow_bootstrap.gq.yaml + inputs: + portfolio_construct_nrp@return_df: log_return.out + portfolio_construct_hrp@return_df: log_return.out + nrp_weight@in: time_features.all_data_distance@cov_df + hrp_weight@covariance_df: time_features.all_data_distance@cov_df + assets_order@in: time_features.all_data_distance@distance_df +- id: all_feature_computation + type: CompositeNode + conf: + input: + - all_max_raise.logreturn_df + - all_max_drawdown.logreturn_df + - all_data_distance.in + output: + - all_corr_feature.out + - all_data_distance.cov_df + - all_data_distance.distance_df + subnode_ids: + - all_max_raise + - all_max_drawdown + - all_data_distance + - all_max_drawdown_feature + - all_max_raise_feature + - all_mean_feature + - all_std_feature + - all_corr_feature + subnodes_conf: + all_max_raise: + conf: + negative: true + window: 60 + all_max_drawdown: + conf: + negative: false + window: 60 + all_data_distance: + conf: + window: 60 + all_max_drawdown_feature: + conf: + name: all_max_drawdown + all_max_raise_feature: + conf: + name: all_max_raise + all_mean_feature: + conf: + name: all_mean + all_std_feature: + conf: + name: all_std + all_corr_feature: + conf: + name: all_corr + taskgraph: notebooks/10assets/feature_computation.gq.yaml + inputs: + all_max_raise@logreturn_df: log_return.out + all_max_drawdown@logreturn_df: log_return.out + all_data_distance@in: log_return.out +- id: load_raw_csv + type: LoadCsvNode + conf: + csvfile: notebooks/data/pricing.csv + 17assets: false + inputs: {} + module: investment_nodes +- id: bootstrap + type: BootstrapNode + conf: + offset: 0 + samples: 4096 + partitions: 200 + inputs: + in: load_raw_csv.df_out + module: investment_nodes +- id: log_return + type: LogReturnNode + conf: {} + inputs: + in: bootstrap.out + module: investment_nodes +- id: aggregate_time_feature + type: AggregateTimeFeatureNode + conf: {} + inputs: + in: time_features.all_corr_feature@out + module: investment_nodes +- id: merge_features + type: MergeNode + conf: + column: sample_id + inputs: + left: aggregate_time_feature.out + right: all_feature_computation.all_corr_feature@out + module: investment_nodes +- id: merge_target + type: MergeNode + conf: + column: sample_id + inputs: + left: merge_features.merged + right: performance_diff.hrp_nrp_diff@out + module: investment_nodes +- id: time_features + type: CompositeNode + conf: + input: + - all_max_raise.logreturn_df + - all_max_drawdown.logreturn_df + - all_data_distance.in + output: + - all_corr_feature.out + - all_data_distance.cov_df + - all_data_distance.distance_df + subnode_ids: + - all_max_raise + - all_max_drawdown + - all_data_distance + - all_max_drawdown_feature + - all_max_raise_feature + - all_mean_feature + - all_std_feature + - all_corr_feature + subnodes_conf: + all_max_raise: + conf: + negative: true + window: 12 + all_max_drawdown: + conf: + negative: false + window: 12 + all_data_distance: + conf: + window: 12 + all_max_drawdown_feature: + conf: + name: max_drawdown + all_max_raise_feature: + conf: + name: max_raise + all_mean_feature: + conf: + name: mean + all_std_feature: + conf: + name: std + all_corr_feature: + conf: + name: corr + taskgraph: notebooks/10assets/feature_computation.gq.yaml + inputs: + all_max_raise@logreturn_df: log_return.out + all_max_drawdown@logreturn_df: log_return.out + all_data_distance@in: log_return.out +- id: split + type: DataSplittingNode + conf: + train_size: 0.9 + target: portfolio + inputs: + in: merge_target.merged + module: greenflow_gquant_plugin.ml +- id: xgboost_train + type: TrainXGBoostNode + conf: + num_of_rounds: 100 + columns: + - month + - sample_id + - year + - portfolio + include: false + xgboost_parameters: + eta: 0.3 + min_child_weight: 1 + subsample: 1 + sampling_method: uniform + colsample_bytree: 1 + colsample_bylevel: 1 + colsample_bynode: 1 + max_depth: 8 + max_leaves: 256 + grow_policy: depthwise + gamma: 0 + lambda: 1 + alpha: 0 + tree_method: gpu_hist + single_precision_histogram: false + deterministic_histogram: false + objective: 'reg:squarederror' + target: portfolio + inputs: + in: split.train + module: greenflow_gquant_plugin.ml +- id: train_infer + type: InferXGBoostNode + conf: + prediction: predict + pred_contribs: false + inputs: + data_in: split.train + model_in: xgboost_train.model_out + module: greenflow_gquant_plugin.ml +- id: test_infer + type: InferXGBoostNode + conf: + prediction: predict + pred_contribs: false + inputs: + data_in: split.test + model_in: xgboost_train.model_out + module: greenflow_gquant_plugin.ml +- id: train_rsquared + type: RSquaredNode + conf: + columns: + - portfolio + - predict + inputs: + in: train_infer.out + module: investment_nodes +- id: test_rsquared + type: RSquaredNode + conf: + columns: + - portfolio + - predict + inputs: + in: test_infer.out + module: investment_nodes diff --git a/gQuant/plugins/hrp_plugin/notebooks/10assets/xgboost_shap.gq.yaml b/gQuant/plugins/hrp_plugin/notebooks/10assets/xgboost_shap.gq.yaml new file mode 100644 index 00000000..96e58896 --- /dev/null +++ b/gQuant/plugins/hrp_plugin/notebooks/10assets/xgboost_shap.gq.yaml @@ -0,0 +1,273 @@ +- id: '' + type: Output_Collector + conf: {} + inputs: + in1: train_shap_dot.summary_plot + in2: test_shap_dot.summary_plot + in3: train_shap_bar.summary_plot + in4: test_shap_bar.summary_plot +- id: performance_diff + type: CompositeNode + conf: + input: + - nrp_weight.in + - hrp_weight.covariance_df + - assets_order.in + - portfolio_construct_nrp.return_df + - portfolio_construct_hrp.return_df + output: + - hrp_nrp_diff.out + subnodes_conf: {} + taskgraph: notebooks/10assets/workflow_bootstrap.gq.yaml + inputs: + portfolio_construct_nrp@return_df: log_return.out + portfolio_construct_hrp@return_df: log_return.out + nrp_weight@in: time_features.all_data_distance@cov_df + hrp_weight@covariance_df: time_features.all_data_distance@cov_df + assets_order@in: time_features.all_data_distance@distance_df +- id: all_feature_computation + type: CompositeNode + conf: + input: + - all_max_raise.logreturn_df + - all_max_drawdown.logreturn_df + - all_data_distance.in + output: + - all_corr_feature.out + - all_data_distance.cov_df + - all_data_distance.distance_df + subnode_ids: + - all_max_raise + - all_max_drawdown + - all_data_distance + - all_max_drawdown_feature + - all_max_raise_feature + - all_mean_feature + - all_std_feature + - all_corr_feature + subnodes_conf: + all_max_raise: + conf: + negative: true + window: 60 + all_max_drawdown: + conf: + negative: false + window: 60 + all_data_distance: + conf: + window: 60 + all_max_drawdown_feature: + conf: + name: all_max_drawdown + all_max_raise_feature: + conf: + name: all_max_raise + all_mean_feature: + conf: + name: all_mean + all_std_feature: + conf: + name: all_std + all_corr_feature: + conf: + name: all_corr + taskgraph: notebooks/10assets/feature_computation.gq.yaml + inputs: + all_max_raise@logreturn_df: log_return.out + all_max_drawdown@logreturn_df: log_return.out + all_data_distance@in: log_return.out +- id: load_raw_csv + type: LoadCsvNode + conf: + csvfile: notebooks/data/pricing.csv + 17assets: false + inputs: {} + module: investment_nodes +- id: bootstrap + type: BootstrapNode + conf: + offset: 0 + samples: 4096 + partitions: 200 + inputs: + in: load_raw_csv.df_out + module: investment_nodes +- id: log_return + type: LogReturnNode + conf: {} + inputs: + in: bootstrap.out + module: investment_nodes +- id: aggregate_time_feature + type: AggregateTimeFeatureNode + conf: {} + inputs: + in: time_features.all_corr_feature@out + module: investment_nodes +- id: merge_features + type: MergeNode + conf: + column: sample_id + inputs: + left: aggregate_time_feature.out + right: all_feature_computation.all_corr_feature@out + module: investment_nodes +- id: merge_target + type: MergeNode + conf: + column: sample_id + inputs: + left: merge_features.merged + right: performance_diff.hrp_nrp_diff@out + module: investment_nodes +- id: time_features + type: CompositeNode + conf: + input: + - all_max_raise.logreturn_df + - all_max_drawdown.logreturn_df + - all_data_distance.in + output: + - all_corr_feature.out + - all_data_distance.cov_df + - all_data_distance.distance_df + subnode_ids: + - all_max_raise + - all_max_drawdown + - all_data_distance + - all_max_drawdown_feature + - all_max_raise_feature + - all_mean_feature + - all_std_feature + - all_corr_feature + subnodes_conf: + all_max_raise: + conf: + negative: true + window: 12 + all_max_drawdown: + conf: + negative: false + window: 12 + all_data_distance: + conf: + window: 12 + all_max_drawdown_feature: + conf: + name: max_drawdown + all_max_raise_feature: + conf: + name: max_raise + all_mean_feature: + conf: + name: mean + all_std_feature: + conf: + name: std + all_corr_feature: + conf: + name: corr + taskgraph: notebooks/10assets/feature_computation.gq.yaml + inputs: + all_max_raise@logreturn_df: log_return.out + all_max_drawdown@logreturn_df: log_return.out + all_data_distance@in: log_return.out +- id: split + type: DataSplittingNode + conf: + train_size: 0.9 + target: portfolio + inputs: + in: merge_target.merged + module: greenflow_gquant_plugin.ml +- id: xgboost_train + type: TrainXGBoostNode + conf: + num_of_rounds: 100 + columns: + - month + - sample_id + - year + - portfolio + include: false + xgboost_parameters: + eta: 0.3 + min_child_weight: 1 + subsample: 1 + sampling_method: uniform + colsample_bytree: 1 + colsample_bylevel: 1 + colsample_bynode: 1 + max_depth: 8 + max_leaves: 256 + grow_policy: depthwise + gamma: 0 + lambda: 1 + alpha: 0 + tree_method: gpu_hist + single_precision_histogram: false + deterministic_histogram: false + objective: 'reg:squarederror' + target: portfolio + inputs: + in: split.train + module: greenflow_gquant_plugin.ml +- id: train_infer_shap + type: InferXGBoostNode + conf: + prediction: predict + pred_contribs: true + inputs: + data_in: split.train + model_in: xgboost_train.model_out + module: greenflow_gquant_plugin.ml +- id: test_infer_shap + type: InferXGBoostNode + conf: + prediction: predict + pred_contribs: true + inputs: + data_in: split.test + model_in: xgboost_train.model_out + module: greenflow_gquant_plugin.ml +- id: train_shap_dot + type: ShapSummaryPlotPlotNode + conf: + max_display: 20 + plot_type: dot + inputs: + model_in: xgboost_train.model_out + data_in: split.train + shap_in: train_infer_shap.out + module: investment_nodes +- id: test_shap_dot + type: ShapSummaryPlotPlotNode + conf: + max_display: 20 + plot_type: dot + inputs: + model_in: xgboost_train.model_out + data_in: split.test + shap_in: test_infer_shap.out + module: investment_nodes +- id: train_shap_bar + type: ShapSummaryPlotPlotNode + conf: + max_display: 20 + plot_type: bar + inputs: + model_in: xgboost_train.model_out + shap_in: train_infer_shap.out + data_in: split.train + module: investment_nodes +- id: test_shap_bar + type: ShapSummaryPlotPlotNode + conf: + max_display: 20 + plot_type: bar + inputs: + model_in: xgboost_train.model_out + shap_in: test_infer_shap.out + data_in: split.test + module: investment_nodes diff --git a/gQuant/plugins/hrp_plugin/notebooks/17assets.ipynb b/gQuant/plugins/hrp_plugin/notebooks/17assets.ipynb new file mode 100644 index 00000000..58f65826 --- /dev/null +++ b/gQuant/plugins/hrp_plugin/notebooks/17assets.ipynb @@ -0,0 +1,3513 @@ +{ + "cells": [ + { + "attachments": { + "8d481b07-4c2b-4a82-9227-51542091858c.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## GPU Accelerated Interpretable Machine Learning for Diversified Portfolio Construction\n", + "\n", + "In this notebook, we accelerated a pipeline to benchmark Hierarchical Risk Parity (HRP) relative to Naive Risk Parity (NRP) in the GPU as described in the [paper](https://papers.ssrn.com/sol3/papers.cfm?abstract_id=3730144). It is an example of diversification strategy allocating to liquid multi-asset futures markets with dynamic leverage (\"volatility target\"). This workflow includes following steps:\n", + "\n", + "* Load csv data of asset daily prices\n", + "* Run block bootstrap to generate 100k different scenarios.\n", + "* Compute the log returns for each scenario. \n", + "* Compute assets distances to run hierarchical clustering and Hierarchical Risk Parity (HRP) weights for the assets\n", + "* Compute the weights for the assets based on the Naïve Risk Parity (NRP) method.\n", + "* Compute the transaction cost based on weights adjustment on the rebalancing days\n", + "* At every rebalancing date, calculate the portfolio leverage to reach the volatility target.\n", + "* Compute the Average annual Returns, Std Returns, Sharpe Ratios, Maximum Drawdown, and Calmar Ratio performance metrics for these two methods (HRP-NRP)\n", + "\n", + "## Background\n", + "\n", + "**Naive Risk Parity** Naive Risk Parity (NRP), is here called naive because it ignores the correlation among the assets. In an RP portfolio, an asset weight is indirectly proportional to its historical volatility as explained in Roncalli (2013). More formally, the weight $w_i$ for the i-thasset with i spanning the portfolio universe $i =1,...,N$ is\n", + "$$ w_i = \\frac{\\sigma_i^{-1}}{\\sum_{j}\\sigma_j^{-1}}$$\n", + "where $\\sigma_i = \\sqrt{\\sum_{ii}}$ denotes the volatility of asset i.\n", + "\n", + "**HRP** The standard HRP approach (Lopez de Prado (2016a)) uses a tree clustering algorithm to perform a quasi-diagonalization of the covariance matrix. After the quasi-diagonalization is carried out, a recursive bi-sectioning method is used to define the weights of each asset within the portfolio. The following dendogram shows the top 13 companies by global market cap clustered by the tree clustering algorithm. Notice how financial stocks such as Bank of America and JPMorgan are clustered together. Same happens for Asian stocks (Tencent and Alibaba) or IT giants (Google, Amazon, Facebook). \n", + "\n", + "![image.png](attachment:8d481b07-4c2b-4a82-9227-51542091858c.png)\n", + "\n", + "**Performance metrics**\n", + "\n", + "Statistics | Short | Description\n", + "--- | --- | ----\n", + "Volatility | SD | Annualized volatility\n", + "Returns | RET | Annualized returns\n", + "Maximum Drawdown | MDD | Drawdowns percentage\n", + "Sharpe ratio | SR | The ratio between returns and volatility (annualized)\n", + "Calmar Ratio | Calmar | The ratiobetweenannualizedreturns and max drawdown\n", + "\n", + "\n", + "**Backtests**\n", + "The strategies are rebalanced every month. At every rebalancing date, the portfolio leverage is set to reach the volatility target of $\\sigma_{target} = 5\\%$ annualized in a hindsight. The portfolio leverage\n", + "determines the total market value of the portfolio and thus the position quantities of each instrument. The estimation of realized volatility used for the updated leverage number is the\n", + "maximum of the volatilities of the portfolio measured over 20 and 60 trading days, respectively $\\sigma_{t=20}$ and $\\sigma_{t=60}$. The target weight is calculated as\n", + "$$W_{target} = \\frac{\\sigma_{target}} {\\max(\\sigma_{t=20}, \\sigma_{t=60})}$$\n", + "\n", + "Start the Dask cluster for distributed computation" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "
\n", + "

Client

\n", + "\n", + "		\n", + "

Cluster

\n", + "
    \n", + "
  • Workers: 8
    • \n", + "
  • Cores: 8
    • \n", + "
  • Memory: 503.80 GiB
    • \n", + "
\n", + "
" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# run this cell if you need Dask\n", + "from dask_cuda import LocalCUDACluster\n", + "import dask\n", + "dask.config.set({\"distributed.comm.timeouts.tcp\": \"90s\"})\n", + "cluster = LocalCUDACluster()\n", + "from dask.distributed import Client\n", + "client = Client(cluster)\n", + "client" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Results for the empirical dataset \n", + "\n", + "Following is the workflow from CSV data loading to backtest performance metrics computation. " + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "0fc23eae56364f1597f6ba11f0e7155d", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "GreenflowWidget(sub=HBox(), value=[OrderedDict([('id', 'load_raw_csv'), ('type', 'LoadCsvNode'), ('conf', {'cs…" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import cupy\n", + "import cudf\n", + "import matplotlib.pyplot as pl\n", + "from greenflow.dataframe_flow import TaskGraph\n", + "from IPython.display import display, HTML\n", + "taskGraph=TaskGraph.load_taskgraph('./17assets/workflow_empirical.gq.yaml')\n", + "taskGraph.draw()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "taskGraph.draw(show='ipynb')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can run the workflow by clicking on the button in the widget or we can run following command. The result will be saved in the `result` variable" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "result = taskGraph.run()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "All the intermediate result can be fetched by the keys of `result` variable. We can list all the keys by running: " + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "('hrp_nrp_diff.out',\n", + " 'raw.out',\n", + " 'log_return.out',\n", + " 'assets_order.out',\n", + " 'hrp_weight.out',\n", + " 'portfolio_construct_hrp.out',\n", + " 'portfolio_construct_nrp.out',\n", + " 'nrp_weight.out',\n", + " 'distance_node.cov_df',\n", + " 'distance_node.distance_df',\n", + " 'leverage_hrp.lev_df',\n", + " 'leverage_nrp.lev_df',\n", + " 'performance_nrp.calmar_df',\n", + " 'performance_hrp.calmar_df',\n", + " 'performance_nrp.sharpe_df',\n", + " 'performance_nrp.sd_df',\n", + " 'performance_nrp.ret_df',\n", + " 'performance_nrp.maxdd_df',\n", + " 'performance_hrp.ret_df',\n", + " 'performance_hrp.sd_df',\n", + " 'performance_hrp.sharpe_df',\n", + " 'performance_hrp.maxdd_df')" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "result.get_keys()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's plot the empirical dataset strategies performances" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "date = result['leverage_nrp.lev_df'].sort_index()['date'].values.get()\n", + "pl.plot(date, cupy.exp(cupy.cumsum(result['leverage_hrp.lev_df'].sort_index()['portfolio'].values)).get(), color='g', label='HRP')\n", + "pl.plot(date, cupy.exp(cupy.cumsum(result['leverage_nrp.lev_df'].sort_index()['portfolio'].values)).get(), color='b', label='NRP')\n", + "pl.legend()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Organize all the performance metrics in a table" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
NRPHRP
metrics
SD0.0532350.051569
RET0.0451180.054740
MDD0.1553290.098149
Calmar0.2904640.557726
SR0.8475111.061491
\n", + "
" + ], + "text/plain": [ + " NRP HRP\n", + "metrics \n", + "SD 0.053235 0.051569\n", + "RET 0.045118 0.054740\n", + "MDD 0.155329 0.098149\n", + "Calmar 0.290464 0.557726\n", + "SR 0.847511 1.061491" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "nrp_metrics = [result['performance_nrp.sd_df']['portfolio'].values.item(),\n", + " result['performance_nrp.ret_df']['portfolio'].values.item(),\n", + " result['performance_nrp.maxdd_df']['portfolio'].values.item(),\n", + " result['performance_nrp.calmar_df']['portfolio'].values.item(),\n", + " result['performance_nrp.sharpe_df']['portfolio'].values.item()]\n", + "hrp_metrics = [result['performance_hrp.sd_df']['portfolio'].values.item(),\n", + " result['performance_hrp.ret_df']['portfolio'].values.item(),\n", + " result['performance_hrp.maxdd_df']['portfolio'].values.item(),\n", + " result['performance_hrp.calmar_df']['portfolio'].values.item(),\n", + " result['performance_hrp.sharpe_df']['portfolio'].values.item()]\n", + "metrics = ['SD', 'RET', 'MDD', 'Calmar', 'SR']\n", + "df = cudf.DataFrame({'metrics': metrics, 'NRP': nrp_metrics, 'HRP': hrp_metrics})\n", + "df.set_index('metrics')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Robustness of the strategies\n", + "\n", + "Bootstrapped dataset To account for the non-stationarity of futures return time series, we generate an additional dataset of time-series by block bootstrapping (Hall (1985), Carlstein and others(1986), Fengler and Schwendner(2004) and Lohre, Rother, and Schaefer (2020)):\n", + "\n", + "* Blocks with a fixed length, but a random starting point in time are defined from the futures return time-series. One block corresponds to 60 business days. This block length is motivated by a typical monthly or quarterly rebalancing frequency of dynamic rule-based strategies and by the empirical market dynamics that happen on this time scale. Papenbrock and Schwendner (2015) found multi-asset correlation patterns to change at a typical frequency of a few months.\n", + "* A new return time-series is constructed by sampling the blocks with replacement to reconstruct a time-series with the same length of the original time-series. \n", + "\n", + "We added a Bootstrap Node to accelerate the bootstrap computation in the GPU. Run 4096 bootstrap samples, we can build a distribution of the performance metrics. Following is the workflow of running the bootstrap." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "0581891ba62e433ab29e39fcbf2b8a8d", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "GreenflowWidget(sub=HBox(), value=[OrderedDict([('id', 'load_raw_csv'), ('type', 'LoadCsvNode'), ('conf', {'cs…" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "taskGraph=TaskGraph.load_taskgraph('./17assets/workflow_bootstrap.gq.yaml')\n", + "taskGraph.draw()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Collect the results and list all the result keys:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "taskGraph.draw(show='ipynb')" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "('hrp_nrp_diff.out',\n", + " 'performance_nrp.ret_df',\n", + " 'performance_nrp.sd_df',\n", + " 'performance_nrp.sharpe_df',\n", + " 'performance_hrp.ret_df',\n", + " 'performance_hrp.sd_df',\n", + " 'performance_hrp.sharpe_df',\n", + " 'performance_hrp.maxdd_df',\n", + " 'performance_nrp.calmar_df',\n", + " 'performance_hrp.calmar_df',\n", + " 'performance_nrp.maxdd_df')" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "result = taskGraph.run()\n", + "result.get_keys()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Draw the performance statistics distribution:" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "result['performance_hrp.sd_df'].to_pandas()['portfolio'].hist(bins=100, color='g', alpha=.5, label='HRP')\n", + "result['performance_nrp.sd_df'].to_pandas()['portfolio'].hist(bins=100, color='b', alpha=.5, label='NRP')\n", + "pl.xlabel('SD')\n", + "pl.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "result['performance_hrp.ret_df'].to_pandas()['portfolio'].hist(bins=100, color='g', alpha=.5, label='HRP')\n", + "result['performance_nrp.ret_df'].to_pandas()['portfolio'].hist(bins=100, color='b', alpha=.5, label='NRP')\n", + "pl.xlabel('RET')\n", + "pl.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "result['performance_hrp.maxdd_df'].to_pandas()['portfolio'].hist(bins=100, color='g', alpha=.5, label='HRP')\n", + "result['performance_nrp.maxdd_df'].to_pandas()['portfolio'].hist(bins=100, color='b', alpha=.5, label='NRP')\n", + "pl.xlabel('MDD')\n", + "pl.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "result['performance_hrp.sharpe_df'].to_pandas()['portfolio'].hist(bins=100, color='g', alpha=.5, label='HRP')\n", + "result['performance_nrp.sharpe_df'].to_pandas()['portfolio'].hist(bins=100, color='b', alpha=.5, label='NRP')\n", + "pl.xlabel('SR')\n", + "pl.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "result['performance_hrp.calmar_df'].to_pandas()['portfolio'].hist(bins=100, color='g', alpha=.5, label='HRP')\n", + "result['performance_nrp.calmar_df'].to_pandas()['portfolio'].hist(bins=100, color='b', alpha=.5, label='NRP')\n", + "pl.xlabel('Calmar')\n", + "pl.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "result['hrp_nrp_diff.out'].to_pandas()['portfolio'].hist(bins=100, color='g', label='HRP-NRP')\n", + "pl.xlabel('Calmar(HRP) - Calmar(NRP)')\n", + "pl.legend()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Interpretable Machine Learning\n", + "In this section, we train a supervised learning model to fit the spread between the Calmar ratios of HRP and the NRP using statistical features of the bootstrapped\n", + "datasets. \n", + "\n", + "**The features**\n", + "\n", + "To characterize the portfolio universe, we select a set of classical statistical features plus a set of quantities that can indicate properties of the hierarchical structure of the asset universe. This particular set of features is tailored to both strategies, and without the help of ML it would be quite difficult to link them to the performances of the strategies. We also look at some features that encode non-stationarity properties. Whenever the feature name has the suffix `_std`., we measure the standard deviation of the statistical property across time. That helps to identify the heterogeneity of that property across the years. \n", + "\n", + "In total, we use 30 features associated with the portfolio universe. For example, X_mean_mean identifies the mean across assets of the mean returns across time. In other words, it provides information regarding the overall trend of the returns of the full portfolio. The `X_mean_mean_std` instead represents how the overall trend changes across years and is measured by the standard deviation of the `X_mean_means` measured year by year. Another feature is `X_mean_std` that measures the heterogeneity of the returns across the assets. A high value of this quantity means that the overall trend of the returns is characterized by a very heterogeneous behaviour across assets (in general features that have names ending with `X_std` have been measured with the standard deviation of X across assets). `corr_mean` is the mean of the entries of the correlation matrix (only the lower diagonal terms) and together with `corr_std` (their standard deviation) they provide information on the independence of the asset from the rest of the universe. For example, a negative value of `corr_mean` suggests that there is a high number of assets that are anti-correlated. A value close to zero can represent either a portfolio with independent assets or one with the same degree of positive and negative correlations. In this case, `corr_std` would discriminate between the two possibilities. \n", + "\n", + "Following is the workflow to calculate all the features for each bootstrap sample in the GPU" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "18e2be5342db48e8b5cc94574d4f6aae", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "GreenflowWidget(sub=HBox(), value=[OrderedDict([('id', 'load_raw_csv'), ('type', 'LoadCsvNode'), ('conf', {'cs…" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "taskGraph=TaskGraph.load_taskgraph('./17assets/feature_computation_workflow.gq.yaml')\n", + "taskGraph.draw()" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABMwAAARbCAYAAAB71z2YAAAABmJLR0QA/wD/AP+gvaeTAAAgAElEQVR4nOzdeVRXdeL/8ddH9h1EwBVwBfeNzAHR3MhM1L5p5pq2Wtk2UzN9a0pLT2PTd7IZ23OstDI1y8QUFXewcgHUUhAFQQXEhX37sHx+f/TzMzDaYgoX8Pk4554+3M+be1/31jl5Xr7v+5osFotFAAAAAAAAACTJ3MzoBAAAAAAAAEBDQmEGAAAAAAAA1EBhBgAAAAAAANRga3QAAABw4yooKFBFRYXy8/NVXl6ukpISSVJ+fr6qq6trja35fU1OTk5ydHSstc9kMsnT07PW9+7u7rK3t5e7u3sdXQ0AAACaCgozAADwu128eFHZ2dnKycnRhQsXlJeXp9zcXOXm5l7xc1lZmQoKClRaWqqysjLDcjs6OsrJyUlubm5ydHSUl5eXvLy85OnpecXP3t7e8vX1lZ+fn7y9vQ3LDQAAgPph4i2ZAADgv5WVlenkyZNKT09Xenq6MjMzlZ2draysLOXk5OjMmTPKyclReXl5rd9zd3f/xfLpUkl1adaXm5ub7Ozs5OnpKXt7e7m4uEiSXFxcZG9vX+vYNjY2V5wdVlhYqMrKylr7KioqVFRUJEkqLi6W2WxWfn6+KioqVFBQoLKyMpWWlqqoqEilpaVXLPku/Zyfn1/r2A4ODvLx8VGbNm3k6+urli1bqlWrVmrdurUCAgIUEBCgwMBAOTk5XfO/BwAAABjCTGEGAMANKjMzU0lJSUpOTlZaWpq1HEtPT1d2drZ1nJubm9q1ayc/Pz+1bt1avr6+at26tfz8/Kxlka+vr7y9vWVjY2PgFdWN6upqnT9/Xjk5OVcsDbOyspSdna3Tp0+roKDA+nt+fn7WAi0gIEDt27dXUFCQgoOD1aZNGwOvCAAAAL+CwgwAgKasurpax48f1w8//KDk5GQlJSVZS7JLM6c8PT3VsWNH+fv7W2dHBQYGKiAgQP7+/mrevLnBV9F45OXlWUvHkydP1pqll5qaqtzcXEk/zcQLCgpSUFCQunbtqqCgIPXo0UOdO3dWs2a8kwkAAMBgFGYAADQVlZWVSk5O1oEDB3TgwAEdOXJE8fHxunjxoiSpVatW6t69uzp06KBu3bpZP7dv314mk8ng9DeG3Nxcpaam6scff9SRI0esn5OTk1VVVSV7e3t16tRJ/fv3r7XxeCcAAEC9ojADAKCxyszMVGxsrGJjYxUXF6fDhw+roqJCzs7O6tWrl/r27as+ffqob9++6tGjB6VLA1ZWVqYff/xRCQkJ1u3QoUMqLi6WnZ2dunfvrkGDBik0NFTh4eFq27at0ZEBAACaMgozAAAai5SUFG3btk1xcXGKjY1VWlqabG1t1adPH4WFhWnAgAHq27evunTp0iTXErvRVFdX69ixY0pMTNTevXsVFxen+Ph4VVZWyt/fX+Hh4QoNDdWwYcMUHBxsdFwAAICmhMIMAICGqqSkRHv27FFMTIzWrVuno0ePysXFRX369NGgQYMUFham8PBweXp6Gh0V9aSkpETx8fHW0nTPnj26ePGiWrZsqZEjRyoyMlIjR47kvwkAAIBrQ2EGAEBDcubMGa1atUpRUVGKi4tTZWWl+vXrp1GjRunWW2/VwIEDZWtra3RMNBBVVVXau3evoqOjFR0drf3798vGxkahoaGKjIzUXXfdpXbt2hkdEwAAoLGhMAMAwGg5OTn64osvtHLlSsXGxsrd3V1jxozRbbfdppEjR8rHx8foiGgkzp8/ry1btig6OlpRUVHKy8tTaGioJk2apIkTJ6ply5ZGRwQAAGgMKMwAADBCVVWVoqKi9O677yomJkaOjo4aO3asJk2apFGjRsnBwcHoiGjkzGazNm3apJUrV2rdunUqKSnR0KFDNXv2bI0bN46ZigAAAD+PwgwAgPp07tw5/fvf/9a7776rU6dOKSIiQjNnzlRkZKScnZ2NjocmqrS0VBs2bNBHH32kDRs2qHXr1po9e7buv/9++fn5GR0PAACgoaEwAwCgPpw+fVrz58/XsmXL5OTkpFmzZunhhx9Wp06djI6GG0xaWpreeecdLV26VEVFRZoyZYrmzp2rgIAAo6MBAAA0FBRmAADUpYsXL2rhwoV688035efnp+eee05Tp05lNhkMV1paqhUrVuiVV17R6dOn9fDDD+u5555jzTwAAAAKMwAA6kZ1dbUWL16sefPmyc7OTs8//7wefvhh2dvbGx0NqKWiokIffPCBFixYoKKiIr3wwgv64x//KBsbG6OjAQAAGMXczOgEAAA0NadOndLIkSP1zDPP6LHHHtOJEyf0xBNP1GlZtn//fplMJs2bN6/OzvFbfPTRRzKZTPriiy8MzYHfzs7OTo888ohSUlL05z//WS+88IJuueUWpaWlGR0NAADAMBRmAABcR6tXr1avXr2UlZWl7777Ti+//LLc3NyMjgX8KhcXF/31r3/Vvn37VFBQoD59+mj58uVGxwIAADAEhRkAANfJa6+9pkmTJmnq1Kk6cOCA+vXrZ3Qk4Kr17NlTe/fu1QMPPKB77rlHL7/8stGRAAAA6p2t0QEAAGgK/vWvf+kvf/mL3njjDT3++ONGxwGuiYODg/7v//5PXbp0sa699+yzzxodCwAAoN4wwwwAgGu0fft2PfXUU1q4cGGDK8tKS0v10ksvqWvXrnJ0dJSHh4eGDx+uTZs2XTZ2165dmjp1qjp16iQHBwf5+PgoMjJScXFxl43Ny8vTnDlz1KpVKzk5OSkkJETr16//3Tmjo6NlMpn0xhtvaOfOnRoyZIjc3NwUEhJyVfkuXLggGxsbzZgxo9bxP/74Y5lMJvn5+anm+47OnDkjk8mk2bNnX1Vei8Wijz76SIMHD5anp6fc3Nx000036YMPPlBlZaUkqaqqSosXL1b//v3l5eUlT09PhYSE6PXXX1dJSYkkaefOnTKZTHriiSeueJ4vv/xSJpNJf/vb364q3/Xy4IMP6p///Keee+45bdy40ZAMAAAAhrAAAIDfrayszBIYGGj5n//5H0Nz7Nu3zyLJMnfuXOu+8vJyS1hYmEXSZZvJZLK888471rFZWVlXHCfJYmtra9m5c6d1bGlpqaVPnz5XPOakSZMskiyrV6++qvwbN260SLJMnDjRYmtraz1m3759rzpf//79LX5+fpbq6mrrvilTpliaNWtmkWRJSEiw7l+6dKlFkuWLL774zVmrq6ut13mlbcuWLRaLxWJ55plnfnbM4sWLrcfr0qWLpXnz5paysrLLzjV69GiLjY2N5cyZM7/9ZtaBadOmWVq3bm0pLi42NAcAAEA9KWeGGQAA12D58uXKysrSv/71L6OjXObNN99UXFyc/P39FRUVpfz8fGVkZGjevHkymUx66qmnlJ2dLUkymUwaOXKkoqKidOrUKZnNZp09e1arVq2Sg4ODFi5caD3u4sWLlZiYqKCgIMXExKiwsFCpqal6+OGHtXLlymvKvHr1as2YMUPJycmqrKxUfHz8VeeLiIjQ2bNndejQIUk/zQaLiYnR1KlTZWdnp82bN1vHbt68Wc2aNdOwYcN+c8alS5dq5cqV8vb21rvvvquMjAwVFRVp3759uv/++2VnZydJWrt2rVxcXLRmzRrl5eWpuLhYiYmJevrpp+Xq6mo93r333quLFy9q7dq1tc5z5swZbdq0SaNHj1br1q2v/mZeR6+//rry8/O1ZMkSQ3MAAADUG6MrOwAAGrOIiAjLpEmTjI5xxRlmAwcOtEiyfPvtt5eNf/DBBy2SLO+995513/79+y0TJ060tG7dutYsL0mWtm3bWsfdfPPNFpPJZPnhhx8uO+7w4cOvaYbZwIEDa80Mq+m35tu2bZtFkuXvf/+7xWKxWOLj4y2SLF999ZUlPDzcMnz4cIvF8tNMMR8fH8uAAQOuKmt4eHitmWQ/Z+jQoZbOnTtbKioqfnFcdna2xdbW1jJy5Mha+xcsWGCRZFm7du1V5asrs2bNsgwaNMjoGAAAAPWBGWYAAFyLxMREhYeHGx3jio4fPy5vb28NHDjwsu/GjBljHSNJe/bsUWhoqFavXq3MzEzrOlyXlJaW1jpumzZt1L1798uOO2rUqGvKPGLECJlMpsv2X02+sLAwubi4WNdp27Jli2xtbTVs2DBFREQoNjZWpaWlSkhI0Llz5zRy5MirypiUlCQvLy+NGDHiF8ctWrRI1dXV6tSpkx566CG9/fbbSkhIuGycn5+fxowZo5iYGKWnp0v6aVbchx9+qJYtW+r222+/qnx1JTw8/Ir5AQAAmiIKMwAArkFBQYHc3d2NjvGzrlQ+XcnChQtlNps1d+5cHT9+XKWlpaqurpbFYlFQUFAdp/wPb2/va85nb2+vwYMHW4uxzZs3a+DAgXJ3d1dERITKy8u1a9cu66OZERERdXItvXv3VlJSkpYtW6b27dtr9+7dGjVqlLp3767Dhw/XGnv//fdbSzJJ2rFjh06cOKGZM2fK1rZhvNTcw8NDJSUll5WVAAAATRGFGQAA16Bly5bKyMgwOsYVderUSefPn9fevXsv+27Dhg3WMZKUmpoqPz8/zZs3Tx07dpSjo6NMJpNOnDihlJSUy4575swZ/fjjj5cdNzo6ug6u5OrySbIWY9HR0YqNjbWWYiEhIWrevLk2b96szZs3y8XFRX/4wx+uKktwcLByc3O1devWXx1ra2urwYMH69lnn9WKFSuUlpamgoIC3XfffbXGjRo1Sm3bttWHH36o6upq61ph995771Vlq0vp6eny8fFpMAUeAABAXaIwAwDgGgwZMkRRUVFGx7iiiRMnSpImTZqkDRs2qKCgQKdPn9b8+fP1/vvvy8HBQWPHjpUk+fv7KycnR2+++aby8/OVn5+vDRs2aPTo0aqurq513DvvvFMWi0V33nmntm3bpqKiIqWlpenRRx/9TSXS73E1+aT/zBp78cUXVV5ebv350gL/UVFR2rNnj2655RbrIv2/1T333CNJmjx5sj744AOdPn1axcXFOnDggB588EHt3LlTkhQaGqp3331XR44cUWlpqfLz8xUdHa0LFy4oNTW11jFtbGw0c+ZMZWRkaNWqVfryyy81ZMgQde7c+arvVV2JiorSLbfcYnQMAACA+mHoEmoAADRyu3fvtkiyxMTEGJrjSov+l5eXW0JDQ2stjl9ze+edd6xj165de8Uxffv2tfTo0cPi7e1tHVtaWmrp06fPZWNNJpNl0qRJ17To/6JFi674/dXku6RNmzYWSRYvLy9LVVWVdf/7779v/f033njjqnJaLBZLVVWVZcKECT97Xy+9DMDBweFnxzz++OOXHTctLc1iMpksHh4eFkmWZcuWXXW2uhIXF2eRZNm8ebPRUQAAAOoDi/4DAHAtBg0apHHjxumBBx5Qfn6+0XFqsbe3V0xMjObOnaugoCDZ29vLzc1NQ4cO1caNGzV79mzr2HHjxunTTz9Vr1695OTkpFatWumhhx7S1q1b5eDgUOu4jo6O2r59ux555BH5+fnJ0dFRffv21VdffXXNi/7/nKvJd8mlxfyHDx+uZs3+80eemmuWXe2C/9JPs9RWrVql999/XwMHDpSLi4vc3d01YMAALVmyxDoL6/vvv9ejjz6qbt26ycnJSS1atFBYWJiWLFmiRYsWXXbcwMBAjRgxQvn5+fLw8NCECROuOltdKCoq0n333aeIiIjfdb8AAAAaI5PFYrEYHQIAgMbs7Nmz6tevn4KCgrRhwwY5OjoaHQm4Lsxms8aNG6f4+HgdOHBAbdu2NToSAABAfTAzwwwAgGvk5+en6OhoJSYmatSoUcrLyzM6EnDNCgsLNWbMGMXFxembb76hLAMAADcUCjMAAK6Dnj17avfu3UpNTVWfPn20a9cuoyMZLjExUSaT6Ve38ePHGx21UWWtD/v27dNNN92kQ4cOafv27QoJCTE6EgAAQL2iMAMA4Drp3r27Dhw4oD59+mjo0KF64oknZDabjY4F/GZVVVV69dVXNWjQILVr10779+9X//79jY4FAABQ71jDDACAOvDee+/pT3/6kwIDA/XKK69o7NixRkcCftGGDRv0/PPPKzk5WQsXLtRjjz0mk8lkdCwAAAAjsIYZAAB14aGHHtLBgwfVrVs3jR8/XqGhodq5c6fRsYDLxMXFafDgwbr99tsVGBiohIQEPf7445RlAADghkZhBgBAHenYsaNWrVqlvXv3ytXVVbfccouGDRumL7/8UpWVlUbHww2sqqpK69atU0REhAYNGiRbW1t9++23+uqrrxQUFGR0PAAAAMNRmAEAUMdCQkK0efNmbdu2TS4uLpo4caI6dOigV155RTk5OUbHww3k/PnzevXVV9WpUyfdcccdsrGxsf63OXDgQKPjAQAANBisYQYAQD1LTU3VO++8o6VLl6q4uFi33Xab7r77bkVGRsrZ2dnoeGhiSktL9c033+jzzz/XN998I0dHR82cOVOPPPKIOnfubHQ8AACAhshMYQYAgEFKSkq0cuVKrVixQtu2bZOjo6MiIyM1adIkjRo1So6OjkZHRCNVXl6uTZs2aeXKlVq3bp1KS0s1ZMgQTZkyRXfffbdcXFyMjggAANCQUZgBANAQXLx4UevXr9fq1asVHR0tOzs7hYWFacSIEYqMjFS3bt2MjogGLi0tTVu2bFFMTIw2b96s/Px89e/fX9OnT9ddd92lVq1aGR0RAACgsaAwAwCgocnMzNT69esVHR2trVu3qqCgQJ06ddKoUaMUERGh0NBQeXt7Gx0TBsvNzdWePXu0ZcsWRUdHKzk5Wa6urho+fLhGjRqlMWPGqG3btkbHBAAAaIwozAAAaMgqKysVFxenTZs2KTo6WomJiZKk4OBghYWFadCgQQoNDWUtqhtAamqqYmNjtWfPHsXGxuro0aOyWCzq1auXbr31Vo0aNUphYWGyt7c3OioAAEBjR2EGAEBjkpubq7i4OOu2b98+lZWVyc/PTzfddJP69u1r3QIDA42Oi98pPT1dCQkJSkxMVEJCgvbt26esrCw5ODgoJCSkVlnKbEMAAIDrjsIMAIDGzGw2a//+/dqzZ4/279+vxMREpaSkqLq6Wl5eXtbyrEePHuratauCgoLk6elpdGz8f/n5+UpOTlZSUpIOHz6shIQEJSQk6OLFi2rWrJk6duyovn37KiQkRKGhoQoJCZGDg4PRsQEAAJo6CjMAAJqaoqIiHTx4sNYMpSNHjqisrEyS5OfnZy3PgoKCFBwcrA4dOiggIIA3c9aB8vJypaenKzU1VUlJSUpKStKxY8eUlJSkrKwsSZKDg4O6deumPn36WEvO3r17y83NzeD0AAAANyQKMwAAbgTV1dVKT09XcnKyjh49quTkZOvMpuzsbOu4Vq1aKSAgQAEBAQoMDLR+9vf3l4+Pj3x9fWUymQy8koYnJydHOTk5OnXqlNLT05Wenq6TJ09a/3mpFJMkX1/fWmXlpc8BAQGysbEx8CoAAABQA4UZAAA3uvz8fKWlpVlLnrS0tFqlT25urnWsra2tfH191bJlS7Vq1Uq+vr5q3bq1fH195e3tLU9PT3l5edXaGtMjhOXl5crLy1Nubm6t7eLFi8rJydGZM2eUk5Oj7OxsZWdnKycnRxUVFdbf9/T0rFU4tm/fvtZnHocFAABoFCjMAADAL8vPz9eZM2d09uxZZWZm6ty5c8rKyrIWRpmZmcrJydHFixdlNpsv+31nZ2d5eXnJ09NTjo6O8vLykq2trdzc3OTk5CRHR0e5u7vL1ta2VqHk6el52Ww2d3f3WjOxqqurlZ+ff9k5a5Z8+fn5qqioUEFBgcrKylRaWqqioiJVVFQoNzdX5eXl1mKspKTksmPZ2dmpefPm1nLQz89Pfn5+1sKwVatW8vPzU5s2bSjEAAAAmgYKMwAAcP0UFxcrNzf3irO08vLyVFZWpry8PFVUVKiwsFClpaUqKytTQUGBzGazCgoKJElVVVXWz5dYLBbl5eVdds4rFWtubm6ytbWV9FPJZmdnJw8PDzk4OMjZ2Vmurq6ys7OzzoC7NBvuSjPkXFxc6uhuAQAAoIGiMAMAAI1LSkqKunTpovj4ePXt29foOAAAAGh6zM2MTgAAAAAAAAA0JBRmAAAAAAAAQA0UZgAAAAAAAEANFGYAAAAAAABADRRmAAAAAAAAQA0UZgAAAAAAAEANFGYAAAAAAABADRRmAAAAAAAAQA0UZgAAAAAAAEANFGYAAAAAAABADRRmAAAAAAAAQA0UZgAAAAAAAEANFGYAAAAAAABADRRmAAAAAAAAQA0UZgAAAAAAAEANFGYAAAAAAABADRRmAAAAAAAAQA0UZgAAAAAAAEANFGYAAAAAAABADRRmAAAAAAAAQA0UZgAAAAAAAEANFGYAAAAAAABADRRmAAAAAAAAQA0UZgAAAAAAAEANFGYAAAAAAABADRRmAAAAAAAAQA0UZgAAAAAAAEANFGYAAAAAAABADRRmAAAAAAAAQA0UZgAAAAAAAEANFGYAAAAAAABADRRmAAAAAAAAQA0mi8ViMToEAADAlVRXV2vEiBE6d+6cdV9FRYXS0tIUEBAgBwcH634PDw9t27ZN9vb2RkQFAABA02G2NToBAADAz2nWrJkCAgK0Y8cO/fff8aWkpFg/m0wmjR8/nrIMAAAA1wWPZAIAgAZtypQpl5VlVzJ9+vR6SAMAAIAbAY9kAgCABq2qqkp+fn66cOHCz45xdnbWhQsX5OjoWI/JAAAA0ESZmWEGAAAaNBsbG02ZMuVnH7e0s7PTpEmTKMsAAABw3VCYAQCABm/y5Mkym81X/K6iokJTpkyp50QAAABoyngkEwAANAoBAQHKyMi4bL+Xl5dycnJka8u7jAAAAHBd8EgmAABoHKZNmyY7O7ta++zt7TV9+nTKMgAAAFxXFGYAAKBRmDZtmioqKmrtM5vNmjx5skGJAAAA0FTxSCYAAGg0unbtqqSkJOvPbdu2VUZGhkwmk4GpAAAA0MTwSCYAAGg8ZsyYYX0s097eXvfccw9lGQAAAK47ZpgBAIBGIyMjQ4GBgbr0x5fDhw+rR48eBqcCAABAE8MMMwAA0Hj4+/srJCREkhQUFERZBgAAgDrBK6UAAECDUFZWpqKiIhUUFCg/P1/V1dXKy8tTzcnwhYWF6tmzp/bt26f+/fvrq6++kpubm/V7k8kkT09PNWvWTB4eHnJ3d5eLi4ucnJyMuCQAAAA0UjySCQAA6kRubq7S09N1+vRpnTt3TmfPnlVOTo7OnTun8+fPKysrSwUFBcrLy1NhYaEqKyvrLIuNjY3c3d3l4eEhDw8P+fn5ydfXVz4+PvLx8VHLli3VokULtW3bVgEBAWrevHmdZQEAAECDZ6YwAwAAv0t1dbVOnjyppKQkJSUl6eTJk9YtPT1dBQUF1rEuLi7WYqpmSeXh4SFPT0+5ubnJxcVFrq6u8vDwkJubm2xtbeXq6mpd5F+SnJ2d5eDgoJdfflkvvviiysvLVVJSYv2+srJShYWFqqqqss5UKy4uVlFRkQoLC5Wfn6/8/HxlZWVZi7uzZ8/q7NmzKi4uth7Hzc1NAQEBCgwMtG5BQUHq2rWrAgMDZWNjUz83GQAAAEagMAMAAL8uMzNT+/fvV2Jioo4ePaqkpCQlJyertLRUktSqVSt16NBBgYGBCggIqLX5+/vL2dn5uuaprKyUre31XVmipKREp06dUnp6eq3t5MmTSktL05kzZyRJDg4OCg4OVnBwsLp27arevXsrJCREbdu2va55AAAAYBgKMwAAUFt+fr727Nmj/fv3W7fMzEyZTCZ17NhR3bp1sxZGlz57eHgYHbvOFRQUKCkpSUePHrWWhkeOHNGJEydUXV2tli1bKiQkxLqFhobKy8vL6NgAAAC4ehRmAADc6IqKivTdd98pJiZGsbGx2rt3ryoqKtSqVSv179/fuoWGhsrb29vouA1OYWGhDh48qAMHDli3o0ePymKxqEOHDhoxYoRGjBihYcOGcf8AAAAaBwozAABuRAkJCYqKilJUVJTi4+NlsVjUo0cPDR06VEOGDNHgwYPVokULo2M2WhcuXNDu3bu1Y8cO7dy5U4cOHZIk9enTR5GRkYqMjFS/fv1kMpkMTgoAAIAroDADAOBGUFVVpe3bt2vt2rWKiopSRkaGWrdurcjISN16660KDw+nIKtDFy9e1O7du7Vp0yatX79ep06dUtu2bTVmzBiNHz9ew4cPv+5rsgEAAOB3ozADAKApO3LkiFatWqWPP/5YJ0+eVLdu3RQZGakxY8YoLCyMGU4G+fHHH7V+/XpFRUVpz5498vLy0oQJEzR9+nQNGjTI6HgAAAA3OgozAACampKSEn388cf64IMPlJCQoMDAQE2fPl3Tpk1Tly5djI6H/5Kamqrly5dr+fLlOnHihHr27KkHHnhAs2bNkqurq9HxAAAAbkQUZgAANBVZWVl688039d5776mkpESTJ0/WPffco/DwcGaSNQIWi0V79uzRsmXL9Omnn8rOzk4PPvigHnvsMbVt29boeAAAADcSCjMAABq7zMxMzZs3Tx9//LG8vLz06KOP6uGHH2ZNskbs4sWLeu+997R48WKdP39eU6dO1UsvvSR/f3+jowEAANwIKMwAAGisCgsL9fe//12vv/66fHx89MILL2jatGlycHAwOhquE7PZrBUrVujll19WVlaWHn/8cT377LPy9PQ0OhoAAEBTRmEGAEBjtHLlSj3xxBMym8167rnnNGfOHDk6OhodC3XEbDbr7bff1oIFC2QymfSPf/xDM2bMMDoWAABAU2VuZnQCAADw2+Xl5Wnq1KmaPHmy7rzzTh0/flxPP/00ZVkTZ29vryeffFLHjx/XlClTNHPmTE2YMEHnz583OhoAAECTxAwzAAAaie+//14TJkxQdXW1li5dqltvvdXoSDDItm3bNGvWLJnNZq1atUrh4eFGRwIAAGhKmGEGAEBjEB0dreHDh+UjqHsAACAASURBVKtXr146dOhQnZRl0dHRMplMeuONN677sXF9DRs2TAcPHtQf/vAHRURE6OuvvzY6EgAAQJNCYQYAQAP3+eefa+zYsZo4caK+/vpreXt7Gx2pTsXGxspkMmnBggWGHqOh8/T01OrVqzVr1izdeeed+uijj4yOBAAA0GTYGh0AAAD8vH379mnmzJmaM2eO/vGPf8hkMhkdCQ2IjY2N3n77bXl5eenBBx9Up06dNGjQIKNjAQAANHrMMAMAoIHKzc3VpEmTNGjQIL322muUZfhZCxYssM5CzMzMNDoOAABAo0dhBgBAA/Xkk0+qsrJSn3/+uWxsbOr13Fu3blVoaKicnZ3l6+urBx54QOfOnbtsXGlpqV566SV17dpVjo6O8vDw0PDhw7Vp06bfNXbBggXWBexfeOEFmUwm6yZJVVVVWrx4sfr37y8vLy95enoqJCREr7/+ukpKSn7TMWqu1bZz504NGTJEbm5uCgkJsebYtWuXpk6dqk6dOsnBwUE+Pj6KjIxUXFxcrWuqeazfes/qgslk0r///W+5uLjoiSeeqJdzAgAANGU8kgkAQAOUnJysTz75RJ999platGhRr+fes2ePnn76aVVVVUn6qehasmSJYmNjtW/fPrm6ukqSzGazRo4cWatEKi8v17Zt27R9+3a9/fbbmj179lWP/SX/+7//q9dee63WvgMHDujAgQOyt7fXnDlzruo6n3nmGVVWVkqSqqurJUnZ2dkaMmRIrbHnz5/X+vXrFR0dra1bt2rw4MGXHeu33LO65OHhoUWLFmncuHE6dOiQevXqVefnBAAAaKqYYQYAQAO0bNkytW3bVhMnTqz3c69evVrTp09XSkqKioqKtGvXLvXs2VNJSUl69dVXrePefPNNxcXFyd/fX1FRUcrPz1dGRobmzZsnk8mkp556StnZ2Vc19q9//at2794tSZo/f74sFot1k6S1a9fKxcVFa9asUV5enoqLi5WYmKinn37aWkr92jFqXueMGTOUnJysyspKxcfHS/ppttbIkSMVFRWlU6dOyWw26+zZs1q1apUcHBy0cOHC333P6tqYMWPUpUsXLV26tN7OCQAA0BRRmAEA0ADFxMRo7Nixatas/v9XPWDAAC1dulSdOnWSi4uLwsPDtXbtWtnZ2emLL76wjlu9erUkaeXKlRozZozc3d3Vrl07zZ07V/fff7/Kysq0bt26qx77S9q2bavWrVtr7Nix8vDwkLOzs3r37q3XXntNM2fOvKrrHDhwoJYsWaIuXbrUeuTVz89Pf/vb37Rs2TLdfPPNcnZ2lp+fn+666y4VFxfr8OHDv/ue1TWTyaTx48crJiam3s4JAADQFFGYAQDQAB07dkw9evQw5NwRERGXvWCgQ4cO6tKli06cOGHdd/z4cXl7e2vgwIGXHWPMmDHWMVc79pcsWrRI1dXV6tSpkx566CG9/fbbSkhI+O0XV8OIESOu+CKFPXv2KDQ0VKtXr1ZmZqb1kc1LSktLL/ud33rP6kPPnj117Nixy2bUAQAA4LejMAMAoAEqKSmRi4uL0TF+1dW8ufN6vOWzd+/eSkpK0rJly9S+fXvt3r1bo0aNUvfu3a848+uXeHt7X3H/woULZTabNXfuXB0/flylpaWqrq6WxWJRUFDQNV9DXXN1dVVFRYUqKiqMjgIAANBoUZgBANAAeXt7Kycnx5Bzb968+bLZSampqTp27Jg6duxo3depUyedP39ee/fuvewYGzZssI652rGXHkP975ldl9ja2mrw4MF69tlntWLFCqWlpamgoED33XefdcyvHeOXpKamys/PT/PmzVPHjh3l6Ogok8mkEydOKCUl5Yq/81vvWX3Izs6Wu7u77O3t6/W8AAAATQmFGQAADVC/fv303XffGXLuvXv36r777tPx48dVXFys2NhY3XHHHaqoqNCECROs4y69kGDSpEnasGGDCgoKdPr0ac2fP1/vv/++HBwcNHbs2Kse27x5c0nS7t27deHChVrZQkND9e677+rIkSMqLS1Vfn6+oqOjdeHCBaWmplrH/dIxfo2/v79ycnL05ptvKj8/X/n5+dqwYYNGjx5tfZPm771n9eHbb79Vv3796vWcAAAATY3JwgIXAAA0OO+//76efPJJnTlzRl5eXvVyzujoaN12222aMGGCvvrqK1VVVdX6Pjg4WPv27bO+jdJsNmvo0KHas2fPFY/3zjvvaPbs2Vc9tqqqSgEBATpz5kytMRaLRY6OjiovL7/iMR5//HH985///NVjXLrORYsW6cknn7zsOF9//bXGjx9/2f6+ffuqoqJCWVlZOn/+vKSrv2d1raioSG3atNG8efP01FNP1cs5AQAAmiAzM8wAAGiA7r77bjk7O+vVV1+t93OHhYVp48aNGjBggJycnNSiRQvdd9992rVrV63ix97eXjExMZo7d66CgoJkb28vNzc3DR06VBs3brQWYFc71sbGRl988YUGDRp02Tpu33//vR599FF169bNmi0sLExLlizRokWLftMxfs24ceP06aefqlevXnJyclKrVq300EMPaevWrXJwcLime1bXLt2DGTNm1Ns5AQAAmiJmmAEA0EC99dZbevLJJ7Vt2zaFh4cbHQdX8Guz1erTvn37FB4ervnz5+uZZ54xNAsAAEAjxwwzAAAaqkceeUTjx4/XxIkTlZmZaXQcNGAXL17UpEmTNHz4cP3pT38yOg4AAECjR2EGAEADZTKZtGTJErm7u2vUqFGUZriic+fOKSIiQhaLRcuXL7e+IRQAAAC/H3+iAgCgAfPw8NCOHTsk/bRO1rFjx4wNhAYlPT1d4eHhunjxorZs2WJ9OygAAACuDWuYAQDQCFy4cEG33367Tpw4oQ8++OCKb3HEjWXjxo2699571apVK23cuFF+fn5GRwIAAGgqWMMMAIDGwNvbW1u3btW4ceN0xx136N5771VBQYHRsWCA4uJizZ49W7fffrtGjBihHTt2UJYBAABcZxRmAAA0Ei4uLlqyZIm+/vprffPNN+rVq5dWrFghJovfGCwWi1avXq1evXppzZo1WrVqlZYvXy53d3ejowEAADQ5FGYAADQyY8eO1eHDhzV8+HBNnz5dAwYM0Pbt242OhToUFxen0NBQ3X333QoLC9Phw4c1YcIEo2MBAAA0WRRmAAA0Qr6+vvr3v/+thIQEtWjRQsOGDdPIkSMVHR3NjLMmJCYmRqNHj9agQYPk6uqq/fv3a9myZWrZsqXR0QAAAJo0CjMAABqxnj17auPGjdq6datMJpNGjx6tHj16aMmSJSorKzM6Hn4Hs9msjz/+WL1799bIkSNVXl6u6OhobdmyRX379jU6HgAAwA2Bt2QCANCEHDt2TG+99ZY++OADOTg4KDIyUjNmzNDw4cNlMpmMjodf8OOPP2r58uX68MMPlZubq/Hjx+tPf/qTbr75ZqOjAQAA3GjMFGYAADRB2dnZWr58uT7++GP9+OOP6tKli6ZNm6aJEycqODjY6Hj4/44fP67Vq1dr+fLlOnr0qIKDgzVjxgzdc889at26tdHxAAAAblQUZgAANHXx8fFatmyZVqxYoZycHHXu3Fljx45VZGSkBg0aJBsbG6Mj3jCqqqr07bffKioqSuvWrVNSUpK8vb119913a8aMGRowYIDREQEAAEBhBgDAjaOqqkp79uyxljXJyclq3ry5hg8friFDhuiWW25Rt27deHTzOjt69Kh27NihnTt3auvWrTp//rw6d+6syMhIa2lpa2trdEwAAAD8B4UZAAA3qpSUFK1bt07bt2/X7t27VVBQIF9fXw0ZMkSDBw/WgAED1KtXLzk6OhodtdEoLy/XwYMHtW/fPu3evVs7duzQ2bNn5erqqvDwcA0dOlSRkZE8FgsAANCwUZgBAICfZp/Fx8dr586d2rFjh+Li4pSXlyc7Ozv16NFD/fv3V0hIiPr166fg4GC5ubkZHdlwRUVFSkpKUnx8vPbv368DBw7o8OHDqqiokLu7u8LCwjRkyBANGTJEISEhzCIDAABoPCjMAADA5SwWi44fP24tgvbv36/4+HgVFhZKkvz9/RUcHKxu3bqpa9euCg4OVocOHdS6dWs1a9bM4PTXT3V1tbKzs3XixAklJSUpKSlJP/74o5KSkpSRkSGLxSJXV1f17dtXISEh1mKxc+fOTeo+AAAA3GAozAAAwG9TXV2t1NRUHTlyREePHtXRo0d15MgRJSUlWYs0Ozs7tWvXTgEBAfL391dgYKDatWsnX19f+fj4yM/PT76+vnJxcTH4aqSSkhLl5OQoOztb586d07lz53Tq1Cmlp6dbt1OnTslsNkuSXF1dFRwcrK5du6pbt24KDg5W9+7d1aFDB16cAAAA0LRQmAEAgGt35swZnTx5UidPnqxVOGVkZOjUqVMqKiqqNd7Z2Vm+vr7y9vaWu7u7XF1d5erqKjc3N3l4eMjV1VUODg6ysbGRu7u79ffs7Ozk6upq/bmoqEgVFRXWnwsLC1VZWany8nIVFxcrLy9PhYWFKi4uVlFRkfLz85Wbm6uzZ8+quLi4ViYXFxe1bdtWAQEBtbbAwEAFBASoXbt2dXT3AAAA0MBQmAEAgLpXWlqqc+fO1ZrNdfbsWeXm5io/P19FRUUqLi5WYWGh8vLyVFRUJLPZLLPZXKvYKisrU2lpqfVnJyenWi8lcHZ2loODg7VY8/LyspZxrq6u8vDwkKenp/z8/OTj4yMfHx+1bNlSPj4+cnZ2rtd7AgAAgAaLwgwAADQuKSkp6tKli+Lj49W3b1+j4wAAAKDpMbMaLQAAAAAAAFADhRkAAAAAAABQA4UZAAAAAAAAUAOFGQAAAAAAAFADhRkAAAAAAABQA4UZAAAAAAAAUAOFGQAAAAAAAFADhRkAAAAAAABQA4UZAAAAAAAAUAOFGQAAAAAAAFADhRkAAAAAAABQA4UZAAAAAAAAUAOFGQAAAAAAAFADhRkAAAAAAABQA4UZAAAAAAAAUAOFGQAAAAAAAFADhRkAAAAAAABQA4UZAAAAAAAAUAOFGQAAAAAAAFADhRkAAAAAAABQA4UZAAAAAAAAUAOFGQAAAAAAAFADhRkAAAAAAABQA4UZAAAAAAAAUAOFGQAAAAAAAFADhRkAAAAAAABQA4UZAAAAAAAAUAOFGQAAAAAAAFADhRkAAAAAAABQA4UZAAAAAAAAUAOFGQAAAAAAAFADhRkAAAAAAABQg8lisViMDgEAAHAl1dXVGjFihM6dO2fdV1FRobS0NAUEBMjBwcG638PDQ9u2bZO9vb0RUQEAANB0mG2NTgAAAPBzmjVrpoCAAO3YsUP//Xd8KSkp1s8mk0njx4+nLAMAAMB1wSOZAACgQZsyZcplZdmVTJ8+vR7SAAAA4EbAI5kAAKBBq6qqkp+fny5cuPCzY5ydnXXhwgU5OjrWYzIAAAA0UWZmmAEAgAbNxsZGU6ZM+dnHLe3s7DRp0iTKMgAAAFw3FGYAAKDBmzx5ssxm8xW/q6io0JQpU+o5EQAAAJoyHskEAACNQkBAgDIyMi7b7+XlpZycHNna8i4jAAAAXBc8kgkAABqHadOmyc7OrtY+e3t7TZ8+nbIMAAAA1xWFGQAAaBSmTZumioqKWvvMZrMmT55sUCIAAAA0VTySCQAAGo2uXbsqKSnJ+nPbtm2VkZEhk8lkYCoAAAA0MTySCQAAGo8ZM2ZYH8u0t7fXPffcQ1kGAACA644ZZgAAoNHIyMhQYGCgLv3x5fDhw+rRo4fBqQAAANDEMMMMAAA0Hv7+/goJCZEkBQUFUZYBAACgTvBKKQAA0CAUFBSoqKhIxcXFKigoUFVVlQoKCi4b07NnT+3bt0/9+/fXmjVr5OHhUWuMu7u7bGxs5O7uLhcXF7m4uFw2BgAAAPglPJIJAACuu+LiYqWnp+v06dPKycnR+fPndf78eZ09e1bnzp3T+fPnde7cORUWFloLsrrm5uYmFxcXubu7q0WLFmrRooV8fHzk5+dn/ezj46O2bdsqICBArq6udZ4JAAAADZKZwgwAAFy1qqoqpaWlKTk5WceOHdPJkyeVnp6ujIwMZWRk6MKFC9ax9vb21oLKz8/PWky1aNHCOgvM3d3d+tnZ2Vmenp6SJE9Pz1qL+ru4uMje3l4vv/yyXnzxRVVUVKioqKhWttzcXElSfn6+iouLrYVczXKuZml39uxZ62ez2Ww9TvPmzeXv7y9/f38FBgbK399fXbp0UXBwsNq3by9bWybqAwAANFEUZgAA4OdVV1crJSVF8fHxOnz4sJKTk5WcnKyUlBRrudSqVSu1b9/eWi75+/srICBAAQEBatOmjZo3b37dc1VWVtZJYZWbm6szZ87o5MmT1vLv0paWlqbMzExJP5WAHTt2VHBwsHUttX79+ikoKEjNmrFELAAAQCNHYQYAAP7j6NGj2rdvn+Lj4xUfH6/ExEQVFhbKzs7OWg4FBQXV+uzu7m507HpTWFioY8eOKTk5WUePHrUWiEePHlVFRYVcXV3Vu3dv9e/fX/369dNNN92krl271polBwAAgAaPwgwAgBtVVVWVkpKSFBcXp9jYWO3YsUOnTp2SnZ2dOnfurP79+9fanJycjI7cYFVWVio5OVkHDhywbgkJCSopKZG7u7sGDBigESNGKCwsTAMGDJC9vb3RkQEAAPDzKMwAALiRZGVl6ZtvvtGGDRu0detWFRQUqHnz5goLC9PgwYMVHh6ufv36yc7OzuiojV5lZaUSEhIUGxurnTt3KjY2VhcuXJCbm5uGDh2q22+/XbfffrvatGljdFQAAADURmEGAEBTl5CQoLVr1+qbb75RfHy8HB0dNWzYMI0aNUpDhgxR9+7dWXerHlgsFh05ckQ7d+7Upk2bFBMTo9LSUvXp00ejR4/WuHHjdNNNNxkdEwAAABRmAAA0TRkZGVqxYoU++ugjJSUlyc/PTxEREYqMjNSoUaPk5uZmdMQbXllZmWJjYxUTE6Ovv/5aSUlJCggI0N13361Zs2YpKCjI6IgAAAA3KgozAACaipKSEn3yySdaunSpvv/+e7Vs2VJ33XWXpkyZoptvvtnoePgVBw4c0GeffabPP/9cmZmZCgkJ0axZszRjxgy5uroaHQ8AAOBGQmEGAEBjl5GRobfeektLlixRSUmJ7rrrLk2dOlXDhw+XjY2N0fFwlaqqqrRjxw598sknWrlypRwcHHTffffp0UcfVfv27Y2OBwAAcCOgMAMAoLFKTk7W3LlztWbNGvn6+uqRRx7Rgw8+KB8fH6Oj4Tq5cOGClixZorfeekuZmZm644479NJLL6lbt25GRwMAAGjKzKzwCwBAI3P69Gk98MAD6tGjh3744QctW7ZMJ0+e1PPPP09Z1sR4e3vrL3/5i1JTU7VixQqlpKSoV69emjVrltLT042OBwAA0GRRmAEA0EiYzWbNnTtXnTt3VkxMjJYsWaKDBw9q8uTJsrOzMzoe6pCtra0mTpyo+Ph4LVu2TLt371ZQUJCee+45lZeXGx0PAACgyeGRTAAAGoHExETNnDlTx48f18svv6w5c+bI3t7e6FgwSEVFhd599109//zz8vf310cffaSQkBCjYwEAADQVPJIJAEBD9/e//10DBgyQu7u7Dh48qD/+8Y+UZTc4Ozs7PfbYYzp06JBatmypP/zhD5o/f774e1AAAIDrg8IMAIAGqrKyUg8++KCee+45vfLKK9qxY4c6dux43c+zf/9+mUwmzZs377ofG3UrMDBQW7Zs0aJFizR//nzNmjVLFRUVRscCAABo9CjMAABogMrKyjRu3Dh9+umn+vLLL/X000+rWTP+t321YmNjZTKZtGDBAqOj1BmTyaQ5c+Zo/fr1+vLLL3X77beruLjY6FgAAACNGn/yBgCgAXr44Yf17bffavv27Ro7dqzRcdAIREREaNeuXUpMTNT9999vdBwAAIBGjcIMAIAG5q233tKyZcv0ySefaMCAAUbHQSPSp08fffnll1qzZo3+8Y9/GB0HAACg0aIwAwCgAUlJSdEf//hHvfTSSxo9erShWUpLS/XSSy+pa9eucnR0lIeHh4YPH65NmzZdNjY3N1ePPPKIWrZsKScnJ4WEhGj9+vX66KOPZDKZ9MUXX1zVuaOjo2UymfTGG29o586dGjJkiNzc3KxvgrRYLFq6dKlCQ0Pl5uYmJycn9e7dW2+99ZZ14fsFCxYoPDxckvTCCy/IZDJZN0lasmTJz2a79N3atWt/U6aa33333Xe65ZZb5OLiIm9vb91zzz26ePHiVV3/tRg0aJAWLlyoZ599Vj/88EO9nRcAAKApsTU6AAAA+I+5c+eqS5cu+t///V9Dc5jNZo0cOVJxcXHWfeXl5dq2bZu2b9+ut99+W7Nnz5b003prw4YNU2JionXsgQMHNHbsWN11113XlGPPnj165plnVFlZKUmqrq6WxWLR9OnT9emnn9Yae+jQIc2ZM0cHDx7U+++/f03nvdpMl+zbt0/PPvusysvLJUklJSVatmyZTp48qZ07d9ZZpv/25JNP6rPPPtOLL76oL7/8st7OCwAA0FQwwwwAgAbi4sWLWrNmjZ5++mnZ2NgYmuXNN99UXFyc/P39FRUVpfz8fGVkZGjevHkymUx66qmnlJ2dLUlavHixEhMTFRQUpK1bt6qwsFBpaWmaM2eOVq5ceU05Vq9erRkzZig5OVmVlZWKj4/XJ598ok8//VQ9e/bUhg0bdOHCBRUVFWnnzp3q3bu3PvjgA3377bf661//qt27d0uS5s+fL4vFYt2ud6ZLPvvsM82aNUspKSkqKSlRbGys/P39tWvXLh08ePCazns1mjVrpj//+c+KiopSVlZWvZ0XAACgqaAwAwCggdi5c6cqKys1fvx4o6No9erVkqSVK1dqzJgxcnd3V7t27TR37lzdf//9Kisr07p16yRJX3zxhUwmk9asWaNhw4bJ1dVVgYGB+te//qWRI0deU46BAwdqyZIl6tKli7VE/PDDD2VjY6NNmzbptttuU/PmzeXi4qLBgwfrs88+kyR9/fXX13Teq810SUREhN555x116tRJTk5OCgsL05///GdJqtfCTJIiIyPVrFkzbd++vV7PCwAA0BRQmAEA0EAcO3ZMAQEB8vDwMDqKjh8/Lm9vbw0cOPCy78b8P/buOyyqM/0b+BeG3pE6dLEgoFKDha6ICthAYkGwxcRsolmTdVPMJsZo2iYxidl1LYkFRQUbFuzSVaQr1ULvIL0OU94/8uO8omiiAmcG7s91zTXDMHPOfRSYM995nvvx82MeAwAPHz6EoaEhrK2tn3rszJkzX6kOLy8vpudYj+zsbAgEAhgbG0NGRgYcDgfS0tKQlpZmaigpKXml/b5oTT08PDyeus/c3BwA0NLSMmA19UVRURFjx45FXl7eoO6XEEIIIWQooB5mhBBCiJhoa2uDsrIy22UwnhUKvchjX3X6o5aW1lP39fQMEwgEz3wej8f7021LS0v32t7jOjo6XqimHoqKik/d1/Nv86r/Fi9DRUUFra2tg75fQgghhBBJRyPMCCGEEDGhpaWFmpoatssAAIwePRp1dXW4ffv2U9+LiopiHgMAo0aNQllZGXJycp567JUrV/q9tnHjxkFJSQmNjY29+pI9fulZ+bInFOtp0P84XV1dAEBhYeFT37t+/Xq/182Gqqoq6OjosF0GIYQQQojEocCMEEIIERMODg6oqanB/fv32S4FgYGBAIBFixYhKioKzc3NKCsrw5dffondu3dDXl4ec+fOBQAEBARAJBJh4cKFiImJQVtbG4qLi7FhwwZcvny532tbvXo12tvb4eXlhXPnzqG2thY8Hg/FxcU4f/48AgICcO3aNQDAiBEjAADx8fF49OhRr+1YWVkBAH766SfExMSgo6MDRUVF+OCDD3D69Ol+r3uwlZWVoaioCA4ODmyXQgghhBAicWhKJiGEECImJk+eDC6XiwMHDmDr1q2s1vLuu+/ixIkTuHHjBnx9fZ/6/k8//QR9fX0AwLp163D48GHcuXMHnp6ezGOkpKQQGBiIiIgIyMrK9ltty5cvR2xsLPbv3485c+b0+Zg1a9YAAMaMGQNDQ0Ncv34d2trazPdFIhHMzc3h7++PkydP9qpbRkYGwcHBCA0N7bea2bB//35oaWnBzc2N7VIIIYQQQiQOjTAjhBBCxISMjAzeeecd/PLLL6iurma1Fjk5OVy9ehWff/45LCwsICcnB1VVVXh6euLChQtYu3Yt81hFRUVER0fjrbfegq6uLhQUFODg4IAzZ84wo7g0NTX7rTYpKSns27cPx44dg5eXFzQ1NSEnJwdzc3PMnz8fp06dgpeXFwCAw+Hg+PHjcHFx6bM/3G+//YZVq1ZBS0sLCgoKmDJlCq5evSrxIVN9fT22b9+Ot99+GwoKCmyXQwghhBAicaREbHSgJYQQQkif2tvbYW1tjQkTJiAyMvKFGu+LG6FQCEdHR2RkZKC2tva5zfJJ/xEKhZgzZw7u3r2LrKwsqKmpsV0SIYQQQoik4dGUTEIIIWSQNDQ0oKKiAg0NDaisrGRuP/l1XV0doqKi8Nlnn+HLL79ku+y/5IMPPoCdnR1cXV2ho6ODe/fuYevWrUhPT4enpyeFZYPos88+w/Xr1xEXF0dhGSGEEELIS6LAjBBCCHlJ7e3tqKysRFVVFWpqalBRUYHa2lrU1dUx99XW1qKmpgb19fW9nisvLw9tbW3o6upCX18fOjo6mDx5MnO7vr4eH3zwAYRCIbZu3Sr2I83y8/Px448/PnW/iooKc39GRgbs7Oz+dFvz5s0bEk332bB161Z89dVX+P333/Haa6+xXQ4hhBBCiMSiwIwQQgh5DJ/PR01NDaqqqlBZWckEYTU1Nb3CsfLycrS2tvZ6bk8Apq2tDT09PdjY2EBHRwc6OjpMEKajowM9PT1oaGj8y804CwAAIABJREFUaS1aWlp44403UFpair1790JOTm6gDvuVbd++HTo6OkhISEBpaSnU1NTg7u6Ozz//HOPHj2e7vCFPIBDg3XffxZ49e/Cf//wHK1asYLskQgghhBCJRj3MCCGEDAsdHR2oqKhAZWUlysrKUFVVhYqKClRXV/cKx2pqavD4S6OSkhIMDAygp6cHPT09GBgYQFdXl7lPX18fXC4Xurq6/boSZI/Lly9j4cKFmDBhAvbt24exY8f2+z6IZCssLMSqVauQnJyMI0eOPHPlUEIIIYQQ8pfxKDAjhBAi0bq7u1FdXc2EYGVlZaisrER5eTlz3dMbrAeHw3kq7DI0NISuri64XC709fWZ+/paWXGwZWVlISQkBHl5edi2bRvee+89SEvTQtfDnUgkwn//+1989NFHGDlyJA4ePAhbW1u2yyKEEEIIGQooMCOEECK+6urqUF5ejtLS0l7h1+OBWHV1da8RYT3TH42NjaGnpwdjY2Po6+vD0NAQXC4XhoaG0NPTA4fDYfHIXlx3dze+/vprbNu2DXZ2dvj222/h7u7OdlmEJYmJifjwww+RlJSEjz76CP/617/EesouIYQQQoiEocCMEEIIOzo6OlBZWYmCggImBHv89v3799Hc3Mw8XkFBAQYGBuByuc+8NjU1hYqKCotHNfDu3LmDf/zjH7hy5QpmzZqFr7766i810idDw927d7Fp0yacPXsWnp6e+P7772Fvb892WYQQQgghQw0FZoQQQvpfU1MTysrKUFJSgrKysl63y8vLUVxcjPb2dubx6urqMDIygomJCYyMjJjbhoaGzG1xmBopTq5du4ZPPvkEKSkp8PPzw3vvvYdp06axXRYZILGxsdixYwdOnToFW1tbfPXVV5g5cybbZRFCCCGEDFUUmBFCCHkxQqEQlZWVKCoqQlFREYqLi5lLaWkpSkpKeq0eqaKiAhMTExgbG8PQ0BDGxsYwNjaGkZERc1tVVZXFI5JcIpEIkZGR+PHHHxEfH4/x48dj/fr1WLZsGRQVFdkuj7yizs5OhIWF4bvvvkN+fj6mTp2K999/H/7+/pCSkmK7PEIIIYSQoYwCM0IIIb3x+XyUlZUxIVhhYeFToRiPxwMAyMrKwsjICKampszFyMgIhoaGzG11dXWWj2h4yMjIwM6dO3Ho0CHIyspi7ty5CAwMxOzZsyEjI8N2eeQvEgqFuHHjBiIiIhAWFoampiZ0d3dDQUEBDg4OcHFxgbOzM1xcXKCpqcl2uYQQQgghQxUFZoQQMtzweDyUlZX16hv2+KWkpAR8Ph8AICcnByMjI5ibmzO9wszNzZmLiYkJhTFipqamBmFhYQgLC0NycjIMDAywaNEiBAYGYtKkSbS6phgSCoVITU1FREQEjhw5grKyMtjb2yMoKAhLly5Fe3s7EhISkJiYiISEBOTm5kJaWhoWFhZMgObm5gYzMzO2D4UQQgghZKigwIwQQoai2tpaFBQU4OHDh8x1z+2KigpmVUkVFRWYmprCzMys1yixnguXy2X5SMiruHfvHhOe3b9/H9ra2pg1axZ8fX0xc+ZMGqHEoqamJly+fBlRUVGIiopCTU0NzM3NsXTpUixduhSWlpbPfG51dTVu377NBGjJycng8Xjgcrm9RqDZ2dlRQEoIIYQQ8nIoMCOEEEnE5/NRUlLyzFCsZ3VJWVlZmJmZwdzcHKNGjWJGhvUEYlpaWiwfCRksOTk5OHXqFA4fPoy8vDxwOBxMmjQJbm5ucHV1hYuLC/WSG0Ctra24ceMG4uPjERsbi5s3b0IkEmHq1Knw9fWFj48PJkyY8FLbbmtrQ3p6OhOgJSQkoLGxEWpqanBycmICNBcXFygoKPTzkRFCCCGEDEkUmBFCiLjq6upCeXn5U1MmCwoKkJOTg46ODgCAgoICM1XSysoK1tbWNGWSMLq7u3H58mWEhYUhMjISPB4Pnp6emDt3LjIyMhAfH4/8/HxwOBzY2trC1dUVU6ZMgb29PUaNGkXN5V9SQUEB0tLScPPmTcTHxyM9PR18Ph9jxoyBq6srZsyYMWCj/AQCAfLy8pgALS4uDsXFxZCRkYGNjQ0ToE2bNo1Cc0IIIYSQvlFgRgghbOrq6sL9+/dx79495pKfn48HDx6gpqYGACAlJQVDQ0NmhNiT19ra2iwfBRFHqampOHjwII4ePYqamho4ODggODgYixcvhp6eXq/HVldXIz4+HnFxcYiLi0N2djb4fD7U1dVhZ2cHe3t72NvbY+LEiRg7dizk5eVZOirxw+PxcO/ePdy5cwdpaWlIS0tDeno6GhsbweFwYGVlxYzic3NzY22ac0VFBROgJSYmIi0tDSKRCObm5kyA5uzsDGtra1bqI4QQQggRMxSYEULIQBMKhSgpKWGCsfz8fOTn5+P+/fsoLi6GUCiEtLQ0TExMMHbsWIwZMwZjxozBqFGjMGrUKIwcOZKmUZG/JCcnB+Hh4Th06BAePnwIKysrBAYGYtmyZRg9evRf3k5HRwcyMzORnp7OhEBZWVng8XjgcDgwMzODhYUFLC0tYWFhAQsLC4wcORIGBgbgcDgDeITsEAgEqKysRGFhIfP7m5eXh7y8PBQWFkIgEEBWVhbW1tZMuGhvbw8bGxsoKSmxXX6fmpubcfv27V6LCXR2doLL5fZajXPSpEmQlZVlu1xCCCGEkMFGgRkhhPSXhoaGXtMms7OzkZOTg/z8fLS2tgIANDU1e60y2TOFcty4cVBWVmb5CIgkKisrw4kTJxAREYHExEQYGRnB398fgYGBcHFx6bf98Hg8JizKz89Hbm4uc7ulpQUAICMjAwMDA5iYmMDU1BQmJiYwNDSEvr4+dHR0oKOjA21tbejo6PRbXa+qrq4OtbW1qKurQ11dHSorK1FeXo7CwkKUlpaitLQUFRUV6O7uBgAoKyszIaGVlRVze9y4cZCTk2P5aF5ed3c37ty5wwRo165dQ319PVRUVGBjYwMXFxd4eXlh6tSpYhsCEkIIIYT0IwrMCCHkRQgEAjx8+BBZWVnMFMq8vDzcu3cPjx49AgDIy8tjzJgxGDt2LHPpeVNN/YJIf2hoaMDZs2cRGhqKa9euQUNDA35+fggJCcG0adMGfWXEiooKJmAqKSlBaWkpiouLUVxcjIqKCtTV1fV6PIfDYcIzVVVVKCsrQ0NDA8rKylBWVoaqqirU1dUhLS0NeXn5XgGNnJxcr3C5vb0dXV1dT30tFArR1NSE1tZWtLW1oa2tDQ0NDWhra0NraysTkvH5/F61aWlpwcDAAHV1dVBUVMSqVauYfoCmpqYwMjIaoH9F8VNQUICrV68yIVpBQcFTfdA8PDzEKgAlhBBCCOknFJgRQkhfBAIBCgsLkZWVhZycHGRlZSE3Nxe5ubno6uqClJQUM4WyJxDruW1qajrogQUZ+jo7O3HlyhWEhoYiMjIS0tLS8PLyQkhICObNmyfWo5v4fH6vkVxVVVWoq6tDRUUF9uzZgylTpkBRUZEJtlpbW9HY2AiRSPRUINbR0YHOzk7mawUFBSgqKjJfPx6oaWpqQllZGSoqKhAIBKirq4ObmxtUVFSYkW56enpMeKetrc1MP0xKSoKvry8mTJiAyMhIqKmpDdK/lvh6sg9aeno6hELhU33QrKysaLEIQgghhEg6CswIIaSiogI5OTnMFMrs7GxkZGSgra0NAMDlcmFtbc1Mn7SysoKtrS1UVFRYrpwMdQKBADdv3kRoaCiOHDmC9vZ2TJ48GSEhIViyZAlUVVXZLvGVfPDBB9i/fz/y8/MHfPGKa9euwcvLCwkJCXB2dv5Lz8nOzsbMmTOhr6+PCxcu0EiqJ7S0tCApKYkJ0BITE9HR0QE9PT289tprTIDm5OQk1oEuIYQQQkgfKDAjhAwffQVjmZmZTH+xvoIxGxsbiQ8liOTpWeEyPDwcVVVVzAqXixYtgr6+Ptvl9YucnBzY2tri119/xZtvvjko+3RxcYGmpibOnj37l59TWFgIb29vyMjI4PLlyzA2Nh7ACiUbn89HZmYmE6DFxMSgtrYWysrKsLW1ZQK0nv8HQgghhBAxRoEZIWToqa+vR3p6OjIzM3Hnzh1kZ2cjNzeXGTFmbGwMKysrjB8/HpaWlpgwYQIsLS0pGCOsys3NxbFjxxAWFob79+/D0tISr7/+OoKCgjBmzBi2y+t306ZNQ3NzM5KSkgZtZc2oqCj4+voiOTkZjo6Of/l5VVVVmDVrFhoaGnD58mVYWFgMYJVDS0FBQa+VOHNzcyEtLQ0LCwsmQHN3d4epqSnbpRJCCCGEPI4CM0KI5BKJRCgsLERGRgZzyczMRElJCQBAT08PNjY2zGixnoBMXV2d5coJ+UN5eTmOHz/OrHBpaGiIgICAfl/hUtyEhYUhODgYN27cwKRJkwZ136+99hpMTU1x/PjxF3peY2Mj/Pz8kJubi/Pnz2Py5MkDVOHQVlVVheTkZCZAS05OBo/HA5fL7TUCzc7OjnpBEkIIIYRNFJgRQiRDd3c37t27h9TUVGY65a1bt5jV97hcLhwcHJiLtbU1zM3NWa6akKc1NjbizJkziIiIwIULF6Cqqoo5c+YgMDAQs2fPhoyMDNslDqiWlhZYWlrC19cXu3btGvT9nzx5EgsXLkRmZiYmTJjwQs9tb29HQEAAEhIScPLkScyYMWOAqhw+2trakJ6ezgRoCQkJaGxshJqaGpycnJgAzcXFBQoKCmyXSwghhJDhgwIzQoj4aWpqwt27d3uFY6mpqejs7IScnBxGjx7dKxyjBvxE3PWscBkREYETJ05AKBTCy8sLgYGBWLhwIZSUlNgucdAMZqP/vohEItjY2GDChAk4fPjwCz+fx+MhJCQEp0+fxqFDh7Bw4cIBqHL4EggEyMvLYwK02NhYlJSUQFZWFhMnTmQCtGnTpkFLS4vtcgkhhBAydFFgRghhV1VVFW7fvo3U1FRkZmYiIyMDxcXFAP7/lEo7OzvY2trCxsYGY8eOHbR+R4S8CqFQiBs3biA0NBRHjx5Fa2srpkyZgpCQECxevBhqampslzjo2Gj035cjR44gODgY2dnZL9WPTCQS4f3338eOHTuwa9curF69egCqJD0qKiqYAC0xMRFpaWkQiUQwNzdnAjRnZ2dYW1uzXSohhBBChg4KzAghg6etrQ1paWlISkrC7du3kZSUhJKSEkhLS2P06NGwtbWFnZ0dbGxsYGtrCy6Xy3bJhLyw7OxshIaG4sCBA6iqqoKVlRVCQkIQEhIy7H+m2Wj03xeBQABra2tMnToVv//++0tv59tvv8XHH3+Mb7/9Fhs3buzHCsnzNDc34/bt20yAFh8fj66uLmZqvouLC7y8vKgPGiGEEEJeBQVmhJCB0TOtJjU1lbn0NHfW19eHo6MjM6Vy6tSpNLWGSLSioiIcO3YMv//+O+7duwczMzMsWrQIq1atwtixY9kuTyyw2ei/L/v378ebb76J/Px8jBw58qW38+uvv+K9997Dxo0b8fXXX0NKSqofqyR/RXd3N+7cuYOrV68iISEBN27cQH19PVRUVDB58uReo9AUFRXZLpcQQgghkoECM0JI/6ioqOgVjiUmJqKhoQHKysqwtbV9qiE/IZKuoqICERERiIiIwI0bN8DlcrFw4UIEBgbC2dmZgpPHsN3ovy/d3d2wsLDAzJkzsXPnzlfa1qFDh7Bq1SoEBQVhz549Q37hBnEnFAqRm5vbayGBwsJCyMjIwMbGhgnQPDw8oKOjw3a5hBBCCBFPFJgRQl5ca2srMjIymHCs580Ih8OBhYVFr3DMyckJcnJybJdMSL9oampCZGQkIiIicPHiRSgrK2Pu3LnDZoXLl8V2o/9n2bVrF9577z0UFRVBX1//lbZ19uxZLFq0CDNnzsSRI0doRUcx82QftPT0dAiFwqf6oFlZWVHYTQghhBCAAjNCyF9RXFyM+Ph45pP63NxcCIVCGBkZYdKkSZg0aRKcnJzg4OBAq1WSIaerqwuXL19mVrgUCASYMWPGsFzh8mWIS6P/vnR1dcHU1BRvvvkmtmzZ8srbi42Nxbx58+Dg4IDTp09DVVW1H6okA6GlpQVJSUlMgJaYmIiOjg7o6enhtddeYwI0+tCHEEIIGbYoMCOE9CYUCpGVlYX4+HimmXJZWRnk5OTg6OgIFxcXTJkyBU5OTjAwMGC7XEIGRM8KlxEREQgLC0N9fT2mTJmCwMBABAUFidUoKXHX0+j/9u3bYtmAffPmzdixYwdKS0v7JfxMS0vD7NmzYWpqiqioKPpZkRB8Ph+ZmZlMgBYdHY26ujqmrUBPgObq6goNDQ22yyWEEELIwKPAjJDhjs/n4/bt24iJiWE+ZW9qaoK6ujqmTp3KvEF47bXXqFkyGfJ6Vrg8ePAgKisrmRUug4ODKSB+CeLW6L8vNTU1MDU1xc8//9xvI+AKCgrg7e0NeXl5XLp0CUZGRv2yXTK4CgoKmACtZ3S1tLQ0LCwsmADN3d0dpqambJdKCCGEkP5HgRkhww2fz0daWhqio6MRExODhIQEtLa2wsDAAG5ubkxANn78eHA4HLbLJWTAFRcX4+jRo9i3bx/y8/NhamqKxYsXY+XKlbCwsGC7PIkljo3+n2X16tVITExETk5Ov42Cq6ysxMyZM9HS0oLLly9jzJgx/bJdwp6qqiokJyczAVrPys9cLpcJ0FxcXGBnZyeWoykJIYQQ8kIoMCNkqHt8tbCrV6/i6tWraGhogK6uLtzd3ZkTfHt7e2p0TIaNR48e4cSJEzh48CBu3LiBESNGICAgAMHBwbTCZT8R10b/fcnKysLEiRNx7tw5+Pj49Nt2Gxoa4Ovri4KCAly8eBG2trb9tm3Cvra2NqSnpzMBWnx8PJqamqCmpgYnJyfm9dXFxYUWgSCEEEIkDwVmhAxFRUVFuHz5Mq5cuYJr166hoaEBOjo6cHd3h6enJzw8PGBlZcV2mYQMqubmZpw+fZpZ4VJOTg6+vr4IDg6mFS77mTg3+n+WmTNnQigU4sqVK/263ba2Nvj7++P27ds4e/YsXFxc+nX7RHwIBALk5eUxAVpsbCxKSkogKyuLiRMnMgHa9OnTMWLECLbLJYQQQsjzUWBGyFDQ0tKC6OhoJiS7d+8elJWV4e7uDm9vb0yfPh3W1tY0aoYMO4+vcHny5Enw+XxmhcuAgAAoKyuzXeKQJO6N/vty8eJFzJ49GxkZGbCxsenXbfN4PCxbtgxnzpzBkSNHsGDBgn7dPhFfFRUVTICWmJiItLQ0iEQimJubMwGal5cXzM3N2S6VEEIIIb1RYEaIJBKJREhLS8OFCxdw5coV3Lx5EwKBALa2tvD29oa3tzemTp0KeXl5tkslZNA9b4XLpUuXQkdHh+0Sh7TDhw8jJCRErBv9P4uNjQ0cHBzw+++/9/u2BQIB3n77bezbtw+7d+/GypUr+30fRPz1BMlXr15FQkICUlJS0NXVRX3QCCGEEPFDgRkhkqKtrQ1XrlzB+fPnERUVhYqKChgYGDABmZeXFwUBZFjLzs5GREQEDh48iMLCQlhZWSEwMBDLly/HyJEj2S5vWGhpacG4ceMwZ84c/O9//2O7nBe2d+9evPvuuygsLASXy+337YtEInz88cf47rvv8P333+P999/v930QydLe3o60tDRmFNqNGzdQX18PFRUVTJ48mQnQnJ2daaVqQgghZHBRYEaIOOvpRXb27FlcvXoVPB4PdnZ28PLygp+fHzUnJ8NeSUkJTp06hf379yMjIwMmJiaYP38+Vq5cSQ3WWSBJjf770tXVBTMzM6xZswZbtmwZsP38/PPP2LBhA/75z3/im2++GbD9EMnzZB+0hIQEFBYWQkZGBjY2NkyA5uHhQR+SEUIIIQOLAjNCxE1KSgpOnjyJM2fOIDs7G2pqavD29oavry98fHygq6vLdomEsKq+vh7Hjx9nVrjU1NTEwoULaYVLlklio/++bN68GTt27EBpaSmUlJQGbD979+7F2rVr8e6772L79u30c0ue6ck+aOnp6RAKhb36oDk7O8PKyop+jgghhJD+Q4EZIWwTCoVITEzEyZMncerUKRQXF8PMzAzz58+Hn58fXF1dIScnx3aZhLCqo6MD586dw8GDB3Hp0iXIyMjAz88PwcHBmDVrFmRlZdkucdiTxEb/fampqYGJiQl27tw54H3GIiIisGzZMixbtgy7d+8Gh8MZ0P2RoaGlpQVJSUlMgJaYmIiOjg7o6+vD0dGRCdCcnJzo/IEQQgh5eRSYEcIGgUCAmzdvIiIiAsePH0dFRQXMzc3h5+eHwMBAGiVDCP74PYmOjsbBgwdx6tQpdHR0wNPTE8HBwfD394eKigrbJZL/I8mN/vsSFBSEhw8f4tatWwO+rwsXLiAgIABz5szBoUOHKPwlL4zP5yMzM5MJ0KKjo1FXVwdlZWXY2toyAZqrqys0NDTYLpcQQgiRFBSYETJYhEIhYmNjcfjwYZw8eRINDQ2wt7eHv78//P39YWlpyXaJhLDu8RUujx49irq6OmaFyyVLltCUZDEk6Y3++xIXFwd3d3ekpqbC3t5+UPY3Z84cuLi44Pjx49TcnbyygoICJkBLSEhATk4OOBwOLCwsmADNw8MDJiYmbJdKCCGEiCsKzAgZaGlpaTh8+DCOHTuG8vJy2NnZYenSpQgICKCV+wj5Pz0rXIaGhqKgoIBZ4TIkJATm5uZsl0eeQ9Ib/T/L+PHj4ezsjF27dg3K/lJSUjBr1iyMHz8eZ8+ehaqq6qDslwwPVVVVSE5OZgK027dvo7u7G1wulwnQXFxcYG9vTyPcCSGEkD9QYEbIQCgpKcGRI0ewf/9+5OXl0cp9hPShtLQUJ0+exMGDB5GWlgZjY2MsWLAAy5cvH5RRPeTVZWdnw87OTuIb/ffl559/xqeffory8nKoqakNyj5zcnIwY8YMGBgY4OLFi9DS0hqU/ZLhp7W1FRkZGUyAFh8fj6amJqipqcHJyYkJ0FxdXSEvL892uYQQQggbKDAjpL+0trYiIiICv/32GxITE6Gnp4dFixZh6dKlQ6KnDyH9oaGhAWfPnkVoaCiuXbsGDQ0N+Pn5ISQkBNOnT6eRDRJmqDT670tjYyMMDQ3x73//G3/7298Gbb/5+fmYMWMG1NTUcOXKFXC53EHbNxm+BAIB8vLymAAtJiYGpaWlkJWVxcSJE5kAbfr06RgxYgTb5RJCCCGDgQIzQl5VUlISfvvtNxw9ehQ8Ho8ZSebl5UUrnhGCvle4nD59OkJCQjB//nxqci6hhlqj/76sWrUK6enpSE9PH9T9lpSUwMvLC9LS0rhy5QqMjY0Hdf+EAEBFRQUSExNx9epVJCQkIDc3F1JSUhg3blyvhQSovQQhhJAhigIzQl5GY2MjwsPDsXPnTmRkZMDS0hLLly/HqlWroKOjw3Z5hLDueStcLliwgPozSbih2Oi/LwkJCXB1dUV6evqgT6evrq6Gt7c3mpqacPXqVYwePXpQ90/Ik2pqapCUlMSMQktJSUFXV9dTfdDs7OyG3IhTQgghwxIFZoS8iNTUVPzyyy84duwY5OTksHjxYqxevXrIjq4g5EWlpqbi4MGDOHr0KGpqauDg4IDg4GAsXrwYenp6bJdH+slQbfTfl3HjxmHWrFn46aefBn3fDQ0N8PHxQVFRES5fvowJEyYMeg2EPEt7ezvS0tKYAC0xMRENDQ1QVVXFpEmTmADN2dmZVn4lhBAiiSgwI+TP8Pl8nDp1Cr/88gsSEhIwceJErFu3DkuWLIGysjLb5RHCupycHISHh+PQoUN4+PAhs8LlsmXLaFTMEDSUG/33ZevWrfjpp59QXl7OSvPz1tZWzJs3D+np6bhw4QJ9QEPE1pN90OLj41FUVAQZGRnY2NgwAZqnp+eQD9oJIYQMCRSYEfIsTU1N2L9/P7Zv347S0lJMmzYN69evh5+fHzUmJ8NeWVkZTpw4gYiICCQmJsLIyAj+/v4IDAyEi4sL2+WRflBfX99nc++h3Oi/L2VlZTAzM0N4eDj8/f1ZqaG9vR0BAQG4efMmzp8/D2dnZ1bqIORF9fRB6xmBlp6eDqFQCHNz814j0KysrOjcihBCiLihwIyQJ5WWluK7777D77//DllZWaxevRrvvvsuNbUlwx6tcDm82NvbY/Lkydi2bRs0NTUBDI9G/33x9vaGgoICzpw5w1oNPB4PQUFBiIqKwqlTp+Dt7c1aLYS8rJaWFiQlJTEBWkJCAjo7O6Gvrw9HR0cmQHNycoKcnBzb5RJCCBneKDAjpEdBQQG+/vprHDx4EPr6+ti4cSNWrFgBFRUVtksjhDWdnZ24cuUKQkNDERkZCWlpaXh5eSEkJATz5s2jNzRDVEdHB1RVVSEUCqGuro4ffvgBCxcuhKWl5ZBv9N+XsLAwLF++HGVlZaz24hMIBFizZg0OHz6MY8eOYf78+azVQkh/4PP5yMzMZAK06Oho1NXVQVlZGba2tr1W49TQ0GC7XEIIIcMLBWaEPHz4kBlRZmRkhL///e946623oKCgwHZphLBCIBDg5s2bCA0NxZEjR9De3o7JkycjJCQES5YsoRUuh4EbN270mvYnJSUFIyMjNDc34+HDh9DS0mKxusHX3t4OPT09fPPNN3jnnXdYrUUkEmH9+vXYtWsXjhw5goCAAFbrIaS/FRQU9BqBlpOTAw6HAwsLCyZA8/DwgImJCdulEkIIGdooMCPD1/379/Hpp5/i+PHjsLCwwCeffILFixdDRkaG7dIIYUXPCpfHjh1DdXU1s8LlokWLoK+vz3Z5ZBD9/PPP+Mc//gE+n8/cJyMjA4FAgKCgIGzfvn3YNe0OCgpCaWkp4uLi2C4FIpEIGzZswK+//op9+/YhODiY7ZIIGTCVlZVISUlhArTbt2+ju7sbXC6XCdBcXFxgb29PrQEIIYT0JwrMyPBTV1eHLVu24H//+x/GjBnxH1BjAAAgAElEQVSDzZs3IyAgYFg0rybkSbm5uTh27BjCwsJw//59WFpa4vXXX0dQUBDGjBnDdnmEJUFBQQgPD+8VmPWQkZGBkpIStmzZgnXr1g2bv51nzpzB/PnzUVhYCFNTU7bLAQB8+umn+Oabb7Bnzx6sXLmS7XIIGRStra3IyMjotRpnU1MT1NTU4OTkxARorq6urKxsSwghZMigwIwMHzweDzt37sTmzZshIyODTz/9FO+88w6NKCPDTnl5OY4fP86scGloaIiAgABa4ZIwRo0ahYKCgmd+X0pKCiKRCG+88Qb27NkziJWxh8fjgcvlYtOmTXj//ffZLoexefNmbNmyBTt27GB9uighbODz+cjPz0diYiKuXr2K2NhY1NTUQElJCXZ2dswoNGdn5z5X/iWEEEKegQIzMvSJRCKEhYXhk08+waNHj/DBBx9g48aN1MyfDCuNjY04c+YMIiIicOHCBaiqqmLOnDkIDAzE7NmzKTgmjObmZmhoaOB5pwccDgfe3t44duzYsOppt2rVKmRnZyMpKYntUnr59ttv8fHHH2P79u1477332C6HENY92QctNzcX0tLSvfqgubq60grohBBCnocCMzK0PXjwAG+99RZiY2OxYsUKbNmyBQYGBmyXRcgLKSkpeanmxs9a4TIwMBALFy6EkpLSAFRLJN3169cxffr05z5m3bp12L59OzgcziBVJR4uXbqE2bNn48GDBzA3N2e7nF6+//57bNy4EVu3bsWmTZvYLocQsVJTU4OkpCQmQEtJSUFXV9dTfdDs7OyGzTRzQgghf4pHQwrIkMTn8/Gf//wHmzZtgrm5ORISEjB58mS2yyLkhUVERGDlypW4e/fuX/okXCgU4saNGwgNDcXRo0fR2tqKKVOmYMeOHVi8eDHU1NQGoWoiyZKTkyErK4vu7u5e93M4HEhJSWH37t3Dtl/W9OnToampidOnT4vVtEwA+Mc//gFlZWW888474PP5+Pzzz9kuiRCxoaurizlz5mDOnDkA/lj5Ni0tjQnQvvjiCzQ0NEBVVRWTJk1iAjRnZ2coKiqyXD0hhBC20AgzMuRkZmbijTfeQFZWFj788EN88sknkJOTY7ssQl6IUChkGnoDwNatW/HJJ5888/HZ2dkIDQ3FgQMHUFVVBSsrK4SEhGD58uW0wiV5If7+/jhz5gwEAgFzn6ysLJSUlBAZGQl3d3cWq2NfcHAwSktLERMTw3YpfdqzZw/Wrl2LjRs3Mn8/CCHPJxAIkJeX12shgaKiIsjIyMDGxoYJ0Dw9PYfdCsGEEDKM0ZRMMnQIBAJ88cUX+Oqrr+Dq6ordu3fTKn9EIjU3N2Pp0qW4cOEChEIhAGD06NG4f/9+r8cVFRXh2LFj+P3333Hv3j2YmZlh0aJFWLVqFcaOHctG6WQI4HK5qKqqYr6WlZXFqFGjcOHCBZiZmbFXmJgIDw/H0qVLUV1dDS0tLbbL6dPhw4exYsUKbNiwAd999x3b5RAikSoqKpgALTExEenp6RAKhTA3N+81As3a2rrf9nnq1CnMnz8fUlJS/bZNQgghL40CMzI0VFVVYenSpbh58yZ+/PFHrF27lk42iETKz8+Hr68vSkpKnpoSl5mZCW1tbURERDArXBoYGGDhwoUIDAyEs7Mz/dyTV1JbWwtdXV3maw6Hg+nTpyMiIoKm8/6f1tZWaGtrY+/evVi2bBnb5TzT0aNHERwcjDVr1uA///kP/W0g5BW1tLQgKSmp12ICnZ2d0NfXh6OjIxOgOTk5vdTMhurqaujr68PFxQW///47fehLCCHso8CMSL7Y2FgsWbIEcnJyCA8Ph5OTE9slEfJSzp07h8WLF4PH4z0VlsnKysLQ0BAlJSVQU1ODv78/goKC4OHhQQ2KSb+JioqCr68v8/U///lPfP311/Qz9gRvb29oamri2LFjbJfyXBEREQgKCsLKlSuxc+dO+n8kpB/x+XxkZmYyAdr169fx6NEjKCsrw9bWlgnQ3NzcoK6u/qfbO3HiBAIDA5l+kZs3b8bGjRshKys7CEdDCCGkDxSYEcklEomwbds2bN68GQsWLMBvv/1GIyDEiEgkQmNjI4RCIZqamphr4I+TzJaWlj6f1/PYJ0lJSUFDQ6PP56iqqkJG5o81TNTU1MDhcKCurg5paWnmWpyJRCJ89913+PjjjyElJdXn8QOAiooKDhw4AF9fX8jLyw9ylUQcNDQ0oK2tDW1tbWhtbe3zd6m5ublX/7Ge34PHqaioQFZWFsrKylBWVoaKigo0NDSwZcsWbN68GTIyMtizZw9WrFgxGIclcXbs2IFPP/0UtbW1Yt8j8/Tp01i0aBGCg4Oxe/dusf97SIgkKygo6DUCLScnBxwOBxYWFkyA5unpCWNj46eeu2HDBvz3v/8Fj8cD8McI3zFjxmDfvn3DeuGqzs5OdHR09DqPfPx1jsfjoa2t7ZnPf/I18UmPn0M+SVZWFioqKszXPeeYCgoKUFRU7PP1lRAypFBgRiRTZ2cnVqxYgVOnTuHf//431q9fz3ZJQ0ZbWxvq6upQXV2NhoYGNDc3M9dPXpqamtDU1ITm5mZ0d3ejoaEBAJhrcaKhoQEpKSloampCRkYGampq0NDQgLq6OtTU1J66aGpqMo/R09ODtrZ2r5Om/tLS0oKgoCBERUU994SuR2xsLNzc3Pq9DjL4ampqUFpaioqKCtTV1aG2thY1NTWoq6vrdWlubkZ7e/tz3xD0Fw6HA5FIBH19fRgZGUFbW5u56OrqQldXF9ra2tDX14eJiQn09PQGvCZxVFRUhJEjR+L69evw9PRku5w/FRUVhYCAACxevBi//fYbhWaEDJLKykqkpKQwAdrt27fR3d0NLpfLBGguLi6wt7eHra0t7ty50+v5HA4HQqEQb7zxBn744QeoqqqydCR/rqurCw0NDaivr2fOG1tbW9HU1IS2tja0t7ejqakJLS0tzGtaY2Mj872eYKu5uRnAnwdd4ubJME1eXh7KysrQ0NDo9eGUuro6lJWVoaSkBHV1daiqqkJJSYk59xwxYgQ0NTXF+v+akGGEAjMieerr67FgwQKkp6cjPDwcs2bNYrsksdfU1ISysjKUl5ejsrIS5eXlqK2tZd6Q19TUMF93dHQ89fye8OjJi7q6OjQ0NKCmpgZZWVkmlHredY+e+56krKzc54iN7u5utLa29nl8jwd0j49m6+u6sbERfD4fTU1NaGxsZAK/Jy99hX4KCgrQ1taGjo4OE6L1XAwNDcHlcmFkZARDQ8NnjoZ73L179+Dr64vi4uKnpmD2RVZWFqtWrcL//ve/P30sYV9zczPy8/Nx7949PHjwACUlJSgpKUFpaSmKi4vR2dnJPFZZWRna2trMz5WOjg7zs6WmpgYlJSUoKytDU1MTSkpKzMl1XyMvn/wd6ut3p7GxESKRqNcbl4aGBmzZsgWvv/46ZGVlnwruqqurUVtb2yu4U1BQgImJCYyNjWFsbAxTU1OMGjUKFhYWGDt27F/6PZBUY8eORWBgILZt28Z2KX/J5cuXMW/ePArNCGFRc3Mzbty4gcTERMTHxyM5ORnt7e3Q0dFBfX39MwMiWVlZaGpqYufOnfD39x/wOjs6OlBdXY2qqirU1taiuroaNTU1vQKxJ6+f9aGOuro68xqmrq4OFRUVKCkpMeHR4997/DWtZyS0nJwclJWVAfxxPgo8/TrXc39fFBUVoaCg0Of3emZDPEt7ezu6urqYr3teO3vuf/z19cnvdXR0MCFha2srMzq8sbER7e3tvb7X1zlgz/95T4D25LWWlhZ0dXXB5XKZ89IRI0Y881gIIS+FAjMiWQoKCuDr64uWlhacP38eNjY2bJfEuq6uLhQVFaGgoAAFBQVMMFZWVobKykqUlJSgvb2debyioiIMDAyYkSI9b84f/7rnjfuIESOG9TTXnuCsurq6V3BQU1PTayRQbW0tKioqev07KykpwdjYuFeIZmRkBHNzc5ibmyMrKwsrVqxAZ2fnC32CqqamJhHTwIaTxsZGpKenIyMjA3l5ebh37x7y8vKYlSbl5ORgbm7eK1gyMzNjbhsZGUFRUZHlo/hjpeGOjo4/HUnZ0dGBiooKJvwrKipCaWkpSktLUVJSgoKCAuYNhp6eHsaNG4exY8fCwsICtra2sLe3f+6bG0nxt7/9DampqUhKSmK7lL+sJzRbsmQJ9u7dS6EZISzr7u5GamoqDh48iJ07dz73sdLS0hAKhfDx8cHu3bthaGj4wvtrbGxEWVkZiouLmfPEmpoaVFZWMqOcKysrn/qQRVVVlTkvfFaI8+R9ampqAzIyfyji8XjMOeezAsn6+vqnbtfU1PRq4yEnJ8eEZ/r6+sztnnNRIyMjmJiYQF9fn/7+E/LXUGBGJEdSUhLmzp0LfX19nD9/HkZGRmyXNGhaW1uRl5eHBw8eoKCgAA8fPuwVkPW8WGpra8PY2JgJZ7hcLhPaGBsbw8DAYEi8URVXjY2NvcLK0tJSVFZWMiFmaWkpamtrX3k/Z86cwZw5c/qhYvKiGhoacOvWLaSnpyMtLQ3p6ekoKCgA8Ec4ZGVlhbFjx2Ls2LEYN24cLCwsYGZmBg6Hw3Llg0cgEKC4uJgJDntG2eXk5DAhopmZGezt7WFnZwc7OztMnjwZWlpaLFf+Yk6ePInXX38dNTU1EvWp/qVLlzB//nwKzQgRI1988QW++uorpn/Z88jKykJeXh5bt27FunXrmN9hgUDAfGjRE4qVlpairKyM+YDj8Z6X6urqMDQ0hI6ODrhcLnR1daGjowMDAwPmg9Se+581QouwSygUMkHn4yMCq6qqmFHhlZWVzPd63i/IysrCwMCAGRneE6aZmpoyI8V7RvURMsxRYEYkw6VLl7BgwQJ4eXnhyJEjQ/aPeHNzM+7fv4+CggJkZ2cjJycH2dnZyMvLg1AohIyMDExMTJhRSo9fRo8eTY1HJUB5eTmuX7+OyspKZrRaeXk5ysvLe43M0dbWhrm5OYyMjDBy5EiMGjUKo0ePxogRI8DlcmFgYMDykQwPlZWVSEhIYJo4p6enQygUgsvlwsHBgblYW1vD3Nyc7XLFXkNDA7Kzs5GamspccnNzIRKJYG5uzvTzcXZ2hrW1NdvlPldjYyO0tbURHh4+KFOk+hOFZoSIl+nTpyM6Ohov+rbM0NAQEyZMQG1tLXJzc5mR7vLy8kyrCAMDA5ibm/e6PWrUqCE9ZZ48rbu7mwnQCgoKUFFR8dTtoqIiJlTT1NTs8/2GtbU1uFwuy0dDyKChwIyIvzNnzuD1119n+q4MlZEa1dXVzBvGlJQUZGRkoKSkBMAf0yYtLS1haWkJa2tr5nrkyJHPXMmHSD4+n4+ioiJkZ2cjNzeXuX78JNjIyAh2dnZMUOPo6Ah9fX2WKx862tracP36dURFReHSpUsoLCyErKwsHBwc4OzsDDc3N0ydOhXa2tpslzpk1NfXMw2xExISkJKSAh6PBxMTE8ycORM+Pj7w8vISy6k9kyZNgoODA/773/+yXcoLu3jxIhYsWIClS5diz549FJoRwhKBQABVVdU+e8jKyMhAJBJBKBQ+FaZxOByoqqpCV1cXCxYswMSJEzF69GiYm5vTaxR5KR0dHSgqKsKDBw/w4MEDPHz4kLldXFwMPp8PABgxYgQsLCwwfvx4WFtbM9d0PkqGIArMiHgLDw/HsmXLsHLlSuzcuVNiT+hbWlpw48YNJCcnMyFZaWkpAGDkyJFwdHSEvb09rK2tYW1tDTMzM4k9VtL/hEIhioqKkJubi6ysLKSlpSE1NRUPHz4E8McnzD3hmaOjI5ydnYd177kXVVJSgtOnTyMqKgqxsbHg8Xiwt7fH7Nmz4enpiUmTJkFJSYntMoeNjo4O3L59GzExMYiKikJKSgpkZGTg5uaG2bNnY8GCBRg5ciTbZQIANm3ahIiICNy7d4/tUl4KhWaEsEsoFOL06dMICAhg7uNwOExvUw6HAz09PZiamsLKygoTJkzAa6+9hgkTJtAqimRQdXd3o7i4mAnRej7YzcrKQl1dHQBAS0urV4g2ceJE2NnZ0TkUkWQUmBHxFRYWhuXLl+PNN9/Er7/+2ueKiuKqpaUFSUlJuHr1KhISEpCcnAwej/fUNK5JkyZBV1eX7XKJhGpubsadO3eemt4mLS0NCwsLuLi4wMvLCx4eHtDR0WG7XLFSX1+Pc+fOITQ0FNeuXYOSkhI8PT0xZ84c+Pr6vlQzZTIwHj16hOvXr+Ps2bM4d+4cGhoaYGVlhZCQEISEhLA6NSQ6OhrTpk1DYWEhzMzMWKvjVVBoRsjgqaio6PWaffPmTTx69AgcDoeZXjl+/HhYWVkxoYO8vDzbZRPyXD3tFnpayeTk5ODOnTuoqakBh8OBhYVFr/c/jo6O1BePSAoKzIh42rNnD9auXYuPPvoI27ZtY7ucP9XZ2Yno6GhERUUhJiYG2dnZkJKSgrW1Ndzd3eHq6go3NzcaqkwGXE1NDeLj4xEXF4e4uDjcuXMHIpEIlpaW8PDwwOzZszF9+nSxWJVxsPH5fERGRmLv3r24evUqFBQUMHfuXCxZsgTe3t608qgE4PP5uHLlCo4cOYLIyEi0tbVh2rRpWL16Nfz9/SErKzuo9fB4PIwYMQI///wzVq9ePaj77k8UmhHS/zo7O5GUlITo6GjcunULKSkpePToEWRkZGBpaQlHR0e89tprcHR0hI2NDb0GkSGnsLAQycnJSElJQUpKClJTU9Hc3Aw5OTnY2NjAyckJrq6u8PDwgJ6eHtvlEtIXCsyI+Dl8+DBCQkLw+eef47PPPmO7nGcqLy/H+fPncf78eVy9ehUdHR2ws7PDtGnT4ObmBhcXF1qRkrCusbERCQkJiI+Px7Vr15CWlgYFBQVMmzYNfn5+8PX1hbGxMdtlDqi6ujrs2bMHO3fuRHl5OXx8fBAUFIS5c+fSNAEJ1tHRgfPnz+PQoUM4d+4c9PT08Pbbb2PNmjWDeuI9a9YsaGpq4siRI4O2z4Fw4cIFLFiwAMuWLcPu3bspNCPkBfUEZDExMYiJicGtW7fQ2dkJU1NTuLq6Mm0TaIoaGa6EQiHu37/PhGhJSUlISUkBn89nPth1d3enAI2IEwrMiHiJjIzEwoUL8e6772L79u1sl/OUsrIyhIWF4dixY0hPT4eSkhKmT58OPz8/+Pj40DQuIvYqKysRFRWF8+fP48qVK2htbYWNjQ0WLVqEoKAgmJiYsF1ivyktLcW2bdtw4MABKCoqYvXq1fjb3/4mNv2vSP8pKSnBzp07sXfvXrS0tGDp0qX47LPPBmWa5Pfff49vv/0W1dXVEh8yUWhGyIspKChAZGQkzp07hxs3bqCzsxNmZmZwd3eHp6cn3N3dJXa6NiGDobW1FfHx8YiNjUVMTAxSU1OZAG3WrFmYO3cuXF1dh8yib0TiUGBGxMe1a9fg5+eHpUuXYu/evWLTs6ylpQUnT55EaGgooqOjoaGhgcDAQMyfPx8eHh40B59IrK6uLsTGxiIyMhLh4eGor6+Hm5sbgoODERAQAHV1dbZLfCm1tbX4+uuvsXPnTujr6+Pjjz/GsmXL6BP9YaCzsxNhYWH4+uuvUVJSgjfffBObNm0a0OnwGRkZsLOzQ3p6OmxtbQdsP4OlJzQLDg7Grl27KDQj5DEikQjJycmIjIzEmTNnkJWVBU1NTcyePRve3t4UkBHyilpaWpCQkIDo6GicO3cOubm50NLSgo+PD+bNm4eZM2eK5arZZMiiwIyIh1u3bmHGjBmYP38+Dhw4IBYn6NnZ2fjhhx9w7NgxCAQC+Pj4ICQkBD4+PtRnggw53d3duHDhAkJDQ3Hu3DlISUlh4cKF+OCDD2BjY8N2eX+JQCDADz/8gC+//BKqqqrYtGkT1qxZQ7+vw1B3dzf27duHL7/8Eg0NDfjoo4/w4YcfDkiPM5FIBB0dHXz66af4+9//3u/bZ0NUVBT8/f0pNCPk/2RlZWHv3r0IDw9HZWUlRo4ciXnz5mHOnDlwc3ODjIwM2yUSMiTdv38fkZGROHv2LBITEyErK4sZM2Zg1apV8PX1HfTepWTYocCMsO/u3btwdXXFtGnTEB4ezvpJR1xcHL777jtERUXB0tIS69atw+uvv44RI0awWhchg6WxsRERERHYsWMHsrKy4O3tjY0bN2L69Olsl/ZM2dnZWLlyJe7evYtPP/0UGzZsoBFlBJ2dnfjll1/wxRdfYOzYsdi3b9+AjAKbP38+ZGRkcPz48X7fNlsoNCPDXUtLC44ePYrffvsNSUlJGD16NEJCQjB//nxMmDCB7fIIGXbq6upw/vx5HDlyBFeuXIGOjg5CQkKwevVqWFhYsF0eGZp4dPZDWFVZWQk/Pz/Y2triyJEjrIZlcXFxmDx5Mtzd3dHc3MwMtV+7di2FZWRY0dDQwJo1a5CZmYmoqCh0d3fDy8sLjo6OuHbtGtvlPWX79u1wcHAAh8NBWloaNm3aRGEZAQAoKCjgn//8JzIzM6GqqgonJyd8/fXX6O/PCl1dXREXF9fv22WTj48P045g7dq1Q+rYCHmevLw8rFmzBlwuF+vXr8eYMWMQHR2Ne/fu4V//+heFZYSwRFtbG8uXL8fFixdRWFiIt99+G+Hh4Rg3bhxcXV1x8uRJCIVCtsskQwwFZoQ1HR0dWLBgAWRlZREREQF5eXlW6qiqqkJwcDA8PDwwYsQI3Lx5E3FxcfDz8xObPmqSbP/+/ZCSkpK4kReSWnd/kpKSwqxZs3Dt2jWkpKTA0NAQXl5eWLx4McrLy9kuD3w+H2vXrsXGjRvxxRdfICEhAZaWlmyXNeSlpKRASkoKmzdvZruUv2z06NGIiYnBd999h88++wwrV64Ej8frt+27urqitrYW+fn5/bZNceDj44MTJ07g4MGDeOuttyg0I0NaTk4OFi5cCGtra8THx+Pbb79FZWUlQkND4eHhIbbnhH39TZbEv9ODQVLP7SS17oFkYmKCzz//HAUFBbh06RJ0dXURGBgIa2trhIWF0esV6TcUmBFWCIVCLF26FA8ePMCFCxego6Mz6DWIRCL8+uuvGDduHBISEnDq1ClERUVh8uTJg14LIeLOwcEBkZGROH/+PFJTUzFu3Dj8+OOPrJ2QtLe3Y+7cuTh06BBOnjyJDz/8kFZQIs8lLS2Nv//97zh79ixOnjwJHx8ftLa29su27e3toaqqiri4uH7Znjjx9fVFWFgY9u/fT6EZGZIePXqEt956CzY2Nnj48CHCw8ORk5ODd955BxoaGmyXRwh5DmlpaXh7e+PEiRPIzs6Gk5MTQkJC4OTkhMTERLbLI0MABWaEFRs2bMDFixdx5swZjBkzZtD339LSgoCAAGzYsAHr1q1DdnY25s2bN+h1ECJpfHx8cPfuXWzcuBEff/wx5s6di6ampkGtgc/nY9GiRUhOTkZMTAzmzp07qPsf7hwdHSESiSR25MKsWbMQHx+Pu3fvYvny5f0SAMnIyGDy5MmIj4/vhwrFj7+/P44ePUqhGRlyTp48CWtra5w/fx6//fYbUlNTERAQQD37CJFA48aNw4EDB5Ceno4RI0bAzc0N69evR3t7O9ulEQlGrwZk0O3atQs7duzA/v37MXXq1EHff0NDA7y8vHDz5k1cu3YNX375JfU7IuQFKCgo4LPPPkNMTAzS09Ph6emJ2traQdv/l19+iWvXruHcuXNwdHQctP2SocPGxgYnTpzAuXPnsHXr1n7ZpqurK2JiYvplW+Lo8dCMepoRSScQCPDhhx9i4cKFmDNnDrKzsxESEkJBGSFDwIQJE3Dp0iXs27cPhw4dgqurK0pKStgui0goelUgg+rWrVtYv349/vWvf2HRokWDvn8ej4e5c+eisrIScXFxcHNzG/QannTx4kVISUnhp59+QnR0NKZOnQplZWUYGxvjm2++YR63Y8cOWFhYQEFBAePGjUNERMRT24qLi0NQUBBGjx4NeXl56OjoYM6cOb2GJAuFQsyePRvS0tI4f/58r+fX1NTAyMgIOjo6KC0tfaHjaGxsxLvvvgsulwtFRUU4Ojri3Llzf3rMsbGxcHd3h6qqaq/w468cy6NHj8DhcBASEtJr+wcOHICUlBT09PR6vakrLy+HlJQU1q5d+1J1A3/03vviiy9gaWkJBQUFqKurY/r06bh06VK/1fX4v8+tW7fg4eEBZWVlaGlpYfny5aivr39mfYNpypQpSEhIQFNTE3x9fdHZ2Tng+7xz5w62bduG77//HpMmTRrw/QH/j737jmvq3v8H/kogrLAie+8h4EaLA1yAo4qtq61Vb1tt1d5aW+2tt8Pua2trtWprra16a71aR7UOFMGBe29AlgECQliGBMJOzu8Pvzk/IqAg4yTwfj4eeWQdcl4HyDmf8z6f8zld4zvaXt85oOmxcVQqFdatW4cBAwZAJBLB2toaoaGhWLVqVaMjuwzDYPPmzRgyZAgsLCxgamqKPn364KeffurUIsywYcPwww8/4LPPPsPly5fb/HkRERHIy8tDTk5OO6TTTZMnT8aOHTuwZcsWKpoRvcUwDObPn481a9Zg8+bN+PXXX2FlZcV1rEZauk5uT11hewdQm7Q7tkmbMnv2bNy6dQsAMHToUGRlZXGciOglhpBOIpVKGVdXVyY6Opqpr6/nJMP777/PWFhYMElJSZzMvylHjhxhADAvvPACY2hoyADQuq1atYp5//33G73O5/OZGzdusJ9TUFDQaBrNzdDQkDl16hQ7bWlpKePh4cGIRCJGLBYzDMMw9fX1zKhRoxg+n88cPXq0VctQVVXF9O3bt9F8eTwe88ILLzAAmN27dzda5mnTpmktc79+/Vq9LAMGDGAcHBwYtVrNvjZjxgyGz+czALR+R5s3b2YAMHv27Hmq3DU1NczQoUObzMXj8Ziff/65XXJpfj8zZsxgjI2NG80rIiKiVX+fjkk8b5oAACAASURBVJaens5YW1szCxcu7PB5TZgwgRk0aJDW77WjdYXvaHt+565cucIAYD799FP2tX/961/N/vy6devY6dRqNfPyyy83O+3rr7/equVqDxEREcyoUaPa/DnV1dWMiYkJs3Xr1nZIpdv27NnDCAQCZt68eZ36XSSkPXz44YeMiYkJEx8fz3WUZrV1ndzUay3RFbZ31Cbt3m3SpshkMqZfv36Mv78/U1FRwXUcol9qqGBGOkVdXR0zfPhwxtPTkykpKeEkQ1ZWFmNkZKS1AdEFmg0RAOadd95hsrOzmYqKCnaHxMrKirGwsGB+++03pqioiCktLWWWLFnCAGBmz57Nfo5UKmWioqKYgwcPMrm5uUxtbS1TWFjI7Nq1ixEKhcy4ceO05nvlyhXG2NiY6d+/P1NdXc188MEHDADmiy++aPUyfPvttwwAJiAggDl27BhTXl7OiMVi5s0332SXranGCQDmtddeY9LS0rSKqK1ZFk3umzdvMgzzcIfc3t6emTVrFiMQCJgVK1aw07744osMn89nHjx48FS5v//+ewYA4+7uzhw8eJCRy+WMRCJhPvvsM4bP5zMmJiZMQUFBm3M1/P3Mnz+fycjIYCorK5mzZ88y7u7uWp+rK7Zs2cIYGhoyqampHTYPiUTC8Pl85q+//uqweTSlK3xH2/M719SOmJ+fHyMUCpm//vqLKSsrY5RKJXPz5k3mvffeY7Zs2cJOt3XrVgYA06tXL+bw4cNMaWkpU1FRwZw6dYrp06cPA4A5f/58q5evLY4cOcLweDwmPT29zZ81bNgwTop+XNi5cydjaGjILFq0iIpmRG9cu3aNMTAwYDZu3Mh1lMdq6zq5rQUzfd7eUZuU2qRNyc/PZ2xsbJh3332X6yhEv1DBjHSOt99+mzE1NWWuX7/OWYavvvqKcXR0ZOrq6jjL0BTNhmjs2LGN3psyZQoDgPn++++1Xq+vr2esrKyY0NBQrdevXr3KTJs2jXF2dm50ZNDV1bXR52/YsIEBwISHhzM8Ho8ZN27cU+34PPPMMwyPx2uy597o0aObbZyEhYU1O7+WLsuJEycYAMy3337LMAzDXL9+nQHA7Nu3jwkPD2dGjx7NMMzDxoGdnR0zaNCgp84dFhbGAGAuXLjQaPo33niDAcD88ssvbc6l+f1ER0c3ms+PP/7IAGB+//33Jn9vXFGpVIynpyfzwQcfdNg8tmzZwpiamjLV1dUdNo+mdIXvaHt+55raERs5ciTj5+f3xPXryJEjGQMDAyY/P7/Re8nJyQwAZunSpa1evrbQ/K1++umnNn/Whx9+yAQGBrZDKv2gKZotWbKE6yiEtMjs2bOZ/v3760WRty3r5LYWzPR5e0dtUmqTNmfNmjWMubk5I5fLuY5C9EcNjWFGOtyuXbuwbt06bN68Gf369eMsx6VLlxAZGQlDQ0POMjzO8OHDG73m4eEBAI3GWjMwMICLiwsKCwvZ186fP48hQ4Zg9+7dyM/PR319vdbPVFVVNfr8efPmYerUqThz5gycnZ2xbds28Hi8VmfPzMyEi4sLgoODG703duzYZn8uMjKyyfm1ZlmGDh0KoVDIjteQkJAAQ0NDjBo1CtHR0Th79iyqqqpw48YNFBcXIyoq6qlzZ2ZmwsbGBmFhYY3emzBhAjtNW3NpjBgxotFr3t7eAB5e6VWX8Pl8jBkzBpcuXeqweaSmpiIoKAjGxsYdNo/H0efvqEZ7fOeasnr1aqjVavj6+mLevHlYv349bty40Wi65ORkqFQquLm5wdDQEAYGBuDz+eDz+ez3sLMH5jUwMEDv3r2Rmpra5s8KDw9HWloaioqK2iGZ7ps+fTq2b9+ONWvW4L333uM6DiFPdOrUKUyfPr1N69HO0NZ1clvp8/aO2qTUJm3OCy+8gIqKCly7do3rKESPUMGMdKjs7GzMmzcPb775Jl588UVOs5SVlUEkEnGa4XFMTEwavabZcDf3nlqtZp9/8803qK2txaefforMzExUVVVBrVaDYRgEBAQ0Oc/CwkKcP38ewMNBQTt7sGobG5smX2/NshgZGSEiIoLd2MfHxyMsLAyWlpaIjo5GTU0NTp8+jfj4eABAdHR0mzK3tPHWHrlMTU2bnT+jg4Nti0QiyGSyDvt8pVLJ6RVtu8J3tD2+c03p06cPUlNTsXXrVnh5eeHMmTMYO3YsgoODcefOHXY6ze9DpVJBpVKx82j4/1xbW9umZXwa5ubmqKioaPPnDB48GDweDxcvXmyHVPph2rRp+O2337B69Wp8+eWXXMch5LFKS0thZ2fHdYwnaus6ua26wvautahN2rXapE2xtbUFn89HSUkJ11GIHqGCGekw9fX1mDlzJlxcXPDdd99xHQcuLi7skZauSCwWw8HBAZ999hl8fHxgYmICHo+He/fuISMjo9H0KpUKL730EqRSKdavXw+BQICpU6eirKys1fP29fXF/fv3kZyc3Oi9uLi4Dl8WzcY+Li4OZ8+eZTf0oaGh6NGjB+Lj4xEfHw+hUIjBgwc/dW5fX1+UlJQ0eUW9w4cPs9O0NZe+yszMhLu7e4d9vq2trdYRbH3D5Xe0vbM1xdDQEBEREfj3v/+NHTt2ICsrCwqFAnPmzGGnCQwMhJmZGcrKythC2aO3PXv2tPvyPYlUKm2XnWgrKysEBAR0aE9LXfSPf/wDv/76Kz799FN8/fXXXMchpFleXl5NbvN1TXusk7lEbVJqk+qilJQUqNVqtmccIS1BBTPSYb744gtcu3YN27dvb/KoRGcbP348Tpw4AalUynWUDuHu7o6ioiL8+OOPkMvlkMvlOHz4MMaPH6911E/j448/xsmTJ/HFF19gwYIF2LJlC8RiMWbPnt3qI0VTpkwBwzCYMmUKTpw4gYqKCmRlZeGf//wnjh8/3uHLotnof/LJJ6ipqWGf8/l8jBo1CgcPHsT58+cxYsQICASCp849bdo0AA+7dB8+fBgKhQJ5eXn48ssvsXHjRhgbGyMmJqbNufRRaWkpjhw5gnHjxnXYPEJDQ5GRkaG332Euv6Ptne1RQ4YMwYYNG5CSkoKqqirI5XLExcWhtLQUYrGYnW7OnDmorKxEZGQkDh06hOLiYtTW1iInJwexsbGYMmXKU60z2qKsrAx37txBaGhou3xeWFhYt+phpvHaa69hzZo1+PDDD/Htt99yHYeQJk2bNg1//PFHhxx4aE9tXSdzjdqk1CbVRWvXroWvry/69+/PdRSiTzpvvDTSnZw+fZoxMDDQqStSVlZWMu7u7lpX8dEFmsE0V69e3eg9zZWH7ty50+i94OBgxsXFhX3+999/N7rUM/DwstghISGMjY0NO+2BAwcYHo/HjB8/XmuA08WLFzMAmK+//rpVy/C0l/BuaplbuywaLi4uDABGJBIxKpWKfX3jxo3sz//www9tyl1TU8MMGTKkyWwAmvx/f5pcj/v9aN5bt25dk787rrzxxhuMo6Mjo1AoOmweSqWSsba2Zr755psOm0dTusJ3tD2/c00NJt3UpeY1t7fffpudTq1WM6+88kqz0wJgjhw50qpla6s1a9YwQqGw3QYB3rBhA2NhYaF1lbXuZPXq1QyPx2uXiygQ0t5KS0sZJycn5sUXX9Tpgf/buk5u66D/+ry9ozYptUmbcujQIYbH4zE7duzgOgrRLzToP2l/ZWVlePnllzFx4kTMnz+f6zgsU1NTrFu3Dn/88Qc2bNjAdZx2N2nSJPzvf/9D7969YWpqCicnJ8ybNw/Hjx/XGiQ9KysLs2fPhru7O/744w+t8Q9WrFiB8PBw9khfS5mYmODkyZN488034eDgABMTE/Tr1w/79u177ACrbV2WhjQDlI4ePRp8/v9ftTUch+HRQUxbm9vIyAjHjh3Dp59+ioCAABgZGcHCwgIjR47EkSNHmvx/f5pc+mbr1q349ddfsXbtWlhYWHTYfMzMzDB//nx89913ePDgQYfNp6Nw+R1tr2zNuXTpEv75z38iKCgIpqamsLW1xdChQ9mxrTR4PB62bNmCnTt3IjIyEiKRCEZGRvD29sZzzz2Hffv2ITIyst2W60kUCgW+/vprzJkzB5aWlu3ymc888wzKy8tx9+7ddvk8ffPOO+/gu+++w1tvvYVffvmF6ziEaOnRowe2bt2KvXv3YuHChTrbW6ut62SuUZuU2qS65OTJk5g+fTpee+01zsfUJvqHxzB6Mkof0Ruvvvoq4uLikJSU1OwAmlz66quv8Omnn+Lnn3/GG2+8wXUcQvTa77//jjlz5uD999/H8uXLO3x+crkcQUFBGDZsGHbu3Nnh8yNdF/N/p75cuHChXbdXKpUK1tbWWL16NebOndsun6mPli1bhuXLl+P333/HzJkzuY5DiJa9e/dixowZiIqKwh9//AFra2uuIxFCOsD69evxzjvvYMqUKdi2bRsMDAy4jkT0Sy31MCPtKjY2Fv/973/x008/6WSxDHg4TsJnn32G+fPnY+HChZxckY0QfVdXV4clS5bg1Vdfxb///e9OKZYBDwdV37p1K/766y+6Ih9pky+++AKxsbHYs2dPu26vDAwM0L9//2438P+jvvzySyxduhSvvPIKduzYwXUcQrRMnjwZiYmJuH79OoKDg3HgwAGuIxFC2pFEIsG4ceOwcOFCLFu2DNu3b6diGXkqVDAj7UYul2P+/PmYOXMmJk+ezHWcx1q2bBn27duHP/74AyEhITh69CjXkXTOzZs3wePxnnh77rnnuI5KOtmZM2cwYMAArF+/Hps2bcJXX33VqfMfPXo0fvrpJ3z66af45JNP9OZy5u2NvqNPb/ny5fj888+xbt06DB06tN0/PywsrNsXzICHv+fFixdj1qxZ2LVrF9dxCNESFhaG5ORkTJgwAZMmTUJUVBRu3rzJdax21xW2FV1hGUjnUCqVWLFiBUJCQpCRkYETJ05g2bJlWqf7EtIaVDAj7WbRokWor6/HmjVruI7SIpMmTUJycjLCwsIwduxYTJw4ERKJhOtYhOis0tJSzJs3D8OHD4e9vT1u3LiBV199lZMs8+bNw5YtW/DNN9/ghRdeQHV1NSc5iH5RqVRYsGABPvnkE6xbt67DTst/5plnkJycDIVC0SGfr09WrFiBefPmYdasWTh48CDXcQjRYm1tjV9++QUXLlxAZWUlBgwYgIkTJ+Ly5ctcRyOEtIJCocCKFSvg4eGBFStW4KOPPkJSUhKGDx/OdTSi52gMM9IuYmNjMWHCBPz1118637usKbGxsVi0aBEKCwsxd+5cvPvuu3B3d+c6FiE64f79+1izZg1++eUXiEQirF69Gs8//zzXsQAAx44dw9SpUxEYGIgtW7agZ8+eXEciOiojIwOvvfYabty4gT///BMTJkzosHnl5+fDxcUFx48fx6hRozpsPvqCYRgsWLAAW7Zswb59+zB+/HiuIxHSCMMw2Lt3L5YvX47r168jPDwcc+bMwbRp02BmZsZ1PEJIE86dO4fNmzdj165dMDIywsKFC/H222+jR48eXEcjXQONYUbaTqlU4s0338RLL72kl8UyAHj22WeRlJSEL774Anv37oWPjw9mzpzZJbvmE9JSd+7cwSuvvAJvb29s374dH330EVJSUnSmWAYAkZGRuHDhAgCgf//++Oabb1BfX89xKqJLVCoVvv/+e/Tp0wdKpRLnz5/v0GIZADg7O8PV1RUXL17s0PnoCx6Ph/Xr12P69OmYOnVqu17hlZD2wuPxMGXKFFy7dg3x8fFwdHTEG2+8AScnJ8yfP596nRGiIwoLC7Fy5Ur2IlDXr1/H119/jezsbHz22WdULCPtinqYkTZ7//33sXHjRty9exdOTk5cx2mzuro67Ny5EytXrsStW7cQERGB2bNnY+rUqbCysuI6HiEdSqFQYO/evdi6dSsSExMRFBSE9957DzNmzICRkRHX8ZqlUqmwatUqfPrpp/D398fy5cupFwtBQkICPvjgAyQlJeHjjz/G0qVLIRAIOmXe06ZNQ11dHf7+++9OmZ8+UKlUmDVrFvbv348jR44gIiKC60iEPFZJSQm2bduGTZs2ISkpCUFBQZg0aRImTZqEgQMHgs+nvgeEdIa8vDwcPHgQ+/fvx4kTJyAUCvHyyy/jtddeQ//+/bmOR7quWiqYkTZJTk5Gv379sGbNGixYsIDrOO2KYRgkJCRg06ZN7NWTYmJiMGvWLIwZM6bTdroI6Wj19fVISEjAtm3b8Pfff0OlUmHChAmYM2cOxo4dq1cDpaanp2Pp0qXYv38/hg4div/85z+0U94NXbhwAR999BFOnjyJZ599Ft9++y2CgoI6NcOKFSvw448/Ijc3t1Pnq+tUKhVmzJiBuLg4JCQkYNCgQVxHIqRFLl26hJ07d2L//v0Qi8VwcnLCxIkTERMTg9GjR8PExITriIR0Kbdu3cKBAwewf/9+XL9+HUKhEGPHjsXkyZPx/PPP03eOdAYqmJGnxzAMRo0ahYqKCly8eLFLX6pXLpdjz5492Lp1K86cOQMbGxs8++yzePbZZxEdHU09z4jeKS8vR3x8PGJjYxEbG4vi4mIMHToUM2fOxPTp0yESibiO2CaXLl3CRx99hOPHj2PkyJFYuHAhYmJiuvR6qrtTq9WIjY3FunXrkJCQgIiICCxfvrxDroLZEgkJCYiOjkZBQQEcHR05yaCramtrMWXKFJw5cwbHjh1DaGgo15EIaZU7d+6wO/JXr16FmZkZwsPDMXz4cIwYMQKhoaEwNDTkOiYheiUrKwuJiYlITEzEyZMnkZubC2dnZ0ycOBGTJk3CqFGjYGxszHVM0r1QwYw8vS1btmDu3Lm4cOFCtzpCnJOTg507dyI2Nhbnzp0Dn89HeHg4xo8fjwkTJiAgIIDriIQ0KSMjA7GxsTh06BDOnDkDlUqFsLAwTJgwAdOnT4e3tzfXEdvdyZMnsWrVKhw+fBhubm5YsGAB5s6dCxsbG66jkXYik8mwadMm/Pzzz8jKysKYMWOwePFiREVFcZrrwYMHsLW1RWxsLMaNG8dpFl1UW1uL559/HpcvX8aJEyfQq1cvriMR8lTy8/MRGxuLkydPIjExEQUFBTA3N8ewYcMwfPhwDB8+HKGhoXRmAiGPaFggS0xMhEQigampKcLCwjB8+HCMGzcOAwcO1KszHUiXQwUz8nRkMhkCAgLw4osvYu3atVzH4YxMJsOxY8dw7NgxHDhwAFKpFI6OjggPD8fQoUMxbNgw9O/fn1b0hBNisRhnz57FuXPnkJCQgKysLAiFQowcOZI9jaS79HwRi8XYuHEjfv31VyiVSkRFRWHatGmYPHkyzM3NuY5HWqmmpgbx8fHYvXs39u7dCz6fj5deeglvv/02goODuY7H8vT0xOuvv46PPvqI6yg6qaqqir3ojmbMREL0XcNtb1xcHCQSCQQCAfz8/DBgwAAMGDAAw4YNQ9++fanXM+k2ysrKkJSUhHPnzuHs2bO4evUqpFIpBAIBevfujcjISERGRmLYsGF0qiXRJVQwI0/n3Xffxf/+9z9kZGTQ6Yj/R6VS4eLFi0hMTMSZM2dw7tw5VFRUwM7ODuHh4YiIiMAzzzyDPn36wNTUlOu4pIuprq7G7du3cenSJZw5cwanT59GYWEhhEIhhgwZgvDwcIwYMQKDBw/u1qeJKJVK7NmzBzt27MCxY8dgamqK5557DtOnT8fo0aNhZmbGdUTSjKqqKpw8eRK7du3Cvn37oFQqMWLECMyYMQPTpk2DhYUF1xEbmTJlCgDgr7/+4jiJ7qqsrMS4ceOQlpaGxMREBAYGch2JkHaVlpaGixcv4urVq7hy5Qpu3bqF6upqWFhYoH///ggNDcWAAQMQEhKCgIAAnb7ADiEtkZubi5SUFNy4cQNXrlzB1atXIZFIAAC+vr4IDQ3FwIEDMWjQIAwcOJBOsyS6jApmpPXu3buHoKAgrF27FvPmzeM6js6qr6/H9evXcfr0aZw+fRpnz56FTCaDoaEhgoKC2AbSgAED0KdPHzqaQlqspqYGt2/fxtWrV3Ht2jVcu3YNycnJqKurg5WVFYYNG4aIiAhERETQOCqPUVRUhF27dmHHjh24cOECjI2NMXz4cIwfPx7jx4+Hr68v1xG7vaysLBw+fBiHDx/GyZMnUVVVhUGDBuGll17CCy+8oPNXZv7qq6+wadMmZGVlcR1FpykUCkRFRSE/Px+nTp3qkqeHE6JRV1eHO3fusIWEK1euIDk5GfX19WxPtODgYPYWEhICX19f2pYTnSOVSpGUlITk5GStm1wuBwC4urqyxTHNvb6PkUu6HSqYkdaLiYnBvXv3cOvWLdp4twLDMMjMzGQLHNeuXcP169chl8thaGiI4OBgBAUFISQkBIGBgQgJCYG3tzf9jrsxlUoFsViM5ORk3L17F0lJSUhJSWGLY5aWlujXrx9beB0wYAD8/f3pFOCnIJVKceTIERw5cgTx8fGQy+Xw8/PDiBEjMGzYMISHh8PLy4vrmF2eRCJhDzAkJiYiLS0NFhYWiIqKwrhx4zBu3Di4uLhwHbPFjhw5gvHjx6O4uBi2trZcx9FpcrkckZGRKCoqwqlTp+Dp6cl1JEI6TW1tLVJTU5GSkoI7d+4gJSUFSUlJEIvFUKvVMDIyQmBgIHx9fdmbj48PfH194erqCj6fz/UikC5KJpMhMzMT9+7dQ2ZmJnu7e/cuHjx4AACwtbVFr1690LNnT/Tq1Yvdn+nRowfH6QlpMyqYkdY5ceIERo8ejbi4OIwZM4brOHqvYRHtxo0bSE5ORkpKCrKzs8EwDNtA6tmzJ4KDg+Hn5wdvb2/4+PjQoOVdSGlpKcRiMcRiMTIzM5GUlITU1FTcvXsXNTU14PF48PDwQFBQEIKDg9G3b18MGDAAfn5+1EjuAPX19Th37hzi4+Nx+vRpXLlyBTU1NXBxcUFERASGDBmCAQMGoHfv3hAKhVzH1VtVVVW4ffs2rl27hvPnz+P06dPIzc2FkZERQkNDER4ejjFjxmDYsGF6O1h2UVERHBwcEB8fz/lFCPSBTCbD6NGjUV5ejlOnTsHZ2ZnrSIRwqqqqCnfv3mXbhw0LF+Xl5QAAY2NjeHt7s4U0b29vuLu7w83NDa6urrCzs+N4KYguq6qqQk5ODvLy8pCXl4esrCy2KHbv3j2UlpYCAAwNDeHp6ckWagMCAtgekPb29hwvBSEdhgpmpOVUKhX69+8Pd3d3HDx4kOs4XZpSqWSPNGoaSSkpKcjJyUF9fT0AwMrKCt7e3uzNx8cH3t7ecHV1hZubGw1krkOUSiVyc3ORl5cHsViMe/fusQUysViMsrIyAA8bI+7u7ggKCmJvwcHB6NmzJxVmOFRdXY0rV66wPZ8uXLgAuVwOAwMD+Pv7o3///ujXrx/69u2LoKAgnT9NkAuFhYXseCaaW2pqKlQqFSwtLREWFsaeSjxo0KAuNc6jq6srFi5ciKVLl3IdRS8UFhZixIgR4PF4SExMpB0xQppRVFSk1eNHU0jLyspCcXExO52JiQnc3d3h4uICNzc3uLu7w9XVlb3Z29vDzs6OzmjogsrKyiCVSlFYWAiJRMIWxSQSCdsu1RTEAMDU1BSenp6NejH6+PjA09OT/kdId0QFM9JyW7Zswbx583D79m0alJcj9fX1kEgkTRZdGhZeAMDS0hKurq5wcXGBs7Mz3Nzc4OzsDFdXVzg5OcHe3h62trY0yHkbVFVVoaSkBEVFRSgoKEBeXh7y8/ORm5uL/Px83L9/H3l5eexYDkDzhU7NEWF97UnT3YjFYly/fl2rACSVSgE8/Bv7+/sjMDAQAQEBCAgIgJ+fH9zc3Lr06QllZWWQSCTIyMhAeno6UlNTkZqaivT0dHbdZG9vj379+qFfv35sodHHx6dLn0YcExMDU1NT7Ny5k+soeiM/Px/Dhw+HUCjEyZMnacwbQlqpurpaq0DSsAeRpljSsG3C4/FgZ2cHe3t7ODg4wNHREfb29nB0dISDgwNbVLOxsYFIJIK1tTWHS9d9VVZWQiaTQSaTobS0FAUFBSgqKkJRURHy8/NRXFzMtkmLiopQU1PD/qyRkRFbJG3YA7FhEZXOXiGkESqYkZapra1FYGAgoqOjsWHDBq7jkGY8ePAA9+/fh0Qi0SrYNCziaMYb0DAzM4OtrS3bGLK1tdW6WVtbw9LSstGtKzWW5HI5FAoFFAqF1uOysjKUlpaiuLgYJSUl7K2oqAglJSVQKpVanyMSibSKk5p7zVFdV1fXLl0w6e4KCwtx9+5dpKWlIT09nX2ck5MDlUoFABAKhfDw8GAbq5r/C833zc7ODg4ODjp1xceKigoUFhay34Pi4mLcv38fubm5yM3NhUQigUQiYU8P4vP58PDwQEBAgFbRMDAwsFv2vvvss8/Yq0qTlsvNzUVERAQcHByQkJCgU98JQrqC8vJy3L9/H8XFxWwvpKKiIq3HmsJLVVWV1s/y+XyIRCKIRCL06NFD617z2NzcHCKRCGZmZhAKhbCwsIClpSWEQiHMzMy6VDuyJSorK1FZWcm2MTXPZTIZlEolKioqIJPJ8ODBA637ho+rq6u1PtPAwIAtdGoOhtvZ2cHZ2Rn29vZarzs4OHTpg1OEdBAqmJGWWbt2LZYuXYr09HS4ublxHYe0QVVVFXsU6tEikOY1TZGotLQUZWVlaG41YWVlBSsrK1haWsLY2BgWFhYwNDR84j3wsLFlZWXV6DM10z2qvLycPR21IYVCwRYj6uvr2eked19TU6NVFGsKj8eDtbU1evTo0aiQ2PBIq6bI4ezsTL31SJNqamogFovZAlNubi5ycnLYx/fv329UfDU2Nmb/t8zNzWFmZgYrKytYWFiwOx+aXjcmJiZapzAaGRlpncJbWVmpdZS5urqa3fmRyWRNNuLLy8vZdcOjDXShUAgnJyf2qLSHhwdb/HNzc4O3tzdd9beBAwcO4LnnnoNM4e5eEgAAIABJREFUJmtynUeal5mZiYiICHh7e+Po0aN0ajohHNEcOHm0gNNUUUfzWFMAehyhUAihUAhzc3NYWVmBz+dDKBTCyMhIa1um2d5p3hMIBFpDj2jabE153HuPbh8f915dXR0qKioAgF0upVKJ2tpare2qpt1cXl6OyspKKJXKFv0eNAXGRwuPzRUmNe1TGsuWkA5FBTPyZEqlEr6+vnj55ZexcuVKruMQDpSXl7M70w0LTQ17Y1VXV6OiooJtUNTV1bFFKk1Rq2Fxq6amBpWVlY3m1bDR0ZCxsTFMTU0bHR0zMzODsbExgP9fhDMwMIClpWWjYp2mgWVsbKzVU05T9NPcW1paUm8G0qkant6r6cGouVVUVECpVGoVtJRKJVvs1TTYG35WwyKXsbGxVjG34Y6GlZUVu8Oi+d83MzODubk5W7DT3NNp3E9HIpHAw8MDZ86cwbBhw7iOo3eSkpIwYsQI9O/fHwcPHmTX94QQ/aDZZpWXl0Mul7PP5XI5u31rWFTStBU17UG1Ws2ePqppVz7ahqytrW104EmjYaHrUY8W3h73nqZtCYAt7mkOVh0/fhzDhg2Dp6cnLC0tYWBg0KgYqOlZpzn4pXlOp5wTotOoYEaebPny5fj6669x7949GnyXcKK4uBj29vY4fvw4Ro0axXUcQnReTU0NTExM8Pfff2PSpElcx+n2RCIR/vOf/+DNN9/kOopeunnzJkaNGoXhw4dj9+7dNPA0IUSnvPvuu1i/fj0OHDiAMWPGcB2HENJ+aqkPJ3mssrIyfP/991iyZAkVywhn7OzsYGFhgaysLK6jEKIXFAoFALBHwwm3QkJCcOfOHa5j6K2+ffsiNjYWx44dw6uvvgq1Ws11JEIIYa1atQozZszA5MmTcf78ea7jEELaERXMyGP98MMPAIDFixdznIR0dx4eHlQwI6SFqGCmW3r37k0FszYaPHgw/v77b+zZswdz585tdmxNQgjpbDweDxs3bsTIkSMRExODlJQUriMRQtoJFcxIsxQKBdauXYtFixbRThfhnJeXF7Kzs7mOQYheoIKZbunVqxdu375NRZ42Gj16NP7++29s374d77zzDtdxCCGEJRAIsHv3bgQHByM6OpoO8hLSRVDBjDTrp59+gkqlwsKFC7mOQgi8vLyo8UFIC1HBTLf06tUL5eXlkEgkXEfRe2PGjMH27duxfv16fPLJJ1zHIYQQlqmpKQ4ePAgHBwdERUVBKpVyHYkQ0kZUMCNNqqysxA8//IC33nqLrt5CdAIVzAhpOSqY6ZbevXuDx+Ph9u3bXEfpEiZPnozffvsN//nPf/DNN99wHYcQQliWlpaIi4uDQCBAdHQ0e/VPQoh+ooIZadIvv/yCiooKLFq0iOsohAB4WDCTSqValxEnhDRNoVBAIBCwl7wn3LKwsICHhweNY9aO/vGPf2Dt2rX44IMPsGrVKq7jEEIIy87ODvHx8VAoFBg/fjyUSiXXkQghT4kKZqSRmpoafP/995g3bx5dGZPoDE9PTzAMQ6c0EdICCoWCepfpmF69elHBrJ3985//xOrVq/Hee+/h119/5ToOIYSw3NzckJCQALFYjOeffx41NTVcRyKEPAUqmJFGtm3bhuLiYixZsoTrKISwvL29AYBOyySkBahgpnt69+5Np2R2gHfeeQcfffQRFixYgD///JPrOIQQwvLz88OhQ4dw8eJFzJgxAyqViutIhJBWooIZaWTt2rWYMWMGXFxcuI5CCMvCwgI9evSgghkhLVBeXk4FMx3Tq1cvpKenUy+DDvDll19i8eLFmD17Ng4ePMh1HEIIYQ0cOBD79+/H4cOH8dZbb3EdhxDSSlQwI1ri4uJw+/ZtGruM6CQa+J+QlikqKoKdnR3XMUgDvXr1Qn19Pe7evct1lC5pxYoVmDNnDqZOnYojR45wHYcQQlgjR47Ezp078dtvv2HZsmVcxyGEtAIVzIiWVatWITIyEn379uU6CiGNUMGMkJaRSqVwdHTkOgZpwN/fH0ZGRkhOTuY6SpfE4/Hw008/Ydq0aZg6dSpOnz7NdSRCCGHFxMRg8+bNWL58OVauXMl1HEJICxlyHYDojqSkJBw7dgyxsbFcRyGkSV5eXjh+/DjXMQjReYWFhQgICOA6BmnA0NAQvr6+SE1N5TpKl8Xn8/H777+jrq4OEydOxPHjxxEaGsp1LEIIAQDMmjULcrkcb7/9NkQiEebMmcN1JELIE1APM8JatWoVAgMDMXbsWK6jENIkLy8vZGdncx2DEJ0nlUrh4ODAdQzyiJ49e9IpmR3MwMAAf/zxB8LDwxEVFYWbN29yHYkQQlhvvfUWPvroI8ybNw+7d+/mOg4h5AmoYEYAACUlJdixYwcWLVoEHo/HdRxCmuTl5YUHDx5ALpdzHYUQncUwDAoLC6lgpoN69uyJlJQUrmN0eUZGRti9ezf69u2LMWPGUK8+QohO+fLLL7Fw4ULMnDkTR48e5ToOIeQxqGBGAACbNm2CsbExZs6cyXUUQprl5eUFANTLjJDHkMlkqKmpoTHMdFDPnj2RmZmJuro6rqN0eaampjh06BD8/f0RFRVF418SQnTKqlWrMGPGDEyePBnnz5/nOg4hpBlUMCNQq9X45Zdf8Morr0AoFHIdh5BmeXh4gMfj0Y4PIY8hlUoBgApmOigoKAh1dXXIzMzkOkq3IBQKcejQIdjb2yMqKgr5+flcRyKEEAAPL1SyceNGjBw5EjExMdT7mBAdRQUzgsOHDyM7Oxvz58/nOgohj2ViYgJHR0cqmBHyGFQw010BAQHg8/k0jlknsrKywpEjRyAQCBAdHY2SkhKuIxFCCABAIBBg9+7dCA4ORnR0NLVvCdFBVDAj+PnnnzF69GgEBgZyHYWQJ/Ly8qIGBSGPIZVKYWhoCBsbG66jkEeYmprCw8ODCmadzN7eHseOHUNlZSXGjRsHhULBdSRCCAHwcLtw8OBBODg4ICoqij3oRQjRDVQw6+bEYjHi4uKwYMECrqMQ0iJUMCPk8aRSKezt7cHn0yZeF9GVMrnh4uKChIQE5OfnY9y4cVAqlVxHIoQQAIClpSXi4uLYnrAymYzrSISQ/0Ot6W5u06ZNcHR0RExMDNdRCGkRKpgR8niFhYV0OqYOCwoKorFqOOLj44OjR48iLS0Nzz//PGpqariORAghAAA7OzvEx8dDoVBg/PjxVNQnREdQwawbU6vV+OOPP/CPf/wDhoaGXMchpEW8vLyQnZ0NhmG4jkKITsrPz6eCmQ7r2bMn0tLSoFaruY7SLYWEhODIkSO4ePEiZsyYgfr6eq4jEUIIAMDNzQ0JCQkQi8VU1CdER1DBrBs7evQocnNzMXv2bK6jENJiXl5eUCqVKC4u5joKITopKysLXl5eXMcgzejZsycqKyshkUi4jtJtDRw4EHFxcTh69Cjmzp1LB2AIITrDz88Phw4dYov6KpWK60iEdGtUMOvGtmzZgoiICBrsn+gVTSEgOzub2yCE6Kjs7GwqmOkwzTY3NTWV4yTd25AhQ7B37178+eefWLRoEddxCCGENXDgQOzfvx+HDx/GwoULuY5DSLdGBbNuqrS0FAcOHMCrr77KdRRCWsXV1RUCgYDGMSOkCTU1NSgoKICnpyfXUUgzRCIRbG1tkZGRwXWUbi86Ohrbt2/H+vXr8cUXX3AdhxBCWCNHjsTOnTvx66+/YtmyZVzHIaTbooGruqlt27ZBIBBg6tSpXEchpFUMDQ3h6upKBTNCmpCTkwO1Wk09zHScn58fFcx0xOTJk/Hbb7/htddeg1AoxJIlS7iORAghAICYmBhs3rwZr7zyCqysrPDee+9xHYmQbocKZt3U1q1bMX36dJibm3MdhZBW8/T0pIIZIU3QfC+oYKbbqGCmW1555RXI5XK8++67sLKywty5c7mORAghAIBZs2ZBLpfj7bffhkgkwpw5c7iOREi3QgWzbig1NRXXr1/HypUruY5CyFPx8vKighkhTRCLxbC2toZIJOI6CnkMPz8/nD17lusYpIFFixahuLgY8+fPh4WFBV544QWuIxFCCADgrbfeglQqxbx582BpaYlp06ZxHYmQboMKZt3Qtm3b4OzsjIiICK6jEPJUvLy8cPr0aa5jEKJz0tLSEBAQwHUM8gT+/v7IyclBbW0tjIyMuI5D/s9XX32FqqoqzJo1CxYWFhg/fjzXkQghBMDD9ZNSqcTMmTNhaWmJMWPGcB2JkG6BBv3vhnbu3IkZM2bAwMCA6yiEPBUvLy9IJBK61DYhj0hLS6MrH+sBPz8/qFQqiMVirqOQR6xcuRKzZ8/G1KlT6cAMIUSnrFq1CjNmzMDkyZNx/vx5ruMQ0i1QwaybuXDhAjIzM/Hyyy9zHYWQp+bl5YXa2lrk5+dzHYUQnZKamko9zPSAn58feDwejWOmg3g8Hn755RdMmDABEydOxLVr17iORAghAB6unzZu3IiRI0ciJiYGKSkpXEcipMujglk387///Q+BgYHo27cv11EIeWqaAc1pHDNC/r/q6mrk5uZSwUwPmJubw9HRkQpmOsrAwADbtm3D0KFDMXbsWNopJYToDIFAgN27dyM4OBjR0dHUFiakg1HBrBtRqVTYvXs39S4jes/R0RFmZmbIzs4GAFRVVSElJQWxsbHsa4R0N+np6VCpVFQw0xP+/v5UMNNhRkZG2LNnD3r27Ek7pYQQnWJqaoqDBw/CwcEBUVFRkEqlzU6rVqs7MRkhXQ8VzLqRU6dOoaioCFOnTuU6CiGtUldXB7FYjOPHj+O3337Dxx9/DHNzc3zyySewsbGBmZkZgoODMWHCBJSXl3MdlxBOpKWlwcDAAL6+vlxHIS3g5+dHBTMdZ2ZmprVT2twwAA8ePADDMJ2cjhDSnVlaWiIuLg4CgQDR0dGQyWRa7zMMg3feeQf79+/nKCEhXQMVzLqRv/76C71796YBoYne+fzzz+Hj44PIyEgsWLAA33//PUpKSpCTk4MHDx6w05mamiIoKIjDpIRw59atWwgICICxsTHXUUgL+Pn5IT09nesY5AmsrKwQFxcHIyMjjBkzBqWlpVrv5+bmYvDgwTh+/DhHCQkh3ZWdnR3i4+Mhl8sxfvx4KJVKAEBtbS1efPFFrFmzBitXruQ4JSH6jQpm3YRarca+ffswZcoUrqMQ0mqLFy+GmZkZAKC+vh41NTVNdjHv168fXf2VdFu3bt1Cnz59uI5BWsjPzw95eXmorq7mOgp5As1OaUVFBcaNG8f2ZE5LS8MzzzyD9PR02iklhHDCzc0NCQkJEIvFeP755yGTyTBx4kTs3bsXAHD+/HncvHmT45SE6C8qmHUTZ8+eRUFBAZ2OSfRSjx49sHjxYggEgmanMTIyQnh4eCemIkS33L59G7179+Y6BmkhLy8vMAxD4y7qCVdXV8THxyM3NxcxMTG4dOkShgwZguLiYgBAfHw8UlNTOU5JCOmO/P39cfDgQVy4cAGDBg3CiRMnUF9fD+DhRQJWr17NcUJC9BcVzLqJv/76CwEBAXS6GtFbS5YseeypZnV1dRg4cGAnJiJEd5SVlSE3N5d6mOkRHx8fAIBYLOY4CWkpPz8/HD16FB4eHhg9ejQUCgW7U2poaIh169ZxnJAQ0l15eHjA2dkZOTk57HoJeNg+3rFjx2MvDEAIaR4VzLoBhmGwb98+TJ8+nesohDw1a2trvPPOO832MmMYBoMGDerkVITohlu3boFhGCqY6RELCwvY2tpSwUzP5OXl4c8//0R1dXWjndJNmzZpjatJCCGdIScnB2FhYcjKykJdXV2T02zYsKGTUxHSNVDBrBu4desWewoBIfrscb3MbGxs4Obm1smJCNENt2/fho2NDZydnbmOQlrB29sbWVlZXMcgLfTnn38iJiYGdXV1UKlUjd5XqVTYtGkTB8kIId1VcnIyBg0ahPv37zdbLKurq8O6detQU1PTyekI0X9UMOsGYmNjYW9vj/79+3MdhZA2sba2xrvvvgtDQ0Ot1/l8PgYPHsxRKkK4d/XqVVrH6yEvLy8qmOmJDRs2YMaMGVCr1U1edAZ4eFGa1atXa/U8I4SQjlJXV4e5c+eiqKjoieudsrIy/Pnnn52UjJCugwpm3UBsbCwmTJgAPp/+3ET/LV68GCYmJlqvGRoaUsGMdGuXLl3CM888w3UM0kre3t50SqYe0OxoMgzzxLaUVCplr05HCCEdSSAQ4MyZM/j999/h7Oz8xCvF09V8CWk9qqB0cQ8ePMDly5fx7LPPch2FkHZhbW2NxYsXa/Uyq62tpfHLSLdVVlaGjIwM+g7oIS8vLyqY6QFra2skJiYiISEBvXr1AoBmd0x5PB6+++67zoxHCOnGDA0NMXv2bIjFYqxfvx4ikajRmRgAoFarkZSUhFOnTnGQkhD9RQWzLu7w4cPg8/kYPXo011EIaTeP9jLj8XgIDQ3lMBEh3Ll8+TLUajUVzPSQt7c3ysvLUVxczHUU0gKRkZG4ceMGEhIS4O/vDz6fDx6PpzWNWq3G1atXcenSJY5SEkK6IyMjI7zxxhuQSCT46quvYGZm1qhwZmhoiFWrVnGUkBD9RAWzLi42NhYRERGwsrLiOgoh7cbKykqrl5mXlxesra05TkUINy5fvgxPT084ODhwHYW0kre3NwDQOGZ6JjIyEklJSfjzzz/h5ubW6DRNgUCA1atXc5SOENKdmZubY+nSpcjJycGSJUsgEAjYK8zX19fj0KFD1LOZkFagglkXplKpEB8fT6djki7p3XffZXuZDRkyhOM0hHDn8uXL1LtMT7m5uUEgENDOix7i8/mYNm0aMjMz8fPPP8POzo49iFNXV4c9e/YgNzeX45SEkO7K1tYW33zzDTIyMvDSSy+Bz+dDIBBArVbjxx9/5DoeIXqDxzAMw3UI0jFOnz6N4cOHIy0tDf7+/lzHIQSVlZXsJa0rKirYy18rFAqoVKomp2tOTU0Nfv/9d+zevRuvvfYaxo4d2+R0pqamjS4S8CgjIyMIhUL2OZ/PZ3tlGhoawsLCAgBgbGwMMzOzJywlIZ2HYRg4Ojri/fffx5IlS7iOQ56Cj48P5syZgw8//JDrKKQNlEolfvjhB3zzzTeoqqqCSqXCv//9b3z99deNptVs/2QyGerr61FeXq71ekNqtRpyubzRZxgYGMDS0rLR62ZmZjA2NgaPx4O1tTUEAgHMzc3Z1wkh3UfD9UtaWhqWLVuGY8eOQSgUIj4+vtE6QSaTtehzm1pXNael6x7Nuqqhhm34hu9r1m+EdIJaKph1YUuXLsWePXtw7949rqMQHVZTUwOFQoHy8nLIZDIoFApUVVVBqVRCqVSitrYWZWVlqK2tRUVFBVvMksvlqKurg0KhQHV1NaqqqlBeXo76+nrU1dWhoqICANj3upqGG3GhUAgjIyN2B8bExASmpqawsLCAQCCAtbU1W2wzNzeHQCCASCTS2pExNTWFlZUVrK2tYWlpCUtLS9q5IU+UlJSEXr164cqVKzSOn56KjIyEt7c3Nm7cyHUU0kJFRUUoKipCcXExSktLIZPJUFZWhrKyMkilUly8eBGpqang8/nw9vZGbW0t5HI5ampqUFlZyWl2KysrCAQCWFpaQigUwtraGtbW1hCJRE3e29jYwM7ODi4uLo12ZgkhLVNTUwOlUomysjKUl5dDqVSisrKSbTfL5XKo1WqUlZVp3cvlcrbopWlb19bWQqlUarWvNe11zby4Xs90NktLS/ZCLJo2ecPXra2twePxIBKJ2GKbps2uOTCuOXiuaa9r2vJWVlYQCoUwNzeHhYUFrKysnni1ZNKl1Da+hAbpMmJjYxETE8N1DNLBqqqq8ODBA5SWluLBgwdaj+VyORQKRaNbWVkZ+/hxPbmaKu5oCkWWlpYQCATw9vZuVAxqeOS74RGhhj20Gh5x0vycRsNeXc3RbPC+/vprLF68uNnikqYR8jiaBotGw4Jfw4ZHVVUVqqurAWg3TjQ95DQ/p5lOoVCgrq4OYrGY/ZzmehY0xcjIiC2eiUQi9rGFhQX7WLOzY2trix49esDGxoa9NzU1fexyE/2XmJgIKysr9OvXj+so5Cm5ubnRqXs6QiaTQSKRQCKRICsrC4WFhcjPz0dxcTEKCgoglUpRXFzcqGeFlZWVVqEpICAAffv2RUZGBtzc3DB48GD2IEjDbaW1tTUMDQ3Z7aVmB+1RTe2gaXaaH6XZHml2tjXTNTzYpdlBr6ysZIt9Dx48gFgsZp/LZLJGO91mZmZwcHCAk5MT7O3t4eTkBAcHB7i4uMDDwwPu7u7w8PB4Yq9uQvRFdXU1+3149L68vBxlZWWoqKiAUqlERUUF+1zzmub5k3pjWVhYsOuC5go8JiYmsLe3b1TgAbTXHY/ridWwsFRSUgI/Pz+tHG3pDdactvRaa9jWblggfLT93HAeDdv0zRUgxWJxswXIhm395piammoV0MzNzSEUCmFhYQFra2sIhUL2uUgkavaARHNXWya6hXqYdVESiQQeHh5ISEhAZGQk13FIK2iOXEulUkilUhQVFaG0tFTr1rAo1tRRJGtra/To0QNWVlZsYaXhTSQSaRVdGhZfrKysYGpqqjenHtbX1zd5+Wx9UlVVhcrKSsjl8maLnJrGWVPFT5lM1mSDxNTUlC2gaYpoDW/29vZwdHSEk5MT7OzsYG9v3+iKb0S3TZs2DdXV1Th48CDXUchT+uSTT7B3714kJSVxHaXLq62txb1795CamorMzEzk5OQgJycH2dnZkEgkUCgU7LR2dnZwcnKCs7Nzo3Wls7MzHBwcYG9vDxsbm8euNysrK/Vme/qo2tpalJaWsoXDoqIiFBQUoLCwEEVFRexrubm57EEmAHB0dGSLZ+7u7vDy8kJAQAD8/f3h7u7O4RKR7qqqqgolJSVsG7ukpAQlJSVs+6mpglhZWVmTZ0hoDiRriiOaYom5ubnWc6FQCJFI1Oi5ZlrNa5reUES3NDzL5tGiqOZxw+dKpZItojZ83lwbHQC779VcQa1Hjx6wtbWFo6MjbG1t2Zu+7/foGTols6v6+eef8f7776OkpIRO69IBtbW1yMvLQ15eHtvYbMmRayMjI7ZB/ujt0d5EDe/piEX3o1arGxVTGz7W3JeUlLCF16KiIq0ehoaGhrC3t2+yB4GDgwOcnZ3h4uICV1dXWq/oAM34Zf/617/w3nvvcR2HPKVff/0VS5Ys0SrWkLZRKBS4ffs2UlNTkZaWhrS0NKSmpiIrKwv19fXg8Xhwc3ODh4cHPD094e7urlXg8fT0pB66rVRaWgqJRMIWIXNyctjnWVlZKC0tBfDwdCl/f38EBAQgICAAgYGB6NmzJ4KCgrR6mhPyOGq1mm1HFxYWori4GCUlJVqPGz5vWNAFHp7xYGdn12zvn+YKGJqCFyGt1VxPxYYHvpt6rbi4uNGZMprCmZ2dHWxtbeHg4MA+1jzXHOTp0aMHR0vcZVDBrKuaOnUqqqurcejQIa6jdAsymQxisRj5+fkoKCiAWCzWep6Tk6M1qL1IJIKTkxNEIhGcnZ3Zo9iPvubo6EjnyZMOVVVVhYKCAuTn50Mmk7GPH31NIpFonbaq+R92dnaGt7c3vL29tZ67u7vTEbAORuOXdQ1xcXEYN24c5HJ5k4O4k8fLz89HSkoKkpOTce3aNVy7dg2pqalQq9UwNjaGj48PgoOD4e3tjaCgIAQHByMgIIDG4+pkmnaSWCxGcnIyUlJS2MfV1dUwNDSEv78/BgwYgODgYAQFBSEsLAx2dnZcRyedTCaTabVDmrp/tE1iYmLCFroatqObe+7k5EQ96oneeLSt3rC93rCXZEFBAXJzc7U6XxgbG6NHjx6N9jebuidNooJZV0S9DtpfeXk5MjMzce/ePdy7d499rCmKaVZMBgYGcHR0hIeHB1xdXeHq6gp3d3e4ubnB1dUVbm5usLe3px5gRO+o1Wr21Ju8vDzk5uZCIpFoPS4oKGALw4aGhmzxzMfHBz4+PvD19WUfa65CSp7ejz/+iI8//hilpaW0TtFjycnJCAkJQVJSEoKDg7mOo9OUSiWuXLmCs2fP4sKFC7h06RJKS0vB4/Hg5eWFvn37srfevXvDw8OD68jkCerq6pCeno6bN2+ytxs3brA90ry9vTF48GAMHjwYw4YNQ0hICK3v9FhNTY3WqdCPPpZKpVo7+0KhEK6urnB0dNS6d3BwYJ87OTlRAZyQBjS9K+/fv4+CggLcv38fUqkUeXl57H1hYSE7PhzwcPw6Nzc3tpe1h4cH2wvb09MTzs7O3bUTBxXMuqI7d+6gd+/euHr1KgYMGMB1HL1RWVmJu3fvIjU1lS2KaQpjRUVFAB4WxNzc3Nidf29vb3bl4ubmBmdnZ+pVQ7qt+vp6SKVS5OTkIDc3F7m5uRCLxez3SCKRsAU1Ozs7rUKar68vAgIC0LNnT2r4ttDEiRMhEAiwd+9erqOQNpDL5bC2tsaRI0cwduxYruPolJKSEpw8eRLnzp3DuXPncPPmTdTX18PNzQ1Dhw7F4MGD0bdvX/Tp04eK8F1MXl4ebt68ievXr+P8+fO4cOECFAoFLCwsEBYWhqFDh2LYsGEYOnQoXWRAh6jVakgkEqSnpyMrK0urGJadnY2CggJodj3Nzc3ZnXHNqdFOTk5ahTFqDxDScTRDBGkKabm5uVqn1efm5rJFNSMjI7i5uTUqpvn4+MDf378r9wamgllXtG7dOixbtox6HTSjtrYWGRkZ7CkcmnvNKRwCgQBubm7saWYNbz179tTbwXsJ4VpdXR1bRHv0dvfuXfYCFk5OTuwpOZr7vn37UsO5gerqatjY2OCHH37A66+/znUc0kZWVlZYuXJlt/9bqlQq3Lx5E8eOHcOxY8eQmJgIhmEQEBDAFkc0p+yR7kWlUiE1NRXXrl3DuXPncPbsWaSkpMDU1BRDhw5FZGQkIiMj0b9/fzpt9gpAAAAgAElEQVTVrhM0d4ptamoqe/VWExMTrWEbHh2+wcvLi/5WhOi4ht/1R4ccSktLY8cHtLa2ho+PD/s917Th/f39YWFhwfFStAkVzLqiqVOnora2FgcOHOA6Cufu37+Pq1ev4urVq7h16xZSUlKQlZUFtVoNIyMjBAYGau2Uh4SEwNvbm3qJEdLJVCqVVsM7KSkJd+/exd27d1FTUwMejwdPT08EBwejd+/eCA0NxcCBA+Hq6sp1dE5oxr3Kycmhq851AcHBwZg6dSo+//xzrqN0urKyMuzfvx9///03Tpw4AYVCAW9vb0RHRyM6OhqjRo2i3mOkSTk5OYiPj8fRo0dx4sQJyGQyuLu7Y+zYsZgyZQpGjRpF7bk2ys/Px+3bt3Hr1i0kJycjLS0NGRkZ7FX/zMzM4OfnB39/f/Zec0VUGmyckK6NYRjk5uYiIyMD6enpSE9PZ9cR2dnZ7DiDrq6u8Pf3h7+/P/r06YPevXujV69e+lJIo4JZV6MZv+z999/HkiVLuI7TqYqLi9ni2JUrV3D16lUUFBSAx+PB398fffv2RUhICHr27ImQkBD4+PhQQ4oQHacppCUlJbGFtFu3biEtLQ1qtRqOjo4IDQ3Vujk4OHAdu8MtWrQIp06dws2bN7mOQtrB2LFj4ezsjM2bN3MdpVMoFArs378fu3fvRnx8PAAgKioKY8eOxZgxY+Dr68txQqJvVCoVLl++jKNHjyI2NhZXr16Fra0tJk+ejOnTp2PEiBF01sVj1NbWIjk5Gbdv32YLZLdu3UJJSQkAwM3NDSEhIQgMDNQqjrm6ulIvMUJII7W1tcjKykJaWhpbTEtNTcXt27chl8vZsUc1BbTevXujT58+8Pb21rV1ChXMupruNH7Z3bt3cerUKZw6dQoXLlxATk4OgIcDxDbceR4wYABdeYyQLqa8vBzXr19ni+RXr15FZmYmgIcN+7CwMAwfPhwjR45EUFAQx2nbn5+fH6ZNm4bly5dzHYW0g9dffx3Z2dlISEjgOkqHYRgGx48fx4YNGxAbGwu1Wo2oqChMnz4dkyZNol5kpF2JxWLs2rULu3btwo0bN2Bvb4+XX34Z8+fPh7+/P9fxOKVSqZCSksKODae5smx9fT1MTEwQEhLC7sBqdmKptxghpL1kZ2c3Ks7fu3cParUaFhYW6NWrFwYNGoTBgwdjyJAhXJ9NQgWzrqYrj1+WmpqKxMREnDp1ComJiZBKpbCwsEB4eDiGDBmCgQMHIjQ0lDbqhHRTMpkM165dw5UrV3D+/HmcOXMGcrkc9vb2GDFiBIYPH44RI0bofQEtPT0dAQEBOH36NMLDw7mOQ9rBF198ge3btyM1NZXrKO1OJpPhv//9LzZs2ID09HSEh4fj1VdfxXPPPQeRSMR1PNINZGRk4P+xd99hUZzr38C/S0d6LwIqoqCAKKA0GyrYgkqQGKNijT0HT+IJJjFHNDlRY2LiibHFEjEnMajRWAGJIChFRZAmqDQF6b3D7s77R96dHwgoKDC7cH+uay9ld9j57rI788w9z/PM77//jmPHjiEnJwdTp07F+vXr4eHh0S9GGpSXlyM6OhoxMTGIjo7GnTt3UFVVBWVlZYwbNw4ODg5sL4/hw4f3ueMHQoj4q62tRUpKCh48eICEhARER0cjKSkJfD4fRkZG7NWSHR0dYWtrC3l5+d6KRgWzvqYvzV9WX1+PkJAQnD9/HiEhIcjPz4eKigrGjx/PHvza2dn1i8YOIaTrBAIB4uPjER4ejvDwcERGRqKqqgp6enpwc3ODp6cnZsyYIXEX8vj222/x1VdfobCwkLZ/fcSJEyewceNGdrLsvuD58+f46quvcOLECUhLS2Px4sVYt24drK2tuY5G+imhUIirV6/iwIEDCA4OhqGhIT7++GOsXr26Nw++elxtbS3CwsIQFBSEGzduIC0tDQzDYNiwYewBp7OzM6ysrKg4RggRW7W1texJcFHBv6SkBPLy8rCzs4O7uztmzJiBsWPHQkpKqqdiUMGsL+kL85eVl5fjypUrOH/+PIKCgtDQ0AAnJye89dZbcHV1pQIZIeS1CQQC3L9/H+Hh4bh8+TJu374NOTk5uLu7w9PTEx4eHhLRQ9XBwQFWVlY4duwY11FINwkNDYWbmxtKS0sl4jP4MmVlZdi9ezf2798PTU1N+Pn5YenSpZIyuS/pJzIzM/HDDz/g0KFD0NPTw7Zt27BkyRKJbWOmpKQgKCgIQUFBiIyMRFNTE8aMGQM3Nze4uLjA0dEROjo6XMckhJA38ujRI8TExCAyMhJBQUHIzc2FlpYWWzybPn16d89lTAWzvkQ0f1lcXBxsbW25jtNp9fX1OHfuHE6dOoWwsDDweDy4urrC09MTc+fOhb6+PtcRCSF9UHFxMf7880+cP38ef/31FwQCASZNmoTFixfD29sbSkpKXEds49mzZxg0aBCuXr2KGTNmcB2HdJP09HRYWFggISEBNjY2XMd5LUKhEN999x2++OILyMnJ4ZNPPsG6deugoKDAdTRCOpSbm4svvvgCJ06cgKmpKX788UdMnTqV61ivJBQKERERgcDAQFy5cgVPnz7t6YNGQggRO8nJyezJglu3brEnC+bMmYN3330X5ubmb7qKph7ru0Z6X3h4ONTU1CSmsZ2eno7169fDwMAAK1asgKKiIk6cOIHCwkIEBQVhzZo1VCzrQT///DN4PB7Onj3LdZQukdTcL9PQ0ICPP/4YpqamkJGRAY/HQ01NDdex+jwdHR2sWrUKV65cQXFxMX755Reoq6tjzZo1MDAwwOrVq5GSksJ1zFZOnz4NdXV1TJkyhesopBsZGxsD+LsgKokyMzMxadIkfPrpp/D19UVGRgb++c9/ik2x7N69e+DxePD393/pfaTrJP19NDIywuHDh5GamgpLS0u4ubnB19cX9fX1XEdrV0pKCv75z3/C2NgYrq6uiI6OxooVKxATE4OioiL8+uuv8PHxkchiGX1PO09S28KSmvtlqA3PLSsrK2zevBmhoaEoLS3Fn3/+CQcHBxw6dAgWFhawtbXF3r172Sv+vg4qmPUhUVFRGD9+vNjPRxATE4M5c+Zg5MiRCA0NxdatW/Hs2TNcuHABixYtgrq6OtcRCelVO3fuxJ49e5CVlQWBQNDj67t16xZ4PB6+/PLLHl+XpFBRUcGCBQtw9uxZ5OXlYceOHYiMjIS1tTVmzZqFW7ducR0RAHDmzBl4enpCTk6O6yikGw0YMACampoSWTA7fvw4bGxsUFVVhbt372L79u00/JJIHDMzM3a0Q0BAAMaMGYP4+HiuYwEA+Hw+fv31V4wfPx5WVla4fPkyVq9ejYcPHyI+Ph7btm2Dg4NDT87hQwjpALXhxYeSkhI8PDxw4MAB5Obm4q+//oK9vT127NgBIyMjvPfee4iNje3y89KWtQ+JiYmBg4MD1zE69OjRI7z99ttwdnZGWVkZzp07h7S0NGzevFkiz4QR0l3+/PNPqKmpITU1FQKBAAzDQFlZmetY/Za2tjY2bdqElJQUXLx4EXV1dZgwYQI8PDyQmprKWa7s7Gzcu3cP3t7enGUgPcfY2FiiCmYMw2DLli1YtWoVNmzYgLt372LUqFFcxyK9zN7eHgzD9JkeQIsWLUJSUhIGDhyIiRMnIigoiLMsfD4fhw8fxvDhw7F06VIYGhri+vXrePToEbZt2wYLCwvOshFC/kZtePEkLS2NKVOm4MiRI8jLy8PBgweRkZEBR0dHTJ06FeHh4Z1+LiqY9RHFxcXIzs4Wy4KZQCDAN998AxsbGzx58gSXLl3CrVu3MG/ePDobRgj+nkPF3NwcI0aMoO+EGJGSksJbb72F8PBwBAcHIy8vD7a2tvjPf/4DPp/f63kCAwOhoaEhEfPrkK6TtILZ1q1bsXfvXpw8eRK7du2iXo+kzzAyMkJQUBC8vLwwb948hIWF9XqGsLAwjB49Gr6+vpg+fTrS09MRGBiIadOmgcfj9XoeQkj7qA0v/pSUlLB8+XLExsbixo0b7Hzp3t7eePr06St/n/6qfURsbCx4PB7s7Oy4jtJKTU0NPD092XlN4uLiMHv2bK5jdUpQUBB4PB6+//57hIWFwdnZGUpKSjA2NsauXbvY5X744QeYm5tDQUEBFhYWOHPmTJvnioiIwKJFi2BmZgZ5eXno6OjAw8MDt2/fZpcRCoWYOXMmpKSkcOXKlVa/X1RUBCMjI+jo6HT5gKqiogIbN26EgYEBFBUVYW9vj8uXL7/yNd+8eROTJk2CiooK7O3tu/RaSktLIS0tDR8fn1bPf/LkSfB4POjp6aHl9Uby8vLA4/Gwdu3a18oN/H3xiO3bt2PEiBFQUFCAmpoapk6diuDg4G7L1fL9iYmJweTJk6GkpAQtLS0sXboUZWVlHeZrz6ZNm8Dj8VBaWoo7d+6Ax+O1eR8YhsHx48fh7OwMFRUVKCoqwsbGBj/++CNevGZLZ/42X375JSZMmAAA+Pzzz9l1ihrgR48e7XB+CdFjFy5cYO971WemK/nFmbu7O+7du4f//ve/2LlzJ2bMmIGKiopezXDy5Em8++67kJWV7dX1kt4hSQWz06dPY+fOnfjpp5+wZMkSznJ0ZpvX3fpC26C79vVA+3NMCQQC/PDDD7Czs4OGhgbU1dVhb2+PvXv3oq6urtXvi+s+QlZWFsePH4enpyfefvvtTh1UdQc+nw9/f39MmzYNBgYGSEhIwMGDB2Fqator6+8J9D2lNjy14akNLy5cXV0RGhqK0NBQPHz4EFZWVjh9+vTLf4khfcLWrVuZ4cOHcx2jlbq6OmbcuHGMvr4+Exsby3WcLrt27RoDgFmwYAEjIyPDAGh127t3L/Pxxx+3uV9KSoqJj49nnyc/P7/NMqKbjIwMc/PmTXbZ0tJSZtCgQYyGhgaTmZnJMAzD8Pl8ZsqUKYyUlBQTHBzcpddQX1/PjB49us16eTwes2DBAgYAc+bMmTav2dvbu9VrHjNmTJdfi52dHaOnp8cIhUL2vvfee4+RkpJiALR6j44fP84AYM6ePftauRsbGxkXF5d2c/F4PObgwYPdkkv0/rz33nuMvLx8m3VNnDixS38fX1/fdjOvWbOGYRiGEQqFzKJFizp8z99//332uTr7t/niiy86XI5hGOann35q8/6KiB47f/48e9/LPjNdyS9J4uPjGSMjI8bGxoapqqrqlXXevn2bAcDcvXu3V9ZHet9XX33FmJqach3jlUpKShh1dXXmgw8+4DRHV/ZHd+/eZQAw27Zte+l9ndEX2gbdua9v733817/+1eHv//DDD+xykrCPqKurYywtLZnp06f3+LoaGhoYNzc3RllZmTl16lSPr6830PeU2vCvyk1teGrDc6WhoYHZsGEDw+PxmF27dnW0WCMVzPoId3d3ZsmSJVzHaGXFihWMlpYW8/jxY66jvBbRRgQAs2nTJiY7O5upqalhzp49y8jKyjJqamqMiooKc/ToUaaoqIgpLS1lPvroIwYA4+Pjwz5PQUEB4+bmxly6dIl59uwZ09TUxBQWFjKBgYGMkpISM3PmzFbrvXv3LiMvL8/Y2toyDQ0NzCeffMIAYHbs2NHl1/D1118zABhzc3MmNDSUqa6uZjIzM5n169ezr629nS0AZsWKFUx6ejrD5/Nf67WIcickJDAM8/eOQ1dXl1myZAkjKyvL7N69m1323XffZaSkpJiysrLXyv3tt98yABgTExPm0qVLTGVlJfP06VPG39+fkZKSYhQUFJj8/Pw3ztXy/Vm7di3z+PFjpq6ujrl16xZjYmLS6nm7Qk1NjXFwcGhzf0BAAAOAsba2Zq5evcqUlpYyNTU1zM2bNxkbGxsGABMVFdXlv01kZCQDgPniiy/arPN1d7btfWa6kl/SZGdnM3p6esw777zTK+tbtWoVY2Vl1SvrItwICAhg5OTkGIFAwHWUl9q6dSujq6vL1NTUcJqjK9u8njgQl+S2QXfu69t7H4cNG8YoKSkx586dYyoqKpja2lomISGB2bx5M3PixAl2OUnZR9y4cYMBwERHR/foehYtWsSoq6u3OuiXdPQ9pTY8teGpDS/u9u/fz/B4POZ///tfew9TwawvEAqFjIaGBvPf//6X6yislJQURkpKqt0vrKQQbURmzJjR5jEvLy8GAPPtt9+2up/P5zNqamqMvb19q/vv3bvHeHt7M4aGhm3OdBkZGbV5/kOHDjEAmAkTJjA8Ho+ZOXNmq7MpneXg4MDweDwmOTm5zWNTp07tcGfr6OjY4fo6+1pEDcyvv/6aYRiGuX//PruhnjBhAjN16lSGYf7+/Oro6DDjxo177dyOjo4dNmZXr17NAGAOHz78xrlE74+7u3ub9ezfv58BwJw8ebLd9+1lOtrZurq6MtLS0szz58/bPJaSksIAYPz8/Nj7Ovu36YmdbXufma7mlzRXr15leDwec+/evR5dT01NDaOqqsp89913Pboewq2wsDAGAFNQUMB1lJcaPnw48/HHH3Mdg2GYzm/zeuJAXJLbBt25r2/vfXR1dWWGDRvGNDc3vzSHJO0jrK2tmU2bNvXY80dERDAAmKtXr/bYOrhC31Nqw78sN7Xh/0ZteG5t3LiR0dfXb+9kYCPNYdYHPHr0COXl5WI14X9QUBD09fXh5eXFdZQ3NmnSpDb3DRo0CAAwceLEVvdLS0tj4MCBKCwsZO+LioqCs7Mzzpw5g+fPn7eZLLy+vr7N869Zswbz589HZGQkDA0N8csvv7zWJK9PnjzBwIEDYWlp2eaxGTNmdPh7HU0q25XX4uLiAiUlJXb+gevXr0NGRgZTpkyBu7s7bt26hfr6esTHx6O4uBhubm6vnfvJkyfQ0tKCo6Njm8feeustdpk3zSUyefLkNveJ5heprq5u89jrSklJgUAggLGxMWRkZCAtLQ0pKSlISUmx741oXpXX+Zx1p/Y+M13JL4lmzpwJMzOzNvOVdLczZ86goaEBixYt6tH1EG4ZGRkB+HsCYXFVW1uLR48etdn3cYHrbZ4ktw1EumNf357vvvsOQqEQZmZmWLNmDQ4cOID4+Pg2y0nSPmLChAm4f/9+jz3/H3/8AXt7e8ycObPH1sEF+p5SG/5VuakNz/33pD+24V/0+eefo7CwEFFRUW0eo4JZH3Dnzh3IycnBxsaG6yiswsJCGBgY9Ikr+SgoKLS5T/S6OnpMKBSyP+/atQtNTU3Ytm0bnjx5gvr6egiFQjAMA3Nz83bX2fILW1paipycnO54KZ2mpaXV7v1deS1ycnKYOHEiu/MKCQmBo6MjVFVV4e7ujsbGRkRERCAkJATA35Oqv4nOfta6I5eiomKH62e6cRJM0edIIBBAIBCw73XLdTQ1NQF4vc9Ze0RX+Gn5GRZ52Q67vc9MV/JLqoEDB6KgoKBH13H8+HHMmTMHOjo6Pboewi19fX0AaHWwJm6qqqoAAKqqqhwn6b5t3uvqC22D7tjXt8fGxgZpaWkICAjAkCFDEBkZiRkzZsDS0hJJSUnscpK0j1BXV0dlZWWPPX9+fj5MTEx67Pm5Qt9TasN3BrXhqQ3PNR0dHQwYMAB5eXltHqOCWR9w584djB49GvLy8lxHYZmbmyM9Pb1HGxeSIjMzE3p6evD398fQoUOhoKAAHo+HjIwMPH78uM3yAoEACxcuREFBAQ4cOABZWVnMnz//ta7IZ2Zmhry8PKSkpLR5LCgoqMdfi2jnFRQUhFu3brE7Lnt7e2hqaiIkJAQhISFQUlKCk5PTa+c2MzNDSUkJ7ty50+axq1evssu8aa7eZmFhgQEDBqCiooLdSb14E10Jpyt/G9EO9cUzWACgq6sLAMjKymrz2I0bN3osvySqq6tDYmIiRowY0WPrSEhIQGRkJFavXt1j6yDiQVlZGUpKSj1egH0TOjo6kJWVFYuzyl3dH4kbLtsG3Z2tPTIyMpg4cSK2bNmC3377DVlZWaiqqsLKlSvZZSRpH5GTk4OBAwf22PNbWloiNjYWDQ0NPbYOLtD3lNrwr8pNbXhqw4uDu3fvora2FtbW1m0eo4JZHxAbGytWwzEBYP78+ZCTk8OOHTu4jsI5ExMTFBUVYf/+/aisrERlZSWuXr2KWbNmtXsGYOvWrQgLC8OOHTuwbt06nDhxApmZmfDx8enymQ8vLy8wDAMvLy/cuHEDNTU1yMrKwoYNG/DXX3/1+GsR7cT+/e9/o7Gxkf1ZSkoKU6ZMwaVLlxAVFYXJkydDVlb2tXN7e3sDABYsWICrV6+iqqoKubm5+OKLL3DkyBHIy8tjzpw5b5yrt61cuRJ1dXWYNm0aLl++jOLiYjQ1NSEnJwdXrlyBl5cX+3505W+jqakJAIiMjERpaWmrx0aOHAkA+P777xEeHo76+npkZ2fjo48+anUp6u7OL4lEZwQXLlzYY+vYu3cvrKysMG3atB5bBxEf+vr6Yl0wk5GRwfjx43Hx4kWuo3R5fyRuuGwbdHe2Fzk7O+PQoUNITU1FfX09KisrERQUhNLSUmRmZrLLSco+oqGhAcHBwXB1de2xdaxatQqVlZX497//3WPr4AJ9T6kNT214asOLu7q6OnzwwQeYOHEi7Ozs2i7w2jOjEbHQ0NDAyMvLi+Xlp0+ePMnweDx2okZJI5oIsb2JtkVX0klKSmrzmKWlJTNw4ED25wsXLrSauFF0GzNmDGNlZcVoaWmxy168eJHh8XjMrFmzWk2++OGHHzIAmJ07d3bpNbzuJak7mly8K69FZODAgQwARkNDo9XV344cOcL+/vfff/9GuRsbGxlnZ+d2swFodUnqN8n1svdH9NgPP/zQ7nv3Mh1NGCoUCplly5Z1+LoAMNeuXWMYpmt/Gz6fz77+ljeRt99+u81jMjIyzJIlSzqcMLS996Qr+SVNQEBAm8udd7e8vDxGTk6OOX78eI+tg4gXZ2dn5h//+AfXMV7q119/ZaSlpZnU1FROc3Rlm9cTk4lLctugO/f17b2P8vLyHW7zW36+JWUfsXfvXmbAgAHtTn7dnUTt5u3bt7/WJPHiiL6n1IanNjy14cVZeXk54+bmxujo6DBpaWntLUKT/ku6pKQkNDY2tl8N5ZiPjw/8/f2xdu1afPLJJ2hubuY6Eifmzp2L//3vfxg1ahQUFRVhYGCANWvW4K+//mo1jDYrKws+Pj4wMTHBqVOnWo3n3717NyZMmMCeueosBQUFhIWFYf369dDT04OCggLGjBmD8+fPv3TC0Dd9LS2JJtycOnUq240YaD2vwIuTcnY1t5ycHEJDQ7Ft2zaYm5tDTk4OKioqcHV1xbVr17B27dpuydXbeDweTpw4gd9//x3Tpk2DhoYG5OTkYGpqinnz5uH8+fNsz6Ou/G2kpaVx9uxZjB8/HkpKSm3We+zYMaxYsQJaWlpQUFCAk5MTQkNDuzzRd1fySwqBQIDt27dj6dKl2LJlS7ufre7y448/Ql1dvUd7sBHxoq+vL9ZzmAHAO++8A1tbW/j4+KCxsZGzHK+zPxInXLYNuitbR2JjY7FhwwaMHDkSioqK0NbWhouLC44ePYrvvvuOXU4S9hEPHz7E559/js2bN8PAwKBH1+Xj44ODBw/iyy+/xJw5c5Cfn9+j6+sN9D2lNjy14akNL66ioqJgb2+P1NRUBAUFdThfHI9hurkfN+lVx48fx8aNG1FdXQ1paWmu47Tr559/xvr162FhYYGjR4/C1taW60iEENJliYmJeP/99/HgwQN8//33PVosq6urw6BBg/DBBx/0uSE6pGPr169HamoqwsPDuY7yUo8fP8a4ceMwdepU/P7772Lb/iDkTeTl5WH8+PEwNDREeHh4rw3vio6OxqJFi1BSUoLPP/8cGzdubHeickIIIV337NkzbN26FadOncL06dNx8uRJdv63djRRDzMJl5SUBEtLS7FurC5btgwPHjyAsrIyxo4di0WLFiEjI4PrWIQQ0ik5OTlYvnw5bG1tISUlhfv37/dosQwAAgICUFNTg3Xr1vXoeoh40dPTE/seZgAwbNgwXLx4EdeuXYOnpydqa2u5jkRIt3r48CFcXFygrKyMixcv9upcSE5OTkhJScFHH32Ebdu2YciQIdi1axddSIsQQt7Ao0ePsGrVKpiZmSEiIgJnzpzBtWvXXlYsA0CT/ku8xMREjBo1iusYrzRs2DDcvHkTv//+O+Li4mBubo533nkHsbGxXEeTOAkJCeDxeK+8zZs3j+uo/Rb9jfqG+/fvY9GiRRg2bBgiIyNx6tQp3L59m51Utac0Nzfj66+/xtKlS6Gjo9Oj6yLiRdwn/W9pwoQJCAsLQ2xsLGxsbHD79m2uI722vrDN7guvQVwEBATAwcEBBgYGuHHjBrS0tHo9g6KiIrZt24asrCwsW7YMO3fuhKGhIVasWNFv28594TPeF15DX0d/o76lqakJgYGBmDZtGiwsLHDz5k0cOHAA6enp8PLy6tRzUMFMwiUnJ7d7+VNxxOPxMH/+fCQnJ+OXX35BVlYWHB0dYWdnhwMHDvTIpdEJIaQrqqqqcOTIETg4OMDOzg6pqak4fvw4Hj58iIULF7aaK6OnHD9+HHl5efDz8+vxdRHxoq+vj4qKCjQ0NHAdpVPGjRuHBw8ewMLCApMnT8aWLVvQ1NTEdSxCXktRURHmzZuHZcuWYfny5QgPD+f8pIWenh527dqFp0+f4uuvv0ZcXBwcHR1hYWEBf39/pKWlcZqPEELEjUAgwI0bN/D+++/DwMAA7733HhQVFfHnn38iLS0NK1euhJycXKefj+Ywk2D5+fkwNDTEX3/9hSlTpnAd57XcunULP/30E86ePQuhUAg3Nzd4enrCw8MD2traXMcjhPQDZWVluHz5Mi5cuIDg4GAIhUJ4eXnh/fffx6RJk3o1S1NTE8zNzTF79mzs37+/V9dNuBcTEwMnJydkZ2dj0KBBXMfpNIZhsH//fvj5+WHo0HoROPkAACAASURBVKHspOUtJ74mRFzV1dVh//792L17N9TV1XHy5EmMHz+e61gdunPnDn777TcEBgbi+fPnsLCwwMyZMzF9+nRMnDiR5jsjhPQ7RUVFCAkJQVBQEEJCQlBcXIwxY8Zg4cKFWLhwIYyMjF73qZuoYCbBQkJCMH36dBQVFXF+BuxNVVZW4ty5czh//jxCQ0PR3NyMCRMmwNPTE/PmzYOJiQnXEQkhfUhubi7+/PNPnD9/Hjdv3oS0tDRcXV3h6ekJb29vaGhocJLrhx9+wMcff4zHjx+/yc6dSKjs7GwMGTIEsbGxGDduHNdxuuzx48f49NNPce7cOYwbNw5ffvmlxF9Fi/RdTU1NOHLkCL766itUV1fD19cXfn5+UFFR4TpapwiFQkRERODKlSsICgpCcnIyFBUVMWnSJMyYMQMzZszo8KpvhBAiyfh8PmJiYhAUFISgoCDEx8dDRkYGLi4umD59OubOnQsLC4vuWBUVzCTZN998g7179+L58+dcR+lWNTU1uHbtGs6fP4+rV6+iqqoKo0aNwuTJk+Hq6ooJEyZAU1OT65iEEAlSUVGByMhIhIWFITw8HAkJCVBWVsbMmTPh6emJWbNmQVVVldOMDQ0NMDMzg7e3N7777jtOsxBuNDQ0sMMG5syZw3Wc13b//n1s3boV165dg4uLCzZs2AAvL68uDYEgpKcUFRXh2LFjOHToEIqKirB27Vp88sknr5z4Wdzl5uYiKCgIwcHBCA0NRUVFBUxMTDB+/Hg4OjrCyckJo0ePhoyMDNdRCSGkS6qqqhAbG4vo6GjExMQgKioKlZWVGDJkCGbMmIHp06dj6tSpUFZW7u5VU8FMki1duhSFhYUICgriOkqPaWpqQlhYGIKDgxEeHo4HDx4AQJsCGle9QQgh4qmyshIREREIDw9ntx0Mw8DKygqTJ09md6zy8vJcR2Xt3bsXn3/+OTIyMqCvr891HMIRdXV17NmzB++//z7XUd7YrVu38N133+HixYvQ0tLCypUrsWbNGuo1TjgRFRWFAwcO4OzZsxgwYACWL1+OTZs2wdjYmOto3U7U++LGjRvsAWZFRQUGDBgAe3t7ODs7w8nJCY6OjhJfKCSE9D3p6emIiYlBdHQ0oqKikJqaCoFAgMGDB8PJyQnOzs5wd3fH8OHDezoKFcwkma2tLaZOnYo9e/ZwHaXXlJeXIyIiAmFhYbh58yYSExMBAJaWlrC3t2dvNjY2YnUgTAjpOY2NjUhMTMS9e/fYW0pKCoRCIVsgmzx5MiZNmsTJ1c46o6SkBMOHD8eaNWuwc+dOruMQDpmbm2Px4sX4/PPPuY7SbXJzc3HkyBEcPXoURUVFmDp1Kt555x14enpSj3HSo9LT0xEYGIjAwEAkJyfDzs4O69evx7vvvosBAwZwHa/XMAyDhw8fsj0zoqOjkZaWBqFQiCFDhsDGxgajRo3CqFGjYGNjA1NT0165yA0hpH9rbGxESkoKHjx4gMTERCQlJSE+Ph5lZWVQUFCAnZ0dWyBzdHSEgYFBb0ekgpmk4vP5UFFRweHDh+Hj48N1HM6UlZUhMjIS0dHRuHfvHuLi4lBRUQFZWVlYWVnB3t4eY8eOhb29PaysrCArK8t1ZELIG2hubkZKSkqr4lhiYiKam5uhqqoKW1tb2Nvbw9HRERMnTpSY+R1Xr16NS5cuIT09nfOhoYRbkyZNgrW1dZ+86ENzczMuXLiA3377DdeuXYNAIMC0adPwzjvvYO7cudRbnHSLJ0+esEWyBw8eQF9fH15eXvDx8ZHIuQF7SkVFBWJiYhAXF8cerD558gQCgQDKysqwsrJiC2ijRo2CtbU11NTUuI5NCJFQubm5SExMRGJiIrvNefToEfh8PhQVFWFpaYnRo0dj1KhRGDduHMaMGSMOUzlQwUxSpaamwtLSEvHx8Rg9ejTXccTK8+fPERcXx95u376N8vJyyMjIwMTEBCNHjoSlpSX7r6WlJRQUFLiOTQhpgc/n4+nTp0hJSUFqair7b2pqKurr6yEnJwdra2u4uLjAzs4OdnZ2GDFihESeEb9//z7GjRuHgIAAvPfee1zHIRx75513wDAMzpw5w3WUHlVfX4/Q0FCcOXMGf/zxBxoaGjB69GhMmzYN06ZNw6RJk+gkF+mU+vp63L59G6GhoQgNDUVcXBw0NTUxe/ZseHt7Y+bMmTRvVyc1NTXh8ePHiIuLY/e9d+7cQVFREQBAQ0MDpqambBva1NQUpqamGDFiRL/qsUcIaV9jYyOePHmC1NRUZGZmIjMzEykpKUhKSkJVVRUAwMDAgD0WF7XhLSwsIC0tzXH6dlHBTFKdO3cOCxYsQE1NDRV7XkEgECAtLQ1JSUlISkrCw4cPkZycjMzMTAgEAsjKysLc3BwjR46ElZUVLCwsYGZmhqFDh1JPD0J6WE1NDZ48eYKMjAykpaUhOTkZqampSEtLQ1NTE6SkpDBkyBBYWVmx39FRo0ZhxIgR4rpj7RKGYTBp0iQIhUJERkaCx+NxHYlw7B//+Afi4+MRGRnJdZReU1VVhWvXriEkJATBwcHIy8uDlpYWpk2bBnd3d4wfP7435ikhEqK5uRn379/HzZs3ERISglu3bqGpqQk2NjZwd3fHjBkzMHHixD6xjxAXohNY6enpePToEXt79uwZAEBGRgaDBg3C8OHDYW5ujuHDh2PIkCEYNGgQBg8eDEVFRY5fASGku5SVlSEnJwc5OTl48uQJuz1IT09HQUEBAEBWVhampqbs9kC0bRg1ahTU1dU5fgVdQgUzSfXVV1/h6NGjyMzM5DqKxGpoaMDDhw9b9V5JTk5GVlYWhEIhAEBHR4ctnr34r6QM9SKEayUlJcjIyEBGRgZbHBP9W1hYCACQkpLC4MGDW/X8tLS0xIgRI/p0Q/vkyZNYuXIl7t27R72FCQDgP//5D37++Wc8fvyY6yicSU5ORnBwMIKDgxEZGYmGhgbo6urCyckJLi4ucHZ2hr29Pc1V2k+UlpayEz/fvn0bd+/eRX19PXR0dODm5gZ3d3dMnz6dLpbCgbq6OvZg+fHjx0hPT0d6ejoeP36M8vJydjk9PT0MGjSILaCJ/i8qqvXAle0IIa+psLCQLYiJbtnZ2cjOzkZOTg6qq6vZZY2MjNiC2LBhw2BhYYHhw4dj8ODBfaVnLxXMJNXy5ctRUFCAa9eucR2lz2lsbER2dnabA/uMjAxkZWWhqakJAKCqqgpTU1MYGxtj0KBBMDIygrGxMUxMTGBsbAxDQ0MaTkL6PD6fj+fPn+Pp06d49uwZcnNz8ezZM+Tk5ODZs2fIzMxEZWUlAEBOTg6DBw/G0KFD2ZuoAG1qatrvDn7Ly8sxcuRIvP322/jxxx+5jkPExLFjx/DPf/6THbrQ3zU2NiIuLg7R0dG4ffs2oqKiUFhYCHl5eYwZMwajR49m/7W2tu7TBfb+oKSkBAkJCYiPj0dCQgLu37+P9PR0AH9fEMPZ2RkuLi5wcnKChYUF9coVYxUVFe0ebIv+LS0tZZfV0tKCsbExjIyMYGBgAENDw1Y3AwMD6OnpSeS0C4SIi8bGRhQUFCAvLw/5+fmt/n3+/DmeP3+O7Oxs1NfXA/j7ZLahoSEGDx7cqtDd8tYPRrpRwUxSOTs7Y+zYsdi3bx/XUfoVoVCIZ8+esUW0rKwstjiQm5uLvLw8NDc3A/h7I6Ovrw8TE5NWxTRdXV0MHDgQOjo60NfXpyuEEbFVXl6OgoICFBUV4fnz5ygqKsLTp0+Rm5uL3Nxc5OTkoKCgAAKBAMDf3a8NDAxgYmLCfu5NTU3Z4piJiQkNkWlh8eLFCAsLQ3JyMk12TliXL1+Gh4cHampqoKSkxHUcsZSRkYGoqCjExsbiwYMHePDgAaqrqyEtLQ1zc3OMHj0aNjY2GDFiBCwsLDBkyJC+cqa7z6itrWWH8KSkpCAhIQEJCQnIzc0FABgaGrLFUEdHRzg5OYntVY7J66mpqUFOTg6ysrKQk5ODp0+ftjmIb3niQEZGBnp6ehg4cCD09fVhZGQEfX19GBoaQltbG9ra2tDR0YGurq6kDfki5LUJBAKUlJSwt8LCQhQXF6OwsBDPnj1DYWEhcnNzUVBQgOLiYvb3eDwedHV1W32XjIyMWhXDjI2NxWHSfa5RwUxSaWtrw9/fHxs3buQ6CmlBKBSioKCgVW8bUTHt2bNnePbsGYqKitgCAwDIy8tDR0cHhoaG0NPTg66uLgwNDdmNmKiopqWlBS0tLWr0k9fG5/NRVlaG0tJSlJaWsoWw4uJi5OfntymONTY2sr8rLS0NXV1dGBkZwcjIqFVRTFQM1tfXp4JYJ124cAFvv/02Ll++jFmzZnEdh4iRe/fuYezYscjIyICpqSnXcSQCwzDIyMhgeyUlJCQgMTGRLb7Iyspi6NCh7FAR0VwqQ4YMgYGBAfVa6SGNjY1sj6L09HSkpaWxRTLR3FeysrIwMzODjY1Nq96Curq6HKcn4qCuro492M/NzW23CJCfn99qiBjw9+dKR0cH2tra0NXVha6ubquimp6eHrS1taGhoQF1dXVoaGjQCQoiFioqKlBeXo6KigqUlZWhsLCQLYaJCmEtC2Qti2DA34UwbW3tdovLRkZG0NPTg7GxMfT09GgkVOdQwUwSlZWVQUtLCyEhIXBzc+M6DukihmFQVFSEoqIi5Ofno7CwsFWRoqCggC1cFBcX48WvqKqqKrS1tdkCmpaWVquCWsv/q6qqsje6elHfUVdXh+rqalRVVaGysrJVEayj/5eUlLBDI1sSNST19PRgYGDQbvFWdMaWDiq7R3FxMaysrODp6YlDhw5xHYeImZycHAwePBgxMTFwcHDgOo5Eq66uZudXSktLYycsT09PR11dHYC/h4qLzqqbmJiwQ09MTExgYGAAAwMD6q3SDqFQyLZlRD3tX7zl5+ezy2tra8PCwoKdANrc3BwWFhYwNTWlgzbyxhobG9stKBQXF7Pt6eLiYva+srKyNs8hJyfXqoAmunX0s6qqKtTU1KCkpAQlJSW6UBgBwzCoqKhATU0NamtrUV1dzRa/ysvL2duLP7e878XjPhkZGbbYq62tDX19/VY/6+npscVhUUGY2uvdigpmkig6OhrOzs7Izs7GoEGDuI5DehCfz0dxcXGbAkhJSclLiyN8Pr/Nc0lLS0NVVZXdyauoqLDFNBUVlVb3KygoQF1dHXJycmxDQE5ODurq6pCVlYWKigoUFRX7w7j1N9bY2Ii6ujrU1NSgubkZ5eXlaG5uRk1NDerq6tDY2IjKyko0NDSgqqoKVVVVqKioQFVVFVsUe/H+9v6+MjIy7RZORf+2LLKK7tPR0aEDFQ54eXkhPj4eDx48gIqKCtdxiJipra2FsrIyrly5Qr0PewjDMMjLy2s1n5Lo9vTp01ZzuACAgoICezKhZe9vXV1daGpqtjqIFv0raXMy1tTUtDpoE/1bVlbW7sm94uLiVr3lNTU1Ww3laTnfzeDBg2n6CSJW+Hw+SkpKOixgvOznF3uztaSqqgolJSUoKyuzbWxRO1pNTQ0qKirsz+rq6pCRkYGKigrb3lZQUICioiLbxha1v1VUVGiESTepr69HQ0MDamtr0dTUhOrqavD5fFRVVUEgEKCiogJCoRAVFRXg8/morq5GZWUlamtrUVtby7bJRT9XVlaiuroatbW17ImYF/F4vA4LsK8q0tJQdM410TdPAj169AgKCgowNjbmOgrpYTIyMuwZ7q6oqqpCaWkpu1FvWXgR7exbPlZcXNzq/sbGxlZXN3oZVVVVyMrKQk1NDfLy8mxPNmVlZbYYo6qqyg7VE83VJCUlBTU1NfZ1tlc4eNW8Ti3X1x7RTvFlKioq2pzNERW3ALA7UADseyIUCtneWqKdacv1VVVVobm5ud0eXe1RV1eHvLw827jS0NCAiooKtLS0MGTIELa4Kbq/ZaFTVVUVWlpa7HtJxNvPP/+MCxcuICwsjIplpF1KSkqQl5dvNSE26V48Ho8dXu7i4tLuMoWFhSgsLGxTLCouLkZWVhaio6NRVFTEngR50YABA9iDHgUFBaipqUFWVhaqqqrsvkt0MKympsb2CGi57xRp7wSV6CCvJdFJGOD/TtaIDgorKyvB5/NRWVnJPtay90NHr0FDQ4MtEBoYGMDW1hZ6enrg8/nYuXMn+Hw+duzYgQ0bNlCvBiIxZGRk2M91VwkEApSXl7O9/Gtra1FTU9NhYUXU2ygzM7NNoUX0XewsUXtaXV0dUlJSUFdXR2VlJdTU1Fq1mVsW2FpuP0SFOaB1O/zF96Yz7ZMBAwa88sRAy/Z0R0S9sl4kEAhazWHXsr3e8nlbtvVFJ6SB/2ufNzU1oba2Fg0NDa1OhLxKy232i4XPgQMHQllZucNCqOhnZWVlqKurUy9lCUc9zCTQZ599hkuXLiExMZHrKKSPE+14RA3uiooKNDU1tekdJTpD03KnVVlZCaFQCODVhab2GgyiHdzLtHfA0JKoV117BAIBGIZhD15aatkI6Kjwp66uDh6P16rBIToIUlFRgaysLFsIGzBgAPs8GhoabXrukf7h4cOHGDduHNauXYs9e/ZwHYeIMUNDQ/j5+cHX15frKKQTampqWvVAebGXVkNDAyorK9Hc3MyelHqx57FIeydx2tvXtVdEa3kwLCsrC2VlZXZ/pqamBhkZmVYnt0S9y1/sHdfZXnK1tbXYs2cPdu7cCSsrKxw4cICGERPyGkTFHFHb+sXeT6I2dcveT4WFhQgMDERBQQGWLVvWag7ZjopLLYtGLdvhLYnW/SrtbateJNoOvUp77WEej9eq0NSyDd6ynd5REVD0/xd78Ym2f6JtqOi5RO30lushBDQkUzJ5e3uDYRicPXuW6yiESKzFixfj/v37SE5OprPipMfV1NTAwcEBqqqquHnzJhVKyUtZW1vD09MTO3bs4DoKIa+Unp6OjRs34saNG1i0aBH27t0LbW1trmMR0icJhUIcPXoUH374IczMzHDixAmMGTOG61iE9FVNdJQogR49eoThw4dzHYMQifbZZ58hPT0df/zxB9dRSD+wcuVKlJSU4MyZM1QsI6+kpaVFQzKJxDA3N8f169dx+vRphISEwNzcHPv27WN7mRNCukdKSgqcnJywceNGbNy4EXfv3qViGSE9jApmEoZhGDx58gTDhg3jOgohEm3EiBHw9PTEl19++cou5YS8iW+//Rbnzp3Db7/9BiMjI67jEAlABTMiiby9vZGeno7Fixdj8+bNcHBwwN27d7mORYjE4/P52L17N+zs7MDj8ZCQkIBdu3bRhZsI6QVUMJMwRUVFqKurw5AhQ7iOQojE+/zzz5GYmIgrV65wHYX0UVeuXIGfnx927dqFKVOmcB2HSAgtLS2UlZVxHYOQLlNTU8O+fftw7949yMvLw9HRET4+PlQAJuQ1JScnw8nJCf7+/ti+fTtu376NkSNHch2LkH6DCmYSJjs7GwAwePBgTnMQ0hfY2Nhg9uzZ+OKLL7iOQvqghw8fYtGiRViyZAk2b97MdRwiQTQ1NanAQCSajY0NIiMjceLECQQHB8PKygoBAQHUo5uQThL1KrO3t4esrCzi4+Ph5+dHE9IT0suoYCZhcnJyIC0tjYEDB3IdhZA+YevWrbhz5w6uX7/OdRTShxQVFWHWrFmwsbHB4cOHuY5DJAwNySR9AY/Hg4+PD9LT0/HOO+9gxYoVmDRpEpKSkriORohYS0xMhIODA7Zv347t27cjMjISFhYWXMcipF+igpmEycnJgaGhIY1ZJ6SbODg4wM3NDf7+/lxHIX1ETU0NZs+eDRkZGfzxxx80yT/pMiqYkb5EXV0d+/btw927d8Hn82FrawtfX19UVVVxHY0QsdLc3Izdu3dj7NixUFRUREJCAvUqI4RjVDCTMDk5ORg0aBDXMQjpUz777DNERUUhIiKC6yhEwjU3N2P+/PnIycnBlStXoKWlxXUkIoG0tLRQU1ODpqYmrqMQ0m3GjBmD27dv49ixY/jtt99gYWFBwzQJ+f8SEhLg4OCAHTt2YMeOHYiIiMDw4cO5jkVIv0cFMwlDBTNCut+kSZMwceJEfPnll1xHIRKMYRisWrUK0dHRCAoKooYueW2iQitN/E/6mpbDNL29vbFixQq4uroiJSWF62iEcKKhoQH+/v4YN24clJWV8eDBA/j5+UFKig7TCREH9E2UMNnZ2TThPyE94LPPPsP169cRFRXFdRQigRiGwfr16/H777/j/PnzsLW15ToSkWCampoAQMMySZ+loaGBffv2ITY2Fg0NDRgzZgx8fX1RXV3NdTRCek1MTAxsbW3x3XffYc+ePQgPD4eZmRnXsQghLVDBTMI8ffqUepgR0gPc3d3h7OyMXbt2cR2FSCA/Pz/89NNPOHXqFKZMmcJ1HCLhRD3MqGBG+jo7OztERUXh6NGj+PXXX9lhmoT0ZfX19diyZQvGjx8PExMTJCUlwdfXl3qVESKG6FspQcrKylBVVUUFM0J6yJYtW3Dp0iXExcVxHYVIkE8//RR79+7FqVOn4O3tzXUc0gdoamqCx+NRwYz0C1JSUuwwzfnz52P58uWYMmUKUlNTuY5GSLeLiorCmDFjcOjQIRw4cADXrl2DiYkJ17EIIR2ggpkEycnJAQAqmBHSQzw8PGBnZ0e9zEinMAyDTz75BLt378bPP/+MhQsXch2J9BGysrJQUVGhghnpVzQ1NdlhmjU1NRg9ejR8fX1RU1PDdTRC3pioV9mECRNgamqK5ORkrF69Gjwej+tohJCXoIKZBHn69CkAwNjYmOMkhPRdfn5+OHfuHJKTk7mOQsSYUCjEunXr8M033+Dnn3/G4sWLuY5E+hgtLS2a9J/0S/b29oiJicH+/ftx8uRJGqZJJN6tW7dgY2ODw4cP4+DBg7h69SqMjIy4jkUI6QQqmEmQ58+fQ0NDAwMGDOA6CiF9lpeXFywtLamXGelQU1MT3nvvPfz88884ffo0lixZwnUk0gdpaWlRDzPSb0lJSWH16tVIS0vDlClTsGzZMkybNg1paWlcRyOk0+rq6rBlyxZMmjQJw4cPZ3uVEUIkBxXMJEh+fj4MDAy4jkFInyYlJQU/Pz+cPn0ajx494joOETN1dXWYN28erly5gkuXLsHLy4vrSKSPooIZIYC+vj4CAgIQHh6OoqIi2NjYYMuWLWhoaOA6GiEvFRISgpEjR+LIkSM4ePAgLl++jIEDB3IdixDSRVQwkyBUMCOkdyxcuBCmpqb4+uuvuY5CxEhFRQWmT5+O2NhYXL9+HW5ublxHIn2YhoYGKioquI5BiFiYOHEi7t+/j6+//hoHDx6EpaUlrly5wnUsQtqorKzEmjVrMGPGDIwbNw7p6enUq4wQCUYFMwlCBTNCeoe0tDT8/PwQEBCA7OxsruMQMVBYWAhXV1dkZGQgPDwcjo6OXEcifZyqqioqKyu5jkGI2JCRkYGvry/S0tLg4uICDw8PeHh4ICsri+tohAAAgoKCYG1tjQsXLiAwMBCBgYHQ0dHhOhYh5A1QwUyCUMGMkN7j4+ODgQMHYs+ePVxHIRxLT0/H+PHjUVdXh+joaFhbW3MdifQDampqVDAjpB0GBgYICAjAjRs3kJWVBUtLS/j7+9MwTcKZiooKrFmzBjNnzoSjoyNSUlIwf/58rmMRQroBFcwkSEFBARXMCOklsrKy2Lx5M44dO4a8vDyu4xCOBAcHw9HREVpaWoiIiMCgQYO4jkT6CephRsjLTZ48GfHx8di5cyf27t0La2trXLt2jetYpJ+5evUqrK2tcfHiRfzxxx8IDAyEtrY217EIId2ECmYSQigUoqioiApmhPSiVatWQVtbG99++y3XUQgHjhw5grfeegszZsxAWFgY9PT0uI5E+hE1NTVUVVVxHYMQsSYrK8sO03RycsKsWbPg4eGBnJwcrqORPk7Uq2z27NlwcnJCcnIyPD09uY5FCOlmVDCTEMXFxeDz+VQwI6QXycvL48MPP8Thw4dRVFTEdRzSS5qamrBy5UqsXbsWn332GX777TcoKipyHYv0MzQkk5DOMzQ0REBAAP766y9kZGRg5MiR8Pf3R2NjI9fRSB906dIlWFpa4tKlS+x8ZVpaWlzHIoT0ACqYSYj8/HwAoIIZIb1s7dq1UFZWxvfff891FNILSkpK4O7ujsDAQJw/fx7+/v5cRyL9lJqaGurr69HU1MR1FEIkxpQpU/DgwQN89dVX+Pbbb2FtbY3g4GCuY5E+oqioCD4+PpgzZw5cXFyQnJyMuXPnch2LENKDqGAmIQoKCgAA+vr6HCchpH8ZMGAANm3ahB9//BFlZWVcxyE9KDExEWPHjkVubi5iYmKoEUw4paamBgA0LJOQLhIN03z48CEcHR0xY8YMeHh44OnTp1xHIxLszJkzsLKyQkREBEJCQhAYGAhNTU2uYxFCehgVzCREUVERFBQUoKqqynUUQvqdDRs2QFpaGv/973+5jkJ6yPHjx+Hk5ARTU1PExsbC0tKS60iknxMVzGhYJiGvx8jICAEBAQgNDcWTJ0/YYZrUa5N0RWFhIebPn48FCxbA09MTSUlJcHNz4zoWIaSXUMFMQpSWltLYeEI4oqqqin/84x/4/vvv6eC1j6mqqsKiRYuwatUqbNy4EcHBwbStJWJBdIKMtjmEvJmpU6fi/v372Lx5M3bv3o1Ro0bh+vXrXMciEuDMmTOwtLTE/fv3cf36dRw+fBgqKipcxyKE9CIqmEkIKpgRwq1NmzYBAA4ePMhxEtJd4uLiYGdnh+vXr+Py5cvYvXs3ZGRkuI5FCADqYUZId1JUVIS/vz+Sk5NhZmYGd3d3eHh4IDc3l+toRAwVFBTA09MTCxYsgJeXFxITEzF16lSuYxFCOEAFMwlBBTNCuKWuro5169bhm2++QU1NDddxyBtgGAb79u2Ds7MzjI2NkZCQgFmz0xSdcAAAIABJREFUZnEdi5BWaA4zQrrf0KFDcfnyZVy8eBHJycmwsrLCvn37wOfzuY5GxISoV1liYiL++usvHD58GMrKylzHIoRwhApmEqK0tBTa2tpcxyCkX/voo4/Q2NiIn376ieso5DWVlJRgzpw52Lx5Mz755BNcv34dhoaGXMcipA1ZWVkoKipSDzNCeoCHhwdSU1OxadMm+Pn5wd7eHrdv3+Y6FuFQfn4+5s6di3fffRfz589HYmIiXF1duY5FCOEYFcwkRElJCfUwI4Rj2traWLVqFb7++mvU19dzHYd0UWhoKMaMGYPExESEh4fD398f0tLSXMcipENqampUMCOkh7QcpmloaIgJEybAx8cHRUVFXEcjvYhhGBw5cgQWFhZITU1FWFgYDh8+DCUlJa6jEULEABXMJAQNySREPPj5+aGyshInTpzgOgrppOrqaqxZswbu7u5wdHREfHw8XFxcuI5FyCtRwYyQnmdmZoarV6/izz//REREBMzNzbFv3z4IBAKuo5Eelp2dDXd3d2zYsAHr1q1DUlISJk6cyHUsQogYoYKZhKCCGSHiQV9fH8uWLcOuXbvo0vQS4Pr167CyssKZM2dw6NAhnDlzBpqamlzHIqRTqGBGSO8RDdP09fWFn58fxo4di+joaK5jkR4g6lU2atQo5OfnIyoqCrt27YKCggLX0QghYoYKZmKosbGxzX1lZWU0hxkhYmLLli0oLCzEL7/80ur+69ev49NPP+UoFWmpqqoKa9aswfTp0zFq1CgkJydj9erVXMcipEvU1NRQUVGB8vJy5OXl4cmTJ4iLi8PTp0+5jkZInzRgwAD4+/sjKSkJurq6cHFxgY+PD4qLi7mORrpJVlYWpk2bhg0bNmD9+vWIi4vD2LFjuY5FCBFTPIZhGK5DkNYcHBxw7949DBgwAMrKylBWVoZAIIC+vj709fWhoqICJSUlqKqq4l//+hf1PCOEAytXrsTNmzfx8OFDBAcHw9/fH3FxcTA2NqaDWY5dv34dq1atQn19Pb755hv4+PhwHYmQV/rtt9+we/duVFdXo6GhAVVVVaivr293WNivv/6KhQsXcpCSkP7l0qVL2LBhA2pqarBt2zZs3LiR5r6UUAzD4KeffsJHH32EIUOG4Pjx47C3t+c6FiFEvDVRwUwM7dixA/7+/ujoTyMlJQWGYTBs2DCkp6f3cjpCCAA8evQII0eOxKBBg5CZmQkZGRnw+XzIysqioaEBUlLUgbe3lZaWws/PD8ePH4e3tzf2798PHR0drmMR0ilZWVkYOnRoh/t+EWlpaRQXF0NDQ6OXkhHSv9XW1mLPnj3YuXMnrKyscODAATg4OHAdi3RBRkYGVq5ciaioKHz44YfYsWMH5OTkuI5FCBF/TXREJ4Zmz5790gazUCiEtLQ0NmzY0IupCCHA39+/S5cu4e2334ZAIEBOTg4AgM/nAwCam5tRWFjIZcR+RygU4ujRozA3N8e1a9cQGBiI33//nYplRKIMGTIErq6ukJGR6XAZHo8HJycnKpYR0ouUlJTg7++PxMREaGpqwtnZGT4+PigpKXnl7wqFwl5I2H/FxMS88pjpyJEjsLGxQUVFBWJiYrBr1y4qlhFCOo0KZmLI1tb2lQd6UlJSWLJkSS8lIoQ0NzfjxIkTGDp0KObOnYu0tDQAaHe41LNnz3o7Xr+VkJCACRMmYN26dVi0aBEePnyI+fPncx2LkNeyfv36l16ZT0ZGBm+//XYvJiKEiJibm+P69es4ffo0QkJC2KtpvqwotmPHDhw7dqwXU/YfDx8+xLRp03D06NF2H09JSYGTkxM2btyIjRs34u7du7C1te3llIQQSUcFMzHE4/Ewd+7cDs9+yMnJYfHixXSGmZBeVF5ejj179iA7OxsMw3R4UMvj8WgOs15QUVEBX19f2Nvbo7m5GdHR0di3bx9UVVW5jkbIa5s7d+5LL/DT3NyMt956qxcTEUJe5O3tjfT0dCxevBibN2+Gg4MD7t6922a5jIwMfPXVV1i3bh1iYmI4SNp31dbWYt68eairq8OmTZtanajk8/nYvXs37OzswOPxkJCQgF27dkFWVpbDxIQQSUUFMzE1e/ZsNDc3t/tYU1MT1q5d28uJCOnfdHV1cfPmTVhYWLy00SUrK0sFs9eUnZ39ymUYhkFAQAAsLCzwyy+/4Ntvv0VMTAxN3Ev6BBkZGbz//vsdbmNMTU0xbNiwXk5FCHmRmpoa9u3bh3v37kFeXh6Ojo7w8fFBaWkpu8zGjRsB/D0s8K233kJubi5XcfucdevWITMzEwzDoLm5GUuXLgXDMEhOToazszP8/f2xfft23L59GyNHjuQ6LiFEglHBTEy5ubm1O48Jj8eDpaUlXf6YEA7o6OggIiICZmZmLy2a0ZDMrjtx4gTGjRuHmpqaDpeJjY3FxIkTsXz5cri7uyM9PR2+vr50gQXSp6xatYqdE7ElOTk5eHl5cZCIENIRGxsbREZG4sSJEwgODoaVlRUCAgJw/vx5BAUFobm5GQKBAFVVVZg5cyZqa2u5jizxjhw5gl9++aXV3LHh4eFYunQp7OzsICcnhwcPHsDPz4+uaEoIeWN0lCGmlJSUMHHixDYHglJSUvD19eUoFSFER0cHN2/exLBhw9otmjU3N7MXAiCd87///Q+rVq1CSUkJDhw40ObxJ0+eYP78+XB0dISsrCzu3buHgICAlw5dI0RSDRkyBFOnTm1z0qypqQkeHh4cpSKEdITH48HHxwdpaWnw9PTE8uXLsWLFilbFmubmZnYY56uuhEs6lpiYiA8++KDNe8gwDM6cOYNPP/0UERERGD58OEcJCSF9DRXMxNicOXPaFMzk5OTw7rvvcpSIEAL8XTS7desWRowY0aZoxjAMMjMzOUomef744w/4+PiAYRgwDIOdO3eyvczKysqwZcsWWFlZITk5GYGBgbhx4wbGjBnDcWpCeta6devazJOoqqoKJycnjhIRQl5FQ0MDBw4cwLJly1BTU9PmO9zc3IyLFy9ix44dHCWUbNXV1Zg3b16HF1kQCASIjo6mXueEkG5FWxQx5uHh0WpYhqysLJYvXw4VFRUOUxFCgL8bxuHh4Rg5cmSbohkNyeyca9euYcGCBWyxDABqamqwf/9+HDlyBObm5jh69Ch2796N5ORkeHt7c5yYkN4xZ86cVj0oZWRk4OHh0e5UDYQQ8fHkyROcOnWq3WHVwN/zmW3fvh2nT5/u5WSSjWEY+Pj4IDc3t8P3trm5GSEhIfjll196OR0hpC/jMdQvWKyZmZkhIyOD/TkxMRHW1tYcJiKEtFRRUQFXV1ekpKSwF+rg8Xioq6uDwv9j77zjorrS//8ZurQZei8iTaoKESyAoKJJDIlYQjRR1xiNMW2TTdnvbhJTNtkkJsbVjbGkN6NGLNEoAnaQJh1p0uvQZmAoAzNzfn/4u3dnYFBAhgE879frvmbuncs9z+He+5znfE7T01OzdeOXuLg4LFu2DFKpdEBrsY6ODrS0tPDXv/4Vb7zxBm0koNyX/OMf/8Cnn36Kvr4+cDgcHDp0CKtXr1a3WRQK5Q4sWbIEFy5cGHThLuB2jKCtrY2rV6/SOYmHyM6dO/G3v/1t0N5lDBwOB0ZGRigqKoK1tfUYWUehUCYxvbSH2Thn+fLl0NHRgYaGBoKCgqhYRqGMM3g8Hi5cuABvb2+2pxkhhK6GdQfi4+MHFcuA28MqXnnlFXzwwQdULKPct8hP/q+hoYElS5ao2SIKhXInfv/9d8TFxd1RLANuxwhSqRRRUVFoaGgYI+smLsnJyXjttdfuKpZpaWlBQ0MD7e3t+Ne//jVG1lEolMkOFczGOQ8//DB6e3tBCGGXp6ZQKOMLHo+HhIQEeHl5sZP8VlVVqdmq8cm1a9cQFRU1qFgG3BbM9uzZc8cVMymUyQ4z+T8AhISEgMvlqtkiCoVyJwoLC+Hr68vGAVpaWoMOo5ZKpWhpaUFUVBTEYvFYmjmhaG1tHXQ6Bvn/r6mpKR599FF8+eWXyMvLw+7du8fSTAqFMomhQzLHiJ6eHnR3d6OzsxO9vb1ob2+HVCpll5ruT19fHzth6F/+8hdoaGjgwIED0NbWhomJyYDzNTQ02GBaT08PU6ZMgYGBAXR0dGBsbEyXVaZQRhGZTAahUAgA7Lvc1dWFpqYmPPvssyguLsZrr72GyMhIpX/f1tY26LW1tLQG7VXF4XDA4/HYfUNDQ2hra7PvvKamJoyNje8hZ6olOTkZCxcuRG9v74DJkPujpaWFf//733j11VfHyDoKZfTp6OiARCJhy34mFgBur3rZ2dmp9O+Y81JTU7Fjxw6sX78eDz/8MADF8r4/2traMDQ0HHAeEzfQeIBCUT1isRiZmZlIS0tDWloakpKSUFZWBkIIdHR02PgfuP2erlmzBj/++OOI0pL3KUw8IpFI0NHRwZ5zJ1/DcKe4hIHH44HD4Qz6u76+PnR1ddl9JkZRVkcZCjKZDEuXLkV8fDwIIazvkkqlMDMzw+LFixEREYEFCxbAzc1tSNekUCiUYdJLBbMh0NnZiYaGBvD5fLS2tkIgEEAoFCp8trW1KRwTi8UQCoWs8DUeMDExYSvU+vr64HK54PF4Az7lN3Nzc1hZWcHCwgI6OjrqzgKFMmwkEglaW1vZrb29HR0dHRAIBOjs7ERnZ6fSfaFQCJFIBLFYzFZ2hxJ0jheYwJYRzg0NDWFoaAgDAwPweLy77nO5XJiamsLMzExBpBspaWlpCA8PR09Pz13FMgZTU1NUV1dDX1//ntOnUIZCR0cHWlpa0NTUBKFQiLa2NnR0dEAkEqGjo4P1FfLH2tvbIRQKIZVKIRAIAABCofCuw4fUCVORZSq4hoaGMDIygqGhIYyNjVmfwBzjcrngcrkwNDQEj8eDmZkZu9EV6SiUwREIBBAIBKipqUFaWhqys7NRUFCAoqIihQbz0NBQeHp6orOzE2KxGAKBAN3d3ejp6WHFLJFIhL6+PoVGu4kMl8uFhoaGQkOhiYkJdHV1oa+vj7q6OhQUFAC4LbS5uLjAw8MDPj4+cHJyYusz8nELj8dT2rGAQqFQRsj9LZg1NTWhuroaNTU1qKysBJ/PR319PZqamsDn89HY2IjGxkZ0dXUp/J2Ojs4AkcnExEThmJ6eHoyNjdnWXqZFhQlOjYyM2G7ETIEhj3xPkp9++gmzZ8+Gu7v7gFYjBrFYzNrJFLBMwcq0OLW1tbGFbFdX1wDRj/lktv6PhomJCSueWVlZwdraGhYWFrCzs4O9vT0cHBzg5OQEAwODUbtHFEp/WltbWQG7rq4OfD4fLS0tCqIYs9/S0qK0BydwW1AyMDCAgYEBjIyMwOVy2X1jY2MYGxvDwMAAU6ZMYd/f/kEdMLCXF3C7lffixYtYv3690rTl3//+MO+vMvoLdvK928RiMSvQE0LYijtzTnt7OysICoVCdHR0sPsCgQAikYjd74+GhgbMzMxgamqqdDMzM4OdnR0sLCxgbW0NGxsbBZErMzMTYWFh6OzsHCAiaGhoQFtbGxKJRKHF3crKCtOmTcOHH36IkJAQpf8PCuVuCIVC1NXVoaGhAXV1dWhsbERzczOam5vR0tIyYOvt7R1wDUY0YsQkLpercIzH47E9txihmnnHGcGa8SM6OjpsGdm/x6g88r7ml19+wZo1a9jf5Mv7/jC+AAAbL8hXrpmKN+MX5OMERgAUiURoa2tT2GdEQWUiIOMDlG3W1tasT7CxsYGlpSXt4UaZcHR2dqK5uXmA/5BvLB8snh4MY2NjdoEbmUwGsVgMNzc32NraQldXFyYmJmxcwdQT5HtwMb5G3qco69HFcDcRifFVgzGUDgD96w6Mz5CvuzANkMD//BHj05jYpbu7G3V1dUhNTWVjNalUCrFYzPokpmPCYCjrECD/aWJiAnNzc5ibm8PMzAyWlpawsLBge+hSKBTK/2dyC2Z8Ph/FxcUoLi5GZWUlKisrUVNTg+rqalRVVSlUSi0tLWFlZcVu8vvyApGpqemY93aQSCRqWUpeKBSCz+eDz+ejqamJFSmY742NjWhqakJNTY1CIWpiYgIHBwc4OjrCwcEBDg4OmDZtGtzc3ODm5kYLI4pShEIhqqqq2He1sbGRreDKi2PyFVotLS1YWlqyYo68qDPYd6aXBGVwmEoAIyLIi5H9RcnW1la2AiGPoaEhbGxsYGhoiPz8fIX7xuFwYGJigmnTpsHT0xPOzs4Km4ODA7uAAoWiDJlMhvr6epSXl6OiogJVVVVoaGhAfX29wsYMVQJuD1e0srJiK0lMRUnZZm5uTnsqKKGrqwsCgUBBZGxqalIqPra0tKC+vl4hPtDU1ISlpSWsra1ha2sLa2tr2NnZwdbWFk5OTqwPoCsMU1SJTCZjG8lra2sHiOnNzc3g8/ns9/6NWHp6ejA3N1doLB9sxEb/BnVDQ0Paa3oU6erqYhv+lI36GUzIbGtrQ0tLi0IZAfzv3sqLaMy+lZUVbG1tYWdnBxsbG1hZWdEethTK5GfiC2ZdXV3Iz89nhbGSkhJ2Y1oe9PX1MXXqVDg6OsLe3h729vZwcnKCg4MD7O3t4ejoSIOze6StrY3tqcf02mOESeaTWe3L1taWFc+YzcvLC66urrTleRLD5/NRWlrKVm6Z54LZl+8JZmpqylamrK2tYWlpCVtbW7aixfRUsLCwuON8GpSxo7e3F01NTaivr2fF9YqKCpw6dQo9PT2QSCTo6ekZUPmwsbFhBXZmYyrObm5utMfqfUxzczOKi4tRVlaGiooKVFZWoqKigvUZjAiro6PDii79hRgrKyvY2dmxjWCUsaezsxO1tbVobGxkP+vq6hSEzZqaGoXeIjY2NgoCmrOzM5ycnODm5gZnZ2caK1AGpaurS0FEr6mpGfDZ2NjIxqTA7d5eNjY2CmK6paWlwr78MdroNnno33uwpaWFFUr7H6uvr1fwU1paWmwZY21tDXt7e4VPR0dHODs70ziGQpnYTCzBrK6uDhkZGSgoKEB+fj4yMjJQVFQEqVQKbW1tODg4wMXFBS4uLvDy8oK3tzdcXFzg7OxMWwDUTF9fH6qrq1FWVsZu+fn5KCgoQGVlJXsP3dzcEBAQAG9vb3h5eSEwMBA2NjbqNp8yRNra2hTuMXOf8/Ly2CBDW1sb5ubmsLW1Zd9XGxsbdt/V1ZWuBjfJaWtrYyvMzHMiv19RUcEO/TIxMVHq1z08PGilZRIgXzYwZQLzvb6+HgDY8l3eT8hvTk5OVECZBHR3dyv4hP4bM3xLPt6T9wk+Pj6wtrZWcy4oqkYsFqO2tlbh2Ris/NDT04OJiQlsbW1Z/yHvR2xsbGBnZzcq83RS7g96enrQ2tqK+vp6heeO+V5XV4fa2loFYY2JY5SVYTTmpVDGPeNXMKuurkZKSgqSk5ORkpKC7OxsiEQiaGhowMXFBf7+/vD19YWvry/8/PwwdepUGjBPUHp6elBQUIDc3Fzk5uYiJycHOTk5aGxsBABYW1sjMDAQQUFBCA4OxuzZs8f1SoD3A21tbcjNzUVeXh5ycnKQm5uLmzdvshUaXV1duLi4wN3dHa6urgq9Ce3s7KiATbkjYrEY5eXlCj2GS0tLUVJSgurqashkMnA4HDg4OMDLywt+fn7w8fGBr68vvLy86AIl45Tq6mpkZWUhOzsb2dnZyMrKQkVFBSQSCTgcDpycnODu7g4PDw94enrC3d0d7u7usLe3pz6DAoFAgJKSEhQVFaGwsBDFxcUoKipCcXEx22vVwsICvr6+8Pf3x4wZM+Dv7w8vLy86xHuC0dvby95r5j4XFhairKwMfD6fPc/U1JTtfdh/aL+joyMVwihqg5lmpKKiAuXl5WwPaeazpaWFPdfCwgIuLi7w9PSEh4cHWw66ubkprDpKoVDUwvgQzCQSCVJSUpCUlITr168jJSUFtbW10NLSgre3N+bMmYOAgAA28KFdW+8P+Hw+K56lpqbi+vXrqKyshIaGBqZPn84KaCEhIfD09FS3uZMSQgiKioqQkZHBipl5eXmorq4GcHtSVV9fX/j4+MDHxwdubm5wdXWFo6MjFbApKkEsFrPiWXFxMfLy8pCXl8fOk6alpQV3d3e2McXX1xcPPPAA7XkyhjB+IzU1lRXHMjMz0draCg6Hg6lTp7JixvTp01lhjFk0g0IZDjKZDFVVVayokpubi6ysLOTn56Onpwc6Ojrw9vaGv78//P39ERAQgICAADqP1DhAIBAgJycHN2/eRHFxMftZUVEBqVQKDQ0NODo6KggI8qIYszAGhTLREIlE7BQDFRUVKC0tZRsCKisrIZPJoKmpyTYkMWKap6cn/P396fyaFMrYoT7BrKysDPHx8YiPj8f58+chEAjYnkRMMBMSEkJbhygKNDQ0IC0tDRkZGcjIyMDVq1chEAhgZWWF0NBQLFq0CEuWLIGTk5O6TZ2Q9P//Jicno6WlBVpaWnB0dISXl5fCkFkvLy86hxhlXCCRSFBVVcUO12eG7hcWFkImk8HGxoYtW2j5Mrp0dnYiMzMTGRkZuHbtGi5cuIDm5malw+znzJkDc3NzdZtMuQ/o7xMyMjKQnp6OhoYGVlifP38+5s2bxz6jFNXBTKsi759v3rwJQgi4XC5cXV0HDL/39PSkjeSU+47e3l7U1NQoTFNQVlaGvLw8NDQ0ALg9zyNTrjJxjaenJ22splBGn7ETzIRCIf744w+cOnUKiYmJaGpqgpmZGcLDw7Fw4UJERETA3d19LEyhTCIkEgnS0tKQkJCAhIQEJCcnQywWw9PTE4sXL8ajjz6KsLAwtawyOhHIz89HYmIirly5gpSUFFRVVYHD4cDDwwOzZ89mN39/fzrMjTIhEQgESEtLQ2pqKrs1NDRAU1MT3t7eCA4OxoIFCxAREUEnhR8iQqEQiYmJSEhIwNWrV5GXlwepVApHR0fMnTsXc+bMwZw5czBjxgw6FI4y7qisrERSUhKSk5ORnJyMrKwsSCQS2NraYu7cuQgPD0dkZCRcXV3VbeqEpaioCNevX8f169eRlZWFvLw8iEQiaGpqws3Nje3t5+/vDz8/P9jb26vbZAplQlBXV4fs7Gzk5OQgKysLOTk5KC4uhkQigYGBAby9vTFz5kwEBwcjODgYHh4etGGbQrk3VCuYNTU14fjx44iNjUVCQgIIIViwYAEiIyMRERGBGTNm0HlJKKNKV1cXrl69ioSEBJw9exY5OTkwMzNDVFQUoqOjsWjRovt6RdSKigokJCQgMTERiYmJaGhoAI/HQ0hICIKCgliBjE5ASpnMVFVVISUlBampqUhOTkZqaiokEgm8vb0RERGBiIgILFiwgL4H/x+pVIr09HTExcUhLi4O169fh0wmw6xZsxASEsKKZHZ2duo2lUIZNl1dXUhPT8e1a9eQlJSES5cuoaOjAy4uLoiMjGRjVuoPlCMSidj/HyOSNTc3Q09PDwEBAZg5cyYrjvn4+NCh1xTKKNPT04P8/HxWQMvMzER6ejq6u7thamqK4OBgtiFr9uzZdCgzhTI8Rl8w6+7uxpEjR/Dtt9/iypUr0NHRwdKlS7F8+XIsW7aMjrmmjCmlpaU4duwYjh07htTUVBgaGuLRRx/F008/jbCwsEnf6iKRSHDp0iXExsbizz//RFlZGfT19TFv3jxWGAgICKBduCn3NSKRCJcvX2aF5OzsbHA4HAQEBCAqKgrLly+Hl5eXus0cU7q7u3H27FkcPnwYcXFxaG1thb29PSsgLFy4kA6tpExK+vr6kJycjLi4OJw/fx4ZGRngcDgIDg5GdHQ0Vq1adV/3iOru7saVK1cQFxeHxMRE5ObmQiKRwN7enhXPg4ODMWvWLNoznUJRE319fcjMzMT169eRnJyMpKQkVFVVQVNTEz4+PoiIiEBkZCRCQ0PpfI4Uyp0ZPcEsKysLBw8exM8//4yuri488sgjeOKJJ7B06VI6/wBlXFBbW4vY2Fj8+OOPSE1NhZubGzZt2oT169dPqqFY3d3dOH/+PGJjY3Hq1Cm0tLTAz88PUVFRWLRoEYKDg+mqOxTKHWhpacHFixcRFxeHkydPoqGhAR4eHli+fDmio6MRGBg4KcX2np4enDt3DocPH8apU6fQ2dmJ0NBQPProo4iMjLzvREMKBbjtDxISEnDmzBmcOHECQqEQc+fOxapVq7By5cr7omdlbm4u28P0ypUr6O7uhpeXFxYvXoy5c+di7ty597WISKFMBGpra5GcnIxr164hPj4eeXl50NPTw/z589nGMD8/v0kZ31Ao98C9CWaEEBw/fhwfffQR0tLS4OHhgU2bNmHdunWwtLQcTUMplFElJycHBw4cwM8//wyRSITo6Gj885//hI+Pj7pNGzGXLl3C/v37ceLECXR3dyMoKIit4E+bNk3d5lEoExKZTIbk5GQcO3YMsbGxKC8vh4ODA9auXYtnnnkGLi4u6jbxnsnKysJ///tfHD58GCKRCPPmzcPq1auxcuVKuroohSJHb28v4uLicPjwYZw8eRIdHR0ICQnB1q1bER0dPWnm7JPJZLh69SoOHTqEEydOoK6uDmZmZli0aBFbsaYCGYUysamrq2OF8Pj4eDQ1NcHa2hpRUVGIiYlBWFgYnTqJQhmpYEYIQWxsLN577z3k5uZi+fLlePHFFxESEkJVacqEoqenB0eOHMGOHTuQl5eH6OhovPXWW/Dz81O3aUOira0N33//Pfbv34+bN29i9uzZWL9+PR577DHY2tqq2zwKZdKRmZmJ33//Hd999x3q6+uxePFibNmyBY888siEWlxEIpEgNjYWu3fvxpUrV+Dl5YXNmzdj1apV1HdQKEOA6ZH5/fff4+TJk7CyssKWLVuwefPmCSs0p6en49ChQ/jtt99QU1MDPz8/rFq1CkuWLEFAQACtPFMokxSZTIbMzEzExcXhyJEjyMzMhK2tLVavXo2YmBj2GrkTAAAgAElEQVQEBQWp20QKRV0MXzC7ePEiXnrpJVZcePvtt+Hr66sqAymUMYHpLfnee+8hOzsbK1aswM6dO8dtC2phYSE++eQT/Prrr9DW1sbatWuxefNmzJw5U92mUSj3BRKJBKdPn8a+fftw7tw5WFtb49lnn8ULL7wAHo+nbvMGpbe3F19++SV27NiBhoYGPPLII3j++ecRERFBG7wolBFSVVWFvXv34uDBg2hvb0dMTAzeffddODs7q9u0u8Ln83HgwAF8//33KCkpgaurK2JiYhATEwNvb291m0ehUNRAUVERfv31Vxw6dAhFRUVwcXHB+vXrJ3SDAIUyQnpBhohQKCRbtmwhHA6HLFu2jOTm5g71T1XGt99+SwCQI0eOsMfS0tIIAPLOO++ozzDKHVF238YLMpmMxMbGEnd3d8Llcsm+ffuITCZTt1kspaWlJCYmhmhoaJDp06eTffv2kY6ODnWbdd8z3vxOd3c3ee2118jUqVOJpqYmAUCfExVSXl5O/u///o+YmJgQLpdL3nnnHSISidRtlgIymYwcOXKETJs2jUyZMoW8+uqrpLy8XN1m3RFl75Uq3rXxXCYNBxoTqZ/u7m7yzTffEHd3d6Knp0def/11IhAI1G2WUvLy8shTTz1FdHV1iampKXn55ZdJSkqKus0aFmPlI+5Hxtv/kcY16iMjI4O8+uqrxNzcnOjo6JA1a9aQ7OxsdZtFoYwV4iH1rY6Li4O3tzeOHTuGX375BadOnZrQcz0NxtWrV8HhcPDBBx+o2xSKmuBwOHjssceQlZWFLVu2YNu2bVi0aBGqq6vValdXVxfeeOMNeHt7Izs7G7/++ivy8vKwefNmGBoaqtU2yvjjo48+wqeffory8nJIpVKVp3e/+05nZ2f861//Qnl5Of72t7/hiy++gIeHB3755Rd1mwbg9jDS+fPn4/HHH8ecOXNQWFiIHTt2TIjeLxOByfr8T9Z8qRI9PT385S9/QV5eHj7++GN8/fXXcHV1xVdffQUyuovSj5iioiKsXr0afn5+7PyFNTU12LlzJ2bPnq1u8ygUpdC4Rn3MmjULO3bsQHV1Nfbt24f8/HzMmDED0dHRyM/PV7d5FIrKuatgtmvXLjz00EOYN28eCgoKEBMTMxZ2jZjAwEAQQrB9+3Z1m0KZwEyZMgUff/wxkpOT0djYiNmzZyM1NVUttqSkpGDmzJnYv38/duzYgZycHKxevZrOJTKOGG9+58SJE+ByuSgoKIBUKgUhhAqrYwCXy8U///lPFBcX4+GHH8aTTz6J6OhoNDc3q8UeQgg+++wzBAcHQ0NDA6mpqfjxxx/h6OioFnsoY8948033C9ra2njxxRdRWlqK9evX44UXXsCyZcvQ1NSkNptEIhFee+01+Pr6oqioCEeOHEF2djaefvppTJkyRW12UcYn48130LhG/ejp6WHDhg3IzMzE8ePHUVFRgRkzZuDll19Ge3u7us2jUFTGHWvcn376Kf7617/iww8/xKFDh2Bubj5WdlEo44LAwEAkJycjICAAixYtQkpKypim/+OPPyIsLAxTp05FXl4enn/++Qk1sThFPdTU1MDDwwPTp0+nwqoasLS0xL59+5CQkIAbN25g9uzZY94KK5FIsGnTJrz55pt49913cenSJQQEBIypDRTK/Q6Px8OOHTtw+fJl3Lx5E3PmzEFpaemY25GZmYnAwEB888032LVrF27cuIHo6Gg6byFlwkDjmvEDh8NBVFQU0tPTsXfvXvzyyy+YNWuW2joWUCiqZlCPc/ToUbzxxhvYtWsXXn/99bG0aQACgQDPP/88bGxsMGXKFAQGBuKPP/5Qem56ejo4HI5Ci4hUKsXu3bsREBAAExMT8Hg8BAYG4vPPP0dXVxcA4IMPPkBISAgA4K233gKHw2E3hsuXL2Pt2rVwdXWFrq4uLCws8Mgjj+DatWsKNpw9exYcDgdffPEFrl+/jgULFsDAwABmZmZYv349WltbB9hNCMF3332H0NBQ8Hg8GBkZ4YEHHsCBAwcgkUgUzvvmm28wd+5cGBkZYcqUKfD398d///vfYXf3H4md3d3dePfddzF9+nTo6emBy+Vi4cKFOHfu3IBzh3PfRjtvo4mRkRFiY2MRFhaGZcuWoaamZkzS/f7777F+/Xps2bIFZ86cgZ2d3ZikOxTkn50LFy5g7ty5MDAwgIODA/7973+z5+3evRseHh7Q09ODp6cnjhw5MuBaQ3mvZDIZHnzwQWhoaOD06dMKf8/n82Fvbw8LC4thDZ2Vz8OlS5cQFhYGIyMjBAYGDss2YOR+h2G0nv2XX34ZHA4HLS0tSE1NZX3Ys88+O6K0hpL/u/nOgwcPgsPh4OjRowPsZX47fvw4e+xu92W8+gllhIeHIyMjA05OTpg3bx6ys7PHJF1CCJ5++mn89ttvOH78ON58881xVcEY6ns12gy3TBqN53+o11FVPmhMND6YM2cOrl+/DlNTUyxYsGBMp3k4ffo05s+fDxsbG+Tk5GDr1q3Q1NQcs/RHgjp8BI1raFzDQOOaoaGhoYFNmzYhPz8fHh4eCAkJUfo/oVAmPMpmNmtsbCRcLpc899xzKpg3bXh0d3eTGTNmEAAKG4fDIY8//viQJrh97bXXBvw9s+3evZsQQsj7778/6DmEEFJfXz/o71paWuTSpUtsen/++ScBQNasWUN0dXUHnB8aGqqQR5lMxuZF2Xb+/Hn2vLVr1w563jPPPDOs/+1w7RSLxWTevHlK0+ZwOGTv3r0jvm+jnTdVIBKJyPTp08nixYtVntaFCxeIpqYm2b59u8rTGgnMs/P4448TLS2tAffr888/J6+//vqA4xoaGiQzM5O9znDeq5aWFuLk5ERMTExIWVkZIYQQiURCIiIiiIaGBjl37tyI8rBq1SqFPMycOXPYto3U7xAyus/+Sy+9pPQaW7ZsGXZaQ83/3XzngQMHBrzvDMxvsbGxQ7ovE8FPKKOrq4uEhoYSR0fHMZkAfOfOnURbW5ucPXtW5WkNl3t9r0Y6EfVwy6TRev6Hk19V5IPGROMLgUBAfHx8SEBAAOnr61N5eomJiURbW5s8/fTTRCKRqDy90UBdPoLGNTSuoXHNyJFKpeT5558nmpqa5M8//1S3ORTKaCJWKpi9+uqrxNbWlnR2do61QQP45JNPCADi4eFB4uPjSUdHBykrKyPPPfcc60zuFhy6ubkRAwMD8vvvvxOBQEA6OztJVlYW+dvf/ka+/fZb9rwrV64QAOT9998fYEdDQwNZvHgxOXXqFKmuria9vb2ksbGRHD58mBgYGJAHH3yQPZdxjADIs88+S0pKSkhXVxe5evUqcXR0JABIVlYWe/7BgwcJAGJmZka++uorUlVVRUQiEUlLSyObNm0iFy9eJIQQ8sMPPxAAxNfXl5w5c4a0tLQQkUhELl26RPz9/QkAkpSUNOT/7XDt/OyzzwgA4ujoSE6dOkWEQiGpqqoi27dvJxoaGkRPT4/U19eP6L6Ndt5UBfOMJCYmqiyNvr4+4urqSpYvX66yNO4V+Wfn5ZdfJhUVFUQkEpGjR48SbW1twuVyiZGRETl48CDh8/mkpaWFvPrqqwQAWbduHXud4bxXhNx+v3V1dcmsWbNIT08P+fvf/04AkPfee++e8rBx40ZSVFSkUKEYjm334ndU8exzuVwSFBQ04Phw0hpO/u/kO0caWCq7LxPFTyijpaWFWFtbq7whqr6+nhgaGpJ3331XpemMlHt9r0ZaGR5umTRaz/9wfdxo54PGROPPHxQVFRE9PT0FgUEVCAQCYmNjQ1atWjWuVvu+G+ryETSuoXENjWvunXXr1hFzc3PS1NSkblMolNFioGAmlUqJjY2NUgehDoKCggiHwyF5eXkDflu4cOGQgsPw8HDi5uZ219a8OzlHQghJT08nq1atIra2tgNan+zt7dnzGMcYGRk54Bp79uwhAMj333/PHgsJCSHA/1pNByM8PJxoamqSurq6Ab/l5+cTAOSNN9644zXkGa6dwcHBBABJTk4ecP7mzZsJALJv3z5CyPDv22jnTZUEBweTjRs3quz6x48fJxoaGqS8vFxladwrzLOzdOnSAb+tWLGCACCfffaZwnGJREK4XC4JDAxUOD7U94rhq6++IgBISEgI4XA45MEHHxxRZYDJQ3Bw8KB/P1Tb7sXvqOLZHyywHG5aQ82/KgJLZfdlIvkJZezdu5fo6+urtJfZJ598QkxNTUl3d7fK0rhX7uW9GmlleLhl0nDsHK3YQRX5oDHR+PQHzz33HPHy8lJpGp9++inhcrmkra1NpemoAnX4CBrX0LiGxjX3jkgkIhYWFuO20Y5CGQHiAbOH19fXo76+HuHh4f1/UgulpaWws7ODt7f3gN+WLl2KhISEu15j586dWLFiBVxdXbFkyRL4+/tjzpw5mDlz5pDtSEpKQnh4OHp7e5X+3t3dPeDYggULBhxzcXEBAHR0dLDHCgsLYWJigkWLFt3Rhvz8fEilUjg4OAAACCHs2Hbms6qq6u6ZGaGdpaWlMDMzQ3Bw8IDzly1bhv3797OT2Q73vqkqb6ogIiJiwHwTo8mVK1cQEBAAZ2dnlaUxWoSFhQ045uTkBAAIDQ1VOK6pqQk7Ozs0Njayx0byXm3ZsgXx8fE4evQo7Ozs8NNPP93TxMWLFi1S+vcjsU2eofqdsXz2h5PWveb/XlF2XyaSn1DGihUrsHXrVmRkZCAiIkIlaVy7dg2RkZHQ09NTyfXvFXU9V8Mtk0bLztHOL42J/sdE9gdRUVH48ssv0dbWBhMTE5Wkcf78eURHR4PH46nk+qpC3WUPjWsGh8Y198ZkjGv6Y2BggMcffxxxcXF4++231W0OhTIqDJgFWCgUAgC4XO6YG6Mq/P39UVhYiB9++AFTp07FlStXsHTpUnh7eyM3N3dI1/j3v/+N3t5evPPOOygtLUV3dzdkMhkIIfDw8FD6N8qW6WYcJRnBJI4ymQzA7Uk3pVIpm778tQYrBO7EcOxU1YpKqsqbKuDxeOx7ogpaW1snzIq0yirlzDMy2G/MvQZG9l41NjYiKSkJANDS0oLKysp7yoOZmZnS4yOxTZ6h+p2xfPaHk9a95p+BmWxe/r4z3Ck4VXZfJpKfUIapqSk0NDTQ0tKisjTa2toGfabHA6P1XKma0bJzPOaXxkTqhynjlS14MFrw+XxYW1ur7PqqQt3vDI1rBofGNbehcc2dsbGxAZ/PV7cZFMqoMUAws7W1BYfDQUVFhRrMGYirqytqa2uRn58/4LezZ88O+TpaWloIDQ3Fm2++iV9//RXl5eVob2/H008/zZ7DOED5FZgYysrKYGVlhe3bt2PatGnQ09MDh8PBrVu3UFJSMoKc/Q9PT0+0tbXdtWXY09MT+vr6EAgErDPtv6lydRJXV1c0NzcrXTb4zJkz7DnM53Dum7rzNhzKy8tVumKlk5MTCgsLx/XKOKPFcN8rqVSKJ554Ag0NDfjyyy+hra2NlStXQiAQqN02ZQzF74zlsz+ctIaT/zv5TktLSwC335v+JCYmqsz+8UhhYSFkMhmmTp2qsjQcHR1RVFSksuvfK6osS+/EcMuk0Xr+Rzu/NCZSPG+i+oPCwkJoaWmpNJZwdXXFjRs3VHZ9VaEuHzFa0LiGxjWqsn+ikJGRAXd3d3WbQaGMGgMEMx6Ph4CAABw7dkwd9gxgxYoVIIRgxYoVSExMhEgkQnl5ObZt2zakoQcAMHfuXHz11VcoKChAd3c3hEIhzp49i5aWFpSVlbHnmZqaArg9JK5/DwBHR0fw+Xzs2bMHQqEQQqEQZ86cwUMPPaS0hWE4rF+/HgDwxBNP4MCBA6ipqUFnZycyMjKwefNmXLp0CQDw9NNPo6urC4sWLcIff/yBpqYm9Pb2orKyEqdPn8aKFSuG/D8ZCatWrQIAPP744zhz5gza29tRU1OD999/H/v374euri6ioqIADP++qTtvQ6W3txcnT56861CRe2HFihUoLy8fVuVnojLc9+qf//wnLly4gPfeew9bt27Ft99+i7KyMqxbt27UBcZ7feeH6nfG8tkfTlrDyf+dfKeXlxcA4IsvvsDFixfR3d2NiooKvPrqqwrLro+2/eORvXv3wtnZGbNmzVJZGlFRUbh48aLSQH48oMqy9E4Mt0wared/tPNLY6LxExPdC9988w2WLFmi0qHT69atQ1xcHNLS0lSWhipQl48YLWhcQ+MaVdk/EcjJycGJEyfw1FNPqdsUCmX0IEr4+uuviba2Nrl586ayn8eU0VhCXdky5sz24osvsudJJBJiZ2c34BxCbk/EruzvZ86cSXx8fIiZmRl7HWZyx507dw7ID/Ob/OpIUqmUrFy5clAb5ZdQ37Bhw6DnARjWUr7DtVMsFpO5c+cOmvbevXtHfN9GO2+q4osvviB6enqksrJSpemsXLmSuLi4kNbWVpWmM1Lu9Owwq0bl5uYO+M3b25vY2dmx+8N5r06ePEk4HA556KGHFCZNfeWVVwgA8tFHH41aHoZr2734HVU8+4NNjjuctIaT/zv5TkIIiY6OHvCblpYWeeqppwigfHJcZfdlovgJZVy6dIloamoqrCSmCnp7e4m3tzdZsmQJkUqlKk1rJNzrezXSCb2HWyaN1vM/nOuoIh80Jhp//uCnn34iGhoa5OrVqypNRyaTkcjISDJ16lSlE4qPV9TlI2hcQ+MaGtfcG3w+n3h4eJDQ0FCF1VkplAmOeEAPM+B2696MGTPwxBNPoKurS9kpY4aenh4uXLiA5557DlZWVtDT08PMmTMRGxuLpUuXDukaKSkp2LZtG7y8vDBlyhSYm5tj3rx5OHjwIHbu3Mmep6mpiaNHj2L+/PkwMDBQuMajjz6Kn3/+GX5+fpgyZQpsbGywZcsWJCQkQFdX957yqKGhgcOHD2P//v0IDg6GgYEBjI2NMXv2bBw8eJCdKJfD4eDbb7/Fb7/9hkWLFsHExAQ6OjpwcXHBY489htjYWJX2fNLR0UF8fDzeeecdeHh4QEdHB0ZGRggPD8eff/6JZ599lj13uPdN3XkbCtnZ2fj73/+O119/HY6OjipNa8+ePZBKpVi2bBna29tVmpY6Gep7VV5ejnXr1sHR0RE//vijwlx6H3/8MUJCQthW2rG2bTCG6nfG8tkfTlrDyf+dfCcAfP3119i4cSPMzMygp6eHOXPmID4+fsAEyqNp/3giKysLjz32GJYvX44NGzaoNC1tbW18/fXXuHTpEl5++eVxN7RblWXpnRhumTRaz/9o55fGROMnJhoJV69exTPPPIOXXnoJ8+bNU2laHA4HP/30E3R1dRESEoLi4mKVpjdaqMtHjBY0rqFxjarsH8+UlZUhNDQUEokEhw4dgqamprpNolBGDQ4ZJJouLy9HUFAQZsyYgZMnT47bFbcolLGgqKgICxYsgJeXF86dOwctrQELzKokzfDwcJiZmeHEiRPsamIUCmXicPz4cTz11FOYM2fOmJalR44cwZo1a/DUU0/hq6++go6OzpikS6FQlHP8+HGsXbsWS5cuxeHDh8esQtnU1IRHHnkE+fn5+M9//oMNGzaobAEnCoVy//HTTz/h+eefh4uLC06fPg0bGxt1m0ShjCa9SnuYAcDUqVNx7tw5ZGRkIDw8HA0NDWNpGIUybrh48SLmzZsHFxcXHD9+fEzEMgDw8PBAamoqtLW1MWPGDBw4cGDc9RahUCjK6ejowJYtWxAdHY01a9bg9OnTY9rwtGrVKpw8eRJHjx7F3Llzx/VCABTKZEYsFuOVV15BdHQ0nnrqKfz2229j2vvCwsICly9fxtatW7Fp0yaEhYUhKytrzNKnUCiTk9zcXCxcuBDr1q3D+vXrkZSURMUyyqRkUMEMAGbOnImUlBQIBAJ4eXlh//79Y2UXZYRkZWWBw+HcdXvsscfUbeq4p6enB9u3b0dkZCTCw8Nx/vx5GBkZjakN9vb2SElJwSuvvIKtW7ciKCiIXXqcMpDJ+vxP1nxNRgghOHLkCHx8fHDkyBH88MMP2LdvH7S1tcfclgcffBA5OTnQ0dGBr68vXnrpJZWsvKYuJst7MVnyQRnIqVOn4O3tjYMHD+Krr77CV199NWaNbvLo6Ojgk08+QVpaGmQyGWbNmoVHHnkE6enpY27LWDIZ3q3JkAdlTNZ83Q/k5+dj3bp1mDlzJgQCAa5evYpdu3bR0WiUScsdBTPg9rLUzMpEW7duxbJly1BTUzMWtlEoaiMpKQkzZ87Ezp07sWfPHhw+fBj6+vpqsUVbWxvbt29HWloa9PX1MX/+fDzyyCMTbuUrCmUyI5PJcOrUKQQGBiImJgZhYWEoLCzEk08+qVa7nJ2dcfnyZezZsweHDh3CtGnT8PHHH6O3t1etdlEok5m0tDSEhobi0UcfxaxZs5Cbm4vNmzer2yzMmjULV65cwbFjx1BbW4vZs2dj0aJFOH78OKRSqbrNo1Ao4xSZTIbTp09j6dKl8PX1RXZ2Ng4dOoS0tDTMnTtX3eZRKCpl0DnMlHHx4kVs2rQJzc3NePHFF/HXv/4VJiYmqrSPQhlT8vPz8cEHH+Dw4cNYunQp9u3bB3t7e3WbpcDJkyfx3nvv4caNGwgPD8eWLVvw2GOP0TmKKBQ10NTUhO+++w4HDhzArVu3sHr1arz11lvssvPjCYFAgA8//BD/+c9/YGtri+eeew4bN26Eqampuk2jUCY8MpkMZ86cwZ49exAXF4ewsDB89tlnmDVrlrpNUwohBOfOncN//vMfnDt3Dra2tli9ejWeeOIJBAYGqts8CoUyDsjKysKvv/6K3377DVVVVVi8eDFeeOEFPPzww3QuRMr9Qu+wBDMA6Orqwueff46dO3dCIpGwwhkNuCkTmdzcXHzwwQc4evQovLy88M4772DlypXqNmtQmEB37969OH36NMzMzLBhwwY888wzcHV1Vbd5FMqkhhCCixcvYv/+/YiNjcWUKVPw5JNPYtu2bfD09FS3eXelvLwcX3zxBb777jtIJBKsWbMGzz//PPz9/dVtGoUy4Whra8M333yDL7/8EuXl5Vi8eDFeeuklPPTQQ+o2bciUlJTghx9+wKFDh1BaWgpXV1c88cQTiImJGZfiP4VCUR1FRUU4dOgQDh06hMLCQkydOhUxMTFYt27dhIhxKJRRZviCGUNHRwf27NmDzz//HGKxGE8++SQ2bdo0blvSKJT+SCQS/PHHHzhw4ADOnj0LHx8fvP3221i+fDk0NO46WnncUFNTg6+//hoHDx5EbW0t5s+fj+joaCxfvhxOTk7qNo9CmRQQQpCamopjx47h999/x61btxAcHIwtW7Zg9erVahuyfS90dHTgxx9/xJ49e3Dz5k0EBQXh8ccfx6pVq8Zdz1oKZTzR09ODP//8E4cPH8bJkyehpaWF9evXY9u2bfDw8FC3efdEWloaDh06hMOHD6OmpgZeXl5YunQpIiMjERoaiilTpqjbRAqFMor09PTgypUriIuLw7lz55CbmwtbW1usWrUKMTExCAoKor3JKPczIxfMGEQiEQ4cOIADBw7g5s2bmDVrFp555hmsWbMGxsbGo2UohTJq3Lp1C19//TW+++47NDY2YvHixdi6dSuioqImdIEglUpx5swZHD58GH/88QcEAgECAgKwfPlyREdHY/r06eo2kUKZUEgkEly+fBnHjh3D8ePHUVtbi2nTpiE6OhpPPvkk/Pz81G3iqEAIQWJiIn788UecOHEC7e3tmDNnDlavXo2VK1fC1tZW3SZSKGpHLBbj3LlzrEjW2dmJkJAQxMTEYO3atWO+KJCqkclkuHr1Kk6cOIG4uDjk5eVBT08PISEhiIyMRGRkJHx9fSd03ESh3K/k5eUhLi4OcXFxuHz5Mrq7u+Hl5YXIyEhERUUhLCxsQnUeoFBUyL0LZvJcvXoVBw4cwJEjR8DhcPDQQw8hOjoaDz/8MBXPKGqlvLwcsbGxOHbsGJKSkmBra4uNGzdi48aNcHZ2Vrd5o05vby8uXLiA2NhYHD9+HI2NjXBzc8PChQsRERGBBQsWwMLCQt1mUijjjqKiIiQmJrJba2sr/Pz8sHz5cixfvnzSD1sUi8WIi4tjRQGRSIQHHniArSAHBwerZZU/CkUdlJWVIS4uDufPn0d8fDxEIhHmzZuH1atXY8WKFbCxsVG3iWNGXV0dzp07h7i4OMTHx6O5uRlWVlaYO3cu5s6di+DgYAQGBtKV8iiUcYZYLEZGRgauX7+OpKQkJCUlob6+Hqampli0aBFbvjs4OKjbVAplPDK6ghmDQCDAb7/9ht9//x0XL16EhoYGFi5ciOXLl+PRRx+lFXXKmJCfn8+KZJmZmTAxMcGyZcuwevVqPPjgg9DU1FS3iWOCTCZDUlIS/vzzTyQmJiI9PR1SqRR+fn6IiIhAREQEwsLCJl3rOIUyFKqqqhQEstraWhgZGSEsLAwRERGIiorCtGnT1G2mWujp6cG5c+dw5swZxMXFoaKiAsbGxoiIiMDixYuxePFiuLm5qdtMCmXUEAqFuHDhAtvz4tatWzA0NER4eDiWLFmCxx57DHZ2duo2U+3IZDLcuHEDiYmJSE5ORnJyMhobG6GtrY1Zs2YhODgYc+bMwdy5c2klnEIZY2pqatj38vr168jIyEBvby8sLS3ZdzMiIgIBAQH3TV2IQrkHVCOYydPW1ob4+HicOnUKsbGxEIlEcHFxwaJFi7Bo0SIsWbKE9j6jjAp8Ph+XLl1CfHw8W7kzNzfHgw8+iFWrVmHJkiV0JUkAnZ2dSE5ORnx8POLj45GZmQmZTAYXFxfMmzcPAQEBCAgIwOzZs+n/izKpEIlEyMrKQkZGBrsVFBRAS0sL/v7+bLkUGhpKn30llJWVsX7j/PnzEAgEsLa2RmBgIAICAjB//nzMnz+f9jChTBjq6upw7do1XL16FRkZGUhNTYVUKnxdCkUAACAASURBVMXMmTNZfxASEgJdXV11mzru6f+/TE9Ph1gsBo/Hg7e3NwICAuDt7Q0vLy8EBATQudAolHtEIpGgqKgIBQUFyM/PZ9+7hoYGaGpqwsPDgy2b582bBy8vLzqEmkIZPqoXzOTp7OzE+fPnkZCQgISEBNy8eRO6uroIDg5mKykBAQEwMDAYK5MoE5iGhgakpKTgwoULSEhIQF5eHrS1tREcHIyFCxciMjISQUFBdAz+XWhqasKVK1eQkpKC1NRUpKenQyQSQV9fnxXOHnjgAfj6+sLd3Z0Ox6JMCEQiEQoKCpCVlYXU1FSkpKTg5s2bkEqlsLW1xezZsxEUFITg4GAEBwdTkWeY9PX1ISUlBdeuXUNSUhKuX78OPp8PXV1dBAQEYM6cOQgODsaMGTMwbdo0GqRT1E5rayuysrKQnp6OpKQkJCcnKzyzwcHBmDdvHkJDQ2Fubq5ucyc8nZ2dyMjIQFZWFrKzs5GdnY38/Hz09PRAW1sbXl5e8PPzg7+/P3x8fODu7g4nJycas1Eo/ZDJZKiqqkJxcTHy8/ORnZ2NnJwc5Ofno7e3F7q6uvD29oa/vz/8/PwwY8YMBAYGwtDQUN2mUyiTgbEVzPpTV1fHimcJCQmoqamBlpYWfHx8EBwcjKCgIAQFBcHT05MG2/c5YrEYN27cQEpKClJSUnD9+nVUVFRAQ0MDvr6+WLhwIRYuXIjQ0FBaQNwjUqkUBQUFrMiQkpKCgoICSCQS6OrqwsvLCz4+PvDx8YGfnx98fHzoinoUtSGRSFBSUoLc3Fzk5uYiLy8Pubm5KC8vh0wmg6GhIWbNmsWWJ0FBQfR5VRElJSXsMJCkpCTk5+dDKpXCyMiIrRj7+/tjxowZ8PHxmZAri1LGPzKZDGVlZaxQw3xWV1cDAGxsbNjhgnPmzEFAQADtQTZGMD1icnJy2HuTk5OD+vp6AICuri7c3d3ZzcPDg91MTEzUbD2Folra2tpQXFyMoqIiFBUVobi4mN16enoAAFZWVqwoxghknp6e0NbWVrP1FMqkRb2CWX+qqqpw/fp1tpJ+48YNdHd3g8fjISAgAH5+fvD19YWfnx+8vLxod+5JSktLC7Kzs9kKMNOS0tvbC3Nzc4WKb1BQELhcrrpNnvT09PSgoKAAeXl5yMvLQ3Z2NvLy8lBXVwcAMDExgZeXF9zd3eHm5sZurq6utMcoZVRoampCSUkJiouLUVJSgtLSUhQXF+PmzZsQi8XQ1NSEq6srK+Iygq6LiwvtsaAmurq6kJeXp9DDJCcnBx0dHdDU1ISbmxvrN9zd3TF9+nS4u7vD1NRU3aZTJgC9vb0oLS1FYWEhW8m8efMm8vPzIRKJoKmpCXd3d1akZQTb+2mi/omCQCBgRYLBhAILCwu4ubnB2dkZTk5OcHZ2VvhORU/KeEcsFqOyshKVlZWoqKhARUUF+72kpAR8Ph/AbeHYzc0NHh4ebPno6elJy0cKRT2ML8GsP319fcjOzkZKSgoyMzPZ7qddXV1ssO3r6wt/f394eHjQCvoEo6mpia38FhQUICcnB7m5uawIY25uDn9/f/j6+iIwMBBBQUFwdXVVs9UUeVpbW5GTk4O8vDwUFBSgtLQUJSUlqKqqgkwmAwDY29vD1dWVFdGcnJzg6OgIR0dH2NjY0N6jFAC3K7/V1dWorq5GVVUVysrKUFJSwm4CgQDA7UBS/nny9vaGr68vvLy86LDKCQAhBLdu3WJ7lshXkLu7uwHcrhjL9yyZOnUqWzGmiwbdX3R3dw+oVBYWFqKoqAgVFRWQSqXQ0NCAo6Mj+7z4+PiwvRhpw+rEhhmKxviI0tJSVmioqKhAe3s7AIDD4cDa2hpTp05lBTQHBwfY29vD2toadnZ2sLKyohOcU1SGVCpFY2Mj6urqUF9fj7q6OlRVVbH+q7y8HPX19WCq3UZGRqzoO3XqVLi4uLACmbOzM23oo1DGD+NbMFOGVCrFrVu3kJOTwwosubm5bOAEAHZ2dgN6uUybNg0ODg60S/cYIpPJ0NDQgKqqKty6dYsVx5hNKBQCAPT09ODp6QlfX19WAPX19aWtwBMYsViMW7dusfeaEdJKSkpQV1fHvqs6Ojqwt7eHg4MDnJyc4OTkBAcHBzbQtbS0hKWlpZpzQ7lXent7wefzUV9fj9raWlRVVaGyspIVyCorK9HQ0MAGknp6enB2dh7gx93c3ODg4EADyUmI/BwtRUVFrChSXFyM2tpaVoDX19dnKxnyvUsYn2FlZUUXbJhANDY2gs/nK1QsGXGssrISjY2N7Lk8Hg+urq7w8PCAp6cnW7n08PCgYvl9Smtrq4KgWlFRgfLyclRUVKC6upptaAEATU1NWFpawtbWlt1sbGxgZ2cHGxsbWFtbw9LSEubm5lRopbB0d3ejubkZTU1NqK+vR0NDA2pra9l4hhHHGhsb2dgWALhcLhwcHNgGn/5llpmZmRpzRaFQhsHEE8wGo7e3F2VlZQqiDFNJr66uZitihoaGbO8WJsBmKuk2NjawsLCgk70OAYlEgqamJvD5fNTU1KC6uhqlpaXg8/lsRbi2tha9vb0AbgsjLi4uChVgphJMK8D3F319fWzLW2VlJaqqqtheRcx+R0cHe76WlhYsLS0VAlo7OzuFY2ZmZjA1NYWpqSmdx2GM6OrqQmtrK1pbW8Hn89HQ0AA+n4/a2lpWHGOONTU1KfytlZUV64MdHR3ZXofMvpWVlZpyRRmPML0P+1eMmU1ehAdu91CzsrJiBTQ7OztYW1uzFWQzMzN2oz1cRx+RSISWlha0tLSgvr4ejY2NqK2tRWNjI2pqathPPp/PxggAYGpqOmC4nfw+nX6BMly6u7tRW1s7QORoaGhATU0Ne1w+5gBuC/Pm5uawsrKCubk5u1lYWLCimrm5OUxMTMDlcsHj8ejolglAZ2cnhEIhBAIBBAIBmpub0dzczMYpzH5zczMaGxvR3NyMzs5OhWsYGhqyZQvTg1G+JyPzSefopFAmDZNHMLsTPT09KC8vZ3szMD0a5If/MHMkAIC2tjYsLCxgYWHBimgWFhawtraGqakpeDzegI3L5U7Y1QO7u7sVChDme1tbG5qamlhhrKGhgf3e3NyscA0ul4uOjg7Y2toiLCwMPj4+bK8hRpikXeEpQ0UgELAtdnV1dawA09jYqHCMz+ejvwszMjJixTNmkxfUjIyMYGJiAgMDAxgYGMDQ0BA8Hg+Ghobs/v1AW1sbOjs7IRKJ0NnZye53dnaio6ODFcMG2+R9JnBbFGda762srGBlZQVbW1tYWFiwAicTSNLeIJTRhBHhGVFGXpxhGnUY3yEPh8NhfYO8iCa/GRsbw9DQEEZGRjAyMmJ9hZGR0aStEEkkEnR0dEAgEKCjowMikQgdHR1ob2+HUCiEUChEbW0tOjs70dzcjNbWVlYga2lpgVgsVriegYGBgnipTMS0t7eHkZGRmnJMud/p7OxEfX29gmAiL5owGxMD9xfYgNuNe4x41r9+wHxyuVzo6+uDx+NhypQp0NPTA4/Hg56eHvT19WFsbAw9Pb37Jg4ZCp2dnejp6YFQKER3dzd6enrQ1taGnp4etv7S1dXF1l3kP9va2hT2+/r6Blzf0NAQlpaWbIcJZusvlpqbm8PW1pYKoxTK/cf9IZgNBT6fzw4NYIQhpvst872hoQFtbW3snAn9YSreXC4Xenp64HK50NDQgImJCTQ1NWFsbAwdHR0YGBhAT0+P7fKtoaGhtOXUwMBgwNCSzs5OhRZZ4PYwVXmb2tvbIZVK0dbWBplMxhYSIpEIYrEYXV1dEIlErEDWP7hlbOLxeKxYyFR2lQmJ9vb20NfXx++//45//OMfqKioQExMDN555x1MmzZt2PeCQhkqEokEfD7/jsJOS0uLwj5TEbyT62Naiw0MDGBkZKTwjjLvNfN+6ujoQF9fH5qamgPe48GGgGtpaSmtHBJCFIaQyMO8wwzy7z2TH8Y/MO85cw5zXUYc699iKo+Ojg4MDQ0HiI532szNzenwAsq4p6+vD42Njayw09zcrCD0ML5Cfr+9vR0SiUTp9Ri/wOVyYWhoCF1dXejr60NXV5ct47W1tWFoaMjGABwOBzweb8A1lGFkZKS0IU4oFLJDVOVhKpAMXV1dEIvF7HHGh/T3C8BtAZ0Rx+Sv0R+mcVAgEMDNzQ1+fn7s+69MeLS2tqaVf8qkQywWo7m5eYBAI9/4LN8ILX9OV1fXoOW8PLq6ujAwMGDjER0dHdaPAGAFN+B2zMLhcFh/A9yuk/Tvcc+cp4z+vqk/g/kdQHnsIh+zMLGJ/HlMnAL8r97S29vLNtr19PQoFSb7w4iP8qIk893ExETpcea7ubk5bcCjUCh3gwpmI0EmkyktEOW/9/T0KAhXTIDKFAZMIAuAPdYfZYUTE5D3R74QNDQ0ZO2ZPXs2eDweW4gyQbyRkZFCS1j/70yBPFz6+vrw66+/4v3330dlZSViYmKwfft2uLi4jOh6FIqqYIQjkUiktLeVvLgkH/i1tbUBADo6OiCRSFBfX4+ysjJMmzaNDf6AgQKXPEwrqTIGqyQDigKcfHBrbGwMTU1NNoCWD5qZv2GCbkNDQ6W96phed3T+JwpFEabi1tHRwfoGZl++Jxbzzvf19bFlPFMp7C9WMchXGoHbQrhEIoGuri7ra/rDiHL96S/EM+U901CnTLRjGgDke84ZGRnB2NgYXC6X3Tc0NGSFva6uLnzyySf46KOP4OPjgy+//BJBQUGj8r+mUO4XmDhAIBCgp6eH7SVVVlaGTz75BJWVlfjLX/6CqVOnsn5FPq5gjsmLUPKiOVMHYWB6jg5Gf1/UH3mBThn9BTr5xgD5v2V8jnycwsQejA9j6ivGxsbQ19dne+Ix1zExMVHoeEChUCgqhApm4534+HgsXrwYra2tw1qwoKCgADNmzMCuXbuwdetWFVqoHHnhrKqqChs2bMBbb70Fe3v7MbeFQlEVQqEQvr6+mDdvHn799Vd1m0OhUCY427dvx88//4ySkpIBv+3YsQNffPEFampq1GDZQIqKivD8888jMTERa9euxc6dO2lPUwrlHvjhhx+wbds2ODs74+eff4afn5+6TaJQKJT7nV460/o4h5n3S76VaCh4eXnhpZdewj/+8Y8BE26PBdra2li3bh0KCgpw4MABJCQkYNq0adiyZQtqa2vH3B4KRRW8/PLL6Onpwa5du9RtCoVCmQSkpqZi9uzZSn9zcnJCfX39gGkZ1IWHhwfi4uLw7bff4ty5c/Dw8MD+/fvvONydQqEMRCAQYM2aNdiwYQM2btyI9PR0KpZRKBTKOIEKZuOckQpmAPD2229DX18ff//730fbrCHDCGc3b97EgQMHEB8fDxcXFyqcUSY8p0+fxnfffYe9e/fC0tJS3eZQKJQJDiEEaWlpeOCBB5T+7uTkBJlMNq7KTg6Hg3Xr1qGoqAhr167Fc889hwULFiAvL0/dplEoE4KEhAT4+PjgwoULOHPmDHbt2qV0yDWFQqFQ1AMVzMY5jGA22KTDd8LIyAg7duzAN998g+Tk5NE2bVjIC2e7d+/GmTNnWOGsrq5OrbZRKMNFKBTi2WefxZNPPokVK1ao2xwKhTIJKCsrQ3Nz8x17mAFAZWXlWJo1JHg8Hnbt2oXU1FSIxWLMnDkTL7300pAm7aZQ7kfEYjHefPNNREZGIjg4GPn5+Vi6dKm6zaJQKBRKP6hgNs5hJv8eSQ8zAIiJiUF4eDi2bds24muMJjo6Oti8eTNu3bqF3bt34/Tp01Q4o0w4XnjhBUj/H3t3HhdV9f8P/DXsqwjIKrIqiKCsoSCYGRIupEWKZaJSqWmFZa5tZFlouWBaappK6SeVstRUEHcBHZBNUPZV0QEREJB97u8PfzNfDTTRmTnM8H4+HvOwZvCe15hxL68559yODlqKSQiRGD6fD1VVVbi5uXX5urGxMTQ1NXtkYSbi7u6OxMRE7NixA3v27MHgwYMRHR3NOhYhPcrVq1cxYsQI/Pjjj/jpp58QExMDAwMD1rEIIYR0gQqzHu5ZlmSK/PTTT7h69Sq2bNkiqVjPTFScFRUVYePGjQ8VZzdv3mQdj5BHOnz4MH799Vds3ryZLnAJIRKTnJyMoUOHPvLObzweDwMGDOjRhRlw/+54omWaEydOxKxZs/Diiy8iJyeHdTRCmOI4Dtu2bcNzzz0HdXV1pKamYs6cOaxjEUIIeQwqzHo4SRRm9vb2CA8Px4oVK3pcGfXv4uzIkSMYNGgQwsPDcevWLdbxCHlIdXU15syZg5kzZ+KVV15hHYcQokAet3+ZiJWVVY8vzEQMDQ2xdetWnD17FpWVlXB3d0dERASam5tZRyNE5gQCAYKCgrBgwQK8//77OH/+PAYOHMg6FiGEkP9AhVkP9yx7mD3oiy++gL6+Pj755BNJxJK4B4uzdevW4cCBAxg4cCAVZ6RHef/996GkpIT169ezjkIIUSAdHR1IS0tTqMJMxM/PD2lpafj222+xbt06ODs749ixY6xjESIzf/31F5ydnZGdnY0zZ84gMjISqqqqrGMRQgh5AlSY9XCiE2pbW9szHUdLSwtr1qzBrl27cO7cOUlEkwp1dXXMmTMHBQUFWLVq1UPFmUAgYB2P9GJ///03fv/9d/z888/Q19dnHYcQokCuXLmCxsbGR274LyKPhRlwfz/W8PBw5OTkwMfHB+PHj0dQUBDKyspYRyNEapqamhAeHo5XXnkF48aNw5UrVzBy5EjWsQghhHQDFWY9nOjW0i0tLc98rKlTp+Kll17Ce++998wz1qRNS0sL4eHhyM/Px6pVq7B//34qzggzt2/fxty5cxEWFobx48ezjkMIUTB8Ph/a2tpwdHR87NdZW1ujvLy8R9zE52mYm5sjOjoaJ0+eREFBARwdHREREYHW1lbW0QiRqOTkZLi6uiI6Ohp79+5FdHQ0dHR0WMcihBDSTVSY9XCSLMwAYOPGjcjLy+tRNwB4HG1tbYSHh6OgoABff/21uDhbtmwZ7ty5wzoe6SXmz58PFRUVfPfdd6yjEEIUUHJyMjw9PcV3xn6UgQMHoqWlBeXl5TJKJh1jxoxBWloaFi9ejNWrV2PYsGE4efIk61iEPDOhUIioqCj4+vpiwIAByMrKwuuvv846FiGEkKdEhVkPp6GhAQAS2yR30KBBWLhwIT755JMedwOAx/l3cbZr1y5YWVlh2bJlqKmpYR2PKLC//voLMTEx2L59Oy3FJIRIBZ/P/8/lmMD9czgA5OfnSzuS1GloaCAiIgJZWVmwtbXF2LFjERoaisrKStbRCHkqpaWleOGFF7B06VKsXLkScXFx6N+/P+tYhBBCngEVZj2cqDCT1AwzAPj888+hr6+PFStWSOyYsvJgcfbpp5/i559/puKMSI1oKeacOXMQGBjIOg4hRAHdu3cPV69e/c8N/4H7d540MDBQiMJMxM7ODkePHsXff/+Ns2fPwsHBAVFRUXK77JT0TgcOHICbmxtu376NixcvYunSpVBSoh+zCCFE3tF38h5OtCRTkrdh19LSwnfffYfdu3fj7NmzEjuuLOno6GDp0qUoLS3FJ598gm3btomLs9raWtbxiIJ49913oampSUsxCSFSc/nyZbS3tz9RYQbcX5apSIWZSFBQEK5du4bw8HAsWbIEXl5euHTpEutYhDxWXV0dZsyYgZCQEEyZMkW8dxkhhBDFQIVZD6eiogJlZWWJFmYAMGXKFAQGBsrFDQAeR1SclZWViYszS0tLKs7IM9u7dy/++OMPbNu2Dbq6uqzjEEIUFJ/Ph5GREaytrZ/o6wcNGoSCggLphmJES0sLERERyMzMhIGBAXx8fBAaGorq6mrW0QjpJCkpCe7u7jhx4gQOHz6MrVu3QktLi3UsQgghEkSFmRzQ0NCQ6JJMkaioKOTn5+PHH3+U+LFl7d8zzrZu3Qo7OztERESgrq6OdTwiZ6qqqrBw4UK8++67CAgIYB2HEKLAkpOTMXz48Cf+ekWdYfYgBwcHxMXFYefOnYiNjYWTkxOio6PBcRzraISgvb0dERER8PPzg4uLC7KysjBhwgTWsQghhEgBFWZyQENDQ+IzzID7n1J/9NFH+Oyzz+TqBgCPo6urK55xtmTJEkRFRVFxRrpt3rx50NbWRmRkJOsohBAFx+fzn3g5JnD/3F1cXCzXs8OfBI/HQ2hoKHJzcxESEoKwsDCMHj0aWVlZrKORXiwnJwfDhw/HmjVrsHbtWvz555/o168f61iEEEKkhAozOSCtwgwAPv30UxgYGGDZsmVSOT4rouKstLQUixcvfqg4u3v3Lut4pAeLjo7GX3/9hZ07d9JSTEKIVN2+fRvFxcVPdIdMkUGDBqG1tRVlZWVSTNZz9O3bF1FRUeDz+WhpaYG7uzvCw8NRX1/POhrpZaKjo+Hp6QllZWWkp6cjPDycdSRCCCFSRoWZHNDW1kZjY6NUjq2lpYXvv/8ev/76K86cOSOVMVjq06cPli5disLCQrz33nvYsGEDFWfkkSoqKvDhhx/ivffew+jRo1nHIYQoOD6fDx6P1+0ZZgAUflnmv7m7uyMxMRHbt2/Hnj17MHjwYERHR7OORXqBqqoqTJo0CWFhYXjvvfdw4cIF2Nvbs45FCCFEBqgwkwM6OjpSK8wAIDg4GAEBAQgPD1fYJR4GBgaIiIhAYWEhFixYgPXr18POzg6rV6/GvXv3WMcjPcSCBQugp6eHVatWsY5CCOkF+Hw+bG1tYWho+MS/R19fH4aGhr2uMAMAJSUl8TLNiRMnYtasWfD390dOTg7raERBxcXFwcXFBRkZGTh16hQiIyOhpqbGOhYhhBAZocJMDujo6KChoUGqY/zwww/Izc1FVFSUVMdhzdDQ8KHi7JtvvoG1tTVWr16NpqYm1vEIQzt37sShQ4ewa9cu6OjosI5DCOkFkpOTu7UcU8Te3h65ublSSCQfDA0NsXXrVpw5cwYCgQDu7u6IiIiQ2vYVpPdpbm5GeHg4AgMD4evri7S0NIwaNYp1LEIIITJGhZkckEVhNmjQICxbtgyff/45SkpKpDpWT9CvXz9xcTZ//nx88803sLKyouKsl6qoqMCiRYuwcOFCuiAmhMhMSkpKt5Zjijg5OSE7O1sKieTLqFGjkJaWhm+//Rbr1q2Ds7Mzjh07xjoWkXNZWVkYPnw4du/ejejoaOzfvx/6+vqsYxFCCGGACjM5IIvCDACWL18OS0tLLFiwQOpj9RQPFmdhYWFYuXIlzTjrhd5++20YGxvj66+/Zh2FENJLFBUVobKy8qlmmDk5OeHKlStSSCV/VFRUEB4ejpycHPj4+GD8+PEICgrqNTdFIJLDcRyioqLg6ekJHR0dpKam4s0332QdixBCCENUmMkBWRVm6urq2LJlC44dO4a///5b6uP1JP369UNkZCRKSkowe/ZsfPnll+LijJZ4KLaff/4ZsbGx2L59OzQ1NVnHIYT0EsnJyVBRUYGrq2u3f6+TkxNu376NyspKKSSTT+bm5oiOjsbJkydRUFAAR0dHREREoLW1lXU0IgfKy8sxZswYfPzxx1i2bBnOnTsHW1tb1rEIIYQwRoWZHJBVYQYAzz//PN544w28//77MhuzJzEyMkJkZCRKS0vFxZm9vT2ioqKoOFNAN27cwJIlS7Bo0SL4+vqyjkMI6UWSk5Ph7OwMbW3tbv9eZ2dnAPeXjpGHjRkzBmlpaVi8eDFWr16NYcOG4eTJk6xjkR4sJiYGrq6uuHXrFi5duoSIiAgoKyuzjkUIIaQHoMJMDsiyMAOAtWvXoqGhARERETIbs6cRFWclJSV44403sHz5cirOFAzHcXjrrbdgamqKL7/8knUcQkgvw+fzn2o5JgCYmZmhX79+tI/ZI2hoaCAiIgJZWVmwtbXF2LFjERoaSjPyyEPu3r2LuXPnYsqUKZgwYQJSUlLg7u7OOhYhhJAehAozOSDrwszExATffvstoqKikJaWJrNxeyJjY+OHirNly5bBwcEBUVFRaGlpYR2PPIMtW7YgPj4eu3btoqWYhBCZ6ujoQGpq6lNt+C8yZMgQKsz+g52dHY4ePYq///4bZ8+eFZ+/Ozo6WEcjjF28eBEeHh44ePAgDh06hOjo6Kea7UkIIUSxUWEmB3R1dWW+PPKdd96Bl5cX5s6dC6FQKNOxeyJRcZaXl4fJkydj2bJl4hlnVJzJn5KSEixduhRLlizB8OHDWcchhPQyWVlZaGxsfOoZZsD9ZZm0JPPJBAUF4dq1awgPD8eSJUvg5eWFS5cusY5FGGhvb0dERAR8fX1hZ2eHjIwMBAUFsY5FCCGkh6LCTA7o6emhtrZWpmMqKSlh69atSE9Px7Zt22Q6dk82YMAAREVFPVScOTg4YNu2bWhvb2cdjzwBjuMwZ84cWFhY4PPPP2cdhxDSC/H5fGhpaWHIkCFPfQwnJydkZWWB4zgJJlNcWlpaiIiIQGZmJvT19eHj44PQ0FBUV1ezjkZkpLi4GKNHj8aaNWuwdu1aHDt2DGZmZqxjEUII6cGoMJMD+vr6aG5ulvneWc7OzggPD8fSpUtRUVEh07F7OlFxlpubi0mTJuGDDz7AoEGDqDiTA5s3b8bp06exe/duaGhosI5DCOmFkpOT4enpCRUVlac+hrOzM+rq6nDjxg0JJlN8Dg4OOHHiBHbu3InY2Fg4OTkhOjqaikcFFx0djWHDhuHu3bu4dOkSwsPDwePxWMcihBDSw1FhJgf09fUBAHfu3JH52F9++SUMDQ2xePFimY8tDywtLcUzzl5++WUqznq44uJiLF++HMuXL3+mvYMIIeRZJCcnP/P3ILpT5tPj8XgIDQ1Fbm4uQkJCEBYWhtGjR9OfpQKqra3F66+/jlmzZiEsLAwpKSkYOnQo61iEEELkBBVmckBUmNXU1Mh8bC0tLURFRWHv3r2Ii4uT+fjyQlScJB5tzQAAIABJREFU5ebmIiAgAAsWLIC9vT0VZz2IUCjE7NmzYWtri08//ZR1HEJIL3Xv3j1kZWU9c2FmYGAAMzMz2vj/GfTt2xdRUVHg8/loaWmBu7s7wsPDUV9fzzoakYD4+Hg4OzsjISEBp06dQlRUFNTU1FjHIoQQIkeoMJMDLAsz4P5mua+++ireffdd3Lt3j0kGeWFlZYWtW7ciPz8fY8eOfag4o7tyycajCsqNGzciISEBv/zyC10wE0KYSU1NRXt7+zNt+C8ydOhQZGRkSCBV7+bu7o7ExERs374de/bsweDBgxEdHc06FnlKzc3NWLZsGV566SV4e3sjPT0do0ePZh2LEEKIHKLCTA6wLswAYNOmTbhz5w6+/PJLZhnkibW1dafibOjQoYiOjqbiTMrGjx+PXbt2PfRcUVERPvvsM3zyySfw8PBgE4wQQnB/w38jIyPY2Ng887E8PDxw+fJlCaQiSkpK4mWaEydOxKxZs+Dv74+cnBzW0Ug3ZGdnw9vbGz/99BN++uknHDhwAAYGBqxjEUIIkVNUmMkBDQ0NaGhoMC3MzMzM8M0332DdunVITU1llkPeiIqzvLw8+Pn54a233qLiTIpqa2tx8uRJzJ49G4GBgaioqIBQKMSsWbNgZ2eHFStWsI5ICOnlkpOTJTK7DLhfmOXk5NASQgkyNDTE1q1bcebMGQgEAri7uyMiIkLmN14i3cNxHLZt2wYvLy9oaGggNTUVc+bMYR2LEEKInKPCTE7o6+szLcwAYO7cuRgxYgTmzp1LZU832djYPFSchYWFYdiwYVScSdiZM2fEdzo7deoU7O3tMW3aNFy6dAm7d++mpZiEEOb4fL7Ebjri6ekJoVCItLQ0iRyP/J9Ro0YhLS0N3377LdatWwdnZ2ccO3aMdaxe6dy5c48tLAUCASZOnIgFCxZg8eLFuHDhAuzs7GSYkBBCiKKiwkxOGBgYMC/MlJSUsH37dly5cgUbN25kmkVeiYqzK1euwMPDA2FhYXBxcUF0dDSEQiHreHLv1KlTUFVVBQC0tbWhsbERMTExsLe3R79+/RinI4T0dnfu3EFxcbHEZphZWVnB2NiYlmVKiYqKCsLDw5GTkwMfHx+MHz8eQUFBKCsre+zvu3v3LlJSUmSUUrFVVFRg8uTJWLJkSZevHzx4EE5OTrh27RrOnDmDiIgIKCsryzglIYQQRUWFmZzoCTPMAMDBwQFLly7Fp59+iqKiItZx5JajoyOio6ORmZkJd3d3cXF24MAB8Qwp0n3Hjh1Da2vrQ89xHIfc3FwMHjwY27ZtY5SMEEKAS5cugeM4ie6l6O7uToWZlJmbmyM6OhonT55EQUEBHB0dERER0el8IxIREYEJEybg+vXrMk6qWIRCIWbMmIG7d+9i06ZNiI2NFb/W1NSE8PBwvPrqqxg/fjwyMzMxcuRIhmkJIYQoIirM5ERPKcwA4JNPPoG1tTUWLFjAOorcGzJkiLg4c3Nzw+uvv45hw4Y9UXFWWVmJBQsW0My0/+/WrVsoLCzs8jXRbLO5c+di0qRJqKyslHE6Qgi5vxzT1tYWxsbGEjump6cnzWaSkTFjxiA1NRWLFy/G6tWrMWzYMJw8efKhr8nMzERUVBRu376NiRMnoqmpiVFa+bd+/XqcPn0aHR0d4PF4eP311yEQCJCcnAwXFxfs3bsXBw8eRHR0NHR0dFjHJYQQooCoMJMT/fr1Q1VVFesYAAA1NTVs2bIFsbGx+P3331nHUQii4iwjIwNubm6YNm3af844++677/Djjz9i3rx5NCsN95dj8ni8R77OcRyUlZWRmJiI3NxcGSYjhJD7JLnhv4iHhwfy8vJQW1sr0eOSrmlqaiIiIgJZWVmwtbXF2LFjERoaisrKSnAch/nz50NJSQlCoRBXr17Fm2++Sefop5CVlYXly5eL/+yEQiEaGhoQHBwMHx8f2NraIjMzE5MnT2aclBBCiCKjwkxOGBsb96hZMX5+fnjnnXfw/vvv4/bt26zjKAwnJydxcTZ48GCEhITA1dW1U3EmEAiwadMmAMCOHTuwcOFCVpF7jJMnTz523xJlZWV4e3sjMzMTfn5+MkxGCCH3JScnS2zDfxFPT09wHIf09HSJHpc8np2dHY4ePYp9+/bh1KlTcHR0xMyZM5GYmIj29nYA92c3Hzx4EKtXr2acVr40NzdjypQpnYrGtrY2JCYm4p133sGxY8dgZmbGKCEhhJDeggozOdHTCjMAWLNmDdTV1bF06VLWURSOs7Mz9u/fj8zMTDg4OCAkJARubm7i4mzNmjXiu2sKhUJs2rQJH330EePUbB0/fhxtbW2dnldSUgKPx8PHH3+MM2fO0AU2IYSJkpISVFZWSnyGmYWFBUxNTWlZJiNTpkxBXl4e3n77bezbt6/T6xzHYcWKFTh06BCDdPLpo48+QkFBgbh4fBDHcdi5cyfy8vIYJCOEENLbUGEmJ0SFWU+a1q+np4cNGzZg586diI+PZx1HIYmKs5SUFFhaWiIkJASenp7YtGnTQ+WQUCjEhg0b8OWXXzJMy05RUREqKio6Pa+qqgo9PT0cP34ckZGRdOcsQggzfD4fysrKcHNzk/ixPTw8aON/hrS0tFBTUwOhUPjI67Rp06YhKytLxsnkz/Hjx7Fly5YuyzKR9vZ2TJ069ZE3XSCEEEIkhQozOWFsbIzW1lbU1dWxjvKQ1157DS+//DLmz59PG9tKkbu7Ow4dOgQ+n4+6urouL8g5jkNERAS+/fZbBgnZ6mo5prKyMkaMGIHs7GwEBAQwSkYIIfclJyfD2dkZ2traEj82bfzPVnJyMrZv3/7IkofjOLS1tSEwMJC2sXiMW7duYfr06Y/djxS4X5hduXIFK1eulFEyQgghvRUVZnJCdEetnrYsEwA2bdoEgUBAFy4yYGFhgevXr3e59FBkxYoV+P7772WYir34+HjxBfaDSzBPnz5NSzAJIT0Cn8+X+HJMEQ8PDxQWFvaYu2n3Jh0dHXjrrbf+cwZze3s7Kisr8dprrz129lRvxXEcZs6cifr6+sfe/VtVVRU8Hg9KSkpISkpCfX29DFMSQgjpbagwkxM9uTCzsLBAZGQkvv/+e/qEW8oiIyMfeyEpsmTJEmzZskUGidjjOA7x8fFob2+HqqoqDAwMcPLkSVqCSQjpMTo6OpCamirxDf9FRowYAQBISkqSyvHJo/3444+4cuUKeDzef55z2tracOHCBbpRTxc2btyI+Pj4Th8I8ng8qKqqAgD09fUREhKCffv24fbt2zh58iR0dXVZxCWEENJL8LietCkWeaT29naoqanhwIEDCA4OZh2nE47jEBAQgMrKSiQnJ0NNTY11JIVz8+ZNWFtbP/GeHTweD7t27UJoaKiUk/2fe/fuoaWlBXfv3kVbW5t4CXFzc3OXS3bv3r0rvnnBg3R1daGiovLQc0pKStDT0wMAaGpqQkNDA7q6usjPz8fIkSMB3L976759+2hWGSGkR8nMzISLiwvS09Ph4uIilTEcHR0xefLkXrksn6XGxkakpaXh8uXLSElJQVJSEgoLCwHcnw3V3t7e5TYKW7Zswdy5c595/La2NjQ0NKCjowN3794Fx3Gora0Vv15XV9flB21CofCx23z06dOnywKQx+Ohb9++4n/v27cveDye+Ot1dHTEBdeTysrKgru7u7gsU1FRQUdHB5SUlODl5YVJkyZh3LhxGDZsWLeOSwghhDyjVpX//hrSE6ioqEBfX79HzjAD7l9Abdu2DUOHDsXq1avx2WefsY6kcCIjI9Ha2golJSWoqqqio6Pjscs6OI7D7NmzoaGhgalTp/7n8Ts6OlBVVYXKykpUVlaipqYGNTU1qK2tfejx4HMtLS2ora1Fa2srGhsbJfl2u01ZWRlZWVnw9PSEhoYG9PX10bdv306PB583MDCAmZkZTExMoKmpyTQ/IURxJScnQ0tLC05OTlIbw8/PD+fPn5fa8UnXtLW14evrC19fX/Fzt27dAp/PB5/PR2JiIvh8PhobG6GsrAwVFRW0tLRgwYIF6OjogLW1Nerr61FXV4e6ujo0NDSgvr6+y+caGxvR1NSE5uZmtLS04N69ewzf+eOJPtjS0NCApqYmtLS0oKurC11dXejp6aFPnz7Q1dWFpqYmduzYIS7L9PT04Ovri4CAAEyYMAE2NjZQUqIFMYQQQtigGWZyxNHREdOmTcMXX3zBOsojrV27FitWrMDly5fh7OzMOo5CEQgEKCgoQHFxMYqLi1FUVIT8/HwUFhZCIBCIP8FWVVWFqqoqWlpa0NHRAWVlZfz8889wdHREWVkZrl+/jhs3bqCqqgoCgQA3b94UF2X//hS6q9Lpwec0NDSgp6cHNTU1aGtrQ0tLC+rq6uIZYvr6+gDuF75dLZvQ1tbucjZiV/vwPPjDwYMz2dasWQNPT084OjqioaFBPJvtv8q+f8/U09XVhbm5OYyMjGBiYgIzMzMYGxvDwsIClpaW4oe6uvrT/QckhPRa8+bNQ3Z2tlQLrV9//RVvv/02ampqoKWlJbVxSGcCgQCVlZW4fv06BAIBbt26hdu3b6O6ulr8EJ1rGxoaOv1+0QxqUYmko6MDXV1d9O3bV1wyiZ5TV1eHlpYWVFVVoaOjA2VlZfTp0+ehmV+iWV8AxOflrujp6XVZRj1u9tmDH5A9OJuttrYWHMeJZ443NDSgra1NfL4WlX4NDQ24e/cu6urqUF9fj/z8fDQ0NIDH46GlpaXL2XCGhoaPfJibm4vP1SYmJjA2Nv7PmwYQQgghT6iVCjM58vzzz2Po0KHYtGkT6yiPJBQKMWrUKLS1tSExMZH2kJKRW7du4fz58+Dz+cjJyUFJSQkEAgHq6uoeKoaUlZVhamoKc3Nz8YWlqCQyNTWFqakpjI2NYWxsDAMDA4bv6Mk1NjY+1V3n7t27h+rqalRUVKCysvKh8vDmzZviH4DKysoeWk5qZmYGS0tLDBgwAJaWlrCxsYG9vT3s7e1haWlJn4QTQjpxd3fHCy+8gLVr10ptjJKSEtjY2ODMmTN4/vnnpTZOb9Le3o7r16+jpKQEJSUlKCsrw61bt3Djxg0IBALxrw/uu6WpqQlTU1MYGRmhX79+nQoeIyMjGBoaQldXFxUVFVBRUcH48eMZvkt2OI5DfX09+vTpI37u3r17qK2tfahsrKqq6lRAVldX4/bt27h58+ZDM+1UVVVhbGyM/v37i693TE1NYWlpCWtra1hbW8PCwqLby0YJIYT0SlSYyZOpU6dCKBQiJiaGdZTHysnJgZubG1atWoWPPvqIdRyFIRQKUVhYiOzsbOTl5SEvLw+5ubnIyckR36ZeQ0MDtra2sLKyEhc6lpaWMDIygpqaGvz8/Ogi8SlUVVWhrKxM/CgtLRX/c3Fx8UN//qLyzN7eHg4ODnB0dISTkxPN+CCkl2pqaoKenh6io6Mxbdo0qY5lZWWFd955B59++qlUx1EkAoEAubm5KCkpQXFxsbgcKykpwfXr18VbH2hoaMDKygomJibi2Uz9+/cX/yoqZ0R7bRLZqa+vF8/uE5WY169ff2jWX2lpqfjDL2VlZVhYWIgLNGtra9jY2MDa2hoODg4wNTVl/I4IIYT0EFSYyZMPP/wQFy9elIu7YH311VeIjIxERkYGBg4cyDqO3GltbUV+fj4uX74sfmRkZIiXcujr62PIkCFwcnKCra0tbG1tMWTIEAwePJhm9TFQW1uLwsJCFBUVoaioCNnZ2bh69SpycnLES1fMzMzg4eEhfoj+2xFCFFtCQgJ8fX1RWFgo9f/np0+fjtu3byM2Nlaq48ibtrY2lJeXP/T9uaioCFeuXIFAIAAAqKmpwcLCAra2tjAzM4O5ubn4/Gprawtra2uaQSznampqxOfpiooK3Lx5U/zvubm54mssPT09DBw48KHrKycnJzg6OtKHX4QQ0rtQYSZP1q5diw0bNqC8vJx1lP/U3t6O4cOHQ1dXF6dPn6b9JB5DKBTi6tWrSExMRGJiIi5evIj8/HwIhUL06dMHw4YNg4uLC1xcXODm5oYhQ4bQBZucEAqFKC4uRnp6OjIyMsSP0tJSAICRkRG8vLwwYsQIjBw5Es899xx0dHQYpyaESNL69euxatUqVFVVSf1cuGXLFixevBg1NTWd7jTcW9y4cQPp6eniR0ZGBoqLi9He3g4lJSVYWlrCwcEBgwcPhoODAxwcHGBvb4/+/fvTtUovV1FRgdzcXOTl5SEnJwc5OTnIy8tDSUkJhEIhlJWVYW1tDVdXV7i6usLFxQWurq4YMGAA6+iEEEKkgwozebJv3z5Mnz4dzc3NcnEhnJ6eDi8vL2zcuBHz5s1jHafHaG5uRmJiIi5cuICkpCQkJSWhrq4OOjo68PLygo+PD9zd3eHi4gIbGxu6gFdANTU1yMjIQHp6Oi5duoSEhASUl5dDRUUFQ4cOxciRI+Ht7Y0xY8bQ0hBC5Nwbb7yBuro6/PPPP1IfKzs7G87OzkhOToanp6fUx2OtsLAQfD4f6enpSEtLQ3p6OqqqqgAANjY24lLD0dFRXI5paGgwTk3kTUtLi7hIu3btmriMLS4uBsdxMDQ0hJubm/jvm5eXF+zt7VnHJoQQ8uyoMJMnomUd5eXlsLCwYB3niSxfvhw//vgjrly5AktLS9ZxmCkqKkJ8fDzi4+Nx/Phx1NfXi5fo+fr6YuTIkfDy8uryjpGkd7h58yZSUlKQkJCACxcuICUlBS0tLbC1tYW/vz/8/f0RGBjY5d1GCSE916BBgzB9+nRERERIfSyO42BiYoLly5fjww8/lPp4stTW1obMzExcuHABly9fxtmzZ1FWVgYVFRXY29uLl7oPGTIEI0aMgJGREevIRMHV19cjIyMDV69eRXZ2Ni5fvozU1FQ0NTWhT58+8PLywsiRI+Hr6wsfHx9aHUAIIfKHCjN5UlpaCmtrayQlJWHEiBGs4zyRlpYWuLu7w8rKCkePHmUdR2aam5tx/PhxHDx4EHFxcbh16xYMDQ3x4osvYuzYsQgICOjVBSL5b42NjTh79ixOnDiBEydOIDs7GxoaGvD19UVQUBCCg4PRv39/1jEJIY9x584d9OvXD4cPH8aECRNkMubkyZOhpKSEP//8UybjSUtzczPOnz+PuLg4XLhwAampqWhtbYWpqal4Gbu3tzc8PT2hrq7OOi4hAO7vQXv58mVcvHgRCQkJSExMxM2bN6Gqqgo3Nzf4+voiICAAo0aNgqamJuu4hBBCHo8KM3nS1tYGTU1N/P7773jttddYx3liCQkJGDVqFHbt2oUZM2awjiM1opLswIEDOHz4MBobG+Hj44Nx48Zh7Nix8PDwoA2DyVOrqKhAXFwc4uLicPToUdTX18Pb2xtTpkxBcHCw3Mw6JaQ3OX78OMaNGweBQABjY2OZjLl27VpERkaisrJS7pb0X7t2DbGxsYiNjcW5c+dw7949ODo6YvTo0fDx8YG3tzfs7OxYxySkW0pKSpCQkICkpCScOXNG/AHYqFGjEBAQgJdeegnOzs6sYxJCCOmMCjN5Y25ujiVLlmDhwoWso3RLeHg4fvvtN1y5cgXm5uas40hUYmIitm7dioMHD6KxsRG+vr547bXXEBwcrHDvlfQMLS0tiIuLw4EDB3Do0CHcvXsXPj4+ePvttxESEkKfWhPSQ6xcuRK7du1CUVGRzMZMTk6Gl5cXsrOzMWTIEJmN+zSEQiEuXLiA/fv34/DhwygrK4O+vj78/f0REBBAs7GJQrpx4wZiY2MRFxeH+Ph4VFdXo3///ggKCsLUqVMxatQouuM5IYT0DFSYyZvhw4fDz88P33//Peso3XLv3j24urrCxsYGx48fl7tPvf+tvr4ev/32G7Zs2YLMzEy4u7tj9uzZCA4OhpmZGet4pBdpaWnBiRMnsGfPHvz555/Q1tbGzJkzMXfuXAwePJh1PEJ6taCgIGhra+P333+X2ZgdHR0wNjbGF198gQ8++EBm4z4pjuOQlJSE/fv3IyYmBjdu3ICzszOCg4MRGBiI5557jsoC0msIhUKkpKQgNjYWf/zxBzIyMmBqaorXXnsNISEh8PHxodUJhBDCDhVm8iY4OBiqqqoyvfiWlKSkJPj5+eHnn3/G7NmzWcd5KgKBAJGRkdixYwc6OjoQEhKCefPmwcvLi3U0QlBZWYlffvkF27ZtQ0lJCV588UV88cUX8PX1ZR2NkF7J1NQUixcvxqJFi2Q6bnBwMFpbW3H48GGZjvs4AoEAW7duxY4dO1BWVobBgwdj6tSpCAkJ6fEz4QiRldzcXOzbtw/79u3D1atXYWFhgVmzZuHdd9+lVQuEECJ7rfSRhZyxsLDA9evXWcd4Kt7e3li4cCEWLlyIsrIy1nG65c6dO1i+fDns7Oywf/9+rFy5Ejdu3MAvv/xCZRnpMYyNjbFs2TIUFBTgn3/+QUdHB/z8/BAYGIjk5GTW8QjpVUpLSyEQCJicI8aOHYvTp0+jpaVF5mP/W0pKCkJDQ2FlZYUffvgB06ZNQ3p6Oq5du4Yvv/ySyjJCHuDg4IDPP/8c2dnZuHLlCmbMmIFt27bB2toar7/+Oi5evMg6IiGE9CpUmMmZ/v37y21hBgCrVq3CgAEDEBYWBnmY3NjR0YE1a9bA1tYWO3bswMqVK1FQUICFCxeib9++rOMR0iUlJSWMGzcOp06dwsmTJ1FfX4/hw4fj1VdflevvH4TIEz6fD2VlZbi5ucl87MDAQDQ2NjL94frkyZMYOXIknnvuOWRmZmLz5s0oKyvD6tWr4eLiwiwXIfLC2dkZ33zzDcrKyrB9+3bk5+fD29sbXl5eOHbsGOt4hBDSK1BhJmcGDBiAiooKdHR0sI7yVNTV1REdHY1z585h69atrOM8Vm5uLnx9ffHFF19g0aJFKCoqwkcffUQbqktBc3MzlixZAltbW6ioqIDH46GhoYF1LIUwZswYJCQk4MiRI7h27RqGDh2K3bt3s45FiMJLTk6Gk5MTdHR0ZD62tbU17OzscOLECZmPnZOTg6CgIPj7+0NfXx9nz55Feno63nrrrR55/kxJSQGPx0NERMRjnyOPRudw6VJXV0doaChSUlKQkJAACwsLjB8/HoGBgcjKymIdjxBCFBoVZnLG2toabW1tuHHjBusoT83d3R0ff/wxPv74YxQUFLCO06WNGzfCzc0NHR0duHz5Mj777DMmP/T0Ft9++y2+++47FBcXy6QMvnDhAng8Hr7++mupj9VTjB8/HqmpqZg9ezbCwsIwadIkVFdXs45FiMLi8/lMl+wHBAQgLi5OZuPV19fj/fffx7Bhw1BeXo74+HgcOXIEo0aNklkGwgadw2XHx8cHf/75J86dO4fq6mq4urpi3rx5qK2tZR2NEEIUEhVmcsbW1hYAUFhYyDjJs4mIiICtrS1mzZoFoVDIOo5YR0cH5syZg48++giffPIJEhMTaX8VGfj777+hp6eHq1evoqOjAxzHUUEpBZqamli3bh1Onz6NjIwM+Pj4oKioiHUsQhSOUChEamoqnnvuOWYZXnrpJVy+fBmVlZVSHyslJQXu7u7Yv38/tmzZgtTUVLz44otSH5f0DHQOlz0/Pz/w+Xzs3LkThw4dgpubG+1vRgghUkCFmZwxMTGBrq6u3P+Qq6amhujoaPD5fGzatIl1HAD3b3X/zjvvYM+ePfjrr7/wySefQEVFhXWsXuH69etwcHCAo6Mj3T5dBkaNGoWLFy9CV1cXL7zwAsrLy1lHIkShXL16FfX19UxnmPn7+0NNTQ1Hjx6V6jhHjhzB888/DxsbG2RkZCAsLIy+j/cydA5ng8fjYcaMGcjIyMCQIUPwwgsv4I8//mAdixBCFAqd1eSQjY2N3M8wAwBXV1esWLECy5cvR15eHus4+P777/Hbb78hJiYGEydOZJLh+PHj4PF42LBhA06fPg0fHx9oa2tjwIABiIyMFH/dDz/8AAcHB2hoaGDw4ME4cOBAp2NxHIdffvkFPj4+0NXVhaamJlxcXLB58+ZON1w4d+4cpk+fjoEDB0JdXR1GRkYICgpCQkLCI/NdvHgRo0ePhra2NgwNDTFz5kzcuXOnW+934cKF4PF4qK6uBp/PB4/HA4/Hw7x586T2Pr7++mv4+fkBAD777DPxmDweDwCwfft28Hg8xMTEdMoreu2vv/7q8s/k7NmzeP7556GrqwtPT89u55clU1NTxMXFQU9PD5MmTeoRd9MjRFHw+XxoaGjAycmJWQZtbW288MILOHLkiNTGOHHiBF599VW88cYbOHbsGExNTaU2Vnc96XlNkugcTudwFoyMjHD48GG8/fbbCAkJker/84QQ0utwRO5MnjyZCwkJYR1DItra2jhPT0/O29uba29vZ5bj2rVrnKqqKvfdd98xy8BxHHfs2DEOABcSEsKpqKhwAB56rFu3jluyZEmn55WUlLi0tDTxcYRCITd9+vROXyd6vPPOO+KvvXnz5iO/TkVFhTt79mynfG+88Qanrq7e6etHjRrVrfcbHh7e5bhz586V2vv46quvHvl1HMdxP//8MweAO3DgQKe8otcOHjzY6c9kypQpD/03c3Nz61Z+VgoKCjhdXV3u888/Zx2FEIUxb948buTIkaxjcJs2beJ0dHS45uZmiR+7rKyM09PT4958801OKBRK/PjPojvnteTkZA4A98UXXzz2uSdB53A6h7M2Z84cTkdHhyssLGQdhRBCFEELFWZyaNGiRZynpyfrGBKTnZ3NaWhocGvWrGGW4c033+ScnZ25jo4OZhk47v8u3ABwCxcu5EpKSriGhgYuJiaGU1VV5fT09DhdXV1u+/btXGVlJVddXc0tWrSIA8CFhoaKjxMdHc0B4IYOHcodPXqUq66u5hoaGrizZ89yLi4uHAAuMTGR4ziOu3XrFjd27Fju8OHDXHl5Odfa2soJBAJu//79nLa2Njdu3LjqVNz3AAAgAElEQVQu882bN4/Lz8/n7t27x124cIGztLTkAHDp6endft96enrc8OHDOz0vrfdx/vx5DgD31VdfdRrzaS+2AXBhYWFcbm6uuPztTn6WVq9ezenq6nI1NTWsoxCiENzd3bkPP/yQdQyutLSU4/F4XGxsrMSPPW3aNG7QoEFcU1OTxI/9rLpzPpBGYUbncOm+DzqHP1prayvn7OzMvfzyy6yjEEKIIqDCTB5t3ryZMzAwYB1DolatWsVpaGhw2dnZMh+7qamJ09HR4bZs2SLzsf9NdOEWGBjY6bXg4GAOALd27dqHnm9vb+f09PQeKlFfeOEFTllZmauoqOh0nOzsbA4At3TpUvFzKSkp3JQpUzhzc/NOn4pbWFh0yhcQENDpuJs2beIAcLt37+72+37Uxba03oc0LrZHjBjRaZZFd/OzUldXx6mrq3O//vor6yiEyL2mpiZOVVWV27t3L+soHMdx3LBhw7gPPvhAosesrKzkVFVVuT179kj0uJL0pOcDaRRmdA6X7vugc/jjHTx4kFNSUuLKy8tZRyGEEHnXQjuayyE7OzvcuXMHNTU10NfXZx1HIpYsWYK///4bM2bMQFJSEtTU1GQ2dl5eHhoaGjBq1CiZjflfnn/++U7PWVlZAUCnnMrKyujfvz8EAoH4uezsbHR0dGDAgAEAAI7jxHttiH4tKysDACQmJuKFF15Aa2trl1mampo6PTd69OhOz4nu4FpfX//Y99Yd0n4fkuTv7y/eQ0WkO/lZ6tOnD9zc3JCamoo333yTdRxC5Fpqaira2tqYbvj/oIkTJ2Lv3r3YsGFDp+9RTys5ORltbW0ICgqSyPEkjfX5gM7h99E5nI3x48dDSUkJSUlJmDJlCus4hBAi12jTfzkkuqiR9ztlPkhFRQV79+5Ffn4+IiIiZDr23bt3AQB6enoyHfdxNDQ0Oj0nupB71GtCoVD876J/7ujoQEdHB4RC4UMXegDEF6WRkZFobW3FF198gYKCAjQ1NYm/3sHBoct8mpqaj8zHSXATXGm/j66I7vD14J+nyOMu2A0NDZ8pP2t6enqoq6tjHYMQuZecnAwDAwPxuZq1V155BSUlJUhNTZXYMWtqaqCmpgYdHR2JHVOSJHU+eFp0DpfN++hKbz2HP0hNTQ26urrdvokDIYSQzmiGmRyytraGsrIyCgsL4eHhwTqOxNjZ2eG7777D/PnzERAQ0OUnoNJgbm4O4P6nhKJ/lneDBw9GamoqKioq/rMILCoqgomJSaeisrCwEPn5+UxnMUrrfYguqNvb2zsdx9jYGABQXFzc6bVTp05JLT9rJSUleO6551jHIETuJScnw8vLS2KzuZ6Vp6cnbG1t8ccff0jsmsHS0hKtra0oKSmBjY2NRI4pST35vPYk6Bz+f+gc3n0CgQA1NTXiWY2EEEKeHs0wk0OqqqoYMGCAQs0wE5k7dy4mTJiAGTNmoKamRiZj2trawsrK6qHbjMu7t956C/fu3YO/vz+OHDmCqqoqtLa2orS0FP/88w+Cg4Nx8uRJAPd/8KmsrMSmTZtQV1eHuro6HD16FOPHj+/yE1pFeB8GBgYAgPPnz6O6uvqh14YMGQIA2LBhA86cOYOmpiaUlJRg0aJF3f470p38LF27dg25ubkYM2YM6yiEyD0+n99jlmOKTJ48GTExMRI73ogRI2BkZISdO3dK7JiS1JPPa0+CzuF0Dn8WO3fuhJ6eXpdLgwkhhHSTVLdII1IzZswY7u2332YdQyoqKys5U1PTh+4YJW2rVq3i9PT0OIFAILMxuyLafHb9+vWdXhPdSevKlSudXnNycuL69+8v/nehUMjNmjXrkbdCB8AdO3aM4ziO++uvv7p83c3NjXN2duYMDQ2fKJ/otR9++KHb7/tRGwZL6320t7dz/fv37/S1Iq+++mqn11RUVLgZM2Y8csPgrv5MupOfpZCQEM7R0VF8ZzBCyNOprq7meDwed/jwYdZRHpKQkPDI88fTWr16Naepqcnl5ORI7JiS0p3zgTQ2/adzuHTfB53DH62oqIjT1dXlIiIiWEchhBBF0EIzzOTUwIEDkZ+fzzqGVIg+tf7111/x+++/y2TMDz74APr6+ggLC2P+iawk8Hg87Ny5E/v27YO/vz/09fWhpqYGW1tbTJ48GQcPHoS/vz8AYNKkSdizZw+GDRsGTU1NmJmZYe7cuTh58iTU1dUV8n0oKysjJiYGvr6+0NbW7jTujh07EBYWBkNDQ2hoaMDb2xvx8fHdvjFEd/Kzsm/fPuzfvx/fffcdlJWVmWYhRN4lJyeD47get7zZ29sbFhYWEp1l9uGHH8LV1RUTJ058aMP6nqAnn9eeBJ3D6Rz+NKqrqzFhwgQMGjQIy5YtYx2HEEIUAo/jJLi7J5GZ9evXY/Xq1bh16xbrKFLz7rvv4vfff0dGRgYsLS2lPl5SUhLGjBmD2bNnY/PmzT1m/xlCpOX06dMYP3485s6diw0bNrCOQ4jc++qrr/DLL790uX8Sa++99x7Onj2LK1euSOyYlZWV8PPzQ3t7O44dOwZ7e3uJHZsQ8uSKioowfvx4tLa24sKFCwqzJy8hhDDWSjPM5NSQIUMgEAhw+/Zt1lGkZu3atTAxMcFbb70lk1lf3t7e+N///oft27dj5syZPfLOR4RISkxMDCZMmIDJkydj7dq1rOMQohBEG/73RFOnTkVWVpZECzNjY2NcuHABRkZGeO655/Dbb79J7NiEkCezf/9+eHh4QFtbGwkJCVSWEUKIBFFhJqdEm5peu3aNcRLp0dLSwt69e3H27FlERUXJZMzJkyfj2LFjOHToEDw8PJCWliaTcRVNeno6eDzefz4mT57MOmqv09TUhGXLliEkJARvvvkmfv31V1qKSYiEpKSk9LjlmCJ+fn6wtrbG3r17JXpcIyMjnD9/Hh9++CFmzpyJF198ERkZGRIdg6XeeD7rje9ZHuXm5mLq1KkICQlBUFAQzp8/DzMzM9axCCFEoVBhJqcsLCygp6eHq1evso4iVe7u7vjss8+wfPlyZGZmymTMF198EWlpaejXrx+GDx+OZcuWoa2tTSZjEyJNFy9ehKurK7Zu3YqffvoJ27Ztg4qKCutYhCiEsrIy3Lx5s8cWZjweD9OmTcOePXskPmtbVVUVERERSEpKQktLC9zd3REaGqrQ20YQwsqdO3cQHh4OZ2dnFBQU4PTp04iOjoaWlhbraIQQonBoDzM5NmLECIwYMULh9x4SCoUYM2YMbt++jZSUFGhoaMhs3PXr1+PTTz+Fvb09vvrqKwQFBdHeZkTuFBYWYuXKldizZw/GjRuHbdu20afQhEhYTEwMQkJCUFtbC11dXdZxunT16lU4OTnhzJkzeP7556UyBsdx2Lt3L5YvX46amhqEhobivffeg6Ojo1TGI6S3yMvLw6ZNm7Br1y7o6Ohg1apVmDlzJpSUaP4DIYRICe1hJs+GDBmi8DPMAEBJSQk7d+5EeXk5PvvsM5mOu2jRIqSnp2PQoEGYPHkyhg8fjtjYWJllIORZlJWVYc6cOXB0dMTFixfx22+/4fDhw1SWESIFycnJcHJy6rFlGXD/usHFxQV79uyR2hg8Hg/Tp09Hbm4uVq1ahRMnTsDJyQkBAQE4fPiwQtyJmhBZEQqFOHbsGMaNG4fBgwfjyJEj+Pzzz5GXl4fZs2dTWUYIIVJG32XlmKOjY68ozADAxsYGGzZswLp163Dq1CmZju3g4ICYmBhcvnwZJiYmCAwMxPDhw7F79240NTXJNAshTyIpKQkzZ87EoEGDEB8fj23btiE7OxvTpk1jHY0QhcXn83vshv8PevPNNxETE4OWlhapjqOpqYkPPvgAOTk5OHLkCJSUlDBp0iTY2tpi2bJltEcoIY+RmZmJTz/9FIMGDcKECRPQ1taGgwcPIj8/Hx9//DF0dHRYRySEkF6BlmTKsX/++QcTJ05ETU0N+vbtyzqOTLz22mtISkpCeno6jIyMmGS4dOkSNmzYgD///BM6OjqYOXMm5s6dCwcHByZ5CAGA+vp67N27Fz/99BMyMjLg7u6O+fPnIzQ0FKqqqqzjEaLQhEIh9PX1sWbNGsydO5d1nMe6ceMGrKyssHfvXkydOlWmY+fm5mLHjh04cOAASkpKYG9vj5CQEISEhMDJyUmmWQjpaXJycrBv3z7s27cP165dw4ABAzBlyhSEhYXR/x+EEMJGKxVmcqy4uBi2trZITEyEt7c36zgyUVtbC3d3dzg4OODo0aNM9xMTCAT45ZdfsG3bNpSWlsLHxwdTpkxBcHAwLCwsmOUivUdzczNiY2Nx4MABHDp0CO3t7QgJCcG8efMwfPhw1vEI6TWys7Ph7OyM1NRUuLm5sY7znyZOnIjW1lbExcUxGZ/jOFy6dAn79+/HgQMHcP36dTg4OCAwMBABAQEYPXo0bWBOFF5TUxPOnTuH2NhYxMbG4urVqzAzM8OUKVMwdepU+Pj40L65hBDCFhVm8kwoFKJPnz6IiorCW2+9xTqOzPD5fPj5+eGbb77BokWLWMeBUChEbGws/ve//+HQoUOor6+Ht7c3XnvtNQQHB2PAgAGsIxIF0tTUJC7JDh8+jMbGRowcORJTp07F9OnToa+vzzoiIb3Ozp07MX/+fNy9e1cuZnT+/fffeOWVV5Cfnw87OzumWYRCIRITE3Ho0CHExcUhMzMTampq8PX1RUBAAAICAuDi4kLFAZF7HMchKysLsbGxiIuLw/nz59Hc3AxnZ2e89NJLCAoKgp+fH+1LRgghPQcVZvLO09MTo0ePxvfff886ikxFRkbi888/x9mzZ3vU7LqOjg4kJSXhwIED+N///oeqqirY2trC398f/v7+CAwM7NEbQpOeqaioCPHx8YiPj8fx48fR2NgIb29vTJkyBVOmTIG5uTnriIT0avPnz0dGRgYSEhJYR3ki7e3tsLKywuzZs/H111+zjvOQqqoqnDlzBvHx8Thy5AgqKiqgq6uL4cOHY+TIkfDw8ICfn1+v2YqCyK+2tjZkZmbiwoULSEhIwJkzZ1BVVQVDQ0OMGTNGfF1oaWnJOiohhJCuUWEm70JDQ1FdXY1//vmHdRSZEgqFGDduHAoKCpCamgo9PT3WkTppbW3F6dOnxZ8kZmdnQ0NDQ/yp+ahRo+Du7i4XsxGIbBUXFyMhIQHx8fGIi4vDzZs30a9fP7z44osICAjA+PHjYWpqyjomIeT/8/T0hJ+fH9avX886yhNbsWKF+A7UKioqrON0SSgUIj09HefPn0dSUhISEhJw/fp1qKiowNXVFT4+PhgxYgTc3NwwaNAgKCsrs45MeimhUIiCggKkpaXh4sWLSEpKQmpqKtra2mBubg4fHx/4+PjA19cXHh4eNIuMEELkAxVm8i4yMhI//vgjysrKWEeRucrKSri6usLX1xf79+9nHec/3bhxAydOnEBcXBzi4+NRVVUFTU1NeHh4iC+kRowYARMTE9ZRiQy1tLQgJSUFFy9eREJCApKSknDr1i2oqanB29tbvCTJ3d2dLrAJ6YGam5uhp6eHnTt34o033mAd54kVFxdj4MCB+OuvvxAUFMQ6zhMrLy8Xf69MTExEeno62tvboa2tjaFDh8LFxQVubm5wcXHB0KFDoa2tzToyUTBNTU24cuUK0tPTkZ6ejoyMDGRmZqKhoQEqKioYOnQoRo4cCW9vb4wcORJWVlasIxNCCHk6VJjJu9jYWAQGBqKyspLZXSNZOnPmDPz9/bFlyxa8/fbbrOM8MY7jkJubi4sXLyIxMRGJiYm4du0ahEIh7Ozs4O7uDldXV7i4uMDFxYVuIqAgGhoakJmZiYyMDGRkZCA9PR1paWlobW2FiYkJRowYIS5PPTw8oKmpyToyIeQ/XLx4Ed7e3sjPz8fAgQNZx+mWsWPHQlVVFUePHmUd5am1tLQgKytLXFyIfr179y6UlZUxcOBADBkyBA4ODnBwcICjoyPs7e1pv0fyn2pra5GXl4ecnBzk5OQgNzcX165dQ15eHjo6OqCrq4thw4aJr9fc3Nzg7OwMDQ0N1tEJIYRIBhVm8u727dswMjJCbGwsAgICWMdhYsWKFVi/fj0uXbqEYcOGsY7z1Orq6pCUlIRLly6JL/iLi4sBAIaGhuILMmdnZ/GFv6GhIePUpCstLS3Iz89HXl4erl27Jv4hrrCwEEKhEHp6euIy1MvLC97e3sw33iaEPJ2NGzfiyy+/xO3bt+VuY/pDhw5h8uTJyM7OhqOjI+s4EsNxHIqLi5GWlobMzExxyZGbm4vm5mYAgLGxMRwdHeHg4AB7e3vY2trC2toaVlZWMDAwYPwOiKzU1taipKQEJSUlKCoqEv89ycnJwa1btwAA6urq4r8ngwcPhouLC1xdXWFnZyd3/88TQgjpFirMFMGAAQOwYMECLFu2jHUUJtrb2zF69GjU1taCz+cr1K3oa2trxbORRI+rV6+iqakJAGBgYCC+gLO3t4e9vT0GDhwIS0tL+vRcylpaWlBWVoaSkhLxBXZeXh7y8vJQWloKoVAIJSUlWFtbi8sx0cPGxoZ1fEKIhMyYMQNVVVU4fvw46yjdxnEcBg8eDH9/f2zevJl1HKkTCoUoLS0VFyK5ubni790VFRUQXRL36dNHXJ7Z2NjA2toa1tbWGDBgAMzNzWFiYkL7pcmBjo4OVFZWoqKiAuXl5eJi7MFHXV2d+OvNzMzEH0ja29uLC1Vra2vaEoEQQnonKswUwaRJk6ChoYF9+/axjsJMeXk53NzcEBwcjK1bt7KOI1Ucx6GsrEw8gyknJ6dTUQMAurq6sLS0hLW1NSwtLWFlZQVLS0tYWlrC1NQUpqamtLfLI7S3t6OyshICgQDXr19HSUkJysrKxI/S0lLcunVL/MOVoaEh7O3txRfZDz7U1dUZvxtCiDQ5ODggJCQEK1euZB3lqURFRWHFihUoLy/v1TOrWlpaUFJSgtLS0i6LlZs3b4q/VklJCSYmJjAzM4O5uXmnX01MTGBkZIR+/frRnbGloL6+HtXV1aiqqoJAIMDNmzdRUVHR6VeBQICOjg7x7zM1NRWXnw8+rKysYG1tTUspCSGE/BsVZoogIiICe/fuRV5eHusoTB05cgQvv/wyfvvtN7naeFmSWlpaUFxcLC51RL+KHjdu3EB7e7v467W1tWFqagoTExMYGxvDzMwMxsbGMDY2hoGBAfr27Yu+ffvi/7F333FN3esfwD+BsJEpsgQHoBYFRARUrAusExfaqq2t1lpr7fDe2lZbV61au7S3Xq+rqLXqdSPOtgp1VklEZYmDKVMQSdgz+f3hj1ypaB3ACcnn/XrlRUww5xNvb74nz3nOcywtLVX3W2IBqLCwEIWFhZDJZJDJZKr7d+/eRW5uLvLz85GTk4M7d+4gPz8feXl59f5+69at6xUcO3TooLrfvn17nhpLpKVkMhmsrKwQHh7eogbnP6i4uBhOTk5YsGAB5s6dK3QctVVRUYHMzMyHijK5ubnIyspS/XywYwkA9PX1YW1t/dDNxsYG1tbWMDMzg7m5OczNzWFqaopWrVrB1NQUFhYWMDMz08hONoVCAblcDrlcjuLiYpSUlKC4uBhyuRxFRUWQy+UoKCjA3bt3cffuXRQUFNS7VVVV1Xs9MzMzODo6ws7OrsGftra2cHZ2ZkGMiIieFgtmmiA8PBxjx45FYWEhzM3NhY4jqPfeew/bt2/H5cuX0bFjR6HjqJ3a2lrk5OTUKw5lZ2erikQP3i8sLKx3ZLaOsbGxqnhmZGQEMzMziMViWFhYQE9PD6ampjAyMoKhoSFMTU2hp6cHAKrHHiQWix86+l5ZWYmysrJ6j9XtXNeRy+WoqamBXC5HVVUVSktLUV5ejoqKChQXF6OqqqpegawhZmZmsLKygr29PWxsbFRddzY2NrC3t1d1CDg5OWnUab5E1Hh+//13DBkyBNnZ2bC3txc6zjObM2cODh48iKSkJIjFYqHjtGjl5eWq9fWvhZ6624OFoLoC0aMYGxurCmkWFhYQiUSwsLAAAFVBre5n3ZprbGxc7+DWg2vxgwwMDBpc3+rW07+qqalBcXGx6s9162/d4w+u1YWFhQDur9d1jxcXF6O4uPihNf5BdQXEusJi69atGyw41j1nZ2fHNZqIiJoKC2aaICMjA87Ozjh9+jT69esndBxBVVRUoHfv3tDR0cH58+d5NPE5FRcX1ys8PdidJZPJUF5ejqKiItTU1EAmk6G6ulp1pDg2NhatW7dW7aQXFxfX624D7v/vVTePrU7dzv9fmZubq2aINFSkq/uCYGZmBn19fVVRr65D7sEuOQsLC408ak9EzWv58uXYtGkT0tLShI7yXJKTk9G5c2ds374dEydOFDqOVmqo2+rBIlNxcTGKiopQW1uLoqIiKJVKREREoLa2Fp06dYJSqVQ9X1JSgurqatVr1xWv/qq0tPShbi0AqnW1IXVFO+B/B710dHRUB2zr5qfWrdmtWrWCWCyGmZmZqnuurvhX91jdTdsP+hIRkdphwUxTtGnTBp999hnmzJkjdBTBpaWloWfPnhg2bBh++eUXoeNopa+++gorVqxASkoKbGxshI5DRNQkxowZAz09Pezdu1foKM9t8uTJiI2NRWxsLAectwA///wzpk2bhj179mD8+PFCxyEiItJEVdwj0hDe3t64cuWK0DHUQvv27bF161bs3LkTGzduFDqO1iktLcXq1avx4YcfslhGRBpNKpXC19dX6BiNYsGCBUhMTMThw4eFjkJ/4+LFi5g5cyYWLFjAYhkREVETYsFMQ/To0QOXL18WOobaGDlyJD7//HN88MEHkEqlQsfRKj/++CPKy8vx4YcfCh2FiKjJZGRkIDs7G35+fkJHaRTu7u4YNWoUli5dCp58oL5yc3Mxfvx4DBgwAIsXLxY6DhERkUZjwUxDeHt7IzEx8bGDVLXNkiVLMGjQIISEhCA/P1/oOFqB3WVEpC0kEgl0dHTQo0cPoaM0mkWLFuHKlSs4ceKE0FGoAdXV1Xj55ZdhYmKCXbt2cRYnERFRE2PBTEP06NEDtbW1iIuLEzqK2tDR0cGOHTugp6eHiRMnNnjFR2pc7C4jIm0hlUrh7u7e4EVKWipvb28MHToUixYtYpeZGnrvvfdw5coVHDhwQHWlTCIiImo6LJhpCBcXF5ibmyM6OlroKGrF0tISBw4cwIULF7Bo0SKh42g0dpcRkTaRSCQaczrmg1auXAmpVIqwsDCho9ADfv75Z2zatAlbtmxB165dhY5DRESkFVgw0xAikQh+fn64cOGC0FHUjpeXFzZs2ICvvvoK+/fvFzqOxmJ3GRFpC4VCgejoaI0Z+P8gT09PvPzyy/jss89QU1MjdBzC/4b8L1y4kEP+iYiImhELZhokICAA58+fFzqGWpoyZQqmT5+OadOmITExUeg4GofdZUSkTa5fv46ioiKNLJgBwIoVK5Camopt27YJHUXrPTjkn53yREREzYsFMw0SEBCA1NRUZGVlCR1FLa1ZswadO3fGK6+8gtLSUqHjaBR2lxGRNpFIJDA0NISHh4fQUZpEhw4d8Oabb2LJkiWoqKgQOo7W4pB/IiIiYbFgpkF69eoFsVjM0zIfwdDQEPv27UNOTg7eeOMNDjRuJOwuIyJtI5VK4e3tDX19faGjNJmFCxfi3r17WLVqldBRtBaH/BMREQmLBTMNYmpqCg8PD56W+Rjt2rVDWFgYDh8+jC+++ELoOBqB3WVEpG00deD/gxwcHDB//nwsX74ct2/fFjqO1uGQfyIiIuGxYKZh+vTpw4LZ3+jbty/Wr1+PpUuXYteuXULHadHYXUZE2qayshJxcXEaO7/sQXPnzoWDgwMWLFggdBStwiH/RERE6oEFMw0TEBCAq1evoqysTOgoam3atGmYPXs23nzzTUilUqHjtFjsLiMibXP16lVUVlZqfIcZABgYGGDlypXYvn07zp07J3QcrcAh/0REROqDBTMNExAQgOrqakgkEqGjqL0ffvgBAwYMwJgxY5CdnS10nBaH3WVEpI0kEgksLCzg6uoqdJRmERISggEDBuCjjz6CQqEQOo5G45B/IiIi9cKCmYZxdnaGk5MT/vzzT6GjqD1dXV3s2LEDJiYmmDBhAiorK4WO1KKwu4yItJFUKoWfnx9EIpHQUZrNv/71L1y+fBkbN24UOopG45B/IiIi9cKCmQbiHLMnZ2lpicOHD+PatWt4++23hY7TYrC7jIi0lTYM/P8rDw8P/OMf/8C8efPYkd1EOOSfiIhI/bBgpoH69OmDP//8k6dOPKHOnTtj165d2LFjB1avXi10nBaB3WVEpI3kcjlu3bqlFQP//2rJkiWwsrLCxx9/LHQUjcMh/0REROqJBTMNFBAQAJlMhsTERKGjtBhDhgzBypUrMXfuXBw9elToOGqN3WVEpK2kUikUCoVWFsyMjY2xdu1a7Ny5E8eOHRM6jsbgkH8iIiL1xYKZBvLy8oKJiQlPy3xKc+fOxZQpU/Daa6+x2PgY7C4jIm0lkUjg5OQEe3t7oaMIYtiwYRg3bhw++OADXo27EXDIPxERkXpjwUwDicViBAQEIDIyUugoLc6GDRvQtWtXjBw5Enl5eULHUTvsLiMibVY38F+brVmzBvfu3cOnn34qdJQWj0P+iYiI1BsLZhoqKCgIERERnGP2lAwMDBAeHg5dXV2MHDmSR9D/gt1lRKTNJBKJVp6O+SAHBwf8+OOPWLt2LX777Teh47RYHPJPRESk/lgw01CDBw/G3bt3ERMTI3SUFsfa2hrHjx9Hamoq3njjDRYd/x+7y4hIm2VmZiI7O1vrO8wA4LXXXkNISAjeeustyGQyoeO0OBzyT0RE1DKwYKahvLy8YGdnhxMnTggdpUVycXHBgQMHcPjwYXz++edCx1EL7C4jIm0mkUigo6MDHx8foaOohXXr1qG6uppXzX1S0F8AACAASURBVHxKHPJPRETUcrBgpqFEIhEGDhzIgtlzePHFF7F161Z8/fXXWLdundBxBMXuMiLSdlKpFC+88ALMzMyEjqIWWrdujQ0bNiA0NJRXl35CHPJPRETUsrBgpsEGDx6Mc+fOoby8XOgoLdbEiROxcOFCfPjhh1pdfGR3GRFpO6lUqvXzy/5q9OjRmDx5MmbMmIF79+4JHUftccg/ERFRy8KCmQZ76aWXUFFRgXPnzgkdpUVbsmQJJk6ciPHjxyM2NlboOM2O3WVEpO2USiWio6NZMGvAv//9b4jFYnzwwQdCR1FrHPJPRETU8rBgpsEcHR3RpUsXre6MagwikQg//fQTfHx8MHz4cGRlZQkdqVmxu4yItN3169chk8k48L8BFhYWCA0Nxc6dO7F3716h46glDvknIiJqmVgw03CDBw9mwawR6OvrY9++fTAxMcHo0aNRWloqdKRmwe4yIqL7A/8NDAzg4eEhdBS1NHjwYEyfPh2zZ89GXl6e0HHUCof8ExERtVwsmGm4wYMHIyYmBrm5uUJHafGsrKxw5MgRpKWl4dVXX0Vtba3QkZocu8uIiO7PL/P29oaBgYHQUdTW999/j1atWmHKlClQKBRCx1ELHPJPRETUsrFgpuEGDBgAsViMP/74Q+goGsHNzQ3Hjh3DyZMn8e677wodp0mxu4yI6D6JRMLTMf+GmZkZdu/ejVOnTmHlypVCx1ELHPJPRETUsrFgpuFatWoFf39/npbZiPz8/PDf//4XoaGhWLFihdBxmgy7y4iIgKqqKsTGxnLg/xPo2bMnvv76ayxatAiRkZFCxxEUh/wTERG1fCyYaYHBgwfj999/FzqGRgkODsbatWuxYMECbN26Veg4z0WpVD70GLvLiIjuu3r1KiorK1kwe0IffvghRo0ahddffx13794VOo4gOOSfiIhIM7BgpgWGDBmCrKwsxMXFCR1Fo8ycOROffvop3n77bfz2229Cx3lmo0ePxnfffVfvQgbsLiMiuk8ikcDc3Bxubm5CR2kRRCIRNm/eDH19fbz++utaN8+MQ/6JiIg0BwtmWsDX1xd2dnY4fPiw0FE0zooVKzB58mRMmDABly9fbvB3SkpKGuziUhfnzp3Dxx9/DCcnJ3z33XfIy8tjdxkR0f+TSqXw8/ODjg53mZ6UhYUFdu3ahYiICHz77bcPPX/s2DGEhoYKkKxxVFRUYOnSpQ9d/IdD/omIiDQL9/60gI6ODkaMGMGCWRMQiUTYtGkT+vTpg6FDhyIpKane8/n5+RgwYIDanhJbVlYGmUwGACgsLMT8+fPRoUMHFBUV4a233hI4HRGR8Djw/9n4+flh+fLlWLBgAc6dOwfg/giAr7/+GiNHjsS//vUvgRM+uyNHjmDx4sUYNmwYCgsLVY9zyD8REZFmYcFMSwQHB0MikSA3N1foKBpHT08Pe/fuRdu2bTFs2DDk5eUBANLT09GrVy9ER0dj9erVAqdsWGpqar3ut5qaGpSVlaGmpgbe3t5YsmQJioqKBExIRCQcuVyOmzdvcn7ZM/roo48wYsQITJo0CZmZmZg8eTI+++wzKJVKxMXFISEhQeiIz2T79u3Q1dXFH3/8ge7duyMuLg4bNmzgkH8iIiINw4KZlnjppZdgaGiIo0ePCh1FI7Vq1QpHjx5FTU0NgoODER0djV69eiEjIwMA8Pvvv+PmzZsCp3xYWlpag4/X1tZCJpNh2bJlaN++Pb777juUlZU1bzgiIoFdunQJCoWCBbNnJBKJEBoaCoVCgd69e2P//v2qmWZ6enrYsWOHwAmfXlFREY4fP47a2lrU1NQgOzsbvr6+eP/997FgwQIO+SciItIgLJhpCSMjIwwaNIinZTYhe3t7HDt2DHfu3MHAgQNRUFCA6upqAIBYLMa6desETviwtLQ06OnpPfL52tpaFBYW4sSJExCJRM2YjIhIeBKJBG3btoWDg4PQUVqsGzduoKKiAnfu3FGticD9eV9bt25tcRcF2Lt3b73ZZTU1NaisrER1dTUqKioemmtGRERELRcLZlokODgYJ06cQHl5udBRNFZWVhby8vJQVlb20BeDjRs3qt3pjampqY8thInFYgwZMgTh4eEwMjJqxmRERMKrG/hPz2b79u0YMGAA5HJ5vTWxTk5ODs6cOSNAsmf3yy+/PPK5VatWYciQIfXmmhEREVHLxYKZFhk1ahQqKirw66+/Ch1FI+3YsQNDhw5FZWVlg0eYKysrH7ujLYSUlJQGv8QAgK6uLoKDg3H48GEYGho2czIiIuFJJBKejvkMampq8P7772PKlCmorq5+ZNeVnp6e2q2Lj5OTk4OzZ88+8v3U1tbi9OnTqrlmRERE1LKxYKZF7OzsEBAQgP379wsdReP88MMPmDJlChQKxSNPL1EoFFi9enW9IftCu3HjRoN5dHV1ERISgj179jz2lE0iIk2Vk5ODrKwsdpg9g/z8fNVVo3V0Hr2rWV1djd27d7eYzvfdu3c/9v0A9+e2FRQUICoqqplSERERUVNhwUzLhISE4NChQ6ioqBA6isYoKCjAwYMHoVQqH7sjrVQqkZycjBMnTjRjuseruyjBg3R1dfHyyy9jx44dEIvFAqQiIhJeVFQURCIRevToIXSUFsfe3h7Hjx/HoUOHYGdn99i1pKysDEeOHGnGdM/u559/fmR3Wd36HxQUhGvXruGtt95qzmhERETUBFgw0zLjx49HSUmJWhVtWjpra2ucOnUKJ06cgLu7O0Qi0SPngonFYqxevbqZEzZMLpejuLi43mM6OjqYNm0atm/fzmIZEWk1qVSKLl26wMLCQugoLVZwcDBu3bqFzz77DGKxuMF1RUdHB1u3bm3+cE8pOTkZMTExDXZl6+npoXXr1ti7dy+OHTsGZ2dnARISERFRY2PBTMs4OjqiV69ePC2zCQQFBSEmJga7d++Gk5NTg91mNTU1+O2333Dz5k0BEtaXmppa7886Ojp4++23sXHjxr895YSISNNJJBKejtkIjI2N8cUXXyA6Oho+Pj7Q0dGpd1CptrYWv/32G+7evStgyr/X0IEksVgMkUiEqVOnIikpCePHjxcoHRERETUFfivWQiEhIQgPD0dVVZXQUTSOSCTChAkTkJSUhHXr1sHa2hq6urr1fkcsFmPdunUCJfyfBwtmIpEI//znP7Fu3brHXjWTiEgbKJVKXLp0iQP/G5GnpycuXLiALVu2wMLCot58TJFIhN27dwuY7u9t37693kVydHR00LlzZ1y8eBEbN25Eq1atBExHRERETYEFMy0UEhICuVyOkydPCh1FY+np6eHtt99Geno6li9fDmNjY9WXg+rqamzcuBFFRUWCZkxLS1PdX7hwIb799lvhwhARqZEbN25AJpOxw6yRiUQivP7667h58yZeffVViEQiiMVi1NbWYvPmzULHe6To6GjVRQz09PRgYGCAFStWICYmhv+NEBERaTCRUp0u2UfNpnfv3nBzc8O2bduEjqIV7ty5g6VLl2LDhg0A7p+CsnbtWrz77ruP/DsKhQJyuRxlZWUoLy+HXC4HcH/22INX4lQqlZDJZA/9fXNz83qnVopEItUsHjMzM6xcuRKbN2/G8uXL8dlnnzXK+yQi0gTbtm3D22+/DblcDgMDA6HjaKxz585hxowZuH79OgDg5s2bcHNzq/c7paWlqKqqQlFREWprayGTyaBUKlFTU/PQHE4AqKqqQmlpaYPbs7CweKiL+sG1UV9fHyYmJjA0NISRkRFMTEygr6+PuXPn4vvvvwcAjBgxAuvWrYOTk9Nzv38iIiJSa1UsmGmpNWvWYP78+bhz5w5MTEyEjqPRampqkJubi9u3byMuLg6hoaGQSqWwsrLCuHHjUFBQgIKCAty7dw8lJSWqIlllZWWzZaz7kmBubg4TExNYW1vD2toaVlZWaN26NVq3bg0rKytYW1vDxsYGTk5OsLOzq3dKDRGRpnj//fchlUpx8eJFoaO0aPn5+apbYWEhZDIZ5HI55HK56n5hYSHi4+ORnJwMc3NzmJqaoqSkBBUVFSgvLxf6LQCA6mI+NjY2sLS0hIWFBczNzWFubg4LCwvV7cHHLC0tYWtrC1tbW5iamgr9FoiIiOjpsWCmrfLz8+Hg4IDt27fjlVdeETpOiyaTyZCcnIzk5GSkpKQgOzsbt2/fRnZ2NrKyspCbm1uvI8zExAStWrVCaWkp3Nzc0KlTJ1WBytTUFObm5jA2NoahoSEsLCxgZGQEIyMj1RHwuiPeD/prN1lDXWfV1dUoKSlRZT537hzc3d0hl8tRUVGB0tJSFBUVoaSkRFXEKygowN27d1X36/4+cH9+i62tLRwdHeHg4ABnZ2c4ODigQ4cOcHFxgaurKywtLRv935uIqKn16tULvr6+WLNmjdBR1E5VVRUyMzORmZmpWutyc3ORn5+PvLw81f38/HzU1NTU+7t1B2bqikoP3tfR0UF8fDzGjBkDU1NTVZeXsbExDAwM0KpVK4jF4nrrXUNrjI6ODszNzR96vLa2tsFRCA+ujZWVlaqu7rp18erVq4iMjERISAgqKipQWVlZr+Ank8lUt7pi4F9nxBoZGcHGxgb29vawsbGBjY0N7OzsYGtri7Zt26Jt27ZwdnaGnZ0d54gSERGpDxbMtNnQoUNhYGCA8PBwoaOoverqaty4cQNxcXFITExUFciSkpJQUFAA4P4wfycnJzg6OsLJyQkODg5o27YtHB0d4ejoiLZt28LW1rbe6T35+fmwsbER6m09tcrKSuTn59crCGZmZiI7OxsZGRnIyspCRkaGajCylZWVqnjm4uKCLl26wMPDAy+88AK704hILVVVVcHMzAwbN27E66+/LnScZldZWYnk5GTcvHkTKSkpuH37Nm7fvq36fM/NzUXdrqO+vj7s7e3rFYL+WhRq06YNbGxsYGVl1SI/96uqqh46SPV3ysrKcO/ePdy5cwd37txpsJiYk5OjeuzBf08HBwc4OTmhXbt2qkKam5sbXF1d4ezszKtYExERNR8WzLTZtm3b8NZbbyEnJwfW1tZCx1Eb+fn5iI6ORmxsLOLi4lRFsqqqKujp6akKQHU3FxcXuLi4oH379i3yy0Bjq6mpQXp6OpKSklRFxeTkZNy6dQtJSUmorq6Gnp6eqnjm6ekJDw8P+Pj4wNbWVuj4RKTlpFIp/Pz8kJiYiC5duggdp0koFAqkpKQgMTERt27dUn0+37p1CxkZGaquaEdHR1Xhpq544+TkhLZt26pOzWdH1POpqqpSHXxKT0+v172XkZGB9PR0FBYWAgAMDAzg4uKiKqC5ubnBzc0N3bp1Q5s2bQR+J0RERBqHBTNtVlxcDDs7O6xatQozZ84UOo4gampqcOPGDZw/fx7nzp1DdHQ0EhMToVQqYWlpCXd3d/j4+KBr166q+0ZGRkLHbrFqampw+/ZtJCQkIDo6GteuXUNCQoLq39ze3h4+Pj7o27cvAgIC+O9NRM1u7dq1+Pzzz3Hv3j2N6OaRyWSIj49Xfd5GR0cjJiZGdRqipaUlOnbsiI4dO8Ld3R1du3ZFx44d0alTJ7Rq1Urg9AQAhYWFSElJqXdLSEhAfHy86oJAdfssD+6veHt7c04tERHRs2PBTNtNnjwZ6enpOH/+vNBRmkV1dTUuXryIiIgInDx5EpcuXUJlZSWsrKzg7++vuvn5+cHKykrouFpDJpNBIpEgKipKdbt79y709fXh4+ODwMBABAUFoXfv3k99agwR0dOYOnUqsrKycOLECaGjPDW5XF7vs/TSpUvIzc0FAFhbW8PLywvdunVDt27d4OnpCXd3dxbFWrjc3FzEx8erOuLj4uKQkJCA8vJy6OrqwtXVFX5+fqr9Gy8vL3bDExERPRkWzLTd77//jiFDhuDatWt44YUXhI7TJK5fv47jx48jIiICp0+fRklJCdq1a4egoCD0798f/v7+cHNz42klaiYpKQkXL17EmTNnEBERgZSUFBgbG6Nfv34IDAzE0KFD0a1bN6FjEpGGcXd3x9ixY7F8+XKho/ythIQEnDt3TlUgu379OhQKBZydneHv7w9fX194eXnBw8MD9vb2QselZlJbW4uUlBTExsYiJiYGUVFRkEgkkMlkMDQ0RI8ePVQFtP79+8POzk7oyEREROqIBTNtp1Ao0KFDB0yaNAkrV64UOk6jSUhIwN69e3HkyBFER0fD1NQUvXr1QlBQEIKCguDj4yN0RHpK2dnZOH/+PE6ePImjR48iKysLHTp0QHBwMCZMmICAgAAWPYnouRQXF8PCwgL79+/HmDFjhI7zkAc/B48fP46MjAyYmprCy8sLPj4+8PHxQb9+/dC+fXuho5Iaqvvvp24ERV2XfceOHVX7R4GBgeywJyIiuo8FMwIWLVqEjRs3IjMzE2KxWOg4zyw+Ph6bN2/GgQMHkJ6ejnbt2mHs2LEYO3YsAgICoKurK3REaiQKhQIXL17EgQMHEBYWhpSUFLRt2xbjxo3DtGnT0L17d6EjElELFBkZicDAQGRmZsLR0VHoOKioqMCJEydw6NAhREREIDU1FcbGxujbty8GDRqEQYMGoUePHlzf6JmUlpbi7NmziIiIQGRkJK5evQqRSIQePXpg8ODBGDt2LHx8fHgwioiItBULZgSkpqbCxcUFhw4dwsiRI4WO81SKi4uxa9cuhIaGIioqCi4uLpg0aRLGjh2LHj16CB2PmsnVq1cRFhaGXbt24ebNm/Dx8cH06dMxefJkmJubCx2PiFqIlStX4scff0R2drZgGeRyOY4dO4awsDAcP34cZWVl8PX1xZAhQzBo0CD06tULBgYGguUjzXXv3j2cOnUKkZGROHr0KNLS0uDk5IQxY8Zg7Nix6NevH4uzRESkTVgwo/sGDhwIKysr7N+/X+goTyQ5ORnffvsttm/fjtraWoSEhGD69OkYMGAAj4RqMaVSibNnzyI0NBT79u0DAEyaNAmffPIJOnXqJHA6IlJ3ISEhUCqVOHDgQLNut6qqCocPH8aWLVtw4sQJKJVK9O/fH+PGjcPo0aPh4ODQrHmIAODKlSsICwvDwYMHERcXB2tra4wfPx5vvvkm/Pz8hI5HRETU1Fgwo/t++eUXTJ8+Hbdv31br4a/x8fFYuXIldu/eDWdnZ8yZMwevvfYaLC0thY5GakYul2Pnzp344YcfkJSUhAkTJmDevHk8XZOIHsnJyQnvvvsu5s+f3yzbS0xMRGhoKH755RfcvXsXQ4YMwaRJkzBy5Eiua6RWkpKScODAAWzbtg0JCQnw8PDA9OnT8dprr8Ha2lroeERERE2hSkfoBKQexo8fDzMzM4SGhgodpUHp6ekYP348PD09ERMTg61bt+LGjRt4//33+aWCGmRubo5Zs2YhMTER//3vf3Hjxg306NEDY8aMQXJystDxiEjN5ObmIjMzs1k6Z44ePYoXX3wR7u7u2L9/P2bPno20tDQcO3YMU6ZM4bpGasfV1RWffPIJ4uPjceHCBfj7+2PhwoVwdHTEG2+8gevXrwsdkYiIqNGxYEYAACMjI0ydOhUbNmxAbW2t0HFUqqqqsGLFCri7uyM+Ph5hYWGIjY3Fq6++2qIvUEDNR0dHBy+//DIuX76Mw4cPIykpCd26dcOSJUtQUVEhdDwiUhNRUVEQiURNdhVlpVKJQ4cOwdfXF8HBwbCwsMDvv/+O5ORkLFq0CE5OTk2yXaLG1qtXL2zatAnZ2dlYu3YtpFIpunbtismTJyMhIUHoeERERI2GBTNSmTVrFrKysnD06FGhowAApFIpPD09sXz5cixYsACxsbEYPXo0Z5TRMxGJRBgxYgSuXLmCZcuWYdWqVejWrRvOnz8vdDQiUgNSqRSdO3eGhYVFo7/2mTNnVB2ubdu2xaVLl3D48GEMHjwYOjrcFaOWydTUFNOnT0d8fDx27tyJuLg4eHp6YuLEicjKyhI6HhER0XPjXhqpuLi4IDAwEOvWrRM6CkJDQ9GvXz+0a9cO165dw/z586Gvry90rGeydetWiEQi1RD6p1FRUYFPPvkEHTt2hFgshkgkQklJSROk1B56enr46KOPkJiYCHd3dwwaNAhr164VOhYRCUwikTT66ZhFRUWYNWsWBgwYAEdHR9UQdXW7ivOlS5cgEomwZMmSxz6mDrimqh8dHR288soriImJwd69e3H58mV07doVGzZsAEclExFRS8aCGdUza9Ys/Pbbb7h165Yg26+trcWsWbMwY8YMfPTRRzh27BjatWsnSJa/OnfuHEQiEZYtW9Zs2/zqq6/w7bffIjU1tVlOlRXiPQrF0dER4eHhWLhwIT744ANMmzYN1dXVQsciIgEolUpcunQJvr6+jfaav/76K7p27YoDBw5g586dOHLkCLy8vBrt9Vs6rqmaR0dHB+PGjUNMTAzeeecdvPfeexg4cCDS0tKEjkZERPRMWDCjeoKDg+Ho6IhNmzY1+7YVCgVef/11bNu2DQcOHMCyZcugq6vb7DnUSXh4OMzNzXHt2jXU1tZCqVTC1NRU6FgaQyQSYcGCBThy5Aj279+PiRMnoqamRuhYRNTMbt68icLCwkbrMPv2228xYsQI9OvXD9euXcPEiRMb5XXp+XBNbR5GRkZYuXIloqKicO/ePfj5+XH8ARERtUgsmFE9YrEY77zzDn766SeUlpY267YXLVqEAwcO4NChQxgzZkyzbltdZWZmonPnznjhhRc456YJDRs2DMeOHcOvv/6Kjz/+WOg4RNTMpFIp9PX1G6UD7IsvvsC8efPw/fffY8eOHbC2tm6EhNQYuKY2rx49euDChQsICAjAkCFDcObMGaEjERERPRXuLdBDZs2ahaqqKmzZsqXZtnn69GmsWLECa9asQWBgYLNtF7h/GuiaNWvg4+MDS0tLWFhYoGfPnli1ahXKysoAAMuWLcOLL74IAFi4cCFEIpHqVkcmk+G9996Dvb09jIyM0LNnTxw5cuSZMs2ZMwcikQgFBQWQSCSqbb3zzjuq31Eqldi8eTP69OmDVq1awcjICF5eXli7du1DM0POnDmDV199Fa6urjAwMICNjQ2Cg4PrHfH9u/f4008/PXJuTN1zBw8eVD3266+/QiQS4YcffsDp06fRv39/tGrVCj179nzq/M2hb9+++Omnn/DDDz/g119/bfbtE5FwpFIpvLy8YGBg8Fyv8/PPP+OLL77Axo0bMWfOnEZK9+ye5LO/sXFNxRO9R01fU+uYmJhg7969GD58OEaNGoXk5GTBshARET01JVED3nnnHWWHDh2UNTU1Tb4thUKh9PT0VI4YMaLJt9WQjz/+WAmgwduaNWuUSqVS+eWXXz7yd5RKpbK8vFzZvXv3h54TiUTKV155RQlAuXfv3ifO9OGHHza4rZkzZyqVyvv/Zq+++uojM82YMUP1Wjk5OY/8PbFYrDx9+vQTvcdNmzY98n3UPRcWFqZ67Pjx40oAygkTJijFYrHqtby9vZ8qf3ObMGGCslOnTsra2lrBMhBR8+rVq5dy9uzZz/Ua6enpSmNjY+Unn3zSSKmez5N+9iuVSqVUKlUCUC5evPixjz0JrqlcUxtSUVGh7NGjh7JXr15KhUIhdBwiIqInUckOM2rQP/7xD6Snp+Pw4cNNvq1Tp04hNjYWy5cvb/JtNeTgwYMwMTHB/v37IZPJUFpaiqtXr2Lu3Lmq2SYLFizA2bNnAQBffvkllEql6gYAa9aswdWrV9G5c2ecPHkSxcXFSElJwaxZs7B79+6nzvTDDz9AqVTC3Nwc/v7+qm2tX78eALB9+3bs2LEDHh4eOHbsGAoKClBSUoLTp0/Dy8sLmzZtwoULFwDcn9M1ePBgHD58GBkZGaiqqsKdO3ewZ88eGBgYYOXKlU/0Hp/V3r178frrr+PGjRuoqanB5cuXnyp/c1u2bBmSkpJw7NgxQbZPRM2ruroaMTExzz3w/8svv4S9vb3aDHh/0s/+xsY1lWtqQwwMDLB582ZIJBKEh4cLmoWIiOhJiYUOQOqpU6dOGD58OFavXt3k88SOHDkCT09Pwa4e1rZtWwDAqFGjIBbf/7+El5fXU+XZv38/RCIR9u/fj65duwIATE1NsXbtWty4cQMRERGNmnnLli3Q1dXFb7/9Bnt7e9Xj/fr1w86dO9G1a1eEh4ejd+/esLW1xVdffYWvv/4aM2fORF5eXr3B9nFxcY2a7a969eqlOr3kWfI3t06dOsHf3x+HDx/GyJEjm337RNS8YmJiUF5e/lwD/ysrK7F37158+eWX0NPTa8R0z06oz36uqVxTH8XLywuDBw/GL7/8wlm1RETUIrBgRo/0j3/8A4GBgZBIJI125bCGxMfHP/eR/eexevVqhISEwNXVFUOGDIGXlxd69+4Nb2/vJ36NpKQkODo6qnbsHzR06NBG37lPSEhAbW0tnJycAKDeUeu6n7dv3wYA/Pnnnxg4cCCqqqoafK3y8vJGzfZXQUFB9XbsgafLLwRfX19cunRJsO0TUfORSCRo1aoVOnfu/MyvkZSUBLlcjkGDBjVisucj1Gc/11SuqY8TGBiIf//730LHICIieiI8JZMeadCgQfD29sZ3333XpNspKSlBq1atmnQbj+Pl5YXr169j27Zt6NChA86ePYuhQ4eia9euTX6k+FkpFAoA94cr19bWQqFQPHSqR93O/MqVK1FVVYXFixcjKSkJ5eXlqt9/mi+IdVcUq9v2gx73BaGhK8Q9TX4hmJmZobi4WLDtE1HzkUql8PPze66rJsrlcgCAhYVFY8V6bo312f+0uKY+GW1aUx9kYWGh+v8LERGRumOHGT3WvHnzMGnSJFy7dg3u7u5Nso02bdogOzu7SV77SYnFYvTr1w/9+vUDAJSVlaFz586YPn06JBIJgP/t3D546kUdV1dXSCQSJCQkPHREvCmuuNilSxdcvnwZ2dnZMDc3f+zvpqSkwNbWFkuWPulRLwAAIABJREFULKn3eHJyMm7dugVLS0vVY497j23atAEApKamPvRcZGRkk+UXQlZWFuzs7ISOQUTNQCqVIjg4+Llew8HBAcD9z0dHR8fGiPXcnuazv7FxTb2Pa+rDUlNTVaftEhERqTt2mNFjjR8/Hl26dMG3337bZNvo3bs3Tp8+3eAOZXPo06cP1q9fj2vXrqG8vBxyuRy//vorCgoKkJKSovo9KysrAMDZs2dRUFBQ7zVCQkKgVCoREhKCyMhIlJSUIDU1FbNnz270U0cAYPr06SgrK0NQUBCOHDmC/Px8VFVVIT09HUePHkVISIhqu87OzsjLy8O///1vyOVyyOVyHDt2DMOHD3/oyPbj3mNdwfSHH37AqVOnUF5ejrS0NHz00Uc4ePBgk+VvbgqFApGRkYLPeiGipldcXIzr168/91iA9u3bw83NDfv372+kZM/vaT77GxPX1P/hmlqfQqHAgQMHEBQUJHQUIiKiJ9NEl98kDbJlyxalnp6eMjU1tUlePzU1Vamrq6vctWtXk7z+3zEwMHjkpdg/+OAD1e/V1NQoHR0dG7w8fHl5ubJ79+4PPScSiZSvvPLKIy8d/3fMzc2V/v7+Dz2uUCiUU6dOfWRuAMrjx48rlUql8uDBgw0+7+3trezWrZvS2tr6id6jUqlUjhs37qHnxGKxcsqUKUoAyrCwMNXvHj9+XAlAuXr16ufK39zCw8OVIpFIee3aNUG2T0TNJzIyUglAmZGR8dyvtXr1aqWRkZEyLS2tEZI9v6f57JdKpUoAysWLFz/2sSfBNZVr6qNs3rxZKRaLlYmJiUJHISIiehKV7DCjv/Xqq6/C0dGxybrM2rdvj8mTJ+PTTz9FSUlJk2zjcaKiojB79my4u7vDyMgIrVu3RkBAAH766SesXr1a9Xu6urrYt28f+vbtCxMTk3qvYWhoiD/++APvvvsubG1tYWhoCG9vb4SFhWHo0KGNnlkkEmHLli3YvXs3goKCYGlpCX19fXTs2BFjxoxBWFiY6gju6NGjsWPHDnh6esLIyAj29vaYOXMmIiIiYGBgUO91H/ceASA0NBRvvvkmrK2tYWhoiN69e+PkyZOq026aIn9zqqiowMcff4xx48bhhRdeaPbtE1HzkkgksLe3b5RTxGbNmgUXFxdMnDgRlZWVjZDu+TzNZ39j4pr6P9q+pj7o+vXr+PDDD/H++++jS5cugmYhIiJ6UiKl8oGJoESP8J///Af//Oc/kZKSoprV0pju3LkDDw8PDBw4ELt27XroClBEzWHatGk4ePAgYmNjVVcbIyLNNX78eNTW1iIsLKxRXu/69evo3bs3+vbti3379jVpYYqopUhOTsaAAQPg5OSEU6dOQV9fX+hIRERET6KKHWb0RN58801YWVk1WZeZra0tdu3ahbCwMHz44YdNsg2ix/n000/xyy+/YMeOHSyWEWkJiUTy3PPLHtSlSxf8+uuvOHv2LIKCgpCXl9dor03UEp07dw69e/eGnZ0djh07xmIZERG1KCyY0RMxNDTE/PnzsX79emRkZDTJNgYNGoSdO3di3bp1mDhxIkpLS5tkO0K6evUqRCLR397GjBkjdFStUVFRgalTp+L777/H1q1bMXz4cKEjEVEzyM3NRUZGBvz8/Br1df39/SGRSJCfnw8PDw9s27atUV9fCOq6dqlrLrq/ti5ZsgSBgYHw9fVFREQELCwshI5FRET0VFgwoyc2c+ZM2NvbY/ny5U22jfHjxyMiIgKnTp1Cz549cf369SbbFlFmZib69++PsLAw7N+/H6+99prQkYiomUgkEohEIvj4+DT6a3fq1AkSiQQTJ07EtGnTMHLkyCY72ESkbv788094e3vju+++w9KlS3H48GGYmZkJHYuIiOipcYYZPZXQ0FDMmjULiYmJcHFxabLtpKenY9y4cUhOTsayZcswa9Ys6OrqNtn2SLsoFAqEhoZi/vz5cHBwwIEDB+Dq6ip0LCJqRgsXLsTevXub/MDMqVOnMGPGDOTl5eH999/HnDlz0Lp16ybdJpEQYmNjsXz5cuzbtw/Dhg3D+vXrG+WCGkRERALhDDN6OlOnToWLiwu++OKLJt1Ou3btcO7cObzzzjv46KOP4OvriwsXLjTpNkk7XLp0Cb1798a7776L119/HRcuXGCxjEgLSSSSRj8dsyEDBgxAbGws5s+fj40bN6JDhw745JNPON+MNMbly5cxduxYdO/eHTdu3MC+fftw5MgRFsuIiKjFY8GMnoquri4WL16MHTt2IDY2tkm3ZWRkhJUrVyImJgZWVlYICAjAxIkTERMT06TbJc2UkJCAKVOmwN/fH4aGhrhy5QpWrVoFExMToaMRUTNTKpWIjo5u1IH/j2NkZIR58+YhNTUVixcvxrZt29ChQwe8+eabOH/+fLNkIGpMlZWV2LVrF4KCgtCzZ09kZGQgLCwMV65cwdixY4WOR0RE1ChYMKOn9vLLL6Nbt25YtGhRs2yvS5cuOHnypOrUGW9vbwQHB7PjjJ6IVCrFuHHj4OnpiStXrmDHjh04deoUunXrJnQ0IhJIUlISCgoKmqXD7EEmJiaYO3cuUlNT8e233+Ly5cvo27cv3N3dsWrVKuTn5zdrHqKnFR8fjzlz5sDR0RFTpkyBsbExjh49ikuXLmH06NEQiURCRyQiImo0nGFGzyQyMhKBgYE4ceIEgoKCmm27SqUSR48exYoVK3DhwgX06dMHb731Fl5++WV2CpFKeXk59u3bh9DQUJw+fRq+vr747LPPMGrUKOjo8DgBkbbbsWMHpk2bhqKiIhgaGgqa5dKlSwgNDcV///tflJeXIygoCGPGjMHo0aPRpk0bQbMRAfc7tMPCwhAWFobLly/DxcUFb775JqZOnQoHBweh4xERETWVKhbM6JkNHz4cOTk5iI6OFqQI8ccff2D9+vUIDw+HgYEBXnnlFUyfPh3+/v7NnoXUQ3R0NEJDQ7Fz506UlZUhODgYs2bNataiLhGpvzlz5uD8+fOQSqVCR1EpKyvD/v37sX//fvz++++oqqpCnz59MHbsWIwZMwYdOnQQOiJpCYVCAYlEoiqS3bp1C/b29hg1ahQmTpyI/v37s5OMiIi0AQtm9OwSExPh6emJTZs2YerUqYLlkMlk2LNnD9atW4erV6+iffv2GDVqFCZMmIA+ffqwo0jDJSQkYO/evdizZw8SExPRuXNnTJs2DVOnToWtra3Q8YhIDfXp0wfe3t5Yu3at0FEaVF5ejpMnT+LIkSM4ePAg8vLy0LFjRwQFBSEgIABBQUHs7KFGlZKSgpMnT+LcuXOIiIhAdna2an8qODgYAwYMgFgsFjomERFRc2LBjJ7Pu+++i/DwcNy8eVMtTomUSqXYt28fDhw4gKSkJDg4OGDMmDEYNWoUXnzxRRgbGwsdkZ5TeXk5zp8/j8OHDyMsLAwZGRno0KEDxo0bh5CQEPTu3VvoiESkxqqrq2Fubo7//Oc/gh7seVLV1dU4c+YMIiIiEBkZiUuXLkGpVMLT0xOBgYHo378//P39efomPTGlUolbt27h4sWLiIyMRGRkJDIyMmBqaor+/ftj0KBBeOmllzjrk4iItB0LZvR88vPz4ebmhjlz5mDJkiVCx6knLi4OBw4cQFhYGGJiYmBgYIDevXsjMDAQgYGB8PX15dHSFqC2thbR0dGIiIhAREQEzp8/j4qKCnTt2hXjxo3D2LFj4e3tLXRMImohoqOj0bNnTyQkJMDd3V3oOE9NLpfj9OnTiIyMREREBBISEqBUKtGhQwf4+/vD398ffn5+6NGjh+Dz2Ug93L17FxKJBBKJBFFRUZBIJLh37x4MDAzQq1cvBAYGYtCgQfD39+d+ERER0f+wYEbP75tvvsEXX3yBa9euoV27dkLHaVB2djYiIiJw8uRJREREICsrC2ZmZggICECvXr1UXzIsLCyEjqr15HI5JBIJLl68iKioKJw/fx4ymQz29vaqYmdgYCCcnJyEjkpELdD69evxySefQCaTacQp+4WFhaoiSN3Pu3fvQk9PDx4eHvDy8kK3bt3g6ekJDw8PnqquwRQKBVJSUhAbG4u4uDjExcXh6tWrSE5OBgC4urrCz89Ptc/TvXt3GBgYCJyaiIhIbbFgRs+vqqoK3bt3R+fOnREWFiZ0nCdy/fp1VbdSVFQUUlJSIBKJ0LlzZ9WOpIeHBzw8PGBubi50XI1VVFSE+Ph4xMbGqr7sXb9+HQqFAu3atUOvXr3Qp08fBAYGomvXrkLHJSINMH36dKSmpiIyMlLoKE0mKSkJUVFRiI6ORlxcHGJjY5GXlwcAsLGxURXPunbtCldXV7i5ucHR0VHg1PSkqqurkZaWhlu3buHmzZtISEhATEwMrl27htLSUujo6KBDhw7w9PSEp6cn/Pz84Ofnh9atWwsdnYiIqCVhwYwax+nTpzFw4ECEh4cjODhY6DhPLS8vD1FRUYiKisLFixcRHR0NmUwGAHB2dka3bt1UBTR3d3e4urqiVatWAqduOUpKSpCUlITExETExsYiPj4e8fHxSEtLAwCYm5ujR48e9br97OzshA1NRBrJw8MDI0aMwMqVK4WO0qzy8vLqdR7FxcUhMTERpaWlAABjY2O4ubmpCmh1P52dneHo6Ag9PT2B34F2KS0txe3bt5Geno5bt26pbklJSUhLS0NNTQ2A+wVQDw8P1X6Kp6cnunbtqhZzZYmIiFo4Fsyo8UyePBnnz5/HtWvXNGJH7fbt2/W+WMTHxyMxMRHV1dUAAFtbW7i6uta7dezYEW3btoWdnZ1GnOrzpBQKBe7cuYPMzEykpKQgKSmp3i03NxcAoKenh86dO9c7Pahbt25o3769sG+AiLRCSUkJLCwssHv3boSEhAgdRy1kZ2erCjFJSUn17tcV03R0dGBnZwdnZ2c4OTmhbdu2aNeuHdq2bQtHR0fY29vDxsaGF9Z5QjKZDLm5ucjPz0d6ejoyMjKQmZmJ27dv4/bt28jMzMS9e/dUv29jY6MqYNYVM+v+zC54IiKiJsOCGTWe3NxcvPDCC5g9ezaWLVsmdJwmUV1djeTk5HrFoLo/p6enq4ppYrEYtra2cHJygr29PZycnODg4ABbW1tYW1s/dBOJRAK/s4cplUrcu3cPBQUF9W537txBVlYWMjMzkZOTg4yMDOTm5qqOdovFYrRr1w4uLi4PFRRdXFygr68v8DsjIm116tQpDBw4ELdv3+YcxCeQk5OD27dvqwo6fy3u5Obm4sHdSBMTE9ja2sLW1hY2NjYwNzeHs7MzbGxsYGlpCQsLC5ibm9f72ZJnh9bU1EAmk0Eul0Mmk6GwsLDe/ZycHNy9exf5+fnIzc1FXl4e8vPzUVVVpXoNfX19ODo6wsnJSVWEdHJyUv3Z2dmZRTEiIiJhsGBGjevHH3/Exx9/jKtXr+KFF14QOk6zqqmpQUZGRr1i0u3bt5GTk4PMzExkZWUhLy8PZWVl9f6eSCRSFc5MTU1hbm4OQ0NDmJiYwMzMDEZGRqr7urq6EIlED33BMDIyqnc1tMrKyoe2I5fLoVAoUFtbi6KiIpSWlqKiogJyuRxlZWWoqKiATCZDSUmJqjj2148HIyMjtGnTRtVV4ODggLZt26p+1u3089QdIlJH33zzDVavXo2cnByho2iEqqoq5OTkqLql6gpDaWlpOH78OORyOdq3b4/8/HwUFhaioqKiwdepK5yZm5tDT08PFhYW0NXVhZmZGfT19WFiYgJDQ0MYGRnB2NhYNaheLBY3OB7B1NT0oXWorKwMlZWV9R5TKpWq8QvA/Q7E6upqFBUVoba2FjKZDLW1tZDL5aipqUFxcTHKy8tVRbG6Dry/MjMzg4WFharzrnXr1vUKiTY2NrCzs0ObNm1gZ2enlgfNiIiIiAUzamS1tbXw8/ODoaEhzpw5A11dXaEjqZ3y8nJVQerevXu4e/cu7t69i4KCApSUlEAul6OiogKlpaUP3VcoFKqd9gcVFxerOryAhr9E1H2BqCu4GRsbw8jICObm5vXum5qawsrKCtbW1rCxsanXCWdkZNQs/0ZERE1hwoQJqK6uxsGDB4WOorH27t2Ld999F6ampggNDcWgQYNUz1VWVqqKTXU/6251f66pqUFhYaHq4E5VVRVKS0tRXl6OiooKVVELACoqKlBeXv5QBplM9tABn7rC21/VHYwCoCrGtWrVCmKxWFW4qyvkmZqawsjISFXc+2u3nKWlJczNzbVqJAMREZEGY8GMGt+1a9fQs2dPLFy4EPPnzxc6jta4desWOnXqhMuXL8Pb21voOEREaqd9+/aYMWMGPv/8c6GjaJzCwkJ88MEH2LFjB2bMmIHvvvuOF8chIiKilqyKh8Co0bm7u2Pp0qVYvHgxLl26JHQcIiIi5OXlIT09Hb6+vkJH0ThHjx5Ft27dEBERgUOHDmHDhg0slhEREVGLx4IZNYl//vOfCAgIwBtvvPHImSVERETNJSoqCiKRCD4+PkJH0RgymQwzZ87EyJEjERAQgISEBIwcOVLoWERERESNggUzahI6OjrYsmULMjMzsWjRIqHjEBGRlpNKpXBzc4O1tbXQUTTC8ePH0a1bNxw6dAjh4eHYs2cPLC0thY5FRERE1GhYMKMm0759e6xatQrff/89Tp06JXQcIiLSYhKJBH5+fkLHaPHkcjlmzpyJ4cOHo0+fPoiPj8eoUaOEjkVERETU6FgwoyY1ffp0jBgxAtOmTUNBQYHQcYiISAsplUpcunSJ88ue02+//QYPDw+Eh4fjwIED2LNnDzv2iIiISGOxYEZNLjQ0FAqFApMmTUJtba3QcYiISMskJyejoKCAHWbPqKioCDNnzsSwYcPQq1cvxMfHY+zYsULHIiIiImpSLJhRk7OxsUF4eDjOnz+Pzz//XOg4RESkZSQSCfT09ODl5SV0lBbn5MmT8PDwQFhYGPbu3Ys9e/agdevWQsciIiIianIsmFGz6N69OzZs2IBvvvkGu3fvFjoOERFpEalUCk9PTxgZGQkdpcUoKyvDvHnzMGTIEHh6eiImJgYhISFCxyIiIiJqNmKhA5D2eO211xAVFYXp06fD3d0dHh4eQkciIiItwIH/T+f8+fOYNm0a8vPzsW7dOrz99ttCRyIiIiJqduwwo2a1atUq9OzZE6NGjeJFAIiIqMlVV1fjypUrHPj/BMrLyzFv3jz069cPbm5uiI+PZ7GMiIiItBYLZtSs9PT0sGvXLlRXV+PVV19FdXW10JGIiEiDxcfHo7y8nB1mf+PChQvw9vbG+vXrsW7dOhw9ehSOjo5CxyIiIiISDAtm1Ozs7Oxw8OBBnD9/HtOnT4dSqRQ6EhERaSiJRAJTU1N06dJF6ChqqaKiAvPmzcOLL76I9u3bs6uMiIiI6P9xhhkJomfPnggPD8fw4cNhZ2eHb775RuhIRESkgaRSKXr27AldXV2ho6idqKgoTJ06FdnZ2fjPf/6DGTNmQCQSCR2LiIiISC2ww4wEM2jQIGzZsgXff/89Vq1aJXQcIiLSQBz4/7Dq6mosWbIEAQEBcHJyQlxcHN5++20Wy4iIiIgewA4zEtSkSZNw7949vP/++7C2tsYbb7whdCQiItIQpaWlSExMxKJFi4SOojZiY2Pxxhtv4ObNm/j+++/xwQcfsFBGRERE1AAWzEhws2fPRlpaGmbMmAE7OzsMGTJE6EhERKQBLl26hJqaGnaY4X5X2apVq7Bo0SL4+voiJiYGrq6uQsciIiIiUlssmJFa+Oabb5Cbm4vx48fj+PHj6Nu3r9CRiIiohZNKpWjTpg2cnZ2FjiKouLg4TJ06FYmJiVi6dCk+/vhj6OhwKgcRERHR43BvidSCSCTC5s2b8dJLL2HYsGE4e/as0JGIiKiFk0ql8Pf3FzqGYGpqavD111+jZ8+eMDQ0xNWrV/Hpp5+yWEZERET0BLjHRGpDT08Pe/bswahRozB06FBERkYKHYmIiFowiUQCX19foWMIIiEhAb1798aSJUuwdOlSnDlzBp06dRI6FhEREVGLwYIZqRVdXV1s27YNY8eORXBwMItmRET0TPLz85GWlqZ188vqusp8fHwgFotx5coVfPrpp9DV1RU6GhEREVGLwhlmpHZ0dXXx888/AwCCg4Nx6NAhBAYGCpyKiIhakqioKIhEIvTs2VPoKM0mMTERU6dORWxsLL744gvMnTuXhTIiIiKiZ8QOM1JLurq62Lp1K0aNGoVRo0YhIiJC6EhERNSCSKVSuLq6wtraWugoTU6hUGDjxo3o2bMnKisrcfHiRXaVERERET0nFsxIbYnFYmzfvh1jxozB/7F353FR1Yv7wJ9hG/ZhkX1RQVM2cQHFjUVNM8XMLLeQzBZts5uV3lbr1tU0tW52K7SuuVSmiYK53IsKqKgsiiHgAqjsOzOALAMz5/dHP+YrouYCc1ie9+s1r1nOYc4zXOd0z8PnfM6UKVOwc+dOsSMREVEXkZiY2CNOx8zJycG4cePwyiuv4NVXX0VSUhJ8fX3FjkVERETU5bEwo05NV1cX27Ztw2uvvYZZs2Zh7dq1YkciIqJOThAEJCcnd+sJ/wVBQEREBAYNGoTKykqcPn0aq1atgr6+vtjRiIiIiLoFzmFGnZ5EIsHq1avh5OSEv/3tb8jNzcUXX3wBiUQidjQiIuqEcnJyUF5e3m0Ls6tXr+LZZ5/FsWPHsHTpUnz88ccwMDAQOxYRERFRt8LCjLqMJUuWwMrKCgsXLoRCocDGjRv5l3QiImojMTER+vr6GDJkiNhR2pUgCNi4cSOWLl2KPn364NSpUxg2bJjYsYiIiIi6JRZm1KWEhYXB2toaTz31FCorK/HLL7/A2NhY7FhERNSJJCUlwcfHB0ZGRmJHaTfXrl3DwoULERcXh6VLl+Kjjz6CVCoVOxYRERFRt8U5zKjLefTRRxETE4OTJ08iKCgIBQUFYkciIqJOpLtN+L9lyxb4+PigqKgICQkJWLVqFcsyIiIiog7Gwoy6pICAAJw6dQp1dXXw9/fH6dOnxY5ERESdgEqlQmpqareYv6yoqAjTpk3DggULMGfOHCQlJXWLz0VERETUFbAwoy7L3d0dp06dgr+/P4KCgrBlyxaxIxERkcjS0tJw/fr1Lj/CbOfOnfD29kZ6ejqOHj2K7777jlMQEBEREWkRCzPq0szMzLB79268/vrrCA8Px5IlS6BWq8WORUREIklMTISJiQkGDhwodpT7UlJSgunTp2PWrFmYOXMm/vjjDwQGBoodi4iIiKjH4aT/1OXp6upi1apVGDBgABYvXoxr165h69atMDMzEzsaERF1oIiICKSkpGD48OHw9/eHl5cXkpKS4OfnBz29rvd/cXbu3InFixfD3NwcR44cQXBwsNiRiIiIiHosiSAIgtghiNrLiRMnMGPGDFhbW2PXrl3w9PQUO1KHUKvVmDBhAsrKyjSvNTU14cqVK+jdu3eryaBlMhmOHDkCAwMDMaISEXWYb7/9FosXL4auri5UKhUMDQ1hamoKNzc3LF26FMOHD0efPn3EjvmXSktLsXjxYkRGRuL555/H2rVrYWpqKnYsIiIiop5M2fX+/Ep0B6NHj8aZM2cwa9Ys+Pn5YcOGDXj22WfFjtXudHR00Lt3b8TGxuLmzvvy5cuaxxKJBNOnT2dZRkTdUt++fQH8OdE/ADQ0NKChoQHV1dWYPXs2BEGApaUlAgIC8NVXX8Hd3V3MuLe0c+dOvPTSSzAxMUFMTAzGjRsndiQiIiIiAucwo27IyckJsbGxeO211/Dcc89h/vz5qK+vFztWu5s7d26bsuxWwsLCtJCGiEj7WgqzmymVSs3+US6Xo7KyEm5ublrLpVarUVVVdcd1qqqqMH/+fMyaNQszZsxAWloayzIiIiKiToSnZFK3FhUVhfDwcLi5uWHnzp1aPWDqaCqVCnZ2dqioqLjtOsbGxqioqIChoaEWkxERaUdjYyOMjIzu+McDHR0dnDlzBr6+vlrLtWrVKiQkJCAqKuqWy3///Xe88MILEAQBERERmDp1qtayEREREdFdUXKEGXVr06ZNQ2JiIlQqFfz9/W978NIiPT39rkZtdQa6urqYO3fubU+31NfXx6xZs1iWEVG3JZVKYWNjc9vlenp6eO2117Ralh0/fhzvvvsuoqOjsXXr1lbL5HI5XnzxRUydOhWjR49Geno6yzIiIiKiToqFGXV7/fv3x8mTJ/H4449j+vTpeOmll1BXV9dmPYVCgYcffhhr1qwRIeX9mTNnDpRK5S2XNTU1Ye7cuVpORESkXbcbOSyRSCCTybBixQqtZamsrMSsWbMgkUggkUiwePFi5OXlAQAOHDgAb29vREVFYc+ePfj1119haWmptWxEREREdG9YmFGPYGRkhE2bNmHXrl3YsWMHhg0bhjNnzrRa56233kJxcTH+/ve/Iy4uTqSk92bkyJFwdXW95TJLS0sEBwdrNxARkZYNGDAAurq6t1z21VdfQSaTaSWHIAiYP38+ysrKoFKpIAgClEolwsLC8Mwzz+DRRx/FuHHjkJGRgccee0wrmYiIiIjo/rEwox5lxowZSE1Nhb29PQICArBixQqo1WrExsZi06ZNEAQBEokEM2bMQEFBgdhx78rTTz8NfX39Vq8ZGBggLCwMenq8EC4RdW99+/Zts6/T19fHyJEjMXv2bK3lWLNmDfbv34+mpibNa01NTYiPj0daWhr27t2LLVu2cFQZERERURfBSf+pRxIEAf/617/w9ttvY+TIkcjKykJxcTFUKhWAPw+2Bg8ejBMnTrQpozqbzMxMeHp6tnn95MmTCAgIECEREZH2bNmyBQsWLIBarda8pquri7Nnz8LHx0crGRITEzF69Gg0NzffcrmxsTEyMzNvOyKYiIiIiDodTvpPPZNEIsGSJUtw4sQJpKentyrLgD9HBZw5cwZ///vfRUx5dzw8PDDO17kfAAAgAElEQVRw4MBWrzk7O2PEiBEiJSIi0p6+ffu2Ksv09PTw5ptvaq0sq6qqwowZM+64TlNTE+bPn99lLipDRERERDwlk3o4lUqFysrKVmXZjcvWrVuHXbt2iZDs3syfP18zEs7AwADh4eGQSCQipyIi6ng3TvovkUhgbW2N9957TyvbFgQBYWFhKC0tve3oMuD/Ts2MiIjQSi4iIiIienA8JZN6LKVSCR8fH+Tk5Nz2QEcikcDQ0BApKSnw8PDQcsK7l5ubiz59+mhGL6SlpcHb21vkVEREHU8QBBgaGmquGLxr1y488cQTWtn22rVr8fbbb7ca4XYrLVfNNDY2xh9//IG+fftqJR8RERER3Teekkk916effnrHsgz480CsubkZM2bMQF1dnRbT3RtXV1f4+fkB+POKcSzLiKinkEgkcHR0BACMHz9ea2VZUlISli9fftuyTCqVAvhzPrVBgwbhrbfeQmRkJJycnLSSj4iIiIgeDC+hRz1SZmYm/vnPf0KtVkNPT+8vT6XJysrCCy+8gG3btmktY21tLRoaGlBdXY26ujo0NjaiubkZNTU1rdZTqVSorq6Gj48PkpKSMGzYMOzcuRNmZmZtrhxnamoKfX19GBgYwMTEBObm5pBKpTAzM9Pa5yIiUigUUKvVqKqqglqthkKhAPDn/ra2trbN+jeuczNDQ0NYWVkhLy8PYWFhiImJAQDNfg4AjIyMYGhoCBMTExgYGGj2hferqqoK06dPbzUnmb6+PpqbmyGRSODr64tHHnkE48ePx+jRo2FoaHjf2yIiIiIicfCUTOqxCgsLceLECcTExODIkSPIysqCRCKBvr6+5tSeG0kkEvz73//GokWL7nob9fX1KCgoQFFREcrLy1FZWam5VVRUtHpeU1OD6upqNDQ03PKAsaOZmppCKpVCJpPB1NQUVlZWmpu1tXWr57169YK9vT2cnZ1hbGys9axEJI6KigqUlZWhrKwMVVVVqK6uhkKh0Nzf6rW6ujrU1taiqakJ1dXVt5wzUizm5ubQ1dWFhYUF9PX1YW5uDgsLC1hYWMDc3BwymUxz3/LYwsICn3zyCeLi4jTv4+bmhqlTp2L8+PEICgqCTCYT8VMRERERUTtQsjAj+v/y8/MRFxeH+Ph4HD58GNnZ2ZBIJDAwMEBjYyOAP6++lpCQAH9/fzQ2NuLq1avIycnBlStXUFBQgPz8fBQVFaGwsBAFBQWQy+WttmFmZtaqgLqxiDIzM4NMJoNUKoWpqWmrAsvQ0BBGRkYAAEtLyzbZW177+OOP8cEHHwAA5HJ5myuytbzW0NCA+vp6KBQKNDY2ora2FrW1tVAqlZDL5aitrW1T6rU8rq6ubvWeMpkMTk5OcHBwgKOjIxwdHeHk5AQ3Nze4ubmhb9++HF1B1IkpFArk5+cjPz8fBQUFKCwsRFlZGcrLy1FSUoLS0lKUl5ejrKyszWjcln1US6lkaWnZ6rm5uTmMjY01I15bCiqZTAYdHR1YWFhAIpG02q/dah8HQPMzN6upqcHu3bsxceLEVvua69eva/740TJKt+W1lgKvpqYGzc3NqK6uhlKphEKhgFwuh1wub1P8KRSKNiN8W3LZ29ujV69esLGxga2trebm4uICR0dHuLi4wM7O7pb5iYiIiKhTYmFGdDslJSU4evQooqOjcfToURQVFQH48wDR2toaxcXFmrlrrK2t4ezsDGdnZzg4OLQpkBwdHdGrV68HOgXobjQ3N7c5DbMjtlFWVqYpBltuLSPpWorD8vJyAP83v1BLeebm5oaBAwfC09MTAwYMgIGBQYfmJerJ1Go18vPzkZ2djaysLOTl5SE3NxcFBQUoKChAXl5eqxGtxsbGcHZ2ho2NDXr16gVbW1vY2dm1KYNsbGxgZWWlmaerpxAEAWlpaZBKpbctFUtKSlBWVobS0lKUlJRoflZfXx8ODg5wcXGBk5MTnJyc4OrqCjc3N7i7u8Pd3Z1/XCAiIiLqPFiYEbXIzs5GamoqMjIycP78eaSnp+PSpUtoamqCnp4eXF1dIZPJoFKpYGNjg8WLF8Pd3R19+/bl6Te3UF1drRl9l5OT0+bW3NwMfX199O/fH15eXpqbr68v+vXrB4lEIvZHIOoSBEHA1atXceHCBWRnZ2vKsaysLFy5ckUzQtbMzAy9e/fWFDYtJb+joyNcXV3h5OQECwsLkT9N99LY2NiqnGz5g0J+fj4KCwuRm5uLwsJCAH/+ccHJyUlTnvXr1w/u7u7o378/PDw8WKYRERERaRcLM+qZioqKkJycjJSUFKSkpOD06dMoKysDADg4OMDLywuenp6a+6FDh3KurnbU1NSEvLw8pKenIyUlBRkZGUhPT8fFixehUqlgbm4OHx8fDBs2THPz8vISOzaR6Kqqqtp8b/744w/NqYKWlpaa06FvvvXt25dFdCfUUqrd+AeF9PR0ZGRkIDc3V3MarIODg2ZfeON/n1pO1yciIiKidsXCjHqGS5cuITY2FkePHsWxY8dQUFAAHR0dPPTQQ/Dz84O/vz/8/PwwePBgFmMiqq+vxx9//IGkpCQkJSUhOTkZFy5cgFqthoODA8aOHYvg4GAEBwfDw8ND7LhEHerq1atISkpCYmIikpKScO7cOc28iPb29vD29taMzPT29oaHhwdHiHUzSqUSWVlZSE9Px/nz55GRkYG0tDRkZ2drRukOHDhQ898xf39/DBo0iKe6ExERET04FmbUPeXn5+PQoUM4evQojh49isLCQpiammLMmDEICgrCiBEjMGzYMJibm4sdlf5CTU0Nzpw5g9OnTyM+Ph7x8fGoqamBvb09QkJCEBwcjEmTJqF3795iRyW6b9XV1Th+/LimHEtKSkJZWRn09PTg6ekJf39/DB06VFOOWVtbix2ZRNTY2IgLFy4gIyMDqampSEpKQkpKCqqrqyGVSuHr66sp0EaPHo1+/fqJHZmIiIioq2FhRt1Heno69u3bh+joaCQkJMDIyAhDhgzBmDFjMGHCBAQGBvKv7t2ASqVCamoqjh8/jhMnTuB///sf5HI5PD09ERoaiqlTp2LUqFG8Gh11arW1tTh16hRiYmI0RVlTU5PmtLthw4ZhzJgxGDlyJExMTMSOS11EYWEhTpw4gePHjyMlJQVnz55FXV0d7O3tMXbsWIwePRpjxozB0KFDeXouERER0Z2xMKOuLSEhAdu3b0dUVBTy8/Ph4uKCqVOnYtq0aQgJCelxV3DriZRKJeLi4hAdHY2oqChcu3YNDg4OmDZtGp5++mmMHj2aB4YkOpVKhYSEBERHR+PIkSNITU2FWq2Gl5cXQkJCEBQUhMDAQNjY2IgdlbqRpqYmJCYmIjY2FrGxsUhISEBdXR2cnJwQEhKCRx99FI888ggsLS3FjkpERETU2bAwo64nNzcXW7duxZYtW3Dp0iV4e3tj5syZCA0NxdChQ8WORyI7d+4coqOjsWvXLpw7dw7u7u4ICwvD/Pnz0bdvX7HjUQ9SW1uLQ4cOISoqCvv370d5eTn69++PRx55hAUZiUKpVCIpKUkzXcGxY8cAAGPHjsW0adMwbdo07ieJiIiI/sTCjLoGQRBw4MABrF+/HkeOHIGVlRXmzp2L8PBwlmR0W+fOncOPP/6In376CaWlpQgKCsLrr7+O0NBQnrJJHaKhoQFRUVHYsmULYmJi0NzcjICAAE0ZMXDgQLEjEmnI5XIcOHAAUVFROHjwIORyOXx8fDBnzhyEhYXB2dlZ7IhEREREYmFhRp2bUqnE9u3bsXbtWmRkZGDixIlYvHgxHn30Uejr64sdj7qI5uZmHDx4EN999x1+//13DBgwAG+88QbCwsJgaGgodjzqBk6fPo0ff/wRv/zyC6qrqzFx4kQ89dRTmDJlCkeRUZfQ1NSE+Ph4REZG4pdffkFVVRUmTJiA8PBwPP744zAyMhI7IhEREZE2sTCjzkmlUmHTpk34+OOPUV5ejjlz5mDp0qXw8fEROxp1cZmZmVi7di22bdsGCwsLvPfee1i0aBH09PTEjkZdTGNjI7Zu3Yr169cjIyMDnp6eeOaZZzBv3jw4OjqKHY/ovimVSuzbtw+bN2/GwYMHYWxsjGeeeQZvvPEGXF1dxY5HREREpA0szKjzOXr0KF5//XVkZmbi5ZdfxptvvgknJyexY1E3U1xcjLVr1+Krr76Cu7s71q9fj4kTJ4odi7qA2tpaREREYN26dSgvL8f8+fPx/PPPw9/fX+xoRO2upKQE27Ztw7/+9S8UFRVh3rx5WLZsGU8vJiIiou5OyUl8qNOoqKjAU089hXHjxsHZ2RlpaWlYv349yzLqEPb29lizZg3S09MxYMAATJo0CY899hhKS0vFjkadVFNTE1avXo0+ffrgww8/xOzZs5GTk4OIiAiWZdRt2dnZYenSpcjKykJERAROnz4NLy8vPPXUU7h27ZrY8YiIiIg6DAsz6hROnTqFoUOH4tSpU9i/f79mnilqraGhAW+//Tbc3Nygp6cHiUSC2tpasWN1ae7u7ti9ezcOHz6M9PR0DBkyBPHx8WLHok7m+PHjGDp0KFasWIGXX34Z165dw+eff97pTr1MTk6GRCLBihUr7vhad8b9ZMfQ19fHM888g/Pnz2Pnzp04f/48vLy8sHr1ajQ1NYkdj4iIiKjdsTAj0X355ZcIDAyEj48Pzp49i8mTJ4sdqdNauXIl1qxZgytXrkClUnX49o4fPw6JRIJPPvmkw7cltnHjxiElJQUBAQEYP348PvvsM7EjUSdQU1OD5557DoGBgXB2dsb58+fx0UcfwcrKSuxodBvcT3YsHR0dzJgxA6mpqVi+fDlWrFiBYcOGITk5WexoRERERO2KhRmJ6oMPPsAbb7yBjz/+GNHR0bC2thY7Uqe2d+9eyGQyZGRkQKVSQRAEmJqaih2r25DJZNi1axfWrFmDd999F2+99ZbYkUhEly9fRkBAAKKjo/HLL7/gwIEDcHNzEzsW/QXuJ7XDwMAA7733HtLS0mBra4uxY8di8+bNYsciIiIiaje8LByJ5ptvvsGnn36KTZs2YcGCBWLH6RLy8/MxYMAAeHh4iB2l25JIJHj99ddhZ2eHsLAw2NvbY+nSpWLHIi3LzMzUzKeYkpICZ2dnsSPRXeJ+Urvc3d1x6NAhvPfee3j22Wchl8vx+uuvix2LiIiI6IFxhBmJ4ty5c1iyZAlWrFghWlkmCAI2b96MwMBAWFhYwMzMDP7+/ti4cSOam5s169XX1+Ojjz6Ch4cHDA0NIZPJMH78eBw6dKjV+x08eBASiQRffPEF4uLiEBQUBDMzM/j5+d1x2d14/fXXIZFIUFFRgcTEREgkEkgkEixatKjV5/nhhx8watQomJmZwcjICL6+vvj6669x88Vw4+PjMW/ePPTr1w9SqRQ2NjYIDQ3FiRMnNOt88sknGDt2LADg/fff12xTIpEAADZt2gSJRIJdu3a1yduybM+ePXf1+7nX/NowZ84cfPbZZ1i2bBlOnTql9e2TeEpLSzFx4kT069cPR44c6RRl2d18ZzsC95PcT94NXV1drFy5Ep9//jneeOMN/Pzzz6JlISIiImo3ApEIRo4cKYwZM0ZQqVSibF+tVguzZs0SANzy9r///U8QBEFobGwURo8efct1JBKJ8M0332je88CBAwIA4cknnxT09PQ06w0ZMuSOy+7GkiVLbpnhxRdf1HyeefPm3fbzPP/885r3Kioquu16enp6QlxcnCAIgvCPf/zjtusJgiBs3LhRACDs3LmzTd6WZZGRkXf1+7mX/NqkVquFhx9+WBg8eLCgVqtFyUDaN2XKFMHd3V2orKwUO4ogCHf/nRUEQUhKShIACB9++OEdX7sb3E9yP3k//va3vwkmJibC1atXxY5CRERE9CAaWZiR1h0/flwAIJw6dUq0DJs2bRIACNbW1sK3334r5ObmCrW1tUJSUpLw3HPPCbGxsYIgCMLatWsFAIKrq6sQHR0tKBQKITc3V1ixYoWgo6MjGBoaCkVFRYIg/N+BDgDh2WefFS5evCg0Nzf/5bJ7IZPJhBEjRrR5fcuWLQIAwcfHR9i/f79QUVEh1NbWCnFxcYKvr68AQEhISBAEQRCKi4uFhx9+WIiOjhby8vIEpVIplJSUCL/++qtgYmIiTJ48WfO+x44dEwAI//jHP9ps834PBG/1O7iX/Np27tw5QSKRCIcOHRJl+6RdR44cEQBo9gGdwb18Z9uzMON+kvvJ+6FUKoX+/fsL8+fPFzsKERER0YNgYUba99Zbbwmenp6iZhg7dmyrERK3ExAQIAAQTp482WbZCy+8IAAQvvvuO0EQ/u9AJyAgoM1opDstuxe3OxAMCQkRdHV1hcLCwjbL0tPTBQDCsmXLNK8lJycLTz75pODo6NhqFAMAwdnZWbNeRxwI3up3cK/5tc3f319YvHixaNsn7QkPDxdGjRoldow27vY7256FGfeT3E/er++++04wNjYWamtrxY5CREREdL8aOek/aV1aWhpGjBghaoYLFy7A0tISEyZMuON6WVlZsLa2RkBAQJtlU6dORUREBLKyslq9PmHCBM38NTe707IHkZ6eDpVKBRcXFwCAIAia+Wxa7nNzcwEACQkJCAkJgVKpvOV71dfXt3u+G93qd3Av+cUwYsQIpKamirZ90p6kpCTMnDlT7BitiPWd5X6S+8n7NXHiRNTV1SE9PR3Dhw8XOw4RERHRfeGk/6R1NTU1MDMzEzvGXbvXAzdra+v7WvYg1Go1AEClUkGlUkGtVrc6mAKgOfBbtWoVlEolPvzwQ2RlZaG+vl6z/oABA+56mzo6Oq22faM7HUze6ndwL/nFIJPJUFNTI9r2SXsUCgUsLS3FjtFKe31nOxL3k7fWk/aTN2r5DsnlcpGTEBEREd0/FmakdXZ2digoKBA1w8CBA1FVVYXDhw/fcb1+/fqhvLwciYmJbZbt379fs47YBg4cCGNjY8jlcs0B1M23lqu05eTkwM7ODitWrIC7uzsMDQ0hkUiQnZ2Ny5cvt3rfloO9G6+G18LW1hYAcOXKlTbLjhw50mH5xZCXlwd7e3vRtk/a4+joiJycHLFjtHIv39n2xP0k95P3q2VEoZOTk8hJiIiIiO4fCzPSutGjRyMuLk7Uv4SHh4cDAObMmYONGzciPz8f169fR0pKCl544QXExcUBAJ588kkAwKxZs7B//35UV1cjPz8f//jHPxAREQGpVIpp06aJ9jlaLFy4EHV1dZgwYQL27duHsrIyKJVKXLt2Db///jueeOIJzUGvq6srSktLsWHDBigUCigUCuzfvx+PPvpom1EQVlZWAIBjx46hoqKi1TJPT08AwBdffIHY2FjU19fj6tWrWLp0Kfbs2dNh+bVNpVLh8OHDGD16tCjbJ+2aNGkSIiMjO81IHeDevrPtiftJ7ifv144dO+Dq6qr5/ERERERdUgdMjEZ0R/n5+YKBgYGwceNG0TKoVCph5syZrSZxvvHWMsl1Y2OjMGrUqNuu980332jes2Wy5vXr17fZ3p2W3YvbTWatVquFZ5555rY5AQgHDhwQBEEQ9uzZc8vlQ4YMEby9vQVra2vN+zY3NwtOTk5t1m0xY8aMNsv09PSEsLCw205mfavfwb3k17affvpJ0NXVFbKyskTZPmlXbm6uYGRkJKxevVrsKBr38p1tz0n/uZ/kfvJ+XLlyRTA2NhbWrFkjdhQiIiKiB9HIEWakdU5OTnj++efxzjvvoKysTJQMOjo6+PXXXxEREYGAgACYmJjA3Nwcw4cPx6ZNmxAcHAwAMDAwQExMDD788EMMGDAABgYGMDMzQ0hICA4cOIBFixaJkv9mEokE//nPf7Bjxw5MmDABlpaWMDAwgJubG6ZPn47IyEjNxN2PPfYYtm/fjkGDBsHIyAgODg548cUXcfjwYUil0lbvq6uri127dmHMmDEwMTFps93vv/8ezz77LKytrWFoaIiRI0ciJiYGgYGBHZZfm+RyOd566y3Mnz8f7u7uWt8+aZ+Liwvef/99vPfeezh+/LjYcQDc23e2PXE/yf3kvaqrq8PMmTPRr18/vPrqq6JmISIiInpQEkG4YbZYIi2prq7G4MGD4erqiv/+978wMDAQOxJRK83NzZgyZQrS09Nx7ty5DpuInDofQRAwc+ZMxMTE4MCBAxg1apTYkYg6vZqaGoSGhiIjIwMJCQmdYt46IiIiogeg5AgzEoW5uTn27t2Ls2fP4oknnkBDQ4PYkYg0mpqaMHv2bJw4cQJ79+5lWdbDSCQS/Pzzzxg3bhzGjx+PH3/8UexIRJ3a5cuXMXLkSFy4cAFHjhxhWUZERETdAgszEo2Pjw/++9//4vjx4wgMDMTVq1fFjqR1qampkEgkf3mbPn262FF7jPz8fISEhOC///0vDhw4gGHDhokdiURgYGCA3bt3Y8WKFViwYAFCQ0ORm5srdqwH1hX3OV0xc0/R3NyML7/8EsOGDYOBgQFOnToFb29vsWMRERERtQsWZiSqESNGIDExEUqlEr6+vvjtt9/EjkQ92NGjR+Hv74/y8nKcOHECY8eOFTsSiUgikWDZsmWIjY1FdnY2PDw88Nlnn0GlUokdjUh0Z86cwciRI/HWW2/hpZdewsmTJ9GnTx+xYxERERG1G85hRp1CfX09Xn31Vfzwww8IDw/HP//5Tzg4OIgdi3qI0tJSvP/++9i0aRPmzJmDb7/9FqampmLHok6koaEBK1euxGeffQZ3d3csX74cs2fPhr6+vtjRiLTq7NmzWLVqFXbt2oWQkBB888036N+/v9ixiIiIiNob5zCjzsHIyAibNm3Czp07cfToUTz00ENYuXIl5zajDqVUKrFmzRo89NBD2L9/P7Zu3Ypt27axLKM2DA0N8dFHH+GPP/6An58fFi5ciIceeggbNmxAfX292PGIOlxcXBwmT56MoUOH4vLly9ixYwdiYmJYlhEREVG3xRFm1OnU19dj7dq1WLVqFXr16oU33ngDCxcuhImJidjRqJuoq6vD5s2bsXbtWhQXF+PNN9/E22+/zX9jdNeuXbuGzz//HN9//z1MTU3x9NNPY8GCBfDx8RE7GlG7qaysxM8//4zNmzcjOTkZwcHBWL58OSZNmiR2NCIiIqKOpmRhRp1WQUEBVq5cif/85z8wNDTEokWL8Oqrr8Le3l7saNRFlZWV4euvv8bXX3+N69evIzw8HH//+9/h6uoqdjTqokpLS/Hdd9/hxx9/RHZ2NoYMGYJnnnkGc+fORa9evcSOR3TPmpubcejQIfz444+IioqCnp4eZs6ciUWLFiEgIEDseERERETawsKMOr+Kigr8+9//xoYNG6BQKPD4449j/vz5mDhxInR1dcWOR52cWq1GTEwMtm7dit9++w0mJiZ46aWX8PLLL8PW1lbseNRNCIKAY8eOYfPmzdi1axcaGxsREhKCadOmITQ0FC4uLmJHJLqturo6xMTEIDo6GtHR0SgtLcXYsWOxYMECzJw5k6epExERUU/Ewoy6joaGBmzfvh2bN2/GiRMnYG9vj3nz5iE8PJyXsac2MjMzsWXLFmzbtg35+fkYOXIkwsPDERYWBmNjY7HjUTd2/fp1REZGYs+ePTh06BBqa2sxZMgQTXk2dOhQSCQSsWNSD1dcXIx9+/YhOjoaMTExaGhogJ+fHx577DHMnj0bbm5uYkckIiIiEhMLM+qacnNz8fPPP2Pjxo3Izs6Gm5sbpk6ditDQUAQFBfHKdT2QWq3G2bNnER0djX379iElJQVOTk544oknsHDhQgwaNEjsiNQDNTc349SpU9i5cyciIyORl5cHGxsbjBgxAmPGjMGECRNYoJFWlJWV4dSpUzhx4gRiYmJw5swZSKVSjBkzBlOnTsXMmTPh5OQkdkwiIiKizoKFGXVtgiDg+PHj2Lt3L6KionD58mXY2NhgypQpmDp1KoKCgjiPUDdWVVWF2NhY7N+/H9HR0SgpKYGbmxumTZuGxx57DIGBgdDR4cWAqXMQBAGpqak4fPgw4uLiEB8fj+rqatja2iIoKAhBQUEYOXIkfHx8WPrTA8vNzUViYiLi4+Nx9OhRpKenQ0dHB0OGDEFQUBBCQkIQEhLCEbdEREREt8bCjLqXCxcuICoqClFRUTh16hTUajV8fHwQHByMkJAQBAYGwsrKSuyYdJ/kcrnm4C8uLg7nzp0DAAwfPhzTpk3DtGnT4OXlJXJKorujUqlw9uxZxMbGIi4uDseOHYNCoYChoSF8fX3h7+8PPz8/+Pv7Y+DAgSx/6bZKSkqQnJyMpKQkzX1paSl0dXUxePBgBAcHIzg4GGPHjoVMJhM7LhEREVFXwMKMui+FQoH4+HjExsYiNjYWqampAABvb2+MGDEC/v7+8Pf3h7e3N/T09EROSzdrbm5GRkYGkpKSkJSUhNOnTyMtLQ2CILQpQS0tLcWOS/TA1Go1Ll68qPk3n5ycjNTUVDQ0NMDMzAy+vr7w9vaGt7c3PD094ePjwxG0PUxjYyMyMjKQkZGB8+fPIz09HefOnUNubi4AoF+/fq2K1qFDh8LExETk1ERERERdEgsz6jmqqqpw7NgxxMfHIykpCWfOnEFtbS2MjIwwePBg+Pv7Y8iQIfD29oaHhwcPMrSorq4OmZmZSE9Px9mzZ5GUlISzZ8+irq4OJiYmGDJkCPz9/REYGMhRgtSjNDU1IS0tDUlJSUhNTUV6ejrOnz+PqqoqAICtrS18fHzg6ekJT09P9OvXD+7u7nB1deVVhLuw8vJyZGdnIzs7GxcuXEBGRgbS0tKQnZ0NlUoFAwMDDBgwAF5eXhg0aBCGDRsGf39//vGAiIiIqP2wMKOeS6VSITMzU3P6SlJSEtLS0tDQ0ACJRII+ffrAy8sLXl5emoNRNzc3ljUPoKqqCjk5OZpyrOV29epVqNVqSKVSeHt7a0b/+fv7w9PTkwf+RKrTQk0AACAASURBVDcpLCzUlGfp6elIS0vDxYsXoVAoAAAGBgbo3bu3pkBzd3dHv3790KdPHzg5ObFYEVljYyPy8/ORl5enKcays7ORlZWF7Oxszf+O+vr6cHNzg7e3N7y8vDT3/fv35zx3RERERB2LhRnRjVQqFXJycnD+/HlkZmYiLS0NmZmZuHDhAhobGwEAFhYWcHNza3Vzd3eHk5MTnJ2dYWZmJvKnEM/169eRl5eHgoIC5OTkICcnB9nZ2ZrHLaNiWkZHeHp6akb0eXt7w93dnafHEj2AG0cmtZQvLbfi4mLNesbGxnB1ddXst1xcXDSPnZycYGNjAxsbG0ilUhE/TdcjCALKy8tRVlaG0tJS5OXlIS8vD4WFhcjNzUV+fj4KCwtRUlKi+RkTExNNodlSbrbcXFxcuE8kIiIiEgcLM6K70dzcjKtXr96yBMrJyUF1dbVmXRMTEzg7O8Pe3h7Ozs6ws7ODi4sLrK2tYWVlBSsrq1aPO/NE3oIgoKKiApWVla1u5eXlKCgoQHFxMfLz8zX3tbW1mp81NTWFu7v7LcvFvn378iCQSMuuX7+Oa9euIT8/HwUFBcjNzUVBQYHmcX5+PuRyeaufMTMzg52dnaZA69Wrl+a5paUlzM3NIZPJYGFhAQsLC81zAwMDkT5l+6mqqkJ1dTUUCoXmVl1djaqqKpSXl6O8vBylpaUoKSnRPC8rK4Narda8h1QqhZOTE5ycnNC7d2/N45ay0sXFBXZ2diJ+SiIiIiK6DRZmRO2hrKwMhYWFmvKopUwqKChAUVERCgoKUFFRoRmldiMLCwtYW1vDwsICJiYmMDAwgKWlJaRSKYyNjWFubg6pVKoZuWZgYNBmfrWWn2vR1NTUqrwC/pwnrGX7tbW1aGxshEKhQH19PRoaGiCXy9HY2Ijr169DLpejqqoKlZWVbfJKpVJYW1vD0dERDg4OmnsnJyfNcycnJ9ja2j7w75WItKuurg75+fma8qe8vBzFxcWtCqGSkhKUlZVBLpfj+vXrt3wfIyMjyGQymJubw8zMDIaGhjAyMoKRkREMDQ1hbGwMqVSq2XeZmppqTjHU1dWFubl5m/dseY8bqVSqVn+waNHY2Ii6ujrNc7lcDkEQUFVVBUEQIJfLoVaroVAoNO+hVCpblWO3oq+vDwsLC015aGNjAzs7O/Tq1avV85aCkWUYERERUZfFwoxIm65fv95mtFZFRQUqKiqgUChQV1enKa8aGhpQX18PhUKBhoYGzYHpjcVXi+rqaqhUKs1zHR0dyGSyVuvcWLSZmJhAKpXCwsJCcxBqYWEBqVQKPT09bNu2DTNnzsT48eM1I+FaRsbxYghE1EKlUkGhUEAul0Mul7cakdXyuKamRlNgtRT0Lfux2tpaKBQKVFVVwdjYGAA0+76b1dbWoqmpqc3rFhYWkEgkrV67uXQzNzeHrq6uZl1LS0vNflJPTw9mZmaQSqWaEXIymQyWlpaa0q/ltZsLOyIiIiLqtliYEVFbixYtwk8//YRTp07B09NT7DhE1I1NmDABtbW1OHnyZJvii4iIiIhIJCzMiKitpqYmhISEoLy8HImJibc8PYqI6EEdPHgQkydPxtGjRxEcHCx2HCIiIiKiFizMiOjWioqKMGzYMIwYMQK7d+/myA8ialdqtRr+/v5wdnbG3r17xY5DRERERHQjZee9PB8RicrBwQHbt2/Hvn37sG7dOrHjEFE389NPP+HcuXP45z//KXYUIiIiIqI2OMKMiO7o888/x/Lly7F//35MnDhR7DhE1A0olUp4enoiMDAQP/zwg9hxiIiIiIhuxlMyieivzZo1C7GxsUhJSYGzs7PYcYioi/vyyy+xfPlyXLx4Ea6urmLHISIiIiK6GQszIvprtbW1CAgIgImJCeLj4yGVSsWORERdVG1tLfr164f58+dj9erVYschIiIiIroVzmFGRH/N1NQUkZGRuHjxIpYsWSJ2HCLqwlavXo3GxkYsW7ZM7ChERERERLfFwoyI7kr//v2xZcsWRERE4Pvvvxc7DhF1QaWlpfjiiy+wfPlyWFtbix2HiIiIiOi2eEomEd2Td955B+vXr8exY8fg5+cndhwi6kIWL16M6OhoXL58GUZGRmLHISIiIiK6Hc5hRkT3Rq1WY8qUKcjIyEBKSgp69eoldiQi6gIuXLgAHx8fREREYMGCBWLHISIiIiK6ExZmRHTvKisr4efnBzc3Nxw6dAi6urpiRyKiTi40NBS5ubk4c+YM9xlERERE1Nlx0n8iundWVlbYvXs3Tp48iQ8++EDsOETUycXGxmLfvn1Ys2YNyzIiIiIi6hI4woyI7tu2bdswf/58/Prrr5g5c6bYcYioE1Kr1Rg+fDhsbW2xf/9+seMQEREREd0NpZ7YCYio63r66adx/PhxPPvss/D09ISnp6fYkYiok9m2bRtSU1Nx9uxZsaMQEREREd01jjAjogfS1NSEkJAQlJeXIzExEebm5mJHIqJOoqGhAQMGDMCkSZMQEREhdhwiIiIiorvFOcyI6MHo6+tj586dqK6uRnh4ONjBE1GLdevWobKyEh999JHYUYiIiIiI7gkLMyJ6YA4ODti+fTv27duHdevWiR2HiDqBsrIyrF69Gm+++SYcHBzEjkNEREREdE94SiYRtZvPP/8cy5cvx4EDB/Dwww+LHYeIRPTyyy9jz549uHTpEkxMTMSOQ0RERER0L5QszIio3QiCgNmzZyM2NhYpKSlwdnYWOxIRieDixYvw8fHBN998g4ULF4odh4iIiIjoXrEwI6L2VVtbi4CAAJiamiIuLg5SqVTsSESkZY899hiuXLmCs2fPQldXV+w4RERERET3ipP+E1H7MjU1RWRkJC5cuIAlS5aIHYeItOzIkSOIiorCmjVrWJYRERERUZfFEWZE1CGioqIwffp0bNy4kadkEfUQKpUKQ4YMQd++fbF3716x4xARERER3S+OMCOijjFt2jQsX74cr7zyCpKTk8WOQ0Ra8M033+DixYtYs2aN2FGIiIiIiB4IR5gRUYdRq9WYMmUKMjIykJKSgl69eokdiYg6SFVVFR566CEsWLAAq1evFjsOEREREdGD4KT/RNSxKisr4efnBzc3Nxw6dIhzGhF1U6+99hp27NiBS5cuQSaTiR2HiIiIiOhB8JRMIupYVlZW2L17NxISEvDBBx+IHYeIOkBmZia+/fZbfPrppyzLiIiIiKhb4AgzItKKrVu3Ijw8HDt37sQTTzwhdhwiakeTJ09GcXExkpOTOYqUiIiIiLoDpZ7YCYioZwgLC8OJEyewYMECeHh4wNPTU+xIRNQOfv/9dxw8eBCxsbEsy4iIiIio2+AIMyLSmqamJoSEhKC8vByJiYkwNzcXOxIRPYCmpib4+Phg0KBB+PXXX8WOQ0RERETUXjiHGRFpj76+Pnbu3Inq6mqEh4eDfT1R1/bVV1/h2rVrvComEREREXU7LMyISKscHBywfft27Nu3D+vWrRM7DhHdp8rKSnz66ad488030adPH7HjEBERERG1KxZmRKR1ISEhWLlyJZYtW4b//e9/bZYLgoCUlBQRkhHR3XrnnXdgaGiIZcuWiR2FiIiIiKjdcQ4zIhKFIAiYPXs2YmNjkZKSAmdnZwCAXC7HvHnzkJmZiZycHJFTEtGtpKSkYMSIEdiyZQvmzp0rdhwiIiIiovamZGFGRKKpra1FQEAATE1NERcXh0uXLiE0NBT5+flQqVRITk7GsGHDxI5JRDdQq9UYPXo09PT0EB8fD4lEInYkIiIiIqL2xkn/iUg8pqam+O2335CZmYlZs2Zh+PDhKCgogEqlgoGBAXbs2CF2RCK6yQ8//IDk5GRs2LCBZRkRERERdVscYUZEompubsb8+fPx888/QyKRtLpypr29PQoLC3lQTtRJVFVVYcCAAZg3bx7Wr18vdhwiIiIioo7CEWZEJJ6ysjKMHz8ev/76KwDg5v6+uLgYJ0+eFCMaEd3Cu+++Cx0dHXz44YdiRyEiIiIi6lAszIhIFAkJCfDy8sLJkyehUqluuQ5PyyTqPM6ePYuIiAisXr0aFhYWYschIiIiIupQPCWTiLROLpfDz88P2dnZf7lur169UFxcDF1dXS0kI6JbEQQBo0ePhkQiwfHjx3maNBERERF1dzwlk4i0z8LCAn/88QeWLVsGHR2dO5Zh5eXliI+P12I6IrrZ5s2bkZiYiK+//pplGRERERH1CCzMiEgUxsbGWLVqFZKTk+Hp6Xnb0kxfXx+//PKLltMRUYvq6mq8++67WLx4MQYPHix2HCIiIiIireApmUQkuubmZqxduxYffPABBEFAU1NTq+UymQxlZWXQ19cXKSFRz/Xqq6/i559/xsWLF2FtbS12HCIiIiIibeApmUQkPj09PSxbtgwZGRkYNWoUdHR0Wp32pVAocOTIERETEvVM58+fx7fffos1a9awLCMiIiKiHoUjzIioUxEEAVu3bsVrr72Guro6NDU1QV9fH3PnzsXmzZvFjkfUYwiCgMDAQDQ3NyMhIYFzlxERERFRT6JkYUZEnVJRURFeeukl7NmzBxKJBCYmJigvL4dUKhU7GlGP8P333+PFF19EYmIihg4dKnYcIiIiIiJtYmFGRJ2LSqVCdXU1AKCpqQl79uzBO++8g4qKCqxbtw6BgYEA/pz3rKam5o7vJQgC5HL5X25TT08PZmZmd1xHIpHAwsKi1Wvm5uaaixVYWloCAHR0dCCTyf5ym0SdWXl5OTw8PBAWFoZ169aJHYeIiIiISNtYmBHR3ZHL5aiurtbc6urqoFAooFQqUVNTg/r6ejQ0NKC6uhpNTU1QKBRoaGhAfX09ampq0NTUBLlcDqVSievXrwP4c24ytVp918VWV3NjESeVSmFsbAwAsLCwgL6+PszMzGBkZARDQ0OYm5vDwMAA5ubmMDQ0hJGREczMzKCvrw8LCwvNz1tYWMDMzAzm5uYwNzeHiYmJmB+Ruqmnn34a8fHxSE9P/8symYiIiIioG1LqiZ2AiLSjoqIClZWVbe4VCoWmBJPL5VAoFKipqWlVjikUitu+b0spdGPxo6+vD5lMpil5HBwcoK+vD0tLS+jr68PU1BQAYGZmBj29P3dDMplMM9l/y0guXV1dmJubAwD09fWRl5cHDw8PzbZvHOF1O6ampn95dc26ujo0NjbecZ2W8u9GVVVVAAC1Wq35Hd048q2xsRF1dXUAoCkUW36uqakJtbW1mm3n5eWhqakJ1dXVtywab6fld2RpaQlzc/NWZZq5uTksLCwgk8kgk8lgZWUFa2tr9OrVS/O45X8LohZHjx7FTz/9hMjISJZlRERERNRjcYQZURfU0NCAkpISFBYWorS0FEVFRSgvL79tKVZRUYGbv+pSqRTW1taQyWRtypUbCxczMzPIZDJYWFi0er1ltBMnAteOlpF5NxacN95uHgF4cwmqUChQUVEBtVrd6n0NDAxgbW2tKdBuvLexsYGtrS1sbW3h6OioefxXJSV1XfX19fDx8YGvry9+++03seMQEREREYmFp2QSdSaVlZXIz89Hfn6+pggrKSlpU47dPOLL0tIStra2tyw9Wu579erV6jWeytczVVVVoaKi4o7last9WVkZSktLW42s09HRga2tLWxsbODo6Ag7OzvY2dnBwcFBU6w5OjrC1dUVRkZGIn5Suh/vvPMONmzYgIyMDDg7O4sdh4iIiIhILCzMiLSlsbERBQUFKCwsRFFREXJycpCTk6N5npWV1aoIMzQ0hKWlJRwdHeHg4NDq8Y2vubq68rQp6lD19fWoqqpCUVGR5t9rYWFhm9daTittYWlpqfn36ubm1uqxm5sbXFxc/vJ0WdKe9PR0DBkyBOvWrcMrr7widhwiIiIiIjGxMCNqT/n5+cjOzkZ2djaysrI099euXUNFRYVmPWNjY/Tu3RvOzs5wdnaGq6srXF1dNc9dXFxYglGX1DIaMi8vD9euXdOMmMzNzUVeXh4KCws1pZquri7s7e3h5uaGfv36wd3dHe7u7prHLVcepY6nVqsRGBgIpVKJkydP8rRbIiIiIurpWJgR3auioiKkp6fj8uXLrYqx7OxszalrJiYmrQ78+/Tp06oUs7KyEvlTEIlDrVajuLhYU6bl5eW1KpmvXbuG5uZmAIC1tXWbEm3gwIHw9PRkodzOvv32W7z66qtITEzEkCFDxI5DRERERCQ2FmZEt1NVVYX09HRkZGRo7tPS0lBSUgLgz1Mm3dzc4OXlpTnFrOXWp08f6OjoiPwJiLqe5uZm5Obmak5ZvvF24cIFXL9+HQDg4OAALy8veHp6au59fX1ZpN2H4uJieHp64rnnnsPq1avFjkNERERE1BmwMCNSqVTIyMhAcnIykpOTcf78eaSnp2tOobSysoK3t3erA3Nvb2/Y2tqKnJyoZ1Gr1bhy5YqmwD5//jwyMjKQmZmJhoYGSCQS9O7dW1Oe+fn5wc/PD66urmJH79Rmz56NkydPIj09HaampmLHISIiIiLqDFiYUc8iCAIuXbqkKceSkpKQmpqK69evw8jICIMHD8agQYNajVyxt7cXOzYR3YFKpcKVK1dw/vx5ZGZm4vz580hNTcWFCxegVqthZ2enKc/8/Pzg7+8POzs7sWN3CgcPHsTkyZMRFRWF0NBQseMQEREREXUWLMyoe1MqlTh9+jSOHj2K+Ph4JCcnQ6FQwMDAAIMGDWp1EO3l5QU9PT2xIxNRO6mpqcHZs2c15XhycjKys7MhCAJcXFwQEBCAoKAghISEwNPTU+y4Wnf9+nX4+PjA398fO3bsEDsOEREREVFnwsKMuhelUonExETExsYiNjYWJ0+eRF1dHVxdXREcHIyAgAD4+fnB19cXBgYGYsclIi2Ty+WaAi0hIQHHjh2DQqGAnZ0dgoKCEBwcjODgYHh4eIgdtcMtWbIEW7duRXp6OhwcHMSOQ0RERETUmbAwo66vqKgIe/fuxZ49e3Ds2DHU1dXBxcUFwcHBCAkJQXBwMPr27St2TCLqhFQqFc6cOYO4uDjExsYiPj4eNTU1sLe3x8SJEzF9+nRMmjQJxsbGYkdtVydPnsSYMWOwefNmhIWFiR2HiIiIiKizYWFGXVN2djYiIyMRGRmJU6dOwdjYGJMnT8akSZMQHBwMd3d3sSMSURfU3NyMM2fOIDY2FtHR0UhISIChoSEeeeQRTJ8+HVOnToWlpaXYMR9IfX09fH190b9/f/z+++9ixyEiIiIi6oxYmFHXUVhYiC1btuCXX37BuXPnYG1tjdDQUDz++OOYOHEiDA0NxY5IRN1MSUkJ9u7di8jISBw5cgSCICA4OBhhYWGYOXMmjIyMxI54z5YuXYrvv/8eaWlpcHFxETsOEREREVFnpNQROwHRnQiCgEOHDiE0NBSurq74/PPPMWbMGBw+fBjFxcX4z3/+g2nTprEso3uWnJwMiUSCFStWiB3lrjQ0NODtt9+Gm5sb9PT0IJFIUFtbK3asbs/Ozg4vvPACDhw4gNLSUmzevBkmJiZYuHAhHB0d8corr+DSpUtix7xrp0+fxpdffol169axLCMiIiIiugMWZtQpqdVqbNu2Db6+vnjkkUdQX1+P7du3o6CgABs2bMC4ceN4Rcsu6vjx45BIJPjkk0+61bY62sqVK7FmzRpcuXIFKpWqw7fXnX537UUmk2Hu3LmIjIxEXl4e3n33XRw6dAgeHh6YPn06EhMTxY54R42NjVi4cCGCg4OxYMECseMQEREREXVqLMyo0zl48CAGDx6MBQsWYPDgwUhNTUVMTAxmzZoFqVQqdjzqJvz8/CAIQpcZYbZ3717IZDJkZGRApVJBEASYmpqKHavHsrOzw5tvvomLFy9i165dKC0tRUBAAJ588klkZWWJHe+WPvzwQ+Tl5eGHH36ARCIROw4RERERUafGwow6jaqqKoSFhWHy5Mno378/0tLSsGXLFvj6+oodjUh0+fn5GDBgADw8PKCjw113Z6Gjo4PHH38cCQkJ2Lt3LzIzM+Hr64v169dDrVaLHU/j7NmzWLduHVavXg1XV1ex4xARERERdXo86qJO4fLlywgICEBMTAwiIyPx22+/YeDAgWLHumvx8fGYN28e+vXrB6lUChsbG4SGhuLEiRNt1q2qqsJLL70Ee3t7GBkZwc/PD/v27cPmzZshkUiwa9eu+17/4MGDkEgk+OKLLxAXF4egoCCYmZnBz88PwJ9zwv3www8YNWoUzMzMYGRkBF9fX3z99de4+fof95rzbn4Hn3zyCcaOHQsAeP/99yGRSDS3FveS8U7+alu3msPs/7F353FV1Yn/x98XuOyrIKu44C6WC6amhmJotpiamm1aU9NYTZtjy3y/zXxrxmmyabG+2tS0zjg6U5ppueaumGaKogaKGygKgqLsyGU5vz/my/1BoIkCh+X1fDzO48K5557P+5x7G4f343POrXr+Nm3apCFDhsjDw0Ph4eGaPXu2fbu5c+eqe/fucnV1VY8ePbR48eIa49fXcTz77LOyWCzKzs7WDz/8YD+Gxx577KrGqo/36eOPP671M1D1uWXLltV6Xq/1c9mUjR07VgkJCfqf//kf/dd//Zduv/125eXlmR1LNptNDz74oIYNG6Zf/epXZscBAAAAmgcDMNnBgwcNPz8/Y+jQoUZWVpbZceosIyPDkFTr4uTkZGzZssW+bXFxsdG3b98a21ksFmPKlCmGJGPx4sVXvf3q1asNScbkyZMNJycn+/b9+vUzKioqjPvvv/+SWR999NGrHvdKz8GsWbMuuZ1hGHXK+HN+bqxdu3YZkoyXX365xvmbMmVKtfNXubz99tvGCy+8UGO9g4ODsXfvXvt+6vM4nnnmmVr3MX369DqPVV/v00cffVTjM1Cp8rmlS5fWOK/X+rlsTrZv324EBgYaQ4YMMYqLi03N8tJLLxkeHh7G0aNHTc0BAAAANCMlFGYwVXFxsdGtWzdj6NChpv9RebXOnDljjBo1yli+fLmRlpZm2Gw2IzMz01i0aJHh4eFh3HrrrfZt//KXvxiSjO7duxsbNmww8vPzjZSUFOOpp56yFwRVS4i6bl9ZTEgyHn74YSM5OdkoKyszDMMw5s+fb0gyrrvuOmPVqlVGdna2UVBQYGzZssXo06ePIcnYvn37VY1bl3MQFxdnSDJmzZpV41zWJeOVuNxYlyvMJBnPPvuskZqaahQUFBhffvmlYbVaDR8fH8PLy8v4+OOPjaysLCM7O9uYOXOmIcmYNm1agx2HYRiGj4+PMWjQoGs6Z/X1Pl1tYXatn8vm5uDBg4avr6+93DRDQkKCYbVajXnz5pmWAQAAAGiGKMxgrnnz5hnu7u7G6dOnzY5yTXbv3m1MnjzZCA0NrTEzqV27dvbtBg4caFgsFuPHH3+ssY9Ro0bVKCHqun1lMTF48GCjoqKi2vYxMTGGo6OjkZ6eXmNfiYmJhiTjxRdfvKpx63IOLlfE1CXjlbjawmzMmDE1tp84caIhyXjrrbeqrS8rKzN8fHyMAQMGNNhxGMalC7O6jlUf79PVFmbX+rlsjhYuXGg4Ojoahw8fbvSxS0tLjf79+xtDhgwxysvLG318AAAAoBkrcRJgopUrV2rixIkKDQ01O8pV2759u2JiYmSz2Wp9vri42P7zsWPHFBYWpsjIyBrb3XLLLVq3bl21dXXdvlJsbGyNb8FLTExUeXm5wsPDJUmGYdjvD1X5ePLkyasaty7n4HLqkrEhDR8+vMa6Dh06SJKio6OrrXd0dFRYWJgyMzPt6xrzOOoyVn29T1frWj+XzdE999yjGTNmaM2aNeratWujjv2nP/1Jhw4d0r59+/iiCAAAAKCO+H/QMFVmZmazLsskafbs2bLZbHr55Zd19OhRFRcXq6KiQoZhqHv37jW2/2lhUMm4xM3N67q9JPn7+9dYV/mNfeXl5SovL7dnrLqfqkVKXcat6zm4lLpmbCiurq411lWej0s9V/UbERvzOOoyVn29T5XlS23fAnm50q0+PpfNjYODg0JCQnTmzJlGHXfnzp169dVXNXv2bHXp0qVRxwYAAABaAgozmKpHjx764YcfzI5xTY4fP66goCC98sor6ty5s1xdXWWxWHTs2DEdOXKk2radO3fWqVOnlJSUVGM/tc0Wq+v2l9OjRw+5u7srJyfHXkj8dKn81sO6jluXc1BZtpSVlV1TxitxubEaUn0fR32NVV/vU2BgoCQpJSWlxnMbN25ssPzN0fnz53X48GH17Nmz0cYsLCzUtGnTFBMToyeffLLRxgUAAABaEgozmOrRRx/Vpk2btHr1arOjXLX27dsrKytL8+bNU25urnJzc7Vq1SrddtttNWbgTJw4UYZhaNKkSdq8ebMKCwt14sQJzZgxQ2vXrq2x77pufzmPPPKIioqKFBsbqxUrVujs2bOy2Ww6ceKE/dLYDRs2XNW4dTkHbdq0kSTFxcUpOzv7qjNeicuN1ZDq+zjqa6z6ep969eolSXrnnXe0efNmFRcXKzU1VTNnztSyZcsaLH9z9PLLL8vT01MTJkxotDGfffZZnT9/Xv/4xz8uOVMUAAAAwM+49vugAddm6tSphq+vrxEfH292lKuybNmyajdOr1z69etn9O7d2/D397dvW1RUZFx//fU1trVYLMbkyZMNScayZcuuevvKm6vPmTOnRs6KigrjoYceqjVr5bJ69eqrGrcu56CsrMwICwursW1dM16Jy411uZv+13b+Kr8N88CBAzWei4yMNMLCwq7qXF+pS930vy5j1df7ZBiGcdddd9V4zsnJyZg6deolb/p/rZ/L5mbevHmGxWIx/v3vfzfamJXv8aJFixptTAAAAKAFKmGGGUz34YcfauDAgRo+fLiWLFlidpw6GzdunBYuXKjrr79ebm5uCgkJ0fTp07Vhwwa5uLhU29bNzU2bNm3S9OnTFRgYKFdXV0VFEtLYvwAAIABJREFURembb76xz9rx8/O76u0vx2Kx6LPPPtMXX3yh2NhY+fn5ydnZWRERERo/fryWLl2q2NjYqxq3LufA0dFRX375pYYNGyYPD4+rznglLjdWQ6rv46ivserrfZKkTz75RA8//LD8/f3l6uqqG2+8UevXr6/xpQj1mb+5KC0t1XPPPaennnpKr732mu65555GGTcrK0vTp0/XI488osmTJzfKmAAAAEBLZTGMy9w5HGgkpaWlevrpp/XBBx/o/vvv15w5c9S2bVuzYzWaiooKDRgwQAkJCTp79mytN0e/lu3Nygm0Nrt27dIvf/lLHT16VB9++KHuv//+RhnXMAyNHTtWBw8eVEJCgry8vBplXAAAAKCFsjHDDE2C1WrV+++/r5UrV2rLli3q3Lmz/vjHPyo/P9/saPVu5syZWrBggU6cOKGioiIlJCTo7rvv1t69ezVixIgaJVRdtzcrJ9CaHT16VPfee68GDRqkNm3aaP/+/Y1WlknSvHnz9O2332rBggWUZQAAAEA9YIYZmpzCwkK98847euONN2SxWDR9+nQ99dRTCgsLMztavbjjjju0cuXKGus9PT0VFxenvn37XtP2ZuVsLAkJCerXr9/Pbjdu3Lg634C+MbWU42jtdu7cqbfeektfffWVunbtqldffVUTJkxo1JvtHzx4UFFRUXrhhRf0yiuvNNq4AAAAQAvGDDM0PR4eHnrppZeUkpKiF154QfPnz1fHjh01fvx4LV++XOXl5WZHvCZz5szRQw89pC5dusjFxUVt27bVpEmTtGPHjlpLqLpub1ZOoLXIycnRX//6V0VFRWnw4MFKTU3VwoUL9eOPP+quu+5q1LKstLRUDz74oCIjI/XSSy812rgAAABAS8cMMzR5NptNS5Ys0ccff6xNmzapbdu2GjdunCZMmKCbb75Zzs7OZkcE0MJlZ2dr+fLlWrp0qdauXSsHBwdNnjxZjz76qIYOHWparhdffFHvvfee9uzZo27dupmWAwAAAGhhbBRmaFaOHTumzz//XMuWLVN8fLy8vb112223acKECbr11lvl6elpdkQALURaWpqWLVumZcuWacuWLbJarbr55ps1YcIETZo0ST4+Pqbmi4uLU0xMjD744AP98pe/NDULAAAA0MJQmKH5OnnypP2P2a1bt8pqtWro0KEaMWKEYmJiNHDgQFmtVrNjAmgmcnJytHXrVm3atEmbN2/Wvn375OXlVa2Ubyo31M/JyVGfPn3Ur18/7nEHAAAA1D8KM7QM586d08qVK7VhwwZt2rRJp06dkoeHh4YMGaIRI0ZoxIgRGjhwoJycnMyOCqCJyM3NVVxcXLWCzDAMXXfddRoxYoTGjBmjmJgYubi4mB21hrvvvlvbtm3Tvn371LZtW7PjAAAAAC0NhRlapqNHj2rz5s3avHmzNm3apPT0dHl6eqp///4aMGCAfenSpUuj3qAbgDlsNpv279+v3bt325cff/xRFRUV6t27t2JiYjRixAhFR0fL39/f7LiX9de//lVPPfWU1qxZo1GjRpkdBwAAAGiJKMzQOhw+fFhxcXHauXOn/Q/l0tJS+fr6VivQoqKi1LFjR7PjArgGZWVlSkxMrFaO7d+/XzabTd7e3urfv79uuOEGDR48WNHR0QoICDA78hU7cOCABg0apOeff15/+MMfzI4DAAAAtFQUZmidSktLdfjwYcXHx9uXXbt22f+g7tq1q3r16qXIyEj7Y6dOnZiNBjQh5eXlOnHihBITE5WUlGR/TEpKUnFxsaxWq7p27aphw4Zp6NChioqKUs+ePeXg4GB29KtSUFCgG264QYGBgdq4caMcHR3NjgQAAAC0VBRmQKWCggIlJCToxx9/1I8//qikpCT9+OOPOnv2rCTJz89PkZGR9qVbt27q0qWLOnTowL3RgAZUWFioY8eO6dixYzp06JD9v8+DBw+qpKREDg4O6tixY7X/Pq+//nr16tWrRf23OW3aNK1Zs0Z79+5VWFiY2XEAAACAlozCDPg5586d04EDB+wFWuVMluzsbEmSk5OTOnTooC5duqhz587VHiMiIuTq6mryEQBN34ULF3T06FF7MVb589GjR5WRkSFJslgs6tChg3r16qXevXtXmwXq7u5u8hE0rE8++USPPvqovv76a40dO9bsOAAAAEBLR2EGXK3z58/X+OO+tj/w27Vrpw4dOqhDhw4KDw9Xu3bt1L59e4WHhys8PLzJ32AcuFbl5eU6c+aMTpw4oVOnTiktLU1paWk6efKk0tLSdPz4cZ0/f16SZLVa1aFDB3Xu3LnaUllEt8YCev/+/brxxhv19NNP67XXXjM7DgAAANAaUJgBDaGoqKhaiXbixAmdOHFCaWlpOnXqlM6dO2ff1s3NTR06dFC7du0UHh6u9u3bKywsTMHBwWrbtq3CwsIUGBgoFxcXE48IqF1+fr7S09OVlZWlM2fO6MyZMzVKsfT0dJWVlUmSHB0dFRwcbC+Qw8PD1alTJ3shxiXO1eXn52vgwIEKCgrS+vXrOTcAAABA46AwA8xQXFxsn21z6tQpe5lWWailpaUpPz+/2mv8/PwUHByswMBAhYaGKjAwUMHBwfZ1QUFB8vf3l7+/v7y8vEw6MjR3hmEoOztb2dnZOn/+vLKyspSRkaHMzExlZmYqPT1dZ8+eVUZGhs6cOaPi4mL7ay0Wi/3zGR4eXmNWZfv27RUSEkLpc4UMw9CkSZP03Xffac+ePQoNDTU7EgAAANBaUJgBTVVxcbEyMzOVkZFRo7T46bqioqJqr3V2dlabNm3sBVrVnwMCAqqt9/Hxkbe3t3x8fOTj49Nsv0EQ1ZWUlCg/P195eXm6cOGCcnNzde7cuWpl2KV+/uk/C5cqa0NCQtS2bVv7usDAQMqwevT666/rd7/7nTZs2KDo6Giz4wAAAACtCYUZ0BIUFBQoMzPzZ8uQ7OxsnTt3TufPn68xg62Sp6envL295e3tLS8vL/n4+MjX19f+e+Vz3t7ecnd3l4uLi3x8fOTs7CwvLy+5ubnJ1dVV3t7eslqt8vHxaeSz0fyUl5crLy9PFy9eVHFxsfLz81VaWqqcnByVlJSoqKhIBQUFKikpUW5urnJycpSXl2cvxCqXyvV5eXkqKSmpMY7FYqlWnlYtUy9VqrZt25bLgU2wefNmjRo1Sq+//rp+85vfmB0HAAAAaG0ozIDWymazKTs7216w5ObmKjc31/57ZRlTWdBULWfy8/OVm5ur4uJiXbx48WfHcnFxkbu7uzw9PWW1WuXn5yfpPzd49/T0lCS5urrKzc1NkuxFnCT7ayTVOgPOw8NDzs7OlxzbYrHI19f3ks9XllWXU1hYKJvNVm1dZZEl/eeedZUFVU5Ojn2GVl5ensrLyyX951sgJam0tFQFBQX21+Tm5qqiouKy40uSl5eXXFxc5O3tbS8wf1pi+vn5Vfu98mc/Pz95e3vL399fFovlZ8eCudLT09W/f38NGzZMixcv5j0DAAAAGh+FGYBrl5ubq9LSUuXl5dlLtLy8PNlsthozp2w2m3JzcyXJvl6qXjoVFBSotLTUvu/KQqmydKqqtnVVVS22LuXnLkWtWuzVtq6yEJSkhIQEeXl5KSoqSl5eXvayz9vbW46OjnJ0dJS3t7e9IKw6E69ynZeXl5ydneXj41Nt32j5SkpKNGLECF24cEE//PCDvL29zY4EAAAAtEY2bjYD4JpVXnYZEBBgchLzrVmzRnfddZccHR31t7/9zV6YAVfiySefVGJionbs2EFZBgAAAJiIu3sDQD0aM2aM1qxZo1WrVumuu+66oktWAUmaM2eOPv30U/3rX/9SZGSk2XEAAACAVo1LMgGgAezatUtjxoxRnz599M0339S4pBOoav369br11lv16quv6oUXXjA7DgAAANDacQ8zAGgoe/fu1ejRo9WzZ0+tWLGCS+xQq5SUFA0cOFAjRozQokWLuMk/AAAAYD4KMwBoSAcPHlRsbKxCQ0O1Zs0a+fv7mx0JTUhOTo6GDBkiDw8Pbd261f5NsQAAAABMZeMeZgDQgHr27KlNmzYpMzNTo0aN0tmzZ82OhCaitLRUkydPVm5urpYuXUpZBgAAADQhFGYA0MC6deumuLg45efnKzo6WqdPnzY7EpqAp59+Wt9//71Wrlypdu3amR0HAAAAQBUUZgDQCDp06KC4uDg5OTnppptuUkpKitmRYKLXX39dH374oRYsWKC+ffuaHQcAAADAT1CYAUAjCQ4O1oYNG+Tt7a0RI0bo6NGjZkeCCZYsWaL//u//1pw5czRu3Diz4wAAAACoBTf9B4BGlpOTo1tvvVWpqalat26devfubXYkNJLt27crNjZWDz/8sObNm2d2HAAAAAC141syAcAMBQUFuvPOO5WYmKhvv/2Wy/JagcTEREVHR+umm27SkiVL5OjoaHYkAAAAALWjMAMAsxQVFWn8+PHatWuXVq9ercGDB5sdCQ3k9OnTGjJkiEJDQ7Vhwwa5u7ubHQkAAADApdm4hxkAmMTd3V3Lly/XiBEjFBsbq40bN5odCQ0gOztbo0aNkre3t1atWkVZBgAAADQDFGYAYCIXFxctWrRIt956q8aOHau1a9eaHQn1qLi4WOPGjVN+fr5WrVolPz8/syMBAAAAuAIUZgBgMqvVqs8//1x33323xo4dq6VLl5odCfWgtLRUkyZNUnJystatW6fw8HCzIwEAAAC4Qk5mBwAASI6Ojvr000/l5eWlu+++W5999pkeeOABs2PhKhmGoenTp2vz5s1at26devToYXYkAAAAAHVAYQYATYTFYtG7774rq9Wqhx56SKWlpfrFL35hdixchRdffFELFizQN998oyFDhpgdBwAAAEAdUZgBQBNisVj01ltvKTAwUI888ojy8/P19NNPmx0LdTBv3jy9+eab+uyzzzRmzBiz4wAAAAC4ChRmANAEvfjii5KkZ599VqWlpZo5c6bJiXAl/vWvf+mZZ57Rm2++qQcffNDsOAAAAACuEoUZADRRL774ory8vPTkk0/q7Nmzmj17ttmRcBkrVqzQQw89pOeee06/+c1vzI4DAAAA4BpQmAFAE/bEE0/IarXqsccek2EYev31182OhFp8++23mjRpkh566CGKTQAAAKAFoDADgCbu0Ucflaenp6ZNm6b8/HzNmzdPDg4OZsfC/9m2bZsmTpyoKVOm6IMPPpDFYjE7EgAAAIBrRGEGAM3AvffeKw8PD919990qLS3V3/72N0qzJmDHjh267bbbNGbMGH3yySe8JwAAAEALYTEMwzA7BADgyqxatUqTJk3SuHHjNH/+fFmtVrMjtVp79+7VzTffrOHDh2vRokW8FwAAAEDLYaMwA4BmZsuWLRo7dqxGjBihRYsWydXV1exIrc6+ffs0cuRI3XDDDfr666/l4uJidiQAAAAA9YfCDACao23btun222/X0KFDtWTJErm5uZkdqdU4cOCARo4cqb59+2r58uUUlgAAAEDLQ2EGAM1VfHy8xowZo169emnFihXy8vIyO1KLd/jwYY0YMUIRERFas2aNPD09zY4EAAAAoP5RmAFAc5aUlKTY2Fi1a9dOa9asUZs2bcyO1GIdPXpUw4cPV/v27bV27VoKSgAAAKDlojADgOYuOTlZsbGxCgwM1LfffquAgACzI7U4qampGj58uIKCgrRu3Tr5+PiYHQkAAABAw6EwA4CWIDU1VbGxsXJ2dtb69esVGhpqdqQWIyUlRTExMfLz89OGDRuYxQcAAAC0fDYHsxMAAK5dx44dFRcXJ4vFopiYGKWlpZkdqUVITU3VyJEj5efnp3Xr1lGWAQAAAK0EhRkAtBAhISHauHGjXF1dddNNN+no0aNmR2rWkpOTNWzYMLVp00br16/nUlcAAACgFaEwA4AWJCgoSJs3b1ZQUJBuuukmJSYmmh2pWTp06JBGjhypkJAQrVu3Tv7+/mZHAgAAANCIKMwAoIXx8/PT2rVrFRERoZEjR2rfvn2X3La8vLwRkzUPBw8e1MiRI9WpUyfuWQYAAAC0UhRmANAC+fj4aO3atbr++usVExOjnTt31tjm9OnTGj58uIqKikxIaJ7z58/r/fffr/W5hIQERUdHq0uXLlq9erW8vb0bOR0AAACApoDCDABaKA8PD61YsUI33XSTYmNjtWnTJvtzWVlZGj58uL777jv97W9/MzFl4/vLX/6iX//61/r000+rrd+zZ49iY2MVGRmpVatWycvLy6SEAAAAAMxmMQzDMDsEAKDh2Gw23XfffVq9erWWLVumqKgo+5cC2Gw2tWnTRmlpaXJ3dzc7aoPLyMhQp06dVFJSIgcHBy1atEgTJ05UfHy8Ro8erYEDB+qrr76Sm5ub2VEBAAAAmMfGDDMAaOGcnZ31+eefa/z48brzzjt144036siRI7LZbJKkvLw8vffeeyanbByzZs1SRUWFJMkwDN1zzz166623NHLkSA0ePFhLly6lLAMAAADADDMAaC3y8/N1/fXX69SpUyorK6v2nI+Pj9LS0lr0ZYipqanq2rVrtWN3cHCQo6Ojhg4dqm+//VbOzs4mJgQAAADQRDDDDABaA5vNpokTJ9ZalklSYWGh5s2bZ0KyxvP73/9eFoul2rqKigpVVFRo165dSkxMNCkZAAAAgKaGGWYA0MKVlpZq3LhxWrduXa1lWSVvb2+lpaW1yG+GTE5OVq9eveyXY/6Uk5OTvLy8tGPHDnXv3r2R0wEAAABoYphhBgAtWVlZme69916tXr36smWZJBUVFendd99tpGSN68UXX5Sjo+Mlny8rK1N+fr5uvvlmnTp1qhGTAQAAAGiKKMwAoAVzcnLSE088odGjR8tischqtV5y27KyMr3xxhvKyclpxIQNb9euXfrmm29UWlp6yW0sFosMw1BhYaHWrl3biOkAAAAANEUUZgDQwo0cOVLffvutkpOT9dhjj8nZ2fmSxVlxcbHeeeedRk7YsH7729/Kycmp1ucq13fo0EFvvfWWTp8+rYcffrgx4wEAAABogriHGQC0MpmZmXr//ff19ttvq7i4uMalmu7u7kpLS1ObNm1MSlh/4uLiFB0dXWO9s7OzbDabBg0apJdeekl33HFHjS8EAAAAANBqcQ8zAGhtgoKC9Morryg9PV1vvvmmQkJCZLFY5ODwn38SSktL9fbbb5ucsn4899xz1WaXOTk5yWq16u6779aBAwf0/fffa+zYsZRlAAAAAKphhhkAtHKlpaX6/PPP9frrrysxMVEWi0Wurq46efKkAgICamxfUlKioqIi++PFixdVXFws6T+XdF68eLHGaypvql8bFxcXubu711hvsVjk6+srSXJ0dJS3t7f9sfJbLS9nxYoV9jLMYrGoTZs2mjFjhn71q1/VelwAAAAA8H9sFGYA0EpkZ2fr7NmzOnfunHJycpSXl6e8vDzl5ubaf09OTta+fft07tw5BQUFycPDQ6WlpSooKJDNZlNhYaHZh1GN1WqVp6en/dHd3V3e3t7y8vLS999/r9zcXLVt21bR0dEaMmSI/Pz85O3tLT8/PwUEBNgXZ2dnsw8FAAAAQNNBYQYAzVVFRYUyMzN1+vRppaenKy0tzV6IZWVl6ezZs/bfz507p/Ly8mqvt1qt8vb2lo+Pj3x9feXt7W3/3WazKTk5WePGjZOvr6/c3d3tM8Eu9Vi5T09Pz1rz+vr61nrpY2FhoWw2W431VQu6yhlqP/dYXFysvLw87du3T8nJyQoJCZGDg4O9HMzLy1NBQUGNsby9vRUUFFStRAsMDFRgYKBCQkLUrl07hYaGKiwsTK6urnV+rwAAAAA0KxRmANBU5eTk6Pjx4zp27JhSU1N16tQpnT59WhkZGTp58qQyMzNVWlpq397f399e+rRt27bWAqht27YKCAiQn5+f3NzcTDy6hlVYWCgPD49an6uoqNCFCxeqlYlnz55VVlaW/fdz584pMzNTWVlZyszMrPbFCAEBAQoJCVH79u3tZVr79u0VERGhzp07KywsjHuiAQAAAM0bhRkAmOnMmTM6ePCgjh07puPHj9uXY8eO6fz585L+c/+usLAwhYeHKywsTKGhoWrXrp1CQkIUHh7OzKcGVttMvoyMDHuBmZ6ertTUVBUVFUn6zz3ZOnXqZC/QIiIiFBERoe7du6tz587VvoQAAAAAQJNEYQYAjeHChQtKTExUUlKS/fHAgQPKzMyU9J+SJSwszF6uVF169uxZ603x0bRcuHChWulZdUlNTVVFRYWsVqvCw8PVq1cvRUZGVntsyTP+AAAAgGaGwgwA6lNFRYUOHz6s+Ph47d69W/Hx8dq/f79yc3MlSW3btlVkZKR69uxpf+zVq5eCg4NNTo6GVFhYqOTkZHthevDgQSUmJiolJUXl5eWyWq3q1q2boqKi7Evfvn0veVkpAAAAgAZFYQYA1+LkyZP67rvv7OXYnj17lJ+fL6vVquuuu04DBgxQv3797AVZQECA2ZHRhFy8eFGHDh3SwYMHtX//fsXHxys+Pl7nz5+Xo6OjevbsqaioKA0YMEADBw5U//79uaQTAAAAaHgUZgBQF8ePH9e2bdv03Xffadu2bUpKSpKTk1ON2UFRUVFcYoerlp6ebi/P4uPjtXPnTp09e1YeHh7q27evhg0bptjYWA0bNox71wEAAAD1j8IMAC7nzJkzWrlypdauXautW7fqzJkzcnd31+DBgxUdHa3o6GgNGjSIe4yhQRmGoYMHD2rr1q2Ki4vTli1bdPr0abm6umrgwIGKjY3Vbbfdpv79+/MNnQAAAMC1ozADgKoMw9CePXu0YsUKrVixQvHx8XJ1ddWIESM0fPhwRUdHa8CAAbJarWZHRSt3/Phxbd26VVu3btXatWt1+vRphYaG6vbbb9ftt9+u2NhY7oEGAAAAXB0KMwCQpB07dmjhwoX66quvlJGRoXbt2un222/XHXfcoZEjRzKDDE2aYRhKSEjQypUrtWLFCu3atUvOzs4aOXKk7rvvPk2YMIHPMAAAAHDlKMwAtF7Hjx/XggULtGDBAh05ckSRkZG65557dMcdd6hv375mxwOuWlZWllatWqWvvvpKa9askaurq+666y5NnTpVMTExcnBwMDsiAAAA0JRRmAFoXSoqKvT1119rzpw52rZtm4KCgnTPPfdo6tSp6t+/v9nxgHp39uxZff7551qwYIF++OEHtWvXTtOnT9cTTzyhNm3amB0PAAAAaIoozAC0DhcvXtQ///lPvfnmmzp69KjuvPNO/epXv9KoUaPk5ORkdjygUSQnJ+vvf/+7PvzwQ5WUlOiRRx7RjBkz1LFjR7OjAQAAAE0JhRmAlq2srEzvvfeeZs+erQsXLmjq1Kl67rnn1L17d7OjAaYpKCjQJ598ojlz5uj06dO655579Nprr6ldu3ZmRwMAAACaAhs3MQHQYsXFxal///767W9/q2nTpik1NVUfffQRZZmJLl68qBdeeEERERFycnKSxWJRQUGB2bFaHU9PTz3zzDM6evSo/vGPf+j7779Xz5499cYbb6i0tNTseAAAAIDpKMwAtDjnz5/XtGnTNHz4cLVr104HDhzQ66+/ruDgYLOjtXqvvfaa3njjDaWkpKi8vLzBx9u2bZssFov+9Kc/NfhYzZGTk5Puu+8+/fjjj3rhhRf08ssvq0+fPtq2bZvZ0QAAAABTUZgBaFH27NmjAQMGaNOmTfrqq6+0atUqdenSxexY+D9ff/21fHx8lJSUpPLychmGIU9PT7NjtXouLi76/e9/r6SkJEVERCgmJkZvv/222bEAAAAA01CYAWgx4uLiNGLECEVERGjPnj0aP3682ZHwE6dOnVL37t3Vs2dPOTjwT1BT07FjRy1fvlx//vOf9cILL2jmzJniVqcAAABojfhrBUCLkJiYqNtvv12jR4/WqlWr1LZtW7Mjac2aNbJYLHrnnXe0adMmDRkyRB4eHgoPD9fs2bPt282dO1fdu3eXq6urevToocWLF9fYl2EY+vTTTzVkyBB5eXnJzc1Nffr00XvvvVet0Kg65pYtWzR8+HB5eXlpwIABkqQLFy7oiSeeUHBwsNzc3DRgwACtWLFCf//732WxWPTll19e1bg/59lnn5XFYlF2drZ++OEHWSwWWSwWPfbYY1c11tatW3X//ferS5cucnFxUdu2bTV27Fh999139m3+9Kc/6aabbpIk/f73v7ePabFYJEkff/xxrcdc9blly5Zd8bm90vzl5eWaO3euoqKi5OfnJ19fXw0YMEBvv/22ioqKrvicNhSLxaLnn39eCxYs0P/+7/9q1qxZZkcCAAAAGp8BAM1cSUmJ0aNHD+Omm24ySkpKzI5jt3r1akOSMWXKFMPJycmQVG15++23jRdeeKHGegcHB2Pv3r32/VRUVBj3339/je0ql0cffbTGmJMnT642Zr9+/Yzi4mKjb9++NV5vsViMKVOmGJKMxYsXX9W4P+eZZ56pdR/Tp0+v81gZGRmX3M7JycnYsmWLYRiGMWvWrEtuZxiG8dFHH9U45kqVzy1duvSKzm1d8j///POX3G7u3LlXfE4bw3vvvWc4ODgYmzdvNjsKAAAA0JhKmGEGoNn74IMPdPLkSS1cuFDOzs5mx6nhiy++0JNPPqnU1FQVFBToyy+/lNVq1R/+8Ae9//77+vjjj5WVlaXs7GzNnDlTFRUVmjNnjv31CxYs0MKFC3Xddddp1apVys7OVkFBgbZs2aI+ffroo48+0o4dO6qNuXjxYk2bNk3JyckqKyvTnj17NHfuXCUkJKh79+7asGGD8vPzlZKSoieffFJffPFFjdxXM+6lvPPOOzIMQz4+Pho0aJAMw5BhGPrggw/qPJbFYtGoUaO0fPlypaWlyWazKTMzU4sWLZKLi4t99t7vfvc7xcXFSZJmzZplH9O4xksMazu3dcm/bNkyeXhYyOQjAAAgAElEQVR4aMmSJcrJyVFhYaESEhL03HPPNbn7uT3xxBMaM2aMZsyYYXYUAAAAoHGZWdcBQH3o06eP8fjjj5sdo4bKGUljxoyp8dzEiRMNScZbb71VbX1ZWZnh4+NjDBgwwL4uJibGcHR0NNLT02vsJzEx0ZBkvPjii9XGHDx4sFFRUVFt24EDBxoWi8X48ccfa+xn1KhRNWZb1WXcK+Xj42MMGjSoxvq6jrV7925j8uTJRmhoaI3Ze+3atbNvFxcXZ0gyZs2aVWO/VzvDrLZzW5f8MTExRteuXY3S0tLaTlGTs3PnTkOSsWfPHrOjAAAAAI2lxKnxKzoAqD/FxcXav3+//vjHP5od5ZKGDx9eY12HDh0kSdHR0dXWOzo6KiwsTJmZmfZ1iYmJKi8vV3h4uCRVmyVV+Xjy5Mlq+4mNjbXfq6vSsWPHFBYWpsjIyBp5brnlFq1bt67auqsZ92rVZazt27crJiZGNput1n0VFxfXS6ZLqe3c1iX/nDlzNHHiRHXp0kW33HKL+vTpoxtvvFH9+vVr0NxXa+DAgWrTpo2+//77JpsRAAAAqG9ckgmgWcvNzZVhGPL19TU7yiW5urrWWFdZuFzquYqKCvvvlT+Xl5ervLxcFRUVNS4t/Gl55O/vX2uWnxY9lYxaLlO8mnGvVl3Gmj17tmw2m15++WUdPXpUxcXF9u27d+9+xWNWfktn1XNd6XKlW23nti75+/Tpo0OHDmn+/Pnq1KmT4uLiNGbMGEVGRurAgQNXnL8xtWnTRjk5OWbHAAAAABoNM8wANGtt27aVi4uLjh07VmO2VkvRo0cP7dmzR+np6fLx8bnq/XTu3Fm7du1SUlKSevXqVe25n84uq89xr0Rdxjp+/LiCgoL0yiuvVFt/7NgxHTlyRH5+fvZ1laVYWVlZjf0EBgZKklJSUmo8t3HjxgbLL0lOTk6Kjo62f2aLiorUvXt3PfLII/rhhx/qNHZDKy4u1qlTp+yz5wAAAIDWgBlmAJo1R0dHjR49WgsXLjQ7SoN55JFHVFRUpNjYWK1YsUJnz56VzWbTiRMntHLlSk2cOFEbNmz42f1MnDhRhmFo0qRJ2rx5swoLC3XixAnNmDFDa9eubbBx6/sY27dvr6ysLM2bN0+5ubnKzc3VqlWrdNttt9WYLdamTRtJUlxcnLKzs6s9V1kavvPOO9q8ebOKi4uVmpqqmTNnatmyZQ2Wf8iQIfrggw+UlJSk4uJi5ebmas2aNcrOztbx48ev6vw1pCVLlqisrEyjR482OwoAAADQaJhhBqDZmzFjhkaOHKkVK1bojjvuMDtOvXvwwQe1ZcsW/f3vf9fYsWNr3ebRRx/92f089dRTWrhwofbv36+YmBj7eovFosmTJ2vx4sWyWq31Pu6VqMtY06dP1+rVq/XUU0/pqaeesj/fr18/9e7dWxkZGfZ1Xbt2VVhYmDZu3KiAgAD7esMwFBERobvuuktfffVVtfPh5OSkqVOn6p///GeD5N+zZ88lv120vs5nfcnPz9fvfvc73X///fYZeQAAAEBrwAwzAM1eTEyMpk2bpgcffFBHjhwxO069s1gs+uyzz/TFF18oNjZWfn5+cnZ2VkREhMaPH6+lS5cqNjb2Z/fj5uamTZs2afr06QoMDJSrq6uioqL0zTff2GdbVb2csb7Gre9jHDdunBYuXKjrr79ebm5uCgkJ0fTp07Vhwwa5uLhU26+jo6O+/PJLDRs2TB4eHjXG/eSTT/Twww/L399frq6uuvHGG7V+/fo6X95bl/w7d+7Ur3/9a/Xq1Utubm4KCAjQ0KFD9fHHH2vOnDlXeQbrX3l5uaZOnaqSkhLNnj3b7DgAAABAo7IYtd3pGQCameLiYsXExOjUqVNat26devbsaXakZqOiokIDBgxQQkKCzp49e8kvDEDrYbPZ9MADD2jlypVau3athg4danYkAAAAoDHZmGEGoEVwc3PT2rVrFRERocGDB+urr74yO1KTNHPmTC1YsEAnTpxQUVGREhISdPfdd2vv3r0aMWIEZRmUlpam6OhorV27VqtXr6YsAwAAQKtEYQagxfD29tbGjRv1+OOPa+LEiRo7dqxOnjxpdqwmJTk5WVOnTlXHjh3l4eGhfv36acmSJfL09NTbb79d5/0lJCTIYrH87DJ+/PgGOBrUp7KyMr377rvq3bu3cnNztX379hb7zbMAAADAz6EwA9CiODk5afbs2dqwYYOOHTumnj176pVXXpHNZjM7WpMwZ84cPfTQQ+rSpYtcXFzUtm1bTZo0STt27FDfvn3NjgeT7N69W0OGDNHzzz+vhx56SLt27bLf1w4AAABojbiHGYAW6+LFi/rLX/6i2bNnKywsTDNnztSDDz4oNzc3s6MBTUJcXJzefPNNLV++XKNHj9bcuXPVtWtXs2MBAAAAZuMeZgBaLldXV/3P//yPEhMTdfPNN2vGjBnq2LGjZs2apezsbLPjAaaoqKjQkiVLdOONNyo6OlrZ2dn65ptvtGbNGsoyAAAA4P8wwwxAq5GVlaW5c+fq/fffV3FxsSZNmqQHHnhAI0eOlKOjo9nxgAZ17NgxLViwQPPnz1dqaqrGjRun559/XjfeeKPZ0QAAAICmxkZhBqDVKSws1Pz58zV//nx9//33CgsL03333aepU6fquuuuMzseUG/Onz+vRYsWacGCBdq+fbuCg4N17733avr06erWrZvZ8QAAAICmisIMQOt2+PBhLViwQAsWLFBKSooiIyN1xx136I477tCNN97IzDM0OykpKVq5cqVWrFihzZs3y9HRURMmTNADDzygUaNG8ZkGAAAAfh6FGQBIkmEY2rZtm7766iutWLFCR48eVZs2bTRmzBjdcccduuWWW9SmTRuzYwI1lJWVafv27faSLCkpSd7e3ho9erTuvPNOjR8/Xl5eXmbHBAAAAJoTCjMAqM3x48e1fv16LV++XGvXrlVZWZl69OihYcOGaejQoRo5cqTatWtndky0QmVlZdq3b5/Wr1+vbdu2adu2bcrJyVFERIRiY2PtBa+zs7PZUQEAAIDmisIMAH5Obm6uNm7cqK1bt2rr1q3at2+fysvL1bNnT0VHR2vYsGG64YYb1LVrVzk48OXDqF/nzp1TfHy8tm/frq1bt2rnzp0qLi5WWFiYhg8frptuukk333wz33AJAAAA1B8KMwCoq9zcXG3btk1xcXHaunWrdu/erdLSUnl7e6tfv34aMGCAoqKiFBUVpa5du8pisZgdGc1Edna24uPjtXv3bsXHxys+Pl4nTpyQJHXq1EnR0dEaPny4oqOj1blzZ5PTAgAAAC0WhRkAXKuSkhLt27fPXnDEx8crMTFRpaWl8vHxUZ8+fdSzZ09FRkaqV69e6tWrl0JCQsyODRMVFhbq0KFDSkxMVFJSkpKSknTgwAGlpqZKksLDw+2la+USGBhobmgAAACg9aAwA4CGcPHiRe3fv1/x8fHat2+fDh48qMTERGVnZ0uS/Pz87AVajx491KVLF3Xu3FkRERFydXU1OT3qQ0VFhU6dOqXjx4/r+PHjOnTokL0cS01NlWEYcnFxUY8ePdSzZ0/17t1b/fv3pxwDAAAAzEdhBgCNKTMzU4mJifYC7eDBg0pKSlJWVpZ9m9DQUEVERNgLtIiICHXq1Enh4eEKCQmR1Wo18QhQVVZWltLT05Wammovxo4fP65jx44pNTVVNptNkuTu7q7u3burR48e6t27t33GYUREhJycnEw+CgAAAAA/QWEGAE1BQUFBtcKl6pKamqqSkhJJksViUVBQkMLCwhQaGmov0cLDwxUWFqbg4GAFBAQoICCAIuYa5OTkKCsrS2fPnlV6erpOnz6ttLQ0ZWRkKC0tTadPn1Z6enq196Wy6KxtCQ4ONvmIAAAAANQBhRkANHUVFRX2oiY9PV2nTp3SqVOnlJGRoZMnT9rXXbx4sdrr/Pz8FBgYqICAAPn7+ysgIEBBQUEKCAiQr6+vvL295evra/+5cnF3dzfpSOtXWVmZ8vLylJOTo9zcXOXl5SkvL0+5ubnKzc3VuXPn7EtmZma130tLS+37cXBwUHBwsNq1a6eQkBC1b99eoaGhCgsLsxeWHTp04FJaAAAAoOWgMAOAliI7O7ta8ZOVlVWtBKpaDOXm5io/P7/W/Tg5OdnLNB8fHzk6OsrX11cWi+Wyj5VcXV3l5uZWY79ubm41SiXDMJSTk1Nj2/LycuXl5dl/Ly4u1sWLF3/2saCgwF6KFRUV1Xp8Li4u8vHxsc/ECwgIsBeLVZfKcjE4OJjZegAAAEDrQmEGAK1VZVlVOfuq6iysqjOzKioqdOHCBfv2FRUV9vW5ubk1yq2CgoJqM7Qq5efnq6ysrMZ6b29vOTo61ljv4+MjBwcHSf+/hKt8rPzZ3d1dLi4u9kcvL69qs+WqFn+VvzMTDAAAAMDPoDADADSuP//5z/rss8905MgRs6MAAAAAQG1sDmYnAAAAAAAAAJoSCjMAAAAAAACgCgozAAAAAAAAoAoKMwAAAAAAAKAKCjMAAAAAAACgCgozAAAAAAAAoAoKMwAAAAAAAKAKCjMAAAAAAACgCgozAAAAAAAAoAoKMwAAAAAAAKAKCjMAAAAAAACgCgozAAAAAAAAoAoKMwAAAAAAAKAKCjMAAAAAAACgCgozAAAAAAAAoAoKMwAAAAAAAKAKCjMAAAAAAACgCgozAAAAAAAAoAoKMwAAAAAAAKAKCjMAAAAAAACgCgozAAAAAAAAoAoKMwAAAAAAAKAKCjMAAAAAAACgCgozAAAAAAAAoAoKMwAAAAAAAKAKCjMAAAAAAACgCgozAAAAAAAAoAoKMwAAAAAAAKAKCjMAAAAAAACgCgozAAAAAAAAoAoKMwAAAAAAAKAKCjMAAAAAAACgCothGIbZIQAALdPOnTv12GOPqayszL7u/Pnzys3NVadOnezrLBaLxo4dq1dffdWMmAAAAABQlY3CDADQYGw2mwICApSfn/+z237++eeaMmVKI6QCAAAAgMuycUkmAKDBODs7a8qUKbJarZfdzs3NTWPHjm2kVAAAAABweRRmAIAGdd9996m0tPSSz1utVk2cOFHu7u6NmAoAAAAALo3CDADQoIYPH662bdte8vnS0lLdd999jZgIAAAAAC6PwgwA0KAcHBz0wAMPXPKyTB8fH8XGxjZyKgAAAAC4NAozAECDu/fee2u9LNNqter+++//2XucAQAAAEBjojADADS4G264QZ06daqxvrS0VPfee68JiQAAAADg0ijMAACNYurUqTVmkgUHB2vIkCEmJQIAAACA2lGYAQAaxU8vy7RarXrwwQfl4MA/RQAAAACaFv5KAQA0ih49eqh3796yWCySuBwTAAAAQNNFYQYAaDTTpk2To6OjJCkiIkJ9+vQxOREAAAAA1ERhBgBoNPfcc4/Ky8tlsVj00EMPmR0HAAAAAGrlZHYAAEDzcfHiRRUXF8tms6mwsFBlZWXKz8+XJFVUVCg3N7fW15WUlKioqEiS1K1bNyUnJ8vHx0eLFy+Wo6OjvL29a32dq6ur3NzcJEkuLi5yd3eX1WqVp6fnZV8HAAAAANfCYhiGYXYIAEDDqKioUHZ2tn3JyclRfn6+8vLylJOTo4KCAuXn51dbV/l7cXGxCgsLZbPZVFxcrIsXL5p9OLWyWCzy9fWVJPn5+dmLNF9fX3l5ecnLy0uenp411nl5ecnX11f+/v72xdXV1eSjAQAAANAE2CjMAKCZyc7O1pkzZ5Senq6MjAxlZmYqKyvLXoqdO3euWkn20/+ZryyUfHx8qhVKPj4+9nWenp7y8PCQm5ubXF1d7bO7nJ2d5eHhIScnJ3l5ecnBwUE+Pj72fXt7e9vvUVbbmJJ0/vx5ffHFF3r88ccl/f9Za7XJz89XWVmZJNlLu8rZaqWlpSooKLDPcquc4Vb5+4ULF+zlX2UxWLmuoKCg1jE9PDwUEBBQbaks0wIDAxUaGqrg4GCFhYUpKChITk5M1AYAAABaIAozAGgqDMNQRkaGUlJSlJqaqpMnTyojI8NejKWnp+vMmTPVZnq5uroqKChIgYGB1codf3//WosfX19fubu7m3iU/1FWVmZ62VRWVqacnJxai8azZ8/af698zMzM1IULF+yvt1gsCgoKqlagtWvXTqGhoerUqZM6duyoDh06yMXFxcSjBAAAAHAVKMwAoDHl5+crOTlZx48fV2pqqr0cS0lJ0YkTJ+xlmNVqtZcvISEhl3xs06aNyUfUuly8eLFagVnbY1pamvLy8iT9p1SrLNAqS7SOHTuqU6dO6tatm8LCwkw+IgAAAAC1oDADgIZw4cIFJSYmKikpScePH7f/nJqaqoqKCkn/ud9WRERErUv79u1Nn4GFq3fhwgV7gXb8+PFqy5EjR+yFmouLizp37qzIyEhFRESoV69eioyMVM+ePZvETEAAAACglaIwA4BrUVhYqP379yshIUF79+7V3r17dfDgQRUWFkqSAgIC1KNHD/Xo0UPdunWz/9yxY0dZrVaT08MsmZmZOnTokJKTk5WcnKyDBw8qOTlZJ06cUHl5uRwdHdWpUyf17dvXvvTr10+hoaFmRwcAAABaAwozALhS+fn52rlzp/bs2aO9e/cqISFBR44cUXl5uXx8fOylRu/eve3FmL+/v9mx0YyUlJTo8OHDSk5OVlJSkhISEpSQkKCUlBRJUmBgoP1z1rdvXw0ePFgdO3Y0NzQAAADQ8lCYAcClpKen67vvvtO2bdsUHx+vH374QaWlpQoJCVFkZKR69eqlqKgoRUVFqWfPnnJwcDA7MlqovLw87d+/X/Hx8UpKSlJiYqJ2796tkpISBQcHa8CAARo2bJiGDh2qG264gS8aAAAAAK4NhRkAVEpJSdGaNWu0ceNGfffdd8rIyJDValX//v01ZMgQDR06VEOGDFFISIjZUQEVFxdr9+7d+u6777R9+3bt2LFD586dk7u7u2644QZFR0frlltu0aBBg7gfHgAAAFA3FGYAWq+ioiJt3rxZa9as0bfffqvDhw/L09NTI0aM0NChQzV06FANGDBAbm5uZkcFfpZhGEpOTtaOHTu0bds2bdq0SSkpKfL19VVsbKxuueUW3XLLLQoPDzc7KgAAANDUUZgBaF3Onz+vpUuXatGiRdq6datKSkrUp08fe5kwdOhQOTs7mx0TqBeHDx/Wt99+qzVr1mjz5s0qKipSr169NGHCBE2ZMkXXXXed2REBAACApojCDEDLl5eXp2+++Uaff/651q1bJ0dHR912220aO3asbrnlFgUHB5sdEWhwFy9e1LZt27R69WotXrxYaWlpioyM1JQpUzRlyhR169bN7IgAAABAU0FhBqDl2r59u+bOnatly5apoqJCo0eP1pQpUzRu3Dh5eXmZHQ8wjWEY2r59u7744gstXrxYZ86cUVRUlB5//HHdd999XIYMAACA1o7CDEDLYrPZtGjRIr377rvavXu3Bg4cqOnTp2vChAny8/MzOx7Q5JSXl2vLli2aP3++Pv/8c3l5eenRRx/Vr3/9a4WFhZkdDwAAADADhRmAlqGkpERz587VW2+9pezsbE2cOFHPPPOMBg8ebHY0oNnIysrSBx98oA8++EDnzp3T5MmTNWvWLEVERJgdDQAAAGhMNgezEwDAtVqyZIl69eqll19+WQ8++KBSUlL073//25SybMmSJbr99tsVFBQkZ2dnBQcH684779Q333zT6FmasvXr1+uee+5R+/bt5erqKn9/f/Xp00e/+MUvtGHDBlVUVNR5n7t375bFYtErr7xy2XW4tMD/1969B2Vx3WEc/74gyB0RvKBiDDWAF6oGqwYVa4UYW60xIaPEEE2kxnRsasfeJr3YVDNNpzaapNYoqImSGkJSYYggBo0oaCpaiVoL1aoYNKLiKze5vm7/yPCOBERJIQv6fGbOiLtn9/zOwuD4zNnz9u7Nb3/7W86ePcumTZs4cuQIQ4cO5Re/+AXl5eVmlyciIiIi8rVRYCYiXdbx48eZNGkSTzzxBOHh4RQWFvLKK6+Y8hpZdXU1s2bNIjo6mvT0dC5dukR9fT0lJSWkpaUxc+ZMnnzySerq6v6vcXJycrBYLKxYsaKdKv96x66trSU2NpaoqCiSkpL47LPPqK2t5erVqxw9epS33nqLyMhI9u/f346Vdzwzvy8dwdnZmblz5/Lpp5+ycuVKNmzYwAMPPMDGjRvNLk1ERERE5GuhwExEuqR169YxZswYamtr+eSTT9iyZQsDBgwwrZ7nn3+elJQUvL29efXVVzl37hy1tbUUFRWxcuVKPDw82Lp1K0uXLjWtxs5g8eLFJCYm4u7uzu9//3tOnDhBdXU1VquVo0ePsnnzZiIjI3F0dDS7VAGcnJxYvHgxJ0+eJCYmhoULFxIdHU1ZWZnZpYmIiIiIdKhuZhcgItIWhmHw85//nFdffZUXX3yRZcuW0a2bub/K8vLyePvtt3FxceHjjz9m1KhR9nMDBw5k6dKlTJgwgYkTJ7JmzRqef/55hg4damLF5jh06BAJCQm4urqSnZ1NWFiY/ZyLiws9evQgNDSU2NhYE6uUlvj4+LB69WpmzpzJ3LlziYiIICMjg379+pldmoiIiIhIh9AKMxHpUn75y1/y+uuvk5iYyPLly00PywA2bdoEwAsvvNAkLLvZ2LFjWbhwIYZh8Pbbb9uPJyQkYLFYeP/995td03guJSUFgBUrVjBx4kQAfvOb32CxWOwNYMeOHVgsFlavXs2uXbsIDw/Hzc2N3r1784Mf/IDLly+3eP/2GLstz+nHP/5xk7Dsdqqrq3nppZcYMmQILi4ueHt7M2XKFDIzM+/4Hl9mGAYbN24kPDwcT09PXF1dGTFiBGvWrOHLn4VjGAZvvfUWERER9OjRA09PT771rW8RHx9PQ0PDHT2bO53Dzd/D7OxsJk2ahKenJ6NHj/7Kc21PkydP5pNPPqG+vp4pU6ZgtVrNLklEREREpEOY/z9NEZE7lJyczJ/+9Cc2b95MTEyM2eXYHThwAIDHH3+81X6PPfYYa9assffvKPv37+enP/0pNpsN+CKsSUhIICcnh7y8PDw8PDp0/Nbqgi+ew52qq6sjKiqK3Nxc+7Ha2lp2797Nxx9/zF//+lcWLVrUpjoMwyA2NpZ33nmnyfGjR4+yePFiPv30U9avX2/vGxMTQ1JSUpO+hw4d4tChQ9x///0dMof9+/fzs5/9jIaGBoCv9CEIHWXgwIHs2rWLcePG8fTTT5OWlmZ2SSIiIiIi7U4rzESkS6ipqWHJkiXExcXx1FNPmV1OExcvXgQgMDCw1X6N4Upj/7b69a9/zb59+wBYvnw5hmHY282Sk5OJjY3l5MmTVFZWsnfvXkJDQykoKOCPf/xjh47dmsZ530nI1Ogvf/kLubm5DBw4kLS0NMrKyjh37hy/+93vsFgs/OQnP2nz80xMTOSdd94hNDSU9PR0SktLqaysJDs7mxEjRhAfH28PNTdu3EhSUhK+vr68+eabnDt3jsrKSvLy8oiLi8PJyem2z+arzCE5OZmnn36awsJCGhoa+Oc//9mmOXY0f39/EhMT2b59uz4BVkRERETuSgrMRKRLSEtL49KlS7z00ktml9LpjRkzho0bNzJ48GDc3d2ZOHEiKSkpODk5tfj6ZWeWnJwMQFJSEtOnT8fLy4uAgACWLVtGXFwcNTU1bQ5sNm3ahKOjI5mZmUybNo2ePXvi7u5OREQEf/vb3wBITU0FsL8+++677/Lcc88REBCAu7s7o0ePJj4+nkmTJnXIHMaNG0dCQgJBQUGd9gMQJk6cyHe/+13WrVtndikiIiIiIu1OgZmIdAkHDhwgLCwMf39/s0tppm/fvgCcPn261X5nzpxp0r+jPPzww832FgsMDCQoKIj//ve/HTp2axrn3fgc7sSpU6fw9fVl3Lhxzc5Nnz7d3qct/vWvf2Gz2QgICKBbt244Ojri4OCAg4MDw4YNA+DcuXMAFBQU4OPjQ2RkZJvG+H/nEBkZ2ab94cwyffp0+6u2IiIiIiJ3EwVmItIlWK1WevbsaXYZLWoMQj744INW+/39738H4KGHHrIfc3D44tdwS3tUVVdXt1eJLfq6xw4PDwdg27ZtbbquvYOjxvnabDZsNhs3btxo9nppXV1du47Z1jn4+vq26/gdxc/Pj/Lycvt+eSIiIiIidwsFZiLSJQQEBHDy5Emzy2jR/PnzAXjjjTc4cuRIi33+8Y9/EB8fj8ViYd68efbjvXv3BlpedbV79+5mxxpDrsbN4Fuyc+fOZnuLnT59mv/85z984xvf6NCxW/PMM88A8Nprr5Gfn39H1wwePJgrV65w8ODBZufS09PtfdoiJCQENzc3rl271mS/sZtb46urISEhWK1Wdu3a1eo9W3s2HTGHzqKgoID+/ft32tdGRURERES+KgVmItIlzJgxg1OnTtk3V+9Mxo4dy1NPPUV1dTWTJ09m9erVFBcXU19fz2effcaf//xnoqKiqKur44c//CFDhw61X9v49erVq9mzZw/V1dWcPXuWpUuXkpKS0mysxlV2+/bto7S0tMV6Dh48yIIFCzh16hRVVVXk5OQwa9Ys6uvriY6O7tCxWzN69Gji4uK4fv06EydO5OWXX6agoIDa2lrKyso4fvw4W7Zs4eGHH7Zvuv/EE08AMHv2bNLT0ykvL6e4uJjly5ezfv16unfvzve///021bFgwQKuX79OZGQkH374IZcvX6auro6ioiK2b9/O448/bg/IGsPNmJgY4uPjKS4upqqqisOHD7Nw4UKys7Nv+2w6Yg6dQUNDA4mJicyYMcPsUkRERERE2p8hItJFTJkyxRg1apRRU1NjdinNVFVVGTNmzDCAW7Y5c+YYtbW1za597LHHmvXt1q2bERsbawDGtm3b7H0bGhqM/v37N+tvGIaRkZFhAP5M138AAAl8SURBVEZ0dLTh6OjYrE9ISIhRUVHRIWPfqZqaGmPu3LmtPifA2Ldvn2EYhlFbW2uEh4ffst/atWvt987LyzMAY9myZa0eu3HjhjF//vxWx8/IyDAMwzBsNpsRHR19y34fffTRbZ9NW+bQ+D1ctWpVm56rGV555RXDxcXFOHnypNmliIiIiIi0t1qtMBORLmPt2rWcOXOG+fPnd7o9k9zc3EhNTeW9997jkUceoVevXjg5OdG7d2++973vkZKSwtatW3F2dm527YYNG3j22Wfx9fXFxcWFhx56iKysLCIiIpr1dXR05P3332fChAm4u7u3WMv48ePJyMhgzJgxuLq64ufnx4IFC9i7dy8eHh4dOvbtdO/encTERHbu3Mns2bMJCAjA2dkZHx8fQkNDeeaZZ/joo4/s+505OzuTlZXFsmXLCA4OxtnZGU9PTyZPnkxGRgaLFi1qcw0Wi4VNmzaRlJREZGQkPj4+ODs7ExgYyKOPPsq2bdvsm/w7ODjw3nvvsX79esaNG4e7uzteXl6MGTOGhIQEvv3tb9/22XTEHMyWlpbGr371K15++eUu+zqpiIiIiEhrLIbxpY1uREQ6sd27dzN9+nSmTZtGYmIirq6uZpfUaezYsYNp06axatUqlixZYnY5cpfavHkzcXFxPPvss7z55ptmlyMiIiIi0hHqtMJMRLqU73znO+zcuZM9e/YwZswYjh8/bnZJIveE6upqFi1axLx581i6dClr1641uyQRERERkQ6jwExEupwJEyaQn5+Pj48PDz74IM899xxXrlwxu6x7Un5+PhaL5bbt0UcfNbtU+T+kpaUxbNgwtm7dytatW/nDH/6AxWIxuywRERERkQ6jwExEuqSAgAD27NlDQkICqampBAcH89prr9HQ0GB2aSJ3jcOHDxMREcHMmTOZMGECBQUFzJkzx+yyREREREQ6nPYwE5Eu79q1a6xYsYI33niDgQMH8qMf/Yj58+fj5eVldmkiXY5hGOzatYvXX3+d7du3M378eFatWkVYWJjZpYmIiIiIfF20h5mIdH09evRg5cqVnDhxgqioKF588UUCAgJYsmQJp06dMrs8kS6hqqqKdevWMXz4cKKioqioqGDbtm3s3btXYZmIiIiI3HO0wkxE7jrXrl1jw4YNrFmzhqKiIiZPnkxMTAyzZs2iZ8+eZpcn0mnYbDb27NnDu+++ywcffEBNTQ1PPvkkL7zwAt/85jfNLk9ERERExCx1CsxE5K5ls9n48MMP2bJlC+np6dhsNqKiopgzZw4zZ87E09PT7BJFvnaGYZCbm0tSUhLJycmUlJQQFhZGTEwM8+bNw8/Pz+wSRURERETMpsBMRO4NFRUVpKamkpSUxM6dO3F0dGTSpEk88sgjTJ06lZCQELNLFOkwVquVrKwsMjMz2bFjB+fPn2fYsGHMmTOH2bNn88ADD5hdooiIiIhIZ6LATETuPVevXiU1NZWMjAyysrKwWq3cd999TJ06lalTpzJlyhS8vb3NLlPkK7PZbOTl5ZGZmUlmZiYHDx7EYrEwduxYpk6dyqxZsxg+fLjZZYqIiIiIdFYKzETk3maz2cjPzycrK4usrCyys7O5ceMGwcHBhIWFMWHCBMaPH8+wYcPMLlXkliorK8nPzyc3N5ecnBxyc3OxWq307duXqKgoZsyYQWRkJD4+PmaXKiIiIiLSFSgwExG52dWrV8nOziYnJ4cDBw5w+PBh6urq6NevH+PHjyc8PJzRo0czYsQI7YEmprDZbBQWFnLkyBEOHDhAbm4ux44dw2azERgYaP85nTRpEkOGDDG7XBERERGRrkiBmYhIa6qrqzl06BC5ubns37+f/fv3U1paisViYfDgwYwcOZJRo0YxcuRIRo4cib+/v9kly13k+vXrHDt2jPz8fI4cOUJ+fj7Hjh3j+vXrODk58eCDDxIeHm4PyfTzJyIiIiLSLhSYiYi0VVFRkT28aGxFRUUA9OnTh9DQUIKCghg6dCjBwcEEBwcTEBBgctXSmZWXl1NYWEhBQQH//ve/KSws5MSJE5w8eRKbzYaXlxcjRoywB7MjR45k+PDhODs7m126iIiIiMjdSIGZiEh7sFqt9hDtxIkTFBQUUFBQQGlpKQAeHh728GzIkCEEBgYyaNAg7r//fq0KukdUVFRw9uxZzp49y+nTpyksLLSHZBcuXACge/fuBAUFERwcTEhICCNGjGDUqFEEBgZisVhMnoGIiIiIyD1DgZmISEe6cuWKfcVQYWGh/euioiLq6+sBcHFx4b777mPQoEH2EG3QoEEMHDiQAQMG0KdPH60k6gIuXbpESUkJRUVF9mDs5tYYnsIXKxGDgoIICQmxh2MhISEMGjQIR0dHE2chIiIiIiIoMBMRMYfNZuP8+fP2MOXMmTOcOXPG/vfi4mJsNpu9f58+fejTp489QBswYAB9+/ZlwIAB9O7dm169etGrVy+8vLxMnNXdp6amhtLSUkpLS7l48SKff/4558+f5+LFixQXF1NSUkJxcTEXL16krq7Ofp2vr689+Ly5NR5zc3MzcVYiIiIiInIbCsxERDqj+vp6Lly4YA9nzp8/z+eff86FCxeahDY3r1oCcHJywtfXt0nz8/OjV69e+Pr64uXlhbe3N97e3nh6etpb43EHBweTZtxxKisrqaiosDer1UpFRQWVlZWUlZXZA7HGdvnyZa5cuUJpaSlVVVVN7uXq6oq/vz/9+vWjX79+9q/9/f3p378//v7+BAQE4OHhYdJsRURERESkHSgwExHpympqaigpKeHKlSv2kKfxz8Z287ny8nLKyspueT93d/cmIZqjoyNeXl44ODjg7e0NgI+PD4A9YGvs16jx/Jd5eHjg5OTU7Pi1a9do6Z+iqqqqJqu2ysvLsdlsVFZWUl9fbz9fXV1NTU0NtbW1XL9+nZqaGns4dqt7wxevwnp7e7cYMPr5+TU73qdPn1vOTURERERE7ioKzERE7kVlZWX2UKm8vLzJyqvGVllZSV1dHVVVVTQ0NFBRUcGNGzfsgZvVagWaBl6N/Vpyq/DK3d29xT3anJ2dcXd3t/+9MXBzc3Oje/fuuLq64uLiQvfu3XFzc8PJyQkPDw+cnZ3x9PS85Uq6Hj164Onp2WJ4JyIiIiIiggIzERERERERERGRJuruvs1qRERERERERERE/g8KzERERERERERERG6iwExEREREREREROQm3YBks4sQERERERERERHpJBr+B8E7uka+NCySAAAAAElFTkSuQmCC\n", + "text/plain": [ + "" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "taskGraph.draw(show='ipynb')" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
sample_idmax_drawdown_mean_meanmax_drawdown_std_meanmax_raise_mean_meanmax_raise_std_meanmean_mean_meanmean_std_meanstd_mean_meanstd_std_meancorr_mean_mean...all_max_drawdown_meanall_max_drawdown_stdall_max_raise_meanall_max_raise_stdall_mean_meanall_mean_stdall_std_meanall_std_stdall_corr_meanall_corr_std
03810.1655130.1088670.1739590.0890460.0000560.0006180.0113220.006126-1.337516...0.4562340.2654720.6511030.1109550.0000830.0001610.0120900.006492-1.3278290.739377
111630.1707210.1074310.1858900.0884550.0000940.0006330.0115450.006176-1.338875...0.5418780.3025610.7455630.1020350.0001140.0001410.0119720.006140-1.3102730.706726
234880.2011960.1334840.1789880.085566-0.0001600.0007450.0123480.007142-1.345710...0.5896330.3396820.6449300.092962-0.0001790.0003780.0130830.007267-1.3098620.694872
311780.1757980.1160840.1811230.0868720.0000240.0006260.0120570.006978-1.325626...0.4826040.2895980.6827900.0615480.0000260.0002400.0124940.006947-1.2812490.667939
432710.1769760.1046990.1808540.0916520.0000490.0006030.0116700.006245-1.307143...0.5268660.2684320.6189360.0950540.0000440.0001030.0121500.006139-1.2903540.670003
..................................................................
409116050.1929720.1215670.1926630.090775-0.0000470.0008400.0126910.007287-1.347182...0.6327300.3235580.7013900.124733-0.0000560.0004140.0133420.007441-1.3022730.694651
409225830.1899800.1171570.1903880.0956980.0000050.0006900.0127420.007406-1.353827...0.4942720.2772200.5937900.1490850.0000500.0001840.0131770.007419-1.3136420.700307
409335070.1780700.1074440.1775900.085778-0.0000020.0006310.0117560.006303-1.327630...0.4650060.2471580.5788090.1442530.0000300.0002540.0120190.006164-1.2918220.686415
40949660.1727110.1114410.1749260.0849730.0000180.0006420.0117210.006507-1.316751...0.4590940.2700030.5948110.1305780.0000430.0002320.0120070.006453-1.2843220.673489
409515800.1797850.1108630.1679670.083570-0.0000610.0006010.0113920.006361-1.304565...0.5337810.3047340.5595490.126392-0.0000500.0002240.0116750.006205-1.2662870.654376
\n", + "

4096 rows × 33 columns

\n", + "
" + ], + "text/plain": [ + " sample_id max_drawdown_mean_mean max_drawdown_std_mean \\\n", + "0 381 0.165513 0.108867 \n", + "1 1163 0.170721 0.107431 \n", + "2 3488 0.201196 0.133484 \n", + "3 1178 0.175798 0.116084 \n", + "4 3271 0.176976 0.104699 \n", + "... ... ... ... \n", + "4091 1605 0.192972 0.121567 \n", + "4092 2583 0.189980 0.117157 \n", + "4093 3507 0.178070 0.107444 \n", + "4094 966 0.172711 0.111441 \n", + "4095 1580 0.179785 0.110863 \n", + "\n", + " max_raise_mean_mean max_raise_std_mean mean_mean_mean mean_std_mean \\\n", + "0 0.173959 0.089046 0.000056 0.000618 \n", + "1 0.185890 0.088455 0.000094 0.000633 \n", + "2 0.178988 0.085566 -0.000160 0.000745 \n", + "3 0.181123 0.086872 0.000024 0.000626 \n", + "4 0.180854 0.091652 0.000049 0.000603 \n", + "... ... ... ... ... \n", + "4091 0.192663 0.090775 -0.000047 0.000840 \n", + "4092 0.190388 0.095698 0.000005 0.000690 \n", + "4093 0.177590 0.085778 -0.000002 0.000631 \n", + "4094 0.174926 0.084973 0.000018 0.000642 \n", + "4095 0.167967 0.083570 -0.000061 0.000601 \n", + "\n", + " std_mean_mean std_std_mean corr_mean_mean ... all_max_drawdown_mean \\\n", + "0 0.011322 0.006126 -1.337516 ... 0.456234 \n", + "1 0.011545 0.006176 -1.338875 ... 0.541878 \n", + "2 0.012348 0.007142 -1.345710 ... 0.589633 \n", + "3 0.012057 0.006978 -1.325626 ... 0.482604 \n", + "4 0.011670 0.006245 -1.307143 ... 0.526866 \n", + "... ... ... ... ... ... \n", + "4091 0.012691 0.007287 -1.347182 ... 0.632730 \n", + "4092 0.012742 0.007406 -1.353827 ... 0.494272 \n", + "4093 0.011756 0.006303 -1.327630 ... 0.465006 \n", + "4094 0.011721 0.006507 -1.316751 ... 0.459094 \n", + "4095 0.011392 0.006361 -1.304565 ... 0.533781 \n", + "\n", + " all_max_drawdown_std all_max_raise_mean all_max_raise_std \\\n", + "0 0.265472 0.651103 0.110955 \n", + "1 0.302561 0.745563 0.102035 \n", + "2 0.339682 0.644930 0.092962 \n", + "3 0.289598 0.682790 0.061548 \n", + "4 0.268432 0.618936 0.095054 \n", + "... ... ... ... \n", + "4091 0.323558 0.701390 0.124733 \n", + "4092 0.277220 0.593790 0.149085 \n", + "4093 0.247158 0.578809 0.144253 \n", + "4094 0.270003 0.594811 0.130578 \n", + "4095 0.304734 0.559549 0.126392 \n", + "\n", + " all_mean_mean all_mean_std all_std_mean all_std_std all_corr_mean \\\n", + "0 0.000083 0.000161 0.012090 0.006492 -1.327829 \n", + "1 0.000114 0.000141 0.011972 0.006140 -1.310273 \n", + "2 -0.000179 0.000378 0.013083 0.007267 -1.309862 \n", + "3 0.000026 0.000240 0.012494 0.006947 -1.281249 \n", + "4 0.000044 0.000103 0.012150 0.006139 -1.290354 \n", + "... ... ... ... ... ... \n", + "4091 -0.000056 0.000414 0.013342 0.007441 -1.302273 \n", + "4092 0.000050 0.000184 0.013177 0.007419 -1.313642 \n", + "4093 0.000030 0.000254 0.012019 0.006164 -1.291822 \n", + "4094 0.000043 0.000232 0.012007 0.006453 -1.284322 \n", + "4095 -0.000050 0.000224 0.011675 0.006205 -1.266287 \n", + "\n", + " all_corr_std \n", + "0 0.739377 \n", + "1 0.706726 \n", + "2 0.694872 \n", + "3 0.667939 \n", + "4 0.670003 \n", + "... ... \n", + "4091 0.694651 \n", + "4092 0.700307 \n", + "4093 0.686415 \n", + "4094 0.673489 \n", + "4095 0.654376 \n", + "\n", + "[4096 rows x 33 columns]" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "del result\n", + "result = taskGraph.run()\n", + "result['merge_features.merged']" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The taskgrpah is a bit complicated, we can use `CompositeNode` to group the sub-graph into a single node. Here is a simplified version of it:" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "f0433a1dd452429096f74b4856bbcad2", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "GreenflowWidget(sub=HBox(), value=[OrderedDict([('id', ''), ('type', 'Output_Collector'), ('conf', {}), ('inpu…" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "taskGraph=TaskGraph.load_taskgraph('./17assets/all_feature_simplified.gq.yaml')\n", + "taskGraph.draw()" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "taskGraph.draw(show='ipynb')" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
sample_idmax_drawdown_mean_meanmax_drawdown_std_meanmax_raise_mean_meanmax_raise_std_meanmean_mean_meanmean_std_meanstd_mean_meanstd_std_meancorr_mean_mean...all_max_drawdown_meanall_max_drawdown_stdall_max_raise_meanall_max_raise_stdall_mean_meanall_mean_stdall_std_meanall_std_stdall_corr_meanall_corr_std
040390.1611520.0995170.1998490.0982090.0002640.0006290.0115890.006199-1.329793...0.3985020.2148160.7722280.1560090.0002650.0001910.0118720.006092-1.3051610.715279
134030.1724050.1031500.1993230.1023380.0001970.0005930.0117660.006638-1.321531...0.4529410.2490630.6993930.1690470.0002020.0001310.0121130.006680-1.2850920.669527
210580.1584910.0951440.1781360.0901950.0001290.0005560.0105770.005622-1.342557...0.4246460.2339420.6307860.1388480.0001210.0000880.0107310.005504-1.3213940.701067
317600.1693250.0957560.1977500.1032890.0002010.0006540.0119040.006260-1.327755...0.5206960.2128600.7030130.2287840.0002150.0001510.0121980.006131-1.3070050.721012
41600.1473430.0932460.1857850.0955500.0002540.0005940.0105610.005641-1.358376...0.3979040.2277360.7833300.1196230.0002490.0001490.0108270.005616-1.3387350.724873
..................................................................
409116050.1678460.1107670.1798240.0943490.0000750.0006190.0116190.006603-1.353803...0.5186820.3091700.6538410.1327260.0000580.0001960.0124210.006972-1.3193230.694665
409225830.1574410.1001870.1788710.0996720.0001500.0006660.0110540.005920-1.330616...0.4601820.2269440.6717350.1696440.0001380.0001030.0112440.005750-1.3181940.689344
409335070.1746980.1099420.1729700.089219-0.0000080.0006670.0110460.006143-1.330879...0.5403920.2770930.6290530.1039700.0000130.0001680.0115120.006169-1.3119320.673679
40949660.1676730.1025400.1797250.0944300.0000840.0006240.0112110.006044-1.307982...0.4876660.2723340.6593080.1781230.0000750.0001530.0115270.005942-1.2858040.662960
409515800.1835220.1149860.1922320.1000930.0000390.0007980.0120130.006712-1.343431...0.5121180.2902420.6755090.1068120.0000550.0001400.0123670.006615-1.3137080.722073
\n", + "

4096 rows × 33 columns

\n", + "
" + ], + "text/plain": [ + " sample_id max_drawdown_mean_mean max_drawdown_std_mean \\\n", + "0 4039 0.161152 0.099517 \n", + "1 3403 0.172405 0.103150 \n", + "2 1058 0.158491 0.095144 \n", + "3 1760 0.169325 0.095756 \n", + "4 160 0.147343 0.093246 \n", + "... ... ... ... \n", + "4091 1605 0.167846 0.110767 \n", + "4092 2583 0.157441 0.100187 \n", + "4093 3507 0.174698 0.109942 \n", + "4094 966 0.167673 0.102540 \n", + "4095 1580 0.183522 0.114986 \n", + "\n", + " max_raise_mean_mean max_raise_std_mean mean_mean_mean mean_std_mean \\\n", + "0 0.199849 0.098209 0.000264 0.000629 \n", + "1 0.199323 0.102338 0.000197 0.000593 \n", + "2 0.178136 0.090195 0.000129 0.000556 \n", + "3 0.197750 0.103289 0.000201 0.000654 \n", + "4 0.185785 0.095550 0.000254 0.000594 \n", + "... ... ... ... ... \n", + "4091 0.179824 0.094349 0.000075 0.000619 \n", + "4092 0.178871 0.099672 0.000150 0.000666 \n", + "4093 0.172970 0.089219 -0.000008 0.000667 \n", + "4094 0.179725 0.094430 0.000084 0.000624 \n", + "4095 0.192232 0.100093 0.000039 0.000798 \n", + "\n", + " std_mean_mean std_std_mean corr_mean_mean ... all_max_drawdown_mean \\\n", + "0 0.011589 0.006199 -1.329793 ... 0.398502 \n", + "1 0.011766 0.006638 -1.321531 ... 0.452941 \n", + "2 0.010577 0.005622 -1.342557 ... 0.424646 \n", + "3 0.011904 0.006260 -1.327755 ... 0.520696 \n", + "4 0.010561 0.005641 -1.358376 ... 0.397904 \n", + "... ... ... ... ... ... \n", + "4091 0.011619 0.006603 -1.353803 ... 0.518682 \n", + "4092 0.011054 0.005920 -1.330616 ... 0.460182 \n", + "4093 0.011046 0.006143 -1.330879 ... 0.540392 \n", + "4094 0.011211 0.006044 -1.307982 ... 0.487666 \n", + "4095 0.012013 0.006712 -1.343431 ... 0.512118 \n", + "\n", + " all_max_drawdown_std all_max_raise_mean all_max_raise_std \\\n", + "0 0.214816 0.772228 0.156009 \n", + "1 0.249063 0.699393 0.169047 \n", + "2 0.233942 0.630786 0.138848 \n", + "3 0.212860 0.703013 0.228784 \n", + "4 0.227736 0.783330 0.119623 \n", + "... ... ... ... \n", + "4091 0.309170 0.653841 0.132726 \n", + "4092 0.226944 0.671735 0.169644 \n", + "4093 0.277093 0.629053 0.103970 \n", + "4094 0.272334 0.659308 0.178123 \n", + "4095 0.290242 0.675509 0.106812 \n", + "\n", + " all_mean_mean all_mean_std all_std_mean all_std_std all_corr_mean \\\n", + "0 0.000265 0.000191 0.011872 0.006092 -1.305161 \n", + "1 0.000202 0.000131 0.012113 0.006680 -1.285092 \n", + "2 0.000121 0.000088 0.010731 0.005504 -1.321394 \n", + "3 0.000215 0.000151 0.012198 0.006131 -1.307005 \n", + "4 0.000249 0.000149 0.010827 0.005616 -1.338735 \n", + "... ... ... ... ... ... \n", + "4091 0.000058 0.000196 0.012421 0.006972 -1.319323 \n", + "4092 0.000138 0.000103 0.011244 0.005750 -1.318194 \n", + "4093 0.000013 0.000168 0.011512 0.006169 -1.311932 \n", + "4094 0.000075 0.000153 0.011527 0.005942 -1.285804 \n", + "4095 0.000055 0.000140 0.012367 0.006615 -1.313708 \n", + "\n", + " all_corr_std \n", + "0 0.715279 \n", + "1 0.669527 \n", + "2 0.701067 \n", + "3 0.721012 \n", + "4 0.724873 \n", + "... ... \n", + "4091 0.694665 \n", + "4092 0.689344 \n", + "4093 0.673679 \n", + "4094 0.662960 \n", + "4095 0.722073 \n", + "\n", + "[4096 rows x 33 columns]" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "del result\n", + "result = taskGraph.run()\n", + "result['merge_features.merged']" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## The ML learning model\n", + "\n", + "For the supervised learning algorithm, we selected XGBoost (Chen and Guestrin (2016)) , a gradient tree boosting library that is fast and accurate as described in the paper. This algorithm can construct non-linear relations among the features. Moreover, for large datasets, it can scale across GPUs to speed-up the learning process. Another benefit of using XGBoost is that it produces fast explanations.\n", + "\n", + "To assess the stability of the explanations, the set of bootstrapped datasets, each across 17 multi-asset futures, is split into 90% training and 10% test set. We trained the model as a regression, to learn the difference between the Calmarratio obtained with HRP minus the Calmar ratio obtained by HRP. " + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'status': 'ok', 'restart': True}" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import IPython\n", + "app = IPython.Application.instance()\n", + "app.kernel.do_shutdown(True)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "
\n", + "

Client

\n", + "\n", + "		\n", + "

Cluster

\n", + "
    \n", + "
  • Workers: 8
    • \n", + "
  • Cores: 8
    • \n", + "
  • Memory: 503.80 GiB
    • \n", + "
\n", + "
" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# run this cell if you need Dask\n", + "from dask_cuda import LocalCUDACluster\n", + "import dask\n", + "dask.config.set({\"distributed.comm.timeouts.tcp\": \"90s\"})\n", + "cluster = LocalCUDACluster()\n", + "from dask.distributed import Client\n", + "client = Client(cluster)\n", + "client" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import cupy\n", + "import cudf\n", + "import matplotlib.pyplot as pl\n", + "from greenflow.dataframe_flow import TaskGraph\n", + "from IPython.display import display, HTML" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "effed80b3df841f39bed46747a1fbfaa", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "GreenflowWidget(sub=HBox(), value=[OrderedDict([('id', ''), ('type', 'Output_Collector'), ('conf', {}), ('inpu…" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "taskGraph=TaskGraph.load_taskgraph('./17assets/xgboost_performance.gq.yaml')\n", + "taskGraph.draw()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "taskGraph.draw(show='ipynb')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Run and collect the results:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "result = taskGraph.run()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's check the R-squared score for both Train dataset and Test dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train R-Squared: 0.9996281424524893 Test R-Squared: 0.17305883654610676\n" + ] + } + ], + "source": [ + "print('Train R-Squared:', result['train_rsquared.out'], 'Test R-Squared:', result['test_rsquared.out'])" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Test')" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "pl.plot(result['test_infer.out'].portfolio.values.get(), result['test_infer.out'].predict.values.get(), 'g.')\n", + "pl.xlabel('true')\n", + "pl.ylabel('predict')\n", + "pl.title('Test')" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Train')" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "pl.plot(result['train_infer.out'].portfolio.values.get(), result['train_infer.out'].predict.values.get(), 'b.')\n", + "pl.xlabel('true')\n", + "pl.ylabel('predict')\n", + "pl.title('Train')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Clearly the XGBoost model is overfitted as we only use 4096 datapoints. We will use more datapoints later" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## The explanation method\n", + "\n", + "We will use Shapley values of feature contribution to explain the ML result. In simple words, what Shapley values tell us is how much each feature (the statistical properties ofthe asset universe described above) has contributed to a specific outcome of theML model. Because of the complexity (non-linearity) of the model, this is a non-trivial task. The Shapley value is a quantity introduced in co-operative game theory to provide the fair payout to a player (the features) with respect to its contribution to the common goal (ML prediction). The SHAP framework (Lundberg and Lee (2017)) provides a tool to evaluate this quantity even in a model agnostic way. It allows comparing these quantitative explanations among different models.\n", + "\n", + "Shapley values can be computed from the XGboost inference node. Following is the workflow to visualize the feature contributions. " + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'status': 'ok', 'restart': True}" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import IPython\n", + "app = IPython.Application.instance()\n", + "app.kernel.do_shutdown(True)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "
\n", + "

Client

\n", + "\n", + "		\n", + "

Cluster

\n", + "
    \n", + "
  • Workers: 8
    • \n", + "
  • Cores: 8
    • \n", + "
  • Memory: 503.80 GiB
    • \n", + "
\n", + "
" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# run this cell if you need Dask\n", + "from dask_cuda import LocalCUDACluster\n", + "import dask\n", + "dask.config.set({\"distributed.comm.timeouts.tcp\": \"90s\"})\n", + "cluster = LocalCUDACluster()\n", + "from dask.distributed import Client\n", + "client = Client(cluster)\n", + "client" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import cupy\n", + "import cudf\n", + "import matplotlib.pyplot as pl\n", + "from greenflow.dataframe_flow import TaskGraph\n", + "from IPython.display import display, HTML" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "38fc3627930d4fb48bf34ea9357e81ab", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "GreenflowWidget(sub=HBox(), value=[OrderedDict([('id', ''), ('type', 'Output_Collector'), ('conf', {}), ('inpu…" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "taskGraph=TaskGraph.load_taskgraph('./17assets/xgboost_shap.gq.yaml')\n", + "taskGraph.draw()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "taskGraph.draw(show='ipynb')" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "result = taskGraph.run()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "

Shap Summary, Train

" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "display(HTML('

Shap Summary, Train

'))\n", + "result['train_shap_dot.summary_plot']" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "

Shap Summary, Train

" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "display(HTML('

Shap Summary, Train

'))\n", + "result['train_shap_bar.summary_plot']" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "

Shap Summary, Test

" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "display(HTML('

Shap Summary, Test

'))\n", + "result['test_shap_dot.summary_plot']" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "

Shap Summary, Test

" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "display(HTML('

Shap Summary, Test

'))\n", + "result['test_shap_bar.summary_plot']" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Scale to 100K Samples\n", + "\n", + "The maximum number of samples that can be computed in a single 32G V100 GPU is 4096. To compute 100K samples, we use Dask to distribute the workloads in multiple GPUs.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'status': 'ok', 'restart': True}" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import IPython\n", + "app = IPython.Application.instance()\n", + "app.kernel.do_shutdown(True)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "
\n", + "

Client

\n", + "\n", + "		\n", + "

Cluster

\n", + "
    \n", + "
  • Workers: 8
    • \n", + "
  • Cores: 8
    • \n", + "
  • Memory: 503.80 GiB
    • \n", + "
\n", + "
" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# run this cell if you need Dask\n", + "from dask_cuda import LocalCUDACluster\n", + "import dask\n", + "dask.config.set({\"distributed.comm.timeouts.tcp\": \"90s\"})\n", + "cluster = LocalCUDACluster()\n", + "from dask.distributed import Client\n", + "client = Client(cluster)\n", + "client" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import cupy\n", + "import cudf\n", + "import matplotlib.pyplot as pl\n", + "from greenflow.dataframe_flow import TaskGraph\n", + "from IPython.display import display, HTML" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "ec7b35c5d6e342088dceb0256d73c921", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "GreenflowWidget(sub=HBox(), value=[OrderedDict([('id', ''), ('type', 'Output_Collector'), ('conf', {}), ('inpu…" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "taskGraph=TaskGraph.load_taskgraph('./17assets/parallel_xgboost_shap.gq.yaml')\n", + "taskGraph.draw()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "taskGraph.draw(show='ipynb')" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 19.5 s, sys: 3.44 s, total: 22.9 s\n", + "Wall time: 2min 52s\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAowAAAI4CAYAAADgaLi1AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOydd5wlRbm/n+pw4pzJM5tzYMmpEAOiBBOK+ZoVRL0/ucbrNVwTgnJFRMxiVlRAr/HqmgUEUVQsJS5x2RxmZyfPnNihfn9Uz8yZYcMAuzu7s/V8PrPbobrq7eo+3d/zvm/VEVprLBaLxWKxWCyW3eFMtwEWi8VisVgsloMbKxgtFovFYrFYLHvECkaLxWKxWCwWyx6xgtFisVgsFovFskesYLRYLBaLxWKx7BErGC0Wi8VisVgse8QKRovFYrFYLJYDjBBigxDimEnblBDi6UKIjwohXj6FOi4WQnxq/1k5jncgGrFYLBaLxWKxTA2t9UXTbcNkrIfRYrFYLBaL5SBCCHG1EOKtyXKTEOInQoj7hRA3CCG+O8mrOE8I8etk/6+EELn9YZP1MFosBxb700qWx8Xq1asBOPfcc6fZEotlRiD2T60vnvis1z/dXTs/FkJU6tZX7qLMRUC/1nqVEKIV+Cfwk7r9EjgFGAR+B7wa+PpjtHy3WMFosVgsFovFMj28VGt9z+iKEELtoswZwNsAtNZ9Qoj/m7T/d1rrgeT4vwPL9oehNiRtsVgsFovFsk8Rk/72K/Ueyoj95Ay0gtFisVgsFovl4OUm4HUAQohm4AXTYYQVjBaLxWKxWCz7lH3qYfwo0CmEuB/4GaAw+YoHFJvDaLFYLBaLxXKA0Vov3sU2mSzeVLe5CLxSa10RQjQCfwa+lpS/eNLxE9b3JVYwWiwWi8VisexT9mneYgvwGyGEC2SA67TW1+/LBqaCFYwWi8VisVgsByla627g5Om2wwpGi8VisVgsln3Kfh8ZfcCxg14sFovFYrFYLHvECkaLxWKxWCwWyx6xgtFisVgsFovFskdsDqPFYrFYLBbLPsXmMFosFovFYrFYDjOsh9FisVgeBaef9zCLihX60j5aQ0stxIsjmqoBW5obePXzc7zk5fOn20yLxWLZp1jBaLFYLHth4du6aIwFnUFILpVmcybDosERGmsBuVoNX0MoBItGStx69RC3fXMroPnE705FiJkXmrJYLHtj5n3ubUjaYrFYdsFH/refVW/bwfx39hCmUgylPNJa4wC5WDOSSTOQz9FTKNCVy3DnrA5EGDN7pEh7uUJTLeA956jpPg2LxWLZJ1gPo8VisdRxxuW9qJ2QQRBl0sypBtzbkKYxjBAj5bFyoeugY03V9wg9l8B1aCuWzE6t8cOIlpESr33B7TzhyDRv+8RR+9TOal+Fnju6+du5N9JYCvHRhI5LLeUQVyMAFr5lFcd94Sn7tF2LxTIVZp6HUWitp9sGi+Vwwn7gDlIe6g448pODxOkMBBFzqgFNseahjE+IADRHVqosrgRorSmEEak4uZxRxPZchhO3djF7cBg3js1mx4E4ppzyqYqYp76gk2f95+MTjqtXryZ+WR9B1sOJNKlajF+JSREj0Ag0I1kfN9Jk4xrVEBZ9+HiWvfdEvIbU4+wli2XGsX+UnXjlxGe9/v4hryCtYLRYDiz2A3cQ8a9NFa68scaNawK6ClmoxSAEroZcFCG0ZiiaeMyplRJtxQBXQyEM8eOYQi2g4jrcl8vwgvsfxkueqxqopXzcWEMU4cYxOoqIfB+B5j23njVlW++94g7uvuxeorSDV43IjYTEaQcn0OSqIR7jbUKMi0YjcIkQgCAe+3PQaFxcNB4RgpgaPg0MkyKigotDgJ9ymf2P15M7bt6+6G6L5WBkPwnGV00SjNdZwWixWB4V9gM3zXzhTyUuujFg0HEhctG+AM+Bagij4tB3QAjQGoaqY8cK4Oz+EWquSf/OBSHLh0fG9l8zq4033LeWuSUTuo6FYHt7K5Hj0lQskq9UQWtirUlXa4gowgkiQOOFMSKO0VGMk3OYdWQjZ3/lSfzouF/hOECs8ZIBNG4YJwaZ9cb+Cg2VcMyO0AU/Gr/VKhlBW7WES0xBl3GAKh4lMsl5RcR4CGJ8AvKU8alSIYWXiE8IqOCR7syQfclRtH/pXDugxzITsIJxiljBaLEcWOwH7gBxZ1fIC66rsH04phY7kHKhGuJkfGLfhSCGSEM2SeWONYwE5vXhu+MVlQOoRaA1hSgi7Xu01kLmlGs4WnNM/yAAkdZUBHSWKzQNjeBFET1NjQwWGkw9WrNwx068KCJdquDEGi0ECA0a3DDCCUJwHBCg0fi1CBFGpKPkraY16WJA7Aji1LiNmVJA43CN4cY0kStoHKyQHhWVQF9ThmwUsHRkJx7j2ysIBmjER+MknsfEWHKUCfCJcMhSRRMTkUKjKTBEAyNExg+JSDyZDjUiUgS4eFQAjwyVxItZJU58nQJBjEdMjEcNhwABhPg4RDiU0QiixbPwGrPoYgmdSePMakDI5TjHzMOd2wJnHmdFq+Xxsp8E46snCcZrD/kbdcYOepFSbgA+pJS6Rkq5GFgPLFBKbZlWwx4HUsrXAJcqpRZPU/unAbcopQ75G78eKeU3AE8pdf502zJdaK0nvHhH1+M4xnGcsW2a8afr6L5Yaxwh0FoTxhpHMHbsUAWiGPIpcFzB2j7NggI81AddRRgOYKAMy5rg/j54YADW7ISljRBrzfoheLAXdkQC4thUpgFHmL9RQg1hjCsg8hwjBjWQTUHeMccBpDziUc9hFBvP4iiOgLxnRGSkxz2MrgMpwfKRMmub8wwDPdkU6ShmfqlCxXFwASeOaa/ViF2X/pYm/EqFqu8hkn5DCGIh8IIQNx7ty6RHBcRJWRHFiNi079UinLo+RwicWJAdCak0gBND5AmcEAaa0kSJiBxqStPea7yc5YxH6LsExOgJ70ZNhEeNFB5VJiII8RK5aGwtkiNLmU76EcS4xKSpEVGjTCMRkALSVDCdHyOoUKQBjxFqNFIjZy4DI6QoAykCcvgM4RKRAhxiYvIIQvwN2xPvZ4aABtw1XXDjw0ANCABNjJGg4/35SGJIQvAROrFuYk/Un/n4/6PlxFgd41OLaBd0lKxnXJjbjMCBWc2Q8SCM0UMjiCceASkPPBfWbIGj5kFjAbp7IBRw4mI4Yh4smQ3/eAiiEOa2my8SDTkYrsLCVnMvzu8w9+3QMOwchnntEEbQmAPfg1IV8hkYKZv/k3uGSnJ9Xdd8jjwXihVoLkAYmjJxDL4PUTReTmvzBSYMzT5d97kYfV5MXp5wG82oV8Vhz4wVjBaLlPJi4DSl1NnTbcvByj+7NC/6ecSOElz8ZIf3n+pwxW0xH/pLTBgbp1vajVnRAvf07KqG6JGb9Ng/k767J9vqXzC7Qmv+tCmGlDOxnBDge3hRTGhUqTEwTkSdEESVaFwcAqliQJDy0KUkXJt2IOebY6uxMb/em+g64ALVpJ7AeP/SscafJEbSYUBLuQzCyBQ3iqi6LlpArlIlX64QplKkqlWi5IWcqVTQAgLPYTCfpeK4zB4awU1etLEjcLRIlIqgVMiQqoRka+PhZieK0Y4gFZhjvEjjBJogPS5+I89FuBoviil65kXfVClTJYWgikOMS0iemDw7qOIn4WkjkRxiMlTHPH4t9DOLYMxDaASlT400MS4Q4qJxx7yXgpAUEV6SS+lSI41PFYcIcAjIJ8KxQkiKGmlzzRjGJwRcNHlgGIcyLmkCCjgEpCgmt9ZodqaDy3gfTbidGBV50Zj1u8P0qIvAQRMjkmNGhWP9PHSi/tavROh1vWZ53c7xMgB3bp3YyO/v3oMFBzkpD46Ya4Tv6UfB806GD33ffDErV6Ay6RqsnAt//CjMbZ0ee6eVmSeWrWCcQUgpfaVUMN12WA4d3nNzzOZhs/yBW2KetRje96d4gjSqRrsTi7thb8/JvXkdhBjPIdzFcaFb99oWdfU5AjxhvIMJXqjRYZAEPDEiMaPNcZEZiEKsjYeoLsSLELixZtFAkZ0Zn6OGSnSEIQ8XctRch3wQclLPAIUwouy6+FGEF8dU0mYUskZQTafRiXfW1ZrCcHHM1k1tzdywbBGx49A5PMLz734QN47HvbzCCGJHa0LfIapBphrhVWNSgSZ2JvcNNA1ViXwo5tJkagF+FBOjaSqWaS8VScUhMYISGRximqkhEsE/6p/zCHAAnzCRTA4eASnMY2XU2zgaita4Sc9qfCoTTHKIKFEABFWyZBnBT9oz/kePgDwZivjU8KkSkK0Li4/eSr4JTyfeyZg04/4/U5smBbsRjI/mtS0Sy8f7ZHz73nJJZp482AW1EO7eZJZvugduXmO+AFZquy7/4Db4xE/h8288cDZa9huHtGCUUr4DuBCYB/QD12LC0Ltwe0y5Tg28DTgfOBK4E3gZ8G/Au4Ac8BWl1AeT8jngGuDJyb61wPuUUn9I9n8MeAFwqlKqLKVcBfwdeOlomT3Y8gTgKmAVcAfw+0n7NwDfAs4ATgHeKKW8D/g8cDTGV/I34K1KqYellG1ANyY0v01KeSZwA/AGpdS3pJQe0As8Qyl1m5RyBfB14GRgHfDtSe3ngMuAFwNZ4M/A25VSm6SUJwF/AlqUUoGU8gLgm8BZSqkbpZSzgG3A3OTY9cDrgPcDC4C/AucppbbvpY8WA18FTsU809cDrwROAD4AOFLK0VEJxyml1iW2fBDoAH4OSfrUAWB4eJhCoXDQLBMbTw6AIzSeGI84TS+Tg4aPAk+YEDWQdjQl4U4QkcSxiS86iYcyiGmqBhRbs0aMxppCuUZHsUo6jhkGbm/IIodLHNk7RFc6xcqhYQqhecyk4og+zyNIebQG5jYqZ1JkqxPDvG4Ujp3RupYmnnXfWprLVe6Z00FPJsWcYjLHoxj7x1wMB7LFkJa+GjXfhOJFrNEOSYg6prFaNlcxhFwlAA1VxyUThzgaYu0QJZPujE6/MzoJj1u37qJJ1X0UspSZLJWqpIjxGJVR5koJHCI8qsS4yajrbN01dHDrvNGjIpO6LYKYFKUxr6apXSAIEkE4TkQal0oSKs4Sk0FT2kei7XHce4cbU1HSvntQPOt2+wzcT+hJ99BMuKMO9V962QI8B2jEiLILgH3xVeY1wAsxgqIC3Ai0AMuAM4F3SylHZ8N1gJ8CK4A24PvAT6SUHcn+izEi7EuJwPox8NkpiMUm4DdJ+VbgP4H/2EXRN2GEbAEjfnTS5jxgMTCCEbQopXoxAng0RPsMjMAdXT8V8ypViXj8JbAG6AReCrx5UtufAZ6Y/C0CeoDVUkoXuD3puyftpq2zgTVKqR119b0cOD2xPQ98dA9dNMrHgU3ALKAdI/T7lVL/m+y7SSnVkPytk1I+FfhSci6twB+Sdg8I9Q+pg2H5C89IcXQbtGXhc2e4HNfp8MWzHFrSJiIM0JiCJ80dX58Se3yJaKNId6VKdRJirpmcxAnlkv+deNJ2AUJrGss1OmoBpBxWjRR59pYeM09iygVXJDFFAeXYeBp9wfxyhSXFCsuHKxy/eYDCcJVMOWBpb5G5pRpDrgsIcrHmwVyGuxty7Ej53NLeygMNxuMVCUFGQM0dD8imgwAHTapaxQtCGkaK5Kq1MduP3dbN4r5BmssVTlu3maZSZex8NBMVuxZizKPoRua8BZCuBhRKFZpK5QkPcldDT2uegaYMVd/4BBwgwB0b1iLQVMlQI02FNFU8qmMT7BgrHEJShHjEFMkR4VIlTXWCEBwNDJv8SOONrOBTw5vwHUzjJPmD9bdHimSi87qBOA5VqmSpkcH0oo/Gx0lyIwUBDlUi0lRpJiLPnl7Hk9vcG5oIiJNcRxeNg56ib2VXbUzeNu3fxabC7rqzJQ9PPgKa8/D8U+Ar/w86GmFhu9k2iiNMescTlsP7X3JQPOt2t2yZOoe0h1Ep9ZO61dullN8DzsJ4nB4PV44OjpFS/hj4BHCxUioG7pRS3glI4C9KqTFBlnCFlPJ9GI/fr5VSkZTylRgB9RegC7hkCjY8DygClyulNPAPKeU3gVdPKvd1pdTtyXIZuKtuX1VKeQlwt5Qyp5QqAddjxNp3k/8/DHxOSimS9T8qpWIp5ZMwgvM9Sqky8JCU8krga0m/OMB5wLlKqa3JtncCfcATlFJ/lVLeCJwtpbwFI7TfDrwb4/k7O7GlnkuUUj1JXdcxNfFfA2YDS5VS9006/13xOuDHdYL9u1LK/zeFdmYkR7cL7nn9xMfAhSc4XHjC/vsuqbVGa001jAki4wxsTDv0lWKIBYMB3Nvr8GCviYClXc1nlKY3gFoU40URNcTYaGK0RoeaoayPEaPwYCGHH2laKjV25NJmEILW44NhAHyX5dUaPbkUXgjEmkwY4whoicxgk7YoQtdgTmC8Yx1hxH3ZNAjBjkyaFUMjzBoy+XTN2QzrG3LkawGzyhXKqRS9yQjpeWUTrhVAOZ0e/0WYhHyQTA2uNWLUPgfyIzXau4cZaEwT+AIn0kSeIBOG5MJRQTbRzVPzHELPhPS7m/PM7xnC1TrJyzPSzKvz9mkcdtDIHPoTmeiTwUzBozEexZAUVfJJazGacW+pS43RnMYKaVJJrqMgIs8AMQ4pKkndHk4yTMUEtYcxw1xSgCDAT049SEZRZyAZYONSSryKDpoUgtqobxwIEmFn6k6+WoyF3EnOu76nJmsiPWEpmpC3OC6j645d3g5POx7+ugaOX4z2s/DsY2HjTsik4IjZMBwglnZAKgWNyWCUbBo298GiNmjIQM8IrJhrvMmuawaoVKpQSASYs4v0jIOJNz1zui2wHCAOacGYCLF3AUsx55LChGAfL/Vh0BLQnYjF+m2FxIYscAVwDsbDFSf7Rj2MKKW6pJQ/xAimMyfVtTvmAxsTsTjK+l2U21C/IqVclthzamLH6PEdwEaMSPu2lLIVWAn8BCMaj8eIuO/Xtd+diMxdtd8BpOu3KaVGpJTdjIeUr8d4/H4CDGC8pV9OQuNn8UiPZX2/FxP798Z7EvtXSynzSRvvT4T8rpgPTP6B3131q2U/IYRACEE25ZCt295ZMCK1E1jRPvGYdz/qX7dLEcVZPnRTjW/8K6JnRJvBLU4yBMI14eibFrdDrGmpRRQqAeWMmQxm9PXcHkbJgBSzJRdrUloTAPc0N/CsjVvGyjaVKxxRrtBVaAAh6C00EHrmEbtlVjtN6zcRCsFwPkcp5TO3u9eEVGNt2hDCrCcjt51aSCXjsmVeIzUhyFbLOBoiV5iRtGPoMb9b5EN/U25MYGhHUPFc0sl5RAgCvGTaGtNODDRRhrrswQpZHGJqeES4NDBMjE+EhyBCEwIODiGj4solJMahTAYj1mKgismIHPU+xsRjxxoxatoxUs4lJMKE13VHC94bT0Nk0zhPW4a+9SGEn0JceBa6WsMNBXQ0TfmOcPdeZK/sSbZNVdIJgGV1E6F3TBoQkkmbP4vlIOOQFYxSygUYz96Lgd8opWpSyk9hPH8HkndhwqhnARuUUlpK2UPd80NK+TTg9Zh8wy9JKU9RShX3Uu9WYJGUUtSJxsW7KDdZfH4Fkxt4nFKqV0p5DHB3nT23YELnb8FMkRNIKa8HXoQRmW+oa7+zzjM5uf2dmLfBYkyoGSllA+Z9vzkpcz0m/Pti4A+Jt/UWTN7pbODmvfTBXlFK7cQI8bdLKZdiwvLvBS7ikX0zel6LJ20bOwfLzMF1BJedmeayMyduv2tbjfN/HnD3xoC4XxOnHPrbcvTnTZ6cCGM2NWRYNFJBA+koJnCN3NDAwkqNtjBkQSXgwTmzWdTbR3O5QoTxFDYJQeC6Zo7FBI1gTXMjv1kwj235LO/95z3Gg1UL8GLMZN6u8YwFlYCOZVmWPG0B8u1Hc+2qn+JqKPuCVGzC70HkEAgHR2uiJNQM4IQBmWpAOWtGgrtBTKBdMjokTPxtJrTskErCyBpBllpipx4bBlNL8gbTlJI9AeGCDNnj55O/8BSazlm1z67VlOTR6ceNL+dy+6xti2X/cBB7hR8jh6xgBBow0YKdQCClfCLwWuC+A2xHI0Y49QKpJBzdPLozGdzxfeAdwHeA3wJfxoRG98QvMYNX3iOl/AxwLEbMTZ4wbVf2PAQMSCnbmZQHmAy8uRUTGr4o2XwD8D2gSyn1YLLtbxiP5OVSyvdiBqe8q66eWEr5XeBjUsp7MR7EK4H7gduSMuuklJuBd9ad7w3Ax4C/TUE07xUp5cuT9jYAg5gQ9WgcqgtYKKVMKaVGh/F9D/itlPJqjGB9BUYoW8F4mHDc3BT/utCIoYFKyK//VeXtPxthuDlLIATpUsD6xhxbGzIsHixx9ECR9VkHIQQ1oFsITqiY0cQIwbbmJlpGSng6ppQzc9+V0mlah0eSkLRgflc3t7Y20Vap8MyNm5k9NAIFj/9303Nw/T2H/1+/2aTY9j/Qx6+f+luCtE/FcwmHHbQryJZDMx+jDyMNOdJhTMNIjZrrkC5HuFFMDTcZ+RyQxqGSjCp2EtEYo3GJcNHUkmB0ZoVH9qnLaf+fM0jNtjlfFsvhziErGJVS90kpP4LxKKWAP2KE2QkH2JRPAydhvHoDwGdJwsRJnt+1wO+VUt9Otr0GuENK+Qal1Dd3V6lSakBK+VzgixhhdwdGaF6wF3v+E5PDOYQZDHIFxntYz/WYkdWjeXw3YUZ4j+WEKqVCKeXzk7q6MaOkv4YZ6FLf1ieAf2CcBLcCz580Sv16jHf1j3Xrn+OR+YuPlRMx59gGDAOrk3WAH2EGtHQl1+JEpdTNUsq3Ad9IjvkF8L/7yBbLIUZzxuNVT/Z41ZPzlGoRyz80yPZ0BmohYRhz9EARF2iOQvo8n22eQ0WIZCbBcba0NNJUKlPLGMGohaCaSjF/Zw9OEBKlUjw31ctzzl/JirOftCtT9krLEa28uvtVrF69muLrhghTglRVU824OLWYIO0SpBy0I0gHkK2E+FEIusYxNz6f1jMWPO7+slgsU2MmjpK2Pw1osRxY7AfuIOet1w3yu1tGGPQ92iI4rlihL+Wyw/fZ4roUHUFnEHJ8qUpTGNJQq+Frzd2NBY7r7cfH/IY0QLpUwg8CTj69wIs+ctyeG54iq1evBuB55zyXKIz4bfs16EAQeS7pwIzCDsOQbKPDotcuY8UXnrZP2rVYZij7RcvF4rwJz3pHf+eQ14yHrIfRYrFY9gdffFUTvKqJ391V4rxvF7lZp2kUEKVdjhgscX8uQ5/r4FfKtNT9qkxLEJhfcvF9cBxEFBHpmMtveNQjdqaEcB081+F5w6/fL/VbLJbHwyGvDx/BYScYpZS/AZ66q31KqYYDbMsazPyFk9molDr6QNpysCKlXAjcu5vd1yilJo+0tlj2Cc86LkfXZ8zgiuPetJlabDyHr9m0jXwY0ZPPmfm/SX62ulrD8Tx6sxky5SoNXsxlvzh1Ok/BYrFY9hk2JG2xHFjsB+4Q530XrWfdupjGWg2hNb7WlFyHmp/CjSLe+vomnvjMWfut/dGQ9Lnnnrvf2rBYDiP2U0j69ZNC0t8+5F2Oh52H0WKxWB4Pl390yXSbYLFYLAccKxgtFovFYrFY9iGTR0nPBKxgtFgslhnEle+9h23/HKSUSvNwc4G2uMJ3rzkG398Xv3VisVgOV6xgtFgslhnCh552M4VY0xlrvn7MCh5uNhNu3/fW7TRHMflaQMvwMN/9yfE4zszzgFgsBw8z7/O1558YsFgsFsshg/B9Kq7L/x2xlIebGswQKw2bmxvJ4iC8FDubW3ntS++eblMtFsshhvUwWiwWywxhc2Mjke8ReB65SkApY34CsS/tszPjM7sS0BhE+K4NT1ss+5OZOB2GFYwWi8VyCPPeV/6dhgcHcYHyEUsQrkuf67BqYIh/zW4fK+fHGrRJxQ80POXf15OuhNzwneUIMfPCZxaLZd9i52G0WA4s9gNneVysXr2aTR8ICEOPqu+DK1i6ZYAgl+a+VXMZchyKjssxW7t5qLWRXxyznNYw4vi+Qeb1D+EIcIRAA8V0inuzafpyHs95YoFL3rT/5o+0WA5S9su3pVC8ccKz3tPfOOS/lVnBaLEcWOwHzvKYuObon1DqD2iNyjREmiEng6MFVc9h+6IOyoUsjf1DOFFMqlTFS362sJJNc//iucwqlUEIAn88sNSTSlHOpPnfpXOpeA7P39RFdyGHE0UUugfZ0dbAOSf4XPTG2fgpG8a2zEisYJwiNiRtsVgsB5jNV/6dDe/+Gy4RVVx8PLJEVB2PgVQOLQQ61jgaammX0BWQ9lkeDrK8twcHzYiT5iNPfxo/POVIFg8VufDO+3FjTSmbJjdcHmvLC0KcapUbZnewbLjIvCAY27exMc/a5gKr+oYZzqRYvXwebhCxsm+EQmMDSysxD95a4bS7uuh2HBzPJRaw7rMd1IKAdCo1Hd1nsRz02HkYLY8ZKeUG4ENKqWuklIuB9cACpdSWaTVsP5P8dvcflVKfnG5b9oSUMgTOVkrdNN22WPYP0Ws/R+3mNeieAK0jnEoF8IgIiCgAMaCJcfEQBKQIyAIxGoHGxyVEIIgRaFzKpEkT41IjxKWGjwYcHGq4uMTE+FTIJsdoimSTlnJUcZKtmrKI6c/mQQjQmlxYo7s9j1+LQUDTcJUocPnT3BUEKQc3irl55QIQgloU05P2WViuUMukKeWz5IpGNG5paeSqo1YQOg43dbbx9gfX0xjH3LJkNjcvnQNA02CF1sEypFwCIeh2PQbaG9Fpj/nDZVpHqjzYkiP0XbQjaH7vAEQxnbWA5cMlHsxn2Z5OUfZc8FyIIn74Wp8nzfdoTLs05uyrxmI51LGfYst+RSn1nOlsv16oT6cdj5sogv/8FtxwN5yyAp5+NBQr4DiwYg6cfTz85T741M/hvq2wtdcc57vQX5xe2x8ju4vdm5lizIxgDvHozDE4dcdoQOCjEQhCIMYBMonwi8kQ04jLCA4RMUNENKBJoXHReLhJnREpaqRxiRE4xKQS30FMngjQuMRUaSBDRIygho/AI8ChSnrM3jIeVdKPOB+XkMh1jVgEEIJYCPwoIvId3FBTavDpzufH5kILPZePXv83Qtejs7eIFnDnsUuoZlPEQCygvzHPQ3NnsaIacH8mhRaCfxXynNW1EzWvbcyGwcY0bQNl3DDmiV19zBss8bsj5jKYSbG1OcdJm3sZzKTQXtK670EtYsT3WdfegBNChEBojRYamvO87Ddw2pp1bG5pJh2GbC7kKfs+aG1OOu2B70AYgzBXjNBIadLe+LonwDEimvrBObGGWgSRNvWkkteZYEx0j5ISEAsx1ndpN8YphmggynggBCfNhu1FwXBNYzS6YF4D5Hx4t4Tfrof1A9DgabaXYG6j4H1PENyxE9YNaHorgguOEZw2f+JsdesHNL/fqDmhU3DqnEd6nf68MeLenZpzVrj8q1uzswwvO0JQSM88D9W+ZPuIZvXDmhUtcMbCg3GGwJl3/axgtDwmpJQuoJVS8XTbclhw3Lvg3s1m+d4t8J0/Ttz/vhfCJ/9vRmVI7u5xOyrWEokxodzo8qiIhGwiGmsISsnWGIHAo4xDDYCQRkIakhpinMTT6GLEnAOUyCPQeEaOIdCUyBvtQwU3EY8eGk1IhJd4D8ctrOLv8pwcYqpeaoIo8qMILQQi0vi1mBSgCSjnTR2xIxACOntHcDWsOWIhPR0tAFRSPoXeQe5fPJ/IdTm6UsXTmnuyaY7uG6CpWKa1WKGYNiHlVBhz0tAIT+4fZNZICVdrXnXner4hVxC4Dv0Zn2P6h7ivrZHQcRLRFxMDhEbcmtMU5pxdAXHMn5ctHjvH5kqFciENQWTEXiZ5/bjCDNsGI/wcxoWh705cH0VrKIVGLAJUAshpyNeFyOuOqU3K1a+FDiTnTmz6/JZtYweOleurmv//bXWdWNXJuXZrfv7wBKP49j2aX70YzllqBMzmIY28JqKvYjTv6hc5Y/sAfnhPyCt+HKA15PMRxUTSXnU7/P21Hp6dXH2X9Fc0p14bsXnYrF/9bDjvmINRNM4srGDch0gp3wFcCMwD+oFrMd6t6HHUqYG3AecDRwJ3Ai8D/g14F5ADvqKU+mBSPgdcAzw52bcWeJ9S6g/J/o8BLwBOVUqVpZSrgL8DLx0tsxs7FmPC6G8E/gtYBiySUj4deD+wBCgCvwDepZQqJsfdBFyvlLpUSpkGvgC8EMgAO4APKKV+lJR9KnAZcFTSf1cBn1ZK7VEGSSlfAXwEmA+UgN8qpc6TUq4GFgLfkFJ+BbhVKfVMKWUB+CJwLjAMXLSn+g8K7t9L5sL/3jqjxOJU2NOrVDCaQ2RKGc9hGZFISeN1HCciV1ejgyYa8woCeISATrYZsVgmg8YhRZkquaTdiAxVBInOQeMQEidC0SOiNlavkbweIT4xfRmfCEFDqYYXRZRyHqHrkKmGY5ZlKxHlnPGI6TH9Yrxpg035MXuDVIqbTzgKv05wLCmVOfuBdTS5Dlvnz+HZa7v427wagSNYOVAhH8WAYCiTpqVcwY/hKZt66cmlOHnLTtoqAc/c1sM/2pv4U2vzuAcvjGFXA2Im3Y/FVCKWfRfiuu+ZQjyy8N6IGReLYDztlQjyuym/p2mDpjKlUH0ZsYttdfzy4XhMFP5lm6avkpis4VfrNOcsHS+7+oF4rBuLkYCkG/+1A7aNwMLGvZt2OHJHtx4TiwCrH9acd8z02bMrZmIOo5Xk+5YtwHOARowouwAjsB4vr8GIrA6gAtwItGBE25nAu6WUT0nKOsBPgRVAG/B94CdSyo5k/8VAL/ClRFz+GPjsnsTiJF6VtFkAdgKDybZm4KnJ34d2c+x5wCnAkUqpxqSeNQBSyqOAXwNXJOf5XOCtwGv3ZExyDt8D3qKUKgBLgW8AKKXOBTYBb1RKNSilnpkc9llM/xwFHIe5VgdkCOjw8PBjW57TsueKn3bUvjFwBqEnPN7GfY6j4k2TIkpyDicKyFFROS5q4kT+lUlRxadGqm6fW3ekS4xDkLRhhGOES4hG08YwBUpkqNJAmWaKZAkQgBdGhCmXgeYsvS153BFN60D5EcJEA7WUR+w4aGCkwafmO7T0jd83Vceh5jnEiRrRwB0L2vjRk49muNAAQGMQ8bwHtvKyu9bTUh0//1gIAsehN5dl3nCF43cMkYnGddKR/SMTwr3ouC4XQKMz46Fhp04IRl5SQxRDpa6/H8tMHQ4T3146CUs/FqbS/oTz3XPRE1trY8sr86UxRyrAk+aaPhj9XD95wbjNfl3FS5ogH4+MrT/m58YMXT6yTdCcGu+vk9pqUz528rJl6lgP4z5EKfWTutXbpZTfA84Cvvo4q75ydHCMlPLHwCeAi5Nw8J1SyjsBCfxFKTWC8TCOcoWU8n0YofZrpVQkpXwlcDvwF6ALuORR2HKJUqqrbv03dctrpZRXAa/bzbE1oAE4Skr5V6XU5rp9/wH8SCn182T9finlF5O6vrsXmwJglZTyDqVUH3DL7gpKKR3g1cBzR88j6Z8X7aWNfUKhUHhsy3d9Bv7tCrh9g8lZfPrRUK6ZAQZHL4ALzoIzjoVP/gw290CxOv6SO0Q9j3syWyehz90RJ749k1lnsgpj0sRkcAipkkWjSRETkiFFLzVa0Tg4BFQp4CYiMkxyETUaj5AwCTWP50aOBxAEMSXSOImaqeFSI0OaGg6CQfKJ31NQxidDjJucR2okIooDtCNIlyNcDV4YMpJNEToO2oFq2kUIQeS5VBsyuGFERWsG2h1qDT4dA4M82NHKSDoFQhDGMfP7+rlGrmQomyJfDYgZ11pVz+X2tibmhRGh64LWlIRgU1OBzni8f2ueC8no6mwUUe8T9DT4QUSsNTUh0GltvH9hErJ2NAQxsXCSnMMYghgGK5D2EHESwhYCwgiqERTSRqFGMQhn/IaozznIe8arGGrIOCbZMNa7zGE0F2f8YKEhHURoATXX1N+Zg1IoqASaGBBCkPdNta9dJbh1O2wZ0mQdTV9N0J4X/JcU3NMD9/ZqiiFccIzg/GNyY02etKCBm1+u+b+1MSd1Cl56hGlr9HN94RM8GjNwb7fmhUc6/LULekrw7yc4tD3WZ8VhsDw7L/jzqzyuuy9mRYvg/GOyj7nO/cfM8zBawbgPSYTYuzBeLg9IAX/bB1Vvr1suAd2TcgdLGI8fUsosxkt3DtCOCd4UMF47AJRSXVLKHwJvB858lHmIG+pXpJTPwIR0VwFpjKeuezfHXgPMAj4DrJBS3gC8Vym1FhPSPlNK+eK68g6w+ZHVjKOUKkkpz8H0+/9IKddhBPZ1uzmkI7Gz/jzW76mNg4LWAtzw0T2XOe8M8zdD2FvIeU+M+vxq3/8TumcIZyQg+sCPEdQIcRCUcKkRIYjwiWlIBs4EhDhUidCYD7BLFYGDIMQhi8bBI0ADIRkCHHzKRLjUEDg4xElIu0yKEj4lHJqo4BMSJT5HjUsRD1fEZjiNjsmWQkikcCXl0BQFtI+UGMym6WvIoh2RpGHGVLIZMuUKoBnK5+lqbiJyHTpHigSuQ+Q4LOoboFAsMZQxHs9i2ufPC9p56sZuhNb8o7WBNuFT1iF+FLE+m2ZtPoeroWVoBB+IBNw2u5knbe0hH0Q80NyAzvpQi3C1ZlGpQhxDlZid2TTBSOJxFJpmN6Yxr7n9vY205nedvzl9HBh7njBH8IQ5uw9gvPq48dfwKfMOhEUzg6PbBf/zVDs36IHECsZ9hJRyAUYQvRj4jVKqJqX8FMbzdyB5F3A6xrO5QSmlpZQ91L1jpZRPA14PfAsTmj5lNOdwCoyJSyllCvg/4L3At5KcyLcC797VgUqpELgcuFxK2YzJI/xWYu/GpI63PIpzHa33JuCmZCDO8zEh+L8rpR6utzehB+PpXAyMpqwvfrRtWg4NUq88fWzZf//UncgN+8OYOta+4Gd0r97KiJsiCk1eZJ6QsqtxY6hmXIK0T3VQ4FU1QYMgXY3AETixGYk8ABQLDYgooqu1mVLGjL6ueh5HdPdRzqRpLpbJV2qc/cAW/rhiHpkwIqzFVGsBiwaHqLY2kY41kesSuS7C95gbBMwvVsjVavytvZlqxiMfxmzN5wgcl20Cji72I1f5XPLiZha12kQ7i2UyMzGH0QrGfUcDxiO2EwiklE/E5N/dd4DtaASqmDzFVBJubR7dKaWchclrfAfwHeC3wJfZfRh5T6Qw3rr+RCwehck73CVSyjMxOY93AWXMIJnReN5VwM1Syt8mNmlgJdChlLp5D3XOAk7DDKwZlFIOJLtG6+3C5CsCkITkrwMukVLek9jxiUd11hbL42T5z1/E8kd5zOeO+AlNVejPpPnrMcsoVKrkdEznwJAZpTyKEESuQ+NIET+KCR3Bc+5cx7n/XEtupMw3nnQs/Zk0SwfhqJ5+ts7uoDWIQGtmj5Tx4phiyufO5jwrhkYoFR0ufWc7Tzyhc5/2gcViObSwg172EUqp+zAjdX8ODAD/jRFmB5pPJ+1vw3jQSiTh1yR/71rg90qpbyeh6NcAZ0sp3/BoG0ryJS8EPimlHAG+BOwuFAwmHP09zAjo7cAi4N+Tuu4Bnge8M9nXDVxNXSh9NzjAW4ANUsrhxIbzlFIbkv2XAq+RUvYnk4iDEcvrgfuBu4HVUJeIZrEchLzjgZdw/oaXsPwKzZztPXhRTLZUBjQLtnfjJCOPc9Uq2VpAOo7BdYhSKdYtmsN9Kxey5sjFnLqlm5V9AwBsb8jRpSP6nZhYB/zg2uVc8/2V/Ow7S/jXVxfwi+8t5/qrl/LEE6wX0WI53LG/JW2xHFjsB87yuFi9ejUA5557LgCXy19SyzYQAv+YNxvt+5zStZN08mwv+z69jeNJ/lEtZEhEdGczbGjMcfvlnTQ12p/4sxy27JfYcVVcOOFZn9ZfPuRj1DYkbbFYLIcw71PPG1v+4NP/wpr2FvqyaeYUzZQ88aTJnwdzPr9aOJ+Ry5oOtKkWy2GDzWG07HOSMOlTd7VPKbW/c+8n27IGEyaezEal1NEH0pZ6pJQfAD6wm93PUUrtdhodi+VwIoPm+E3bGcxn2ZHxaS5XEWGZlOsykM9RdQS/Wj6b1p4RwApGi8UydaxgnGam+7eW65lOUbgnlFIfBz4+3XZYLAc7fa5Lp+eQHxikqVJjMJfhofmzWF/II1yHPy2ZTfNwhXWf2VtqsMVieXxYD6PFYrFYDlI+c8OTeP6Lb+fErgFcISilfHQY87OvLqIw9jvLu/v9PIvFYtk9VjBaLBbLDOIXPz1xuk2wWA57ZmIOo51Wx2KxWCwWi8WyR6yH0WKxWA4SbvGvYDjXQehoHCcijh360ymWffB4nvLWYxBi5nktLJaZycz7rFrBaLFYLNPE0Np+7j3iy3gig4gEAW2kh6CFIkt5gLvyx1LM5dl0+X10XXoHnhtw58KFnPTB8nSbbrFYDjNsSNpisVimgbVfv5MdK75Aa5yiKYpJ1c2XOJBq4u45qxhuzDDU3EBfexOlbI4/nnwiTsrnJ99ezKX/fsf0GW+xWPaIRkz4mwlYD6PFYrEcYB4QH6ZIAZ8CPjEumkwckiVgxMmwYWUbYaqTSLj0zGoFoLe9Ga0FG+fNwQO2d5XZvmGEOYsP6HStFovlMMV6GC0Wi+UAMfjnjTwgLmZIzEaTZ4Q8/TRQwQegmPZwUzXClAvAUNO4GAzSPgt7ejl6w2YWb+8mG4VcduEaahX7M+gWi2X/YwWjxWKxHAC2vPw6ik/9Ih4eWR1QS0QiCMr4bGvK093WwIrwYdJhFa01qWp17HivViNTqeJXauSrVTJhRC3fwDtfcRfved9D/OKPvWhtf6rcYrHsH2xI2mKxWPYja0/5PGm1jk524hLQwzLK5BFoYgQVx8VH0zoyyLDOkQ8Fx2zZjBj2SAcR2zqauH/RLJr7h3BjIwgrQYTTWCAFDOUa2NCd5l/XlvjstWWaymW6Uym2Z9NsbMigBTRVApa2C/754fbp7QyL5TBhpuQt1mMFo8Visexjgp2DdHd+mGb6mYNPhVbSlBmhA02GBswo50GRYXHcQ5qQGh5eEFN1PVr7ypTIATB35yCb2xrHxCKAXw2Ys3E7ueYCA8sX0R6GRCEM+B73tTbTk0vRm0lBHEPWY6A5x+2lAO89A0QpB7SAKCLlwtDFDaRT9lVgsVj2jH1KHEJIKb8ChEqpt063LXtCSrkWuFQpdfV022Kx7GuCOzdQ/OXdBF+5lWhLP/35ZvwgIq55zKeLgEYCMhQQCBqAKnm6icdC0JosJYo5j4aKJq1DAFKEtMVD/Gbx8ZywaRsE422uWb6AVeu2kC+bELWITW3tvYM0d4ww0FzABTyt6awFtAQhI5EmaMwQOybzSOdTiFIVyjFowBHUmnJkPxngVyukg5BaFFPNZsAX4AjQMQiBmVNOm22xNslMUYTI+OQRHNsmaEkLWtOaZyyDY5sFuRzsLGrSPpw0x8FxHDuPpOUwYubd61YwHkIopd48ne1LKW8CrldKXTqddlgOYy77CXz6F0a0nH8GfOp8uPFueMFlUKxCyoP5bVAJYKAGQQw6QEcRWguqoplA5/EokaGPGJcynWgcXKqkqKJx2M4CGtlBE90INCDQaCLSxHg4dJBGsDM3hz8uk3hRyAX3/pCSbifADFSpkQcEaWpENFMBfIbJMsSfFh7LtkI7C7t7aN85MnZ6LbUScwaHuH3FIhZ0DZErVdm4oAPte/zzqGXM2dnP3J4+MpXa2DGiLm8xchxcoOi7xBmPuG6qHrQm1hixCKYPayHa86ilHWppH7SGGECY953rIWJN80AZL4go51OMNGXM8Z6HRjCiNX/tIXk/Cq5ZV9/IqGER6Ai8x/ASFRPPYbf7HgUFH2oR1GJjkhDmVmnJwB9f5rCjBB/8c0xTWnDl0wRXKM0/d2hGatBXgWVN8P3nuRzVPrX2b9+hueB3EWt2Qpjo7ifOgd+91OXPW2Ne8gtNOYCVrXD761wyj6WfLJb9jBWMBwFSSgG4Sqlwum2xWA5abl4DH7h2fP3Tq0Euhwu+aAQiQC2EdTswj7bRx5uLIEQQg9ZofDIM4BBTZA5hEvqNSJGliACa2UkTO+oaNxlJDlXKNDLqPegoDTFrZIDhTBpPR8QTHqmCGmm8OldhRANlP822gskl3NTZTnOtxPzBfmIEQjss7etj26x2/n7yirHjTr19LYXBEmuXzWaksQGhR0jVAna0NdPTXCB0BFXHoew6aOD+xiyBcIwqSrSHO1I1IrFeZLm7GPfoCki7Y+fdMFwlUzGPpsJQlWrGJ8jUnedk0bYrEecJI/Yer4dxH3koh+u8t0Gdvu2rwLN/HDMcwEgAoHnezzSbhycef1cPvOpXEXecN7VX6Mt/GfFQ//h6pOEv2+DdN0d8824jVgHu74M3/Dbm2ue5u67IcshgcxhnAFLKDcA3gLOAU4D1wKuBo4GPAR3Aj4A3K6VCKeW3gbOBZmAzJtR6XVLXG5JjTlBKdUspO4E7gA8rpb65Fzs08E7gtUnbZ0gp88DHgZVACNwAvF0p1Z0cczUmJP3GRGReCrweKAC9wJVKqS8kZY8BrgROAsrAtcBFSqm6R+Uu7TobuAJYBtSAO5RSZ0spvwg8FXiSlPK/ga1KqSOklD5wOfAajG/iM3uqf1JbG3gU1yI5ZiHwaeA0zGN+NfBfSqnhZP/HgVcAncAO4AtKqc8m+xYnbbwOeD+wAPgrcJ5SavtU7X48DA8PUygU7PJjWe4ZekR/VjbtIFPd1S09+WFtQqrGW6iNeARi6l/MDhqBQOOy++9ugvFpbDRQ8XyKXo6d6TYK1UFGSMPYZL0eggidtCOIyIQVUmFAzTMh6oFCmvmDmhiPwIffn3wCI9ksThQRuS6d2/ppGigBsHLtdgq6xIbZHfQ1Fbj7iCUA9KU8YiEQQDrWnNgzzEDKx9eaLdkUPSnfnHVDGsIYIpPbSMYzbjaNEXSaSV5AgYgnevWcxzISe1+IxQPEcA1G6i7/UNV4mCfTXYrHj9nLPdyzmx/m2TYyLhbH69VTqtMu75tly9Q5XKfVOQ/4D6AFuBP4GXAGcDxwLPB84OVJ2T8DJ2AE40eBq6WURwEkovAPwLWJcLoO+MPexGIdb0jaaQBuB6rAWzFC6VhgLvC53Rz7jOQ8TlVKFYAnJLaSCNebgZ8C84AnJeXfPwWbvgt8HmhKjr00Ode3ArcAH1NKNSiljkjK/zfwPODJwBJgMbBoKiefMOVrIaXMADcC9yZtHQXMZ2If3YsRkwXgTcBlUspnTWrz5cDpyfnlMdf1gFD/kLLLj3L5uSfDqSvHtrFyLpl/fza843lMQAjM961RYRORxFmTLYIKzWggS+/YPp8iTjJyuZc5VMlMqFYDMYI0/ThUgJihdIZ8tcaROzfgVLNEZEgxgkOQyFOXCjkEFWpASIUmvYVTN97HrMEBFvd28bRt/6SDTSzin6wK/s7Z625AaI2TeL46ugbHbMiEAQsHB1jR3Y3jC574wFoW9PSgEfgaPD0aGRY0hRG5KGbFSIUFw2Uaw5jWSghpDxoz5rQroclTDGOzrjHur7GT1hQb04SuEUyVrEc14z0yNLwntDZx2Cjee9mDgEtOE/z3E8z5plz4yJNdZhkn9JhsFMAnTh/3t+ztHv74ac4jJGfahY8/1eHC48e3uQI+9XRnSnXa5X2zvL+wv/Qyc/iaUuo+ACnldRiv1hOVUkWgmOTqSeDaSeLvB1LKdwNPxwgTgAuBfwC3AT5G4EyVTymlHk6WIxLBl9Alpfwk8K3dHFsDMsDRUsqdiReyO9n3OuBOpdRXk/WtUsrLMJ7AvYmjGsa7OEsp1QXctJfyrwM+oZRaC5D0zxv2ckw9U74WGGEqlFIXJceWpZQfBm6VUr5JKRUppa6pq/tGKeWvMB7M39Vtv0Qp1VPX5hsfhb2W6SKTgls/Dhu6jahZ0gmeC5+5wIjGNZvMtrltMFyCcgDlGvguum+EuKZJtRbw0EQ/v4Ng83Z0b5FsNYIopvL3KkPDeTQxjfEmRshRTia/yaKNliICclQJSVOhpTrMWRt3EJLGIyLCwSWkikOaIhE5HEKGcVnDiaxgDQ0M0VgZpmNLlQ66cdGkGMZJPJdHdT/AbQtOZnvjHGZ39TDUmiU/VKWxXGZeycQ1N3W2j3n65vcOcG97G0EqZcaiMDGDUAC1lIMfRgx6DpTr3Ge+a1SKJ8aPqkYm5zDjQQyR1uxsyyFCjRZAECWh7Hjca6hHvXCJJ1FPFJ3mf5HkMiZWaW3EqueOH+sk3k5hRJOXJBMAzE3D4kbNxiFNFAuO7BQ0eEaLLi5Aaw7W9MKJneA7xkv4nCWmutu2G5M9AStb4Mh2l5iYh/phbl6Q9zQPDsCxHYLZedP220/SZD1ozgjefLygpwwNKc2WIZjfKGjJTF0EvPkEh387QrCjGNNb1jhCcNIsh6wvuOoZDu85JeLBfnjKPEFD6nD141gOdg5XwVgffiwBkVJq56RtBSmlA1yM8UjNxjx78hgPIABKqZKU8huYMOkFSqnSo7BjQ/2KlPJkTEj6eCCHeYru8ne/lFI3SSk/AHwI+KGU8m/AB5RSCuN9e4qUcqDuEAFMJTHmBcAHgLullDsxgu6zeyg/v/48lFJFKWX37os/gildi2R5CbBw0nmBuS6zMcL47RjP4nzMOWcxnt/dtVmsq99ysOM4sHT2I7cv7jR/ozTnJ+yuv/ldwD9h4SOqyDxiy+7Z3Y/xRSNlej7xR/T//IKIEJ8SO5nNZpYiiGmiDwEUKOIS0EDACG3kqZLFDGSJEcShYPHmLo5duxkBrFk0l3SlRiY2Yi/wxj/KGhhxHUQyGnrEc+hL+8wrVdFCMIQmV64wlMtQS3lmqp1IG8FWCkwNDlx5jssbTkrRlH80PXFo8NQFu9rqsqhxfG1R88S9cxrGBWHWFyzwAQQtj7F72rKCtuyuH8FLml2WNO9yl8Vy0HC4Csap8kqM9+mZwL1KqVhKqahLaJFSrsKIyqsw4c/fJJ65qTA5RvMD4MfAvymlhqSUz8Pk6O0SpdTXgK9JKXOJDT8FFgIbMaOZnztFO+rrvBN4eZIjeRrweynlXUqpG3dhL8BWTBgagCQPs2MX5fYFG4EHlVJH72qnlPIpGC/qWcDflVKRlPLHzMT5DSwHJW5DllmXngOXngNAHEX0eB+gk23MYQsFhohIU6OBeewknQyIWZteRbveRJoy9zUfQUN3lWW9fWM3bufgMGtnzaLs+QS+y8bODnLVKk4c019ooOK6DLiCvDZx7GP7Bim5Lv2+x/y+QfpSPlvTGYgi3iwdvvzSxl2fgMVisewGKxj3TCMmGWon4Egpz8d4/34JkAi1HwGfVUp9REqZBr4vpTxbKRXtps69tTcIDCeDO/57dwWllE8A0phQeBUYhrFs/O8C/yWlvADjXathRN1KpdRv91BnCiOSf6WU6pFS9mNE4mi9XcDySYd9D3hPEjreBnyS/Zcb+0vgfxLP6heAEUye5xOUUj/D9F+EuV5aSvlc4DmYa2SxHHAc12WJvpzq9gE2z72MQbdAWzRChTxu8rEqumnWNizktrYjqKU9Itchdl265rWzdGs3S7b30N9UYMecNlKVKhsWz2VnewsAIozwyhVy5TIiTqODgIbZGb5/5XzymdF5H+dO09lbLIcvMyVvsR6bLLFnvgP8HViL8aQdhRn4McqXMHmDlyTrbwPaMN6+x8K/Yzyawxhv4Z6ETgNmsEcPZoT0M0kGhyQezjOAF2LCxf2YwSRLp2DDy4H7pZQjwC+Ajyilbk72fQaQUsoBKeWaZNtlmPzAv2FGIG/CeAL3OUm4/0zMdbgfI65vwAxKIrHjuxgR3QO8FHPeFsu0kp7TzHJ9OSOL53FPsxkTFuElvydtwsyxMGO4Y9cdyw1cP7eDu5cu4M5lC5i9dafZXgtZ/sBWmvsHyfUNsuScVm66ZgV//+ZCbvvuMm785Lw6sWixWCz7BmF/rN5iOaDYD5yFHvGfFDFzMaYZZlu+wINNK+jpbJggGN0goq+1mbWd7WSqNRAwUMjTVizR1tvPkS+ZxaveOtnpb7FYHgX7xRU4JN494VnfqD91yLscrYfRYrFYDjDt+jPsaEgxSJ4+0cqSYi/P3nY9nk6yP7QZlDJ70yDEmoagxkBjnoHGBprKFZat20I5k7Ji0WKxHDBsDuN+Qkr5G8xE149AKbW7QZb7HSnlq4Gv7mb3/1NKXbubfY+lra9gJvTeFUcppTbtq7YslkONJwy/h1sbryDQLhs4msj1iRx/zN2RLgWkqyFoKNQCsoNDuEFIdnCIBe+s8l+vO2Va7bdYLLtnJuYw2pC0xXJgsR84yyMYuns7d518LffOW0yUz9IwVKG5r0zNdylnoNjq0pPNs+yEPNnnDeO4cO6550632RbLTGC/KLtB8Z4Jz/omfcUhryCth9FisVimmcZj53Ba7d2cNoWyq1fvdqYti8VykDATPYw2h9FisVgsFovFskesh9FisVgOUqqVkFtu7Ka1PcURK/NkCqnpNslisUyJmedhtILRYrFYDjLefMHd6J0RO1sbGRIODbURVoxsoTBYpH17SHdzjuc8K8JLTeXXPi0Wi+XxYwWjxWKxHCR86esb+Z87M6wSTfTO9diR8nGSORl1FHN6dy9BU562IOKqJ12PH4Qs3rIdrwadxX5quJS8LE44zFOid+M4NuvIYpkOZuLoRvs0sVgsloOAp523jjt/Pcib736IxeUqx4yUxsQiwMaGPH4UIQDtueAIgrRPV1s7q4IHOJY1nMTdLAu76KTGVve9bH7lNdN3QhaLZUZhPYwWi8UyjcSx5ri3ddHueYTAtasWE3k+Tx4Y5oSBIZYVy5Rcl97d+CxSYYxbM6FpgaaZHmrMZQGbqfxgJ3f+4CGOiy9GiJmXU2WxHKzYUdIWi8Vi2Wdcfesgs9/VQ0eocT2PDZ3t9LQ20hFHlB2HVSMlfK1pCkOOHC4SCUHkCDKlKiKOyZZqzN3WT5H8WJ1VcrjEFMnjUGMpW9nkvIctSz4+jWdqsVgOdayH0WKxWKaB1ksH6R+IOL4W4gAx5ht8Sy1EAJPHQ+dLNeZs7gUhiF2HpQ/vJFcNAU2NNEM0USVDTJYUEUMsoI31aBHjapeWDRvoFW8k95t3kn32MQf6dC2Ww4yZ52G0gtFisVgOEFt7axxzRZGBXAbcDA35kLBY5a8tBcqey6xKjVrKZflgkcF0CjeOaS1XcMOI2dt24mgQWuPGEd2dBeaXe9jQMouaP4f5O2azpK+LRl1KWhPUyNKoexliDuuyy6n5IYvP/QJBqIGQRv2t6ewOi8VyCGEFo8Visewnrrq1wlt+H0A6BU7icWjMQahBa+b3DPJQc4FVw2XScczafBYda/JhRNXz6Mtm6Mtm6BguEqYdGB6vu1AuMtSQYaghB8DaBR3kaiUKwyUEIIhJM0yZJnyhSccBWzNtzK1uojnsBQQD4k24RERU8S97Nfn3PQdsrqPF8riZiTmMVjAeQKSUXwFCpdRbp9sWi2Um0V/RPNAHR7VBY1pwZ7cm7cLSZri9G+Y3wLzCxAf479ZHrH5YUwogimFnWdM1DJv7I6rlmGFHgOOQrYWEQKwFsSvQrgNaAwJ0bCJPjpOsm//GRZcLrgZXJGXMJuIIYs3DzQWO7y+ysFIDYFY1YEvaRySeRC0EXhwjXIfIdSg2pMiPmLI118Nx4/ETEoI7Vyymb2eBIzZvYil34xBSph1fx7RXh2nf2U2r7gbMCy2kgRoOfbQi3n8b897/I2IEMQ4OLiEChxpDfgP5qEYuHsQlIsYjoICghkeVEIFPRIiDEGm0FsS4uA0peOlJeA15ots34Pb24XTkEdUKUS6P09mC86Ljib99M+wcgKccQ9DYTOCmySxpwG9KQaWKLobw5FU4R88x57quCzb3QsqFVfOhpWFqN8qP/gKZFJx7yvi2YgXu3gjL50B749TqsVgOQ4TWM3G2IIvloMV+4PYx6wY0T74uYkcJFhbg7EWCb91junlxI2wYgowHv3yRw1mLjGh78f+F/GztLirT+pEetji5ZBOE4G6OG32eBjG4zviwwsnHVSOINIQxT9/RT2sQje26vaOA1ppnrd9BKe3jx5qm4RFWbNwKQG64SrYSgtYcP/IAf1p6IlUvZW4sR1ColHjWmn/hE5CllyptY3U7lMjThyAGNFU6AE2KnXjUxnwiAQ1ockQ4FMmTowIIBAEZugFNRB6TaVnDpWim+0m6KcahyFxSjOAzzDDziUkhiCjQjSBMvKAaTXWCL0YDGpeYBsBBownIAwL/o+fgL0zDBV8cvy6dTfCXjxvBtydO+i+4fb1ZPvs4+MPF0D8CT3o/PLDViM6bPwbHLtpzPZaZxn5xBfaID0541rfr/znkXY52lPQ+QEoppJTWW2uxTAPX3afZkaTtbRqGb98z/pzeMGT+r4Rw1R1m+0BF71oswq4F4WgoeU+hWlFXZlQ0usKsTzpOxJp0FJF3NClHsyGXGfsW0ZVPs769gQ2djfx1QRv5SpVCucLcnj7K2QzpSkimEiK0pm2gyF35lTR2FykMl8bslBsexkUQk6LIbFIMAiQS0aFGG1U6ErHoAC4RDRPemg6hOQVifCJG36kaPxF+4CYiEnyM23T8zesQ4zNClSYcIjzKyfEuVfKJWASIHvG2NsIzxejrSSAQGEEdXHkjfO6X42IRoHsQrv3T7q8NwEBxXCwCXH+XuU6/+qcRi2DE47dv3HM9FsthzCEncqSUG4BvAGcBpwDrgVcDRwMfAzqAHwFvVkqFUspvA2cDzcBm4FKl1HVJXW9IjjlBKdUtpewE7gA+rJT65l7s0MA7gdcmbZ8hpcwDHwdWAiFwA/B2pVR3cszVmJD0G6WUArgUeD1QAHqBK5VSX0jKHgNcCZwElIFrgYuUUsFe7Loa8/QOgBcDReDdwH3A14FVgAJerZTalhyTAz4KvARoAm4D3qqUWpvsfwXwfmBJUt8vgHcppYp11+RryTU5FdgA/LtS6ta92LoYc/3OB94HLAJuxlzP9wEXYN5zH1NKfanuuKcClwFHAf3AVcCnlVI6OZdrgCcDOWAt8D6l1B+SY88HPgR8HngvkAd+CPyHUmrczbOfGB4eplAo2OV9uLykaXxKGYC2LPQYfTLm9QJY0mTK53MN5H0o7vGTtAt25X3cVZmY3fqRRRxz3LZB7pzfQjXZ5o9UeTiXJq01/1jYOtbGXZ3N3JNr4NX3r2NRHOPXAvpbGnBwWLyxm0wtYiDWRL6LX6zRqGFW3yCNxXJ9i3iUcYnxGKZGx4R9o0SkiHFxiNBATBqAGEGIh58IyNFA9ujS6DZz0hOJ8ceEZ4w/tt0dq2uiDZOPHkXXlRNL2mCJmCj+AJZ0Anu4T+IaBc+BMKk3lwYhKHU2kHs09djlGbdsmTqHqofxPOA/gBbgTuBnwBnA8cCxwPOBlydl/wycgBGMHwWullIeBZCIwj8A10opfeA64A97E4t1vCFppwG4HagCb8WI1mOBucDndnPsM5LzOFUpVQCekNhKIlxvBn4KzAOelJR//xTteinwE6AVI4i/npz7i4BZmGfwJXXlR4XkE4HZwN+BXyZ9AjAIvArTh09N/j40qc0LgLdjBOcfgO9M0VYwQvU0YCGwOGn/YUz/vR74rJRyIUBy7X4NXIHp5+di+vy1SV0Opt9WAG3A94GfSCnr35SLkn5YhvnS8W/AKx6FvY+Z+oeUXd43y68+yuETT3U4Z4ngc2c63PRylxevELzqSME3niV47lLBO08WfOwpDoVCAd8V/OkVLnPyk+WKGYjixDEijo3405qmYoVCJcALorFtu//D3IGxCTdP3p8tR9T8ib//XEm5NAcRTUFEQ61OTAWa2BGUgXS5SjWdZqi1ifXL5vDn047iwYWtVH3zCE+HESdtXk97f4lBGokQaCBAENFMTDbxKNZ/JxpVthqfYWo0UqWFKs1ExJTJMEgLDsOEokokAnx6EEToxIMJIQ4lNDqRjSZoXaGFmBQp+qlSwCXEpUKaAXyG0NQIcYlIE7npxAoTyq6IJqpOjjjvQmsapyBwGhzcs5aT/tkb4WsXwgVnwbEL4Ykr4bLXwOvO2PN90toCP3sfzGuFRR3w+4sAyD3zZPjmW+Cck+Cil8FbnrNf71W7fPAtW6bOIedhTPiaUuo+ACnldRiP1BMTj1dRSnkTIIFrJ4m/H0gp3w08Hbg32XYh8A+MV83HiM2p8iml1MPJckQi+BK6pJSfBHY3b0UNyABHSyl3Jl7I7mTf64A7lVJfTda3SikvAy7HCL+9caNS6lcAUsrvAl8GvqeU2pJs+zHwpmS5HSMGFymldiTbLsF4T08F/qyU+k1d3WullFclNtbzVaXUmuT4bwDvlFI2KaUGp2Dvx5RSfcmxvwSeq5T6erLvN1LKfuBEYBPmi8KPlFI/T/bfL6X8YmLPd5VSIxgP4yhXSCnfhxGGv062lTHe2ig5nxtI7pcp2Go5CHnfqQ7vO3V8/ScvGBdlFxz7yPInzRJsu3Cqjz9/70WAUiXg1k3wutUh2wGqiWDMeCAcEFBKuRBp0kFE1Xdxo5iOYZPD52pYtnWInVkfHMG2XAaA/mwaAVSz6bG2gpTPSCFLw3CZlmKZxf29tMVDjFBliBa2MguAhWyps1CgETiJnBTEDFIgzw48ihQ9TVlkaQjKVHGJT2ym8YKnkHnL2bv8lZhd9Z7A6OWp9NiuvBUC81CcjDt5wzffMoUWJvG8U2DLKY/cfsFZ5s9i2YfYUdIHD9vrlktApJTaOWlbQUrpABdjvICzMV9i8zAel1FKlRKB82ngAqVUiamzoX5FSnkyJiR9PCYcKjDex0eglLpJSvkBjKfuh1LKvwEfUEopTOj3KVLKgbpDTNrQ1Bjrn+T8Jmwj6Z9keUny/11JuVF8YEFyXs8ALsJ4IdOJHd1MpL7+YvJ/AZiKYJxs2/ZJ+yfbe6aU8sV1+x1MugFSyizG+3gO0I5xoxRgQiyue1L4uVhXv8XymMhlfM5eCdv+65FyadtQwLzPVEA7bMn5eJWAI7f301AJedndN7GxeRZ/n7WIO5tnjR8koKVSw4tjypkUfi2gmjGi0YkivFqIq2NW9vYw4njkGaCFKhvxKJNFE+JTH3cXRHgUyZChQoAgRR8N0bfBcSgw/iGYEKa1WCwWDl3BOFVeCbwReCZwr1IqllIq6iJRUspVGFF5FXCZlPI3SqmuKdY/OXHnB8CPgX9TSg1JKZ8HrN7dwUqprwFfS/LuLsaEUhcCG4HrlVLPnaIdj4eNyf8rJoluAKSUKeD/MPl+31JKlaWUb8XkRU4HGxM7dudieBdwOiafckOS19jDTJx233LIMLfRR39kXEg2vKeXIeGwIZvh2jU3sXC4j+e/8O3QMQu0plALKKVcnrG5i6N7BxhqaWJHPkcKaBkYZlZXD24UEaR8uhvzPDi3k45N25hTKrGMhwAYpJ1u0UqTHiJHlRgYJkOIi/+u02i/8iXT0xkWy2GA9TAeejRiBp/sBJxkwMPxwC9hbLDHj4DPKqU+IqVMA9+XUp79GAdANGI8asNJzt1/766glPIJGG/dbZjcx2HGE4y+C/yXlPICTF5lDZPbt1Ip9dvHYNduSQb7XAdcJaV8p1Jqq5SyGZMT+oekWBroT8TiUZicweniKuBmKeVvgd9ivMYrgQ6l1M2Ya1DFDCJKJeHo5mmy1WLZJSNXmKlumt/Zw2ue8ya+cv13Oa5nK79cdgKn7ujh7wtm44cxQRzTlzeDetqHh8lGNSr4+NWQUlMOR8NaOqj5Pmr2kTxrw99IxSFVskT4NOsyRQoE+GiKMD/Lks0fns5Tt1gshyiH6qCXqfIdzACKtcBWzKjaW+r2fwkTWh0dAPI2zECJix9je/+O8WgOY7yFP9pD2QbMgJgejLh5JslAncTDeQbwQkzYux8zsGfpY7Rrb7wJeAC4SUo5DNyNGQiik5zAC4FPSilHMH123X6yY68ope4BnofJsdyOuX5XMx5y/jQwAGzDDJwpMSl1wGI5WBj4bDstJy3iRa/4MIOzT+JVazfy9wWz0UJQ81z+PKcD7ThoxyEWLq+45c9ccPONdFaH0a5LbqSCF5rBODvybVy36llsTs2nOOE7UkjcGrJQX8lCKxYtlgOEmPR36GMn7rZYDiz2A2d5BDfcOczXLt/OvJESXzxqKYFr0pXnjpR46VaTKZIbKXH0gw+zom8HRT/FmoVLyA+XyZRrBL5D4Hs0lCs8c+ufEHGOGhkqpFkQfgDHnWr6s8Vy2LFf1Fy3uGjCs75Tf/SQV40zPSRtsVgsBz1nHV+g+RMeb/pIF8dt72F9axN+HHPqzj60NtlQbhwxkG/g9nSGpv4KucEKw41ZMpUafi3Cr8XkK1UqToYIh6FZHRy97R3TfWoWy2HJTPQMWA/jbpBS/gYz3+AjUEpN8YdL9z1SylcDX93N7v+nlDqopoaRUq7BzHs4mY1KqaMPtD0HAfYDZ9kjp77mYSLPYXYQ0RnHxHFMLghIRbH5XRYdM2t7L7O396HjmPn9O0kFEbET0xj0svjXr6XpOaum+zQslkOF/eL52zHJwzhrBngYrWC0WA4s9gNnmRJ/uHEnqy99kK7WZgqlEnPKVSIhaCoNsfRtVV726hdOt4kWy0xgvwi5LvGRCc/62fqSQ14w2pC0xWKxHIQ848wOnnFmxyO2r169mqlPyWqxWCz7BisYLRaLxWKxWPYhdh5Gi8VisUw7az9Q5cMf/j1BLk3NhbdefiRLn9w53WZZLJYZjBWMFovFcijxqh00zGpnVnWAqF/Q15Dnd29QrO9s4O3fPJ75y5um20KLxWI9jBaLxWKZDmrlkF/NvpY1KxextLsfADfWbJjVilo2nxKC4Tc/wOU/OpbGluw0W2uxWGYaVjBaLBbLQcq9Z3yP8NZ19Hid7Ghspre9mSgUtPRVGC74bJzbzqbFc+mMYjRw/fIFvPwNa/nf7x1BYz413eZbLIctNofRYrFYLPuVrg/+ip6P30UrRRpdzSee/SLWzppFe7HEy371D45b1wOAH8T8UY6PohbA07bv4PrOdv7fq9ZQW1HgJ59aPk1nYbFYZhpWMFosFstBQBxF9HrvoMhsXLIMkKa7IcvLbv0nDZUqvz7hGBqL1bHyfhCxoKuH7o4WEAI3iljR3cf1HW3c2d6G6ItZ9e+b+dH72zh2SW4az8xiOfyYiRPu2om7LZYDi/3AWR7BVvEfaJqpkaNCDo0DQIpasmRunDI+/TQC0NuaZcecAgP5LEOFBpqLJdJByN/mz4Yo4ra5nZTSKfJhQDqMWfO1+dNzchbLwc1+iR1vFR+d8Kyfpy865GPU1sNosVgs00Ttro0Uj/84ObJExIRj8tDgUiPPEFXy1MiicUinaty1bD5RUjRbCxh0BOV0iqF8lidu3wHAkQODfPzU4+hubyAfhMx7xw4GPc3IlbMP9GlaLIcdNodxhiGlPA24RSk1LVdWSjkf2AwsUUptmA4bLCClDIGzlVI3TbctlplNdNdDlE67mHBY4JMmRUgjZRx6AE0zHsN00MVSXKos4i5cQmIE6zmegAIb5s5isClPw3ARAD+MeGh2J54QHLVpy1hbTbWAWZ5mU85nGJ/mOKaaTyM+UYVKANWQVCrm9gsLHDXbn6YesVgshwqHtWC0zGyklBuADymlrpluWyyPklIVLv0R7BiEdzwXjls8teNqAbzu86AehudLuOFuWLcDVs6BwZKpt1iBcgBhDK6AbBpGyhOSBSbnDYhdbAOISFGhGZ8iPkUEUKaRiAYEMRm6qdFKjEeGXlwC8kCRVirkybN5zA+hEXhAI32EZHEJcQkBcNDk6WeADnLlKuWGLE4c4wUhd89u5+F8hrm1kG2NBZpKZdOFKZ/tzQ1jto5kfBprIX3ZFLg+ZH1qKcExV8f4pRG06xBkXLJhzILeIba0Fqh5LqHjjJ99qM2iJ0CIsWCe0HrMo5KthVRj0FmPjCeIYnBdWN6o6R7RtOVgQbPDQAV2liHlwjHt0OALNHDBMQ6nL5h53hnL4cbMu4etYNwDUkpfKRVMtx0Wy2HHW78O377RLP/iH7D+y9AwhbkFX/9F+N+/mOXP/HJ8+7/W77p8qGG4/IjNu3rUT96mgRHmkaGfNMbbF+IR0YyReFCjgxqNpOnFwzxKRmhjBytxCGhn84QaYwSbOYoaOdIM08KmsXY9ItJUmL1jgNbOfoaaGyCGSDu0BCFDvseaOZ1oz6NtpEjouZy0tZe/LzK/AJMv1ejKpE1laQe0BkeQ7yrihjEAlcY05aYMD85pNYJw8tn7GioRBEBmPHyu68qWM76pWwjK0Wg/w919AhDsqMG9AxP78v6+0R6FHz4Qcf8FLgsbZ94L12I5lDkggjHx9HwDOAs4BVgPvBo4GvgY0AH8CHizUiqUUn4bOBtoxoRsL1VKXZfU9YbkmBOUUt1Syk7gDuDDSqlv7sWOFcDXgZOBdcC3J+2/KalrMXAm8HEp5TWJ7ScDKeAu4J1KqX9KKR2gF3iuUupWKeVS4GHgY0qpi5I67wUuVkr9UEo5G/ga8DRgB/DJSe17wAeA84EW4F/AO5RS90gp24BuYIFSapuU8kzgBuANSqlvJcf2As9QSt0mpdTAW4DXA6uANcD5Sqn799JHTweuB16X9PNs4CfAW4ErgZcCQ8B/KqV+WnfcC4EPA8uA7Zhrdm2yb/7u+jDZfzHwVODvwBuTKr+slPrInmxNjn0F8BFgPlACfquUOk9KuRpYCHxDSvkV4Fal1DOllAXgi8C5wDBw0d7a2JcMDw9TKBTs8t6W19QJqZ4hRh7eSsPxy/d+7N0bp3wtHi8aB42Hy/jI5YAM1OUhalzA5CKOUqIZgBifgBT+2D6HgDQ1zIjmKgW2sYoWtuEDBQKyPMztztGU8lnK+RzlfI5OV9C6fitzdw7Q05hnx5w2GsIQwpBz793AgsESN83rYEsqDTFQjSHngQYnjMfEIoBXCak2MUks1iEEOAKivYzd2t3xU6AcwroBzcJGMf33oV2e8cv7i5mYw+jsvcg+4zzgPzBC6E7gZ8AZwPHAscDzgZcnZf8MnIARjB8FrpZSHgWQiMI/ANdKKX3gOuAPUxCLHvBLjHDqxAifN++i6AXA54Gm5H8HuApYhBFP/wJ+mngfY+CPGHEL8Axg7ei6lHIecARG2AFcC0QYIXM6RhjW8x6MUDsnaesW4A9SykalVG/Sb7tsCzgV8zpQdfWdD7wEaMcI7y/sqY/qcIGnY67LkcCzgb8B/we0AZcB35JS5pLzfAbwTeCdQCvmWn9RSnl6Ut9u+7CuzdOBTcBczL3wASnlU/ZkZNL+94C3KKUKwFKMMEUpdW5S3xuVUg1KqWcmh30WWAEcBRwHvCA53wNC/UPKLu9h+fwzxrZxxjE0HLNkasde+GwOFA4xKYaoMW5DhiIxo0EJjccIEFOjcSyknWV4rHxc9509wKNIAZGEoQFKtFChnRjjXfWIGGp3GW4cDzWngpATH9rMrIFhjt7Uxey+QR5obeTz8ki+duIRbM1n6PXrPmqjYk8IYlcQeeOvgTCd2FM/e0b9cqzN8d4eXh1am3KPkWPa4ZTZ5mU77fehXZ7xy5apcyBD0l9TSt0HIKW8DuNhfKJSqggUE++eBK6dJP5+IKV8N0bA3JtsuxD4B3Ab4GMExt44FeM5fI9Sqgw8JKW8EuPxq+fHSqkkFkYJIzo2je6UUn4IeDtGdNyL8ca9AiNszwY+AXxKStmUrN+plOpNxOOZwHKl1CAwKKW8BPh9XduvBy4f9QJKKT+K8bg9F/h+0tbZwHeT/z8MfE5KKZL1PyYidpQrlFKbkrquBh5NLt8HlVIlYFNybfJKqV8ldX0X+HLSB3cC7wA+p5S6JTn2tsQz+zrgT4kNe+pDgAeVUl9Jlv8mpbwDcz/8ZS92BsAqKeUdSqk+jMjeJYlH+NUYj3BXsu19wIv21hmWA8yFz4YnrIDuQTjrWJMEN9XjjpoPN94DrzgN/vEQ/Ppf8LrT4baHoTEL922BUg0e2ApzmuGIeXDLffDQdmhIQTZNvKkHXTHCbbRljflGVk+aHcRkCPBwCAFNju0UaUnyD4sIYhxiAhxcYlKM0MxWYrzES2kCvg4OO5lPnkGcxNsYkGKEPPkk5F0lhR7yyZSrVPIZADKV6gSbbp3bxs0rFo6Fibc05cmHISPJmQg3Cf4GETiCYlMKvxqhXUGQcWkoVljc3U93Y57upjwI8GshEYLYEeALcDQiDkl5DnHskCVCo2nLC54/K+Rvm8Ft8jhpvsuWISik4FmL4a4uzYo2QXuDoBrC2gFoy8CCRkF7FnrLcPoCQT4187wzlsOLmTh/2oEUjNvrlktApJTaOWlbIXmpX4zxNs7G9HseE7YGQClVklJ+A/g0cEEibPbGfKB7UtldJTZtqF+RUrYn7Twd4/EcfWeM2nM98Nkk1HkGRjy9OFk+O9k/2j5AfcxscvsL6rcppeIknL+grq1vSylbgZWYUPGHMV7aszGisp76Pi8CU/1atatrM1RnV0lKSV19S4AzpJTvqjvGJRFvU+jDybZOyd7EjnOAdwH/I6VcB1w5mr6wCzqANBOv8W6S2yzTzsnLHttxTzvG/AEcOR9el3grzzllylXsyn8mmJor2oUk6GxI72K/e/c6Kse9l5g8ZVrwAIFgKQ+N5TrGCB7mKIZpISCNQ8hWOvErDsfctoGHjp1NkPaZs7EHL4gJUw63Lp3HTSsXTWgvFoJqyqMwVKGKQKQcqsMRW9+RZm6rj8kSmUzDpPXJZzGZ+lfJHsoes5dqLBbLQcuBDElPlVdivGovAVqUUs0YL9bYV04p5SqMqLwKuCzJDdwbW4HO0TBqwuJdlJvsRLgMmAOcqpRqZFy8CQCl1INAFyYc26WU2oYRds/A5GyOCsatyf/1T/PJ7W+u35aI58XJdjACrA2Tm3hLMiDneoyH7NS6tg40GzF5ms11fwWl1DnJ/j324eNBKXWTUur5mLD7pcA1UspRpTH5WvYANSb2+2IslgOMf+xSCvrH5PR3GCGDRieexvFb1kETJRK1Qo4ijQykcxQbPYTQiEhQyqX5x4o5RDWHQneNPj/ziE+Vj8YbKuNXq1Qvb6LysQL6koZELFoslv2BRkz4mwkcjKOkG4EQ2Ak4UsrzMR60X8JY3tqPgM8qpT4ipUwD35dSnq2UivZQ798wwuZyKeV7Mbly79pD+Xp7SkC/lLIBuHwXZa4H3g18K1m/ASNo0yReNqXUliS0+0kp5euBLI8ccHE18F4p5Z8wXrD3Ya7Rr5I6ylLKW5O2Ro+9AZPH15WI1+ngs5g8078Bt2KcKMcCQimlmFofPmqklLOA04DrlVKDUsqBZNfofdCFCXsDoJSKknSIS6SU9wBlTAqBxTJtdOovEQyOMNj8XlwaaWInAqiQoT6wVRUulYIPAqKMS8fOfobyaTYtmceGpQspjJQ58Z9r+eWTVjKS8kHDiTt2Ugti3vKyFi48q2XaztFisRz6HIwexu9gRsuuxXjljmJiXtqXMKOFL0nW34bxul28p0qVUiEm1/G45Pif8sj8xV1xEWaQTC9mdO+tjAuSUa7HiKI/JOt3AxXMyNz6OTtehRGRm5Nz+u6keq7AhJV/jxlFfSbwTKXUUF2ZyW3dBOSYPu8iSqnfA2/C2N+DCS9/hvG41lT68LHgYLytG6SUw5h747y6SdAvBV4jpeyXUv4m2fYOTBj6fsx1Wr2PbLFYHjN+UwPt+ir6cOliAb3MZhsLcYiAmBjoKjQa76EYn+/wiIe3MmfADKIZbshSaWng3X+8ncWDwzQFVV50tMs9X13IhWfZJH+L5UAyEz2M9rekLZYDi/3AWfbKDYs+g7fDobEakqdExc1Qynhszs1G1E1ZE7qC/sY8vzrtBACeqh7k1qWzeXh2Izdd1kF7095yDy2Ww579ouY2iMsmPOsX6/cf8qrxYAxJWywWy2HNWRv/c8L6yI4h/jT/OhwvYPPsNuYODKMFaEeQrgZ09A6Rq1TZ3pQljmrcc9X83dRssVgsj40ZJRiTsONTd7VPKTV52N9hi5RyZDe7blFKPeeAGrMXpJQfwExmviueUzeVj8UyY2mY1cg5wZv5asfVDDYXWLegg+Mf3kquEpAfCThlzTp2NuXZ1JFn9c9PmG5zLRbLDAlD12ND0hbLgcV+4CyPi6tf9z3u6TuaIJPBqwUMBwGDKY9V5V4u+f1Z022exXKosZ9C0p+YFJL+70NeQc4oD6PFYrHMdNr+rZnToy2s+0E7m3dUecdFyzj6GQun2yyLxVLHTPQMWMFosVgshxjCFbzzB0+ebjMsFsthhBWMFovFYrFYLPuQmTKVTj1WMFosFstBypvPvY1ZGwY4uruPwnCVsufxa7mYphNLnHvudFtnsVgOJw7GibstFovlsOd9L7qFtr4yS4eGiV3B9lkFbjp1JU96eCcdv6zy6zfcPN0mWiyW3TATJ+62HkaLxWI5yLjusjWkhzzaioP846gl7GhrYnbPIEev3cTDs1p5wr1bGPzZEHxzui21WCyHC9bDaLFYLAcRtVrEn28cJh1HbJ7VxoZ5nZQzadbP72T93A7SRPzx5OXMHRnm+7Ounm5zLRbLLpiJHkYrGC0Wi+Ug4sWveQA37fNQRzO3rJjHnMEhlu/spalc5mfyCPpyaXoac5SzaZ7QvZmlb3iY9Wt6pttsi8Uyw7GC0WKxWA4STnvlfayd1ULrcJlrT15JJgpZ2tvPrOERjuzqZjDlEboxH/7l72iulfhT+0peuGY933n1Lfw2/+npNt9isSToSX8zAZvDaLFYLAcBbz/rzyxvauSFt97DzoYMoevQMVIe2+9qaCtXOP2hjThAa6XMMZVeGoKIz7zgVJ6wfYA/tXwRLWosygyweNtHp+9kLBbLjMMKRovFYplGvvDl+3lwdZGmdIamSo0gn2b5lp0cuXknd85t4/htvXha05tJsWpTF0P5DF86+wmcee865m4rMnuwSCkKObp7IyDQjsarjbAt+05Koc8/FszitCufxYIXHTvdp2qxHEbMjLzFeg7r35KWUp4G3KKUmpYrK6WcD2wGliilNkyHDfsDKeWHgLOVUk+fblsOQg7fD9whQBxr4hg8b/yREEaaINQMlyMasw7lSkw27dDbG9DYloJaRKWmqVYjhosB4XDM5sGInd1FNuwMKW0eYeemGr2Bg44d5hXLjKR8Fu0YpgEoZXzKrQWEMG02DA2zYEMXkRBsam8ig6antYmvnXQEkedQKWQAyNQCvv2Zn/PPeZ1U8/C2W/+JICJNQAvdpKlQdh28KGRYNLO+pYW55R46ywMEpIlxyNGLBtY1d0JQZUGxhk+Z/pRHtlYhl/RBhMlf0pjXoAOEQAxkXSjNayG9aDZOIQXz24m7BxFLZ+EcOw8am4hntyKWdSL6hiHjo2MBs5sRUQzVGggBTXmo1MBzIZt+dBeuXH30x1gshv3y/n9IfGrCs36FfvchryCth9EyZaSU5wMfUkotn25bLJZ9zd13l/jcF7qp1TSvfEUrz3l2E9feGXL+T6q4cYxXrPGsviEKUUzREWzIZUEIjt/axXFbuwiFIBWEXHHOk9ja3MDZ60qs7KsSiBT3d3SiFrQSO3D+P9fRgKB/UY6WjdtIBQ7N23oZaClQyaUpNuRZ39nCku5+5vUP890zT2TlcI1XrFnPn5bO5qFEMFZSPu9+3VkcvaWLL/7wN2So4hAj0AzRTis7yEQxXcynrLMc37cJB42DJsNOSrQT0kiWPo4Y2EaAQ+R6pKKQWbVwQt/s6kXhknz7iSC7qR+xqR+SbW5dOc242Kx/gw7RTpZhUlQfWflxi+D6i6Gjac8XrXcYnnkJ/GsdnHks/OqDkEnt+RiL5QAwU0ZG12MHvewBKaU/3TZYLJYDw7XX9VGpGA/jdd/vo1KJecvqGi6aaiXi6GKFQhQDkI81+ShGC8Fdc2dTcR0yQci6jma6G/PMGamysm8EAF9rNrXmCDyHRf1F/ORFErsugetxxIbtLNjczVFr1pOq1FibTfOxp53CW19wBm95yVncumwuXhjhpnzOumsdIjayK1MN2NlW4A9yFZ6okSLAI8IhJsSli9mEuPTRyjy24SRyLSaHxiXFCCFZwLhYUsRko9qj6jMx6f/Jy5PL1P810rNrsQhw10b4/K/2bsCXf2vEIsCNd8N1t0zNcIvF8qg5IB5GKeUG4BvAWcApwHrg1cDRwMeADuBHwJuVUqGU8tvA2UAzJmR7qVLquqSuNyTHnKCU6pZSdgJ3AB9WSu1xGlsp5Qrg68DJwDrg25P235TUtRg4E/i4lPKaxPaTgRRwF/BOpdQ/pZQO0As8Vyl1q5RyKfAw8DGl1EVJnfcCFyulfiilnA18DXgasAP45KT2PeADwPlAC/Av4B1KqXuklG1AN7BAKbVNSnkmcAPwBqXUt5Jje4FnKKVuk1Jq4C3A64FVwBrgfKXU/Xvpo5bExjMx98cW4M2YCNRXgJSUciQp/jyl1E1SyucCVwALgZuAtXtqo66ti4GnAgq4APMF5n+An2CuzSnAg8BrlFL31fXRe5M+6kzO6x1KKZXsPwv4OLAysfkG4O1Kqe5k/03APzHX+JlJn75LKfXzqdj8eBkeHqZQKNjlg3DZT41LHc8TOA5kXM3osJNokhLSybqjY0TiOktFEY7WhM7Ewn4iNEdSLmhtQrBA01BxrIwbxTzprvv47ZlPBKCU8iGGo7b20T48wtn3/538poilGwZ5eF4L8v5tfOl5J3PHkXP5yxGLeMb9DwFGjIV4xLh0MZ88xQkiblQ2RqTxKTKdjIa4d0kuvfdrl53oTSyLOJHAB899ZZcP7uX9hfUwPj7OA/4DI4TuBH4GnAEcDxwLPB94eVL2z8AJGMH4UeBqKeVRAIko/ANwbeIBvA74wxTEogf8EiMwOoGXYoTQZC4APg80Jf87wFXAImA2RsT9VErpK6Vi4I8YcQvwDIxYOjtpcx5wBEa0AFyLSQdaCJyOET31vAd4HXBO0tYtwB+klI1Kqd6k33bZFnAqJqVI1dV3PvASoB0jvL+wpz6qsyGXnG8z8CJgi1Lqr5j+WqeUakj+bpJSLgN+ihFpzUmfvWkK7YxyOvBQcr6vwQjPb2LEbitwX1LnKJcALwCeDbQB3wJ+mwhdgCrwVsyXkGOBucDnJrV5HnAl5hp/EfiOlDLHAaD+IWWXD67lN17QzsKFKTraPS58cweplMMPXpGhMycopB3uLmTZnvIoOYIB1zEh6Cji2G07CH2X3lyGWcNllu3op+h7/Gt2MxXHoew6LOop0VasUvU8ykKTLVdoGRga8xYCOHHM8h07WDg4PLbNj2NO7B6iu6mR3xzzZNJOjePWd/OiPz/A3L4RTt3cxUU//y1tlX5GpWCIS5w82mM8OtlGhRzhmP9RE5FCAGmKE0LFe5oKRE9afrx//cyhxqS8Q4ERgS9+IrzjeXu/dv/xbHjZk2FeK/y/Z5I976wpXWu7bJctj54DmcP4tTov0XUYD+MTlVJFoJh4fiRw7STx9wMp5buBpwP3JtsuBP4B3Ab4GLG5N07FeJXeo5QqAw9JKa/EeNPq+bFS6sZkuQRsSv5IbP8Q8HZgRWLP9cArMML2bOATwKeklE3J+p1Kqd5EPJ4JLFdKDQKDUspLgN/Xtf164PJRL6CU8qPAG4HnAt9P2job+G7y/4eBz0kpRbL+x0TEjnKFUmpTUtfVwDVT6KcaRogdAdyulHpwL+VfAdymlBqt+/dSyv8D5k2hLYAHlVLfSJZ/I6XsBX436V65NlkWmL5/rlIqiUPxTSnlOzF9dI1S6s91dXdJKT+JEZX1/K9S6takzq8Bn8ZczzunaLNlBrJoUZqPXzrxtn36EpfN/52v29K6iyPnTlj7z7GlLDBnbK1aDRjqq/D5a1z+8Tdor8X867ilHN/Vw3FbdrCqayfdzQVW1AJO276TwZTPWVt30F4uM5RKMYLH7446jrimmT9coWt+K61pn6ff2c2q7h4K9BPg0cVc3MS74VAjQ5kR1+G+prmk4xKVbJkV24cRuOzwW7l3/hwCQs5afy9VYiI8UkRU0WSBDOA0+egTliJOXwUvfhJi6RxoyIPz2H0Ou+rJR002Df/77n1Rk8WyT5mJoxsPpGDcXrdcAiKl1M5J2wpJmPdijLdxNqbf8xiPEQBK/X/27jtOjrJ+4PhnZrbfXm+55NJ7T+AJRao0QYgiWGgiAjZUUCz4EwVFRIoiNmz0oihFERUNSO88EBIgvVySS+5y/W7vbuvM8/tj5u72LpfkAkmu5Hm/Xns3OzP7zDNbZr/7fZ5nRnYKIW7D/aK/UErZOYDtVwJ1fdbd2M96Vdl3hBAl3naOxc2gdQVkXfV5ErhFCJGLmzG9DDjDmz7BW961fYBNu9j+2Ox5UkrHa84fm7WtO4UQRbhNrg/jBo3zvW39uU952c95BzCQn1U34QbhdwMVQoh/At+WUm7fyfqV9HnOvH0YaMBY0+d+Jzu+V7rqXQJEgce8Jvcufq8eCCEOxs12zsfNlBreY/rdppSyQwgBA3tuNO09Cwb9lFb4+dG3er/VOuIpPv3Z9UScWUxuaSdiO3xk4xaSloXPAAyDwnSaMS2NBNIZAskMqYiPYDIOKofWUJhOciikkY6An+L0ZpJGDqvKynlrzFgOTYc5ctnlFPdTp3x6Di5Ad3Mu7PiBGHkNbJqm7YmhOOjlbNys2plAoZSyADfz0328EkLMwA0qbwV+4vUN3J2tQFmfpscJ/azn9Ln/E9w0waFSyjx6jq8GgJeBqwW+BtRKKbfhBnYn4vbZ7AoYt3r/x+9i+1uy53nB8wRvPrhN1MW4zbXPSynTXvkfw82gPsn7JKXskFJeKaWcg9vHdAxuEAk7Pjfg7lff/eh7f29pwA18T5BSFmTdcqSU13vrPIDbbWCa93qdvY/qoml7RU44wCMPzCQUa8Hf1IaTsXGAYDrdaz3b5/6+T4V8BBNJSutbGLN5O9HmThxLsTVcxLv5Y1mpSimSl3B8zeV8Q57PkcsuH4S90rQDm76W9P6RhztYoR4whRAX4maLAPACvgeBW6SUX8btl/hnIYTVX2FZXsHN7t0ghAh7fe8GciTNw81yNQshosAN/azzJPBN3L6V4PZZPA+31eV5ACllNe6AkBuFEHlCiHLgqj7l3AV8WwgxTQgRAK7EzQL/yysjDrzUz7a+hhus7q75eLeEEIuFEDO957MdSOD2uwQ3MC4TQuRlPeQB4FAhxNlCCJ8Q4gTg9Pdbj/5IKRVuf8SfegOYEEJEhRAfEkJ0tQvmAa1ATAgxDvjOvqiLpu1ttz1+BK0+H03hMJvz8wi0JzEc9zea4TgEEt4IZqUwvPPnFjW0kcHgX1Onsm1MCSfWXcpR6mrCC8fvbDOapmnvyVAMGO8GXsUd0LEVmIUXdHl+gzuy9Yfe/a/iZt1+sKtCpZQZ3L6O87zHP8KO/Rf7cxXuIJlG3BHSL9ETQHV5EjdQ6Qri3sYNtF7ygrwu5wBB3Izh87h9EbPdhNusvAR3FPVxwElSyrZdbOsZ3KbX951d9EwGHgPacJua48AV3rKnve1uFEK0CCGOkVKuwx1AdBXQgtuF6zb2nauBR4FHhRBtuANmvkjPe/nzuBnqGO5r/OA+rIum7VU3vfJB8hpbqMmLUtzYwSGvrWPq6q0seGMDeS1xfCmbjGNgKkApWn0BHlw0g8tWnMFRay8b7OprmuYZiRnGA/pKL5o2CPQHTtut7yx6gnEtnSxYV4uJ2xeknSAZy+IvnzyUSHOMaFM7kWScH7518mBXV9OGs30Sza0wbul1rJ+lvjbso8ahmGHUNE07oH35wUXUlBdw3ymH0hiM0EEQMMj4Tb747/8xbdNmTJXWwaKmDVG7OkXVcDWiLg0ohHgc90TQO5BS9h0pe8DKOvF2X89LKU/Zi9s5Cnh8J4uvk1Jet7e2pWkjydgJBZx+0wxuubmZv354EUe8vo7S1jZmxGpIOwZVJUV8576Fg11NTdMOILpJWtP2L/2B0wZsyd+38PCt23l55lgsJ8MRK6tIOnDceXWcfeHHBrt6mjYS7JOm4neMX/Q61s9Rlw37JukRlWHUNE0bSU46fSwnnZ59psQxPPbYY+hDt6Zp+5s+6miapmmapu1FI2VkdDYdMGqapg1hj026nfY2Pxkjw+SJNnx/INcp0DRN27v0KGlN07Qh6q/Fd/KPymmsGFNMS0Euf3UmEvr4u4NdLU3TdkOPktY0TdP2i+fMn1Jm5PNxuZ6U5SfgpDl+YxXVuTk0PR6DxYNdQ03TDiQ6w6hpmjYEGb4QjmnRWJTHigVjqS0tYlNoFClfPpV/bR7s6mmatgsj8UovOsOoaZo2xFR94a8k/GF8Sdg6vpjKjU2M2toCgNHh0DiqcHArqGnaAUdnGDVN04aYmgc3sXThFJJhPxgQ6UiigFTQJB7x4zdTfOP45we7mpqm7cRIzDDqgFHTNG0Ied24kafGzeSNglySeZ2MramlsSxKKmiSjPhIBy2MTh9Ta1r57IdfGezqapp2gNBN0pqmaUPEOuNyHp9zHFd/6GgAytqa+MorkuXF44lH/ViOYv2UCraPKiSaaMMf8vN/J79KbW4Ob0RyeOoXYygpCAzyXmiaNlJGRmfTlwY8gAghKoEtwEQpZdUgV2dIEUKsA66VUt61jzelP3DaDtYalxLAh0WI++fMZVJdivx4ihmxOnzYxAizyVfKtsoC3l44uftx5S21/GnuHHLSGeY0xGgKBlhRlEt9TpBUMkM0Y9Pmt4jhMDZqcPEHAnzvhFxMUzcuaZpnn7QXLzV+3etYv1B9Zdi3S+sM4wghhFDAUVLKFwa7LkOJEOIZ4Ekp5bWDXRdt6PvfyhSram1OnRdgQrHVPd/e3k7nAyswO9rJPLqczkYHNXkM0TKbwLZa7JwAL3WWUtsRoWB9PROb6mjOCREItjGpYTsJlYufFD5/Gl/appliLBx8gIXDaFIkSRFhO2e8U4iB+8uimShFxMglzvzMCmJqbq/6vjtqLFWFuVzw9kYsBdFMnE7TxLZhc2EO200TK56CiJ8tET9XS8XVb2bAUZB23K2EfWAY0JU8MLzvNdX9Z+AU/X/9miY4CsuAoE+RyoBpGIQDBoUhd9O+tI0fRTM+TAuSGQj54JojDIrD8PWnFXkB+NvpJu/WKdY1Kz4+w6K6A17epjh+nMH8sh03vrpJ8a8NioVl8MFxJhtbFH9fp5hZDCdP1IGztm+MlH6L2XTAqGmaBvzptQSX3N8BwM1PxHn5OwWU5Zk4nWnqjrgb1tdRShURHHKB+vX1tBKmjE3Y5FNptpOxxgB+6oxSRNubRKhjFYeSJgTA6HQVLeTRQBl5xLGwmcQ7+EkTJkMz5Zg4BElioEhiel88Gd6cMJPq4nJy2ttoj+aRskzaAyEmNbdjZcV1ORmbuGmRNC0c2yETCkDKgXgciiNgK+jMuMFdrt8N5gAw+gR7CoysgEqpnmDyvTAMbAM6bS8cTjqkbJPWVFeAavXzGLh4Se+gdcptDiphA/Djl2xaHAtbucHla+dazC3tqWNVq+KQ+2zaUu6u3XEyfPtZh/q4u/zOk+GCOTpo1LSB0AHjMCOEuBT4OlACtAF3A6d6i5cIIRzgASnlxUKIUcAfgGOA7cCNA9zGBGAjcAFwBTAeeBY417t/IeAAP5JS/ibrcUcBPwFmAc3ArcDNUkolhIgA9wEfACLAOuAKKeUT3mMvAL4H/BL4NpAD/BW4REpp76a+JwA3AZOBFPCWlPIEIcSvgaOAw4UQ3wG2SimnCyH8wA3Aed5+/Hwgz4s2sj29Kt093dihWFad4cRZAez1zdjrmwkTx8IB3OAjTAdx8kgTBgxajNzuxyeNAEnDxFKR7mARIEY+rRRgorBQ+MjgJ42NH5sAYVpJUkiADADFtFJDISunz2LF5PGEEkkCaZvGYICE3084Y5OTUdTkhKjoSJAxYGNOBMcAxwAsLxjyW2A7kLbd2ivcIY++rGCpbyzYNzh8P8FiX4bh3hwF1p6Vq4CuFGxj0uj+Fktk4NktqlfA+EqNoi3V87iH1/QEiwD/rVJcMOf97Iim7czIyzDqn1bDiBBiGnA9cJqUMheYDfxDSjnfW+UkKWVUSnmxd/9+wAbGAUfjBoB74kzgSO/xE4BXgfXAaOCzwC1CiHFe3WYB/8YN3Epxg9ivAJ/2yjKBR4CpQDHwZ+BhIURp1vbGA+W4gd8i4BPAWQOo5z24gWY+MAa4FkBK+RXgedzANiqlnO6t/x3gNNzgdaK3b+MH9Iy8T7FYTE8P0ekjp/i77xdEDOaO8RGLxbAmFWCNyyNFCCfrkJkggkkGP24Ekq/au5f5VZqQsgnRiZ9E9/xcWsmhHQcDG4MMfjqJ4uAjTR4+TAwvKAXwY9NBEMeviMTj5LfFiHbEGdUaI2o7BJViWksHL48r5YE547l3xng2R4KU2hmsnfVPt7xMooObbezSd/W+j9+b/d2Vcm/me/xS9apSEHBPWgLgN2FBYWf3KrFYjEWjDHJ6XlYWTzYoCPbsx+GlyV7r6+kDb1obOD3oZRgRQkwC3gU+A/xbStmetaxXH0YhxBigGpgipVzvzTsRWMJuBr1kZRgPkVK+7s27EThVSjk7a7064HNSyke9bF5ESnlh1vJvAKdIKU/YyXYagPOllP/2Moy/BAq7MopCiAeBainl13fzvFThZi9/LaWs7bPsGfr0YRRCrAWul1Le7t3Pwc2Ifl4PejmwPbYsyZrtNh+ZH2RqeU8Taaa6jc5738ZqbSX9r7dJNIE9cTTRogzB+u1kgn5etEexPRahqLqFCS21NEcjhPwtTGx0+zD6SKPCCpWGlkwZoIiQIkiaHFqxsACDLVRQQhsAbeTQSJjp5gYeGX88xfUdOKbBitljWDdxTHf9np5QysbCHAobO5jeFGNtYS7TWztYVphLh8/LLjoO/rCPdMDnBmtJ283yhX30vC2N7uydq5+3a3cfxz14K3t9GA0D/KYikwHTNAj4DXL9gKGw0g4+FDHDh2G41Qv54LuHGZSF4VvPKnID8OjpJm/XKdY1Kc6abbEppnhxK5w4weDQih0D0OX1isfWu30YPzzJZHWT4qE1iplFcMY0nTPR9k0q8A3jt70+IAerLw37lKNukh5GpJQbhBDnAl8CbhNCLAeukVIu6Wf1Su//pqx5G/dwkzVZ05197nfN62qHmwgcJ4Q4I2u5iTsqGyFEGDf7+GHc5nTHe2x2hrGuT/NzR1b5u/JR4LvA20KIeuAPUspbdrF+JVDVdUdK2eEFv9oBbvH8YL/zfZV55P3fEe6d6z/c7zof2oPtjM6aznSkeCt6HeOpwyRMrVFMm8rFxKGDIAt5m6QRoLje7V9pOorJ62rZUFmO7fdRGwrQ4reY0BAj6ThU5wcpiMd5NTeMg4OVTBHIKBKmItey+dvpNkfPGMjHamg5b3bP9MySnulJhQYfHLfzx80rNZiX1Uw9vcjgysOG/Xe3pu13OmAcZqSUjwCPCCECwBeBR4UQxeyYCtjq/R+P24wMbtPrvrIJuENK+eWdLL8ct1n8eKDK69fYwF74dSelXAZ8Sghh4DahLxFCLJdSPgVZ7Xs9tpL1XHgZxtJ+1tO0fc6XE0CoHwDwlvE94j4fyoYCp5XZVBEgw5qCSlSy58NiOAo71sGGihLGtHXwqTdq2OaDyy+v5Jijxux0W5qm7R8jsSlJB4zDiBBiOm4m7zkgDrTivi8doBa3f+ALAFLKaq859kYhxGeBMHDVPqzercCzQoj/AP/x6jUNKJVSPgvkAUmgEQgIIa4ACt7vRr3A+WzgX1LKBiFEM17vLG+VWmBKn4fdC3zLe3624Q4G0m1T2qBboK6lxfolKX+UGn8pealWaqNRnp+2gIKadvJbkjiWQWNRiKZQgA+8u4JrXz4Z8732BdQ0TRsg/SU5vARwg74aoAW4FDhTSpkArgSuEUI0CyF+761/DhDEbRZ+HndwyD4hpXwHdyDJ17z61QF30ZO5u9mr8zbcjGcnWc3C79OngFVCiHbgH8DVXpAK7ghoIYRoEUK86837CfBf4BXcZvrN9G6617RBc6x9KfOTr7OwfS3/nXcE/5p7PKlAmIbRhVRNLWXTlBLai6IcsWkr1716ig4WNW0IGonXktaDXjRt/9IfOG23XjjuPiY+/Q6PH3QEjbkF3fMrGhpp84cpqG/knM1n62BR096/ffIhet34Xa9j/SL1xWH/YdUZRk3TtCHmyKfOo4lS5m3a2D0aOZhKs2jNSg5+dy05iZQOFjVtCFN9biOB7sN4gPKaZ/s79+Cm7FPnDAXeyPDf72TxF6SU9+/P+mja/tBk2IxuTHLq0ufZljOW8qYmiuxa6vP81F5QPtjV0zTtAKObpDVt/9IfOG3AnojcxGirjUntWwDoMPO4a+KhTP95HosXLx7k2mnaiLBPUvWvGL/vdaw/TH1h2DcJ6AyjpmnaEHVi57dYUngTHflzsFWKVdMnM/37kcGulqZpByAdMGqapg1hJzV/q3v6cOCxxx4bvMpomjYgI2VkdDY96EXTNE3TNE3bJZ1h1DRNG8KSnUleKPkD5elWUqaBP1jGptJiLv7Nq3ztpmnMmVs42FXUNK2PkdhZXQeMmqZpQ9SjJX+gOZzPIakEOTZ0EgDDT2lznBOXrefqa3M59sgGvvrVqYNdVU3TRjgdMGqapg1B7bVt1EaK+MCWzWSCFpvCJeR1JomoJJ0EMDLwmX+/SWKJxcxXLea2NPHHB+aQHw0NdtU17YCn+zBqmqZp+5xSiuWT7gCfSXskgKycgBG3iDth/CmD3M4Uhc0pctvTlLYkuP7vr9Cen88XL1jHvIvXDXb1NU0bgXTAqGmaNsSsMr9LudXCcRtX05ibSzCVwWf39Iry2zam03M/J55iS36Uv0way9ZIHtM/t2Uwqq1pmmckXktaB4yapmlDyErzCiaxnUnt7zAFyayWFcSDfjJWz5dOR9DH8oll3fffmjWWiYk081pijI11UB+NMOpr2wej+pqmjVC6D6OmadoQEN9QwxsL7maR2oqJg4EDwMTkWubUVpAKheg0fGwrzOfhw+bw6KwJVDbG8DmKcekUebZitKMIOTCpvoWnCnKJXLadzl/oywhq2v6mR0lrmqZpe1XHf9+k9sN3kuOECOYX0soocqnD372GQWF7HJO0u35ugKqSAjAMqkvyAJhcXY9tug1GiYCfCS0xTmyL8XZhHuO+2Uijcqi5toC8sH+H7Wuapg2EDhi1A5oQohLYAkyUUlYNcnW0ESrV2olv9Ra2HX89ZlKRk1aYGDwxaTobikr5aNQh2l5HZbuNQ5BmxmKwCYsM9YzHyDpUT6xv5OR31lITmU1dbg6BjE1+MkU8GATczMaDsytpiIZ7KqAU+T+3IZXCn8kQiSVozfEzOqx49Kwws8f5CQd1MKlpe8tI6beYTQeM2oglhFDAUVLKFwa7LtowsKUBLvgVbG2C73wM1mzD/uk/+MriC3hyylyu+c8DnLX8ZRRgQPf/LjbQHsrFdDLkpuJAT7NUVyg2BnC7jge4fd6hfO6UCwH46aEf4p07rqQ8voV2RtNOPjXMIo2PbeFC8tNxopkkAI05OeQnUvzfk6+yqSCPYNBPAFhVVkLc7+PtigIacrxT62QcSNpgGBA0IWyRbnVoy41g+Cy2+X0s+rvhVjSThFQGwwAVCdC9A/187wXTGXKSaWZsqactFOCdCeXuikqBmfUAA46tNNjQClti4DfhhqNN3q5zuOtdBQZ8aYHBr0/wcfvbDje97jA21+DW4w2+/6LizTrFJ6cbXHuktdOX7fsv2PxlteKgMoPbP2SSExh5X9SaNhTogFHTNA3g63fAU2+70xffCrbDPeJYfnf4SUQTcT61/BUMeuKnvmGJDyhIxHrFWP2HLg6KBEsmzumesz1awFtl4zh+0woS5GATxIci6U/RGsyhLRCmMNmBMgy25BdQU5zPlK11TG9opqkwn0wowOzt9dwzayKbQkGwHbBMiNveFhQk3T6RBCxUyoawz12nq6J+ExwfynHcALPrccaOe5EM+EkG/Lw0azwXP/EG70wc5a6n2GH9Z6p7plMOfP0p213PG8Tzm6WKs2bYfH6JwlGwuklxxqOKdxrdx/z4FcXRlQ4nTdhxjOYTVQ7XvuKG5WubFTOLFVd/QAeM2uDTGUbtPRNCVAG3AccDi4CNwLnAbOBHQCnwIPBFKWVGCDEOuBk4Evfw+hjwDSllzCvvOuAsoAzYDvxKSnmLt2yCV/75wP8BY4GXgc9IKWt2U88LgO8BvwG+AeQDvwd+AvwBOBHYBlycnbkTQnwOuMzb1gbgCinlEm/ZfOCX3r5awCvAV6SU673ld3nzE8AngA7gGinl7wfwvF4KfB0oAdqAu6WU3xVCLPNWWSKEcIAHpJQXCyFGeftxjPe83bi7bexNsViM3NxcPT0Up1s7e14o2w2uWkMRAIJ2GnOA3dgH+jVx7OaVPDjjEACKO2PMra8mSQEpepqSfbaF4diASVMwStWkcjaOKcF2HJaNr2BufT3by4rBMKgL+NkQyYGEjRFXqFCfrJyTlf3zW/3XVNEnQ7j7vclYJoZSKMMY0PpuudnTBhsbEjgq2D2rPd179dZk/69da7L3evWxFBDqtY6e1tO7mtYGTp9WZ//6DHAJUAgsA/4GfBCYD8wFPgJ8SggRAp4CVgATgVlAJfCLrLJW4AaTucDngJ8IIT7UZ3ufAo7GbQnLAa4ZYD3HAwXAJG8bXwUeB27y6v4IcGfXyl6weAVuAFwIXAk8IoSY4q2igB949ZgAtAP39dnmx3GD4iJve78WQozfVSWFENOA64HTpJS5uAHpPwCklPO91U6SUkallBd79+/HbT0ch/vcXLDbZ2Mvyj5I6ekhNv3Ds6Agx53xpQ/BkTO4QD7DQdUbaMzJ4z/T5tGX6vPfBuJWYIfl2fcVFgoflyx9iof+9it+/OyDPHvfTUQ6c0lRiEWqe/2Ak6SorZOCtgQGJjUVRUzZvJW5VdUs2lBN2vR1B2llqTQlCTeCUoZBTksc0nbPxruCNEeBA6QdtwkZ3P9pBxybQCrTe34/05btljulppGqwlw3WAS3CVxl7bVSFAZ7f9F8fLrBjAK611tQCp9ekMPn57llFIXgluNMJuW76x8/zuCjU4x+X7uPTDE4Ybz7uEn58O3Dgzuso6f19K6m9xXV5zYS6Azj/vUHKeVKACHEn3ADrMOklB1AhxDiGUAAScCQUl7lPS4uhPg+8JIQ4nNSSltKmR1wPSWE+Bdu9vK/WfN/KKVsyNrexQxM3HusAyzzsnWvSylf8cq6D/g/IUS+lLIVN7N4jZSyK6v3byHE07gZ0GullMuzyk4KIX4IvC2EiEgpu9I6T0kp/+FNPyKEaAEWAJt2Uc8M7tfgbCHEJillC272sl9CiDHAccAUr96tXl2WDORJ0Ua4D8yA7XdARxIKowAUbG9GNnfS1LmNotMuhqYYqrWD5nfrKJhfQeLlddirthLJ9dNS3cnqNkWosYnpK9dgA02GD8MMU2jH8AMZTHz48JMig5+F2zfxoTXvUs0sAqwB4LZFJ/GZ1yUAjeTjeIfpgtZOyupa8GV6gkAz7WZCbeCp4gLSNuR0JvH5TPJshw7bAcugLJmmOeQn7TMJZGx8SpEyMpjNGTAUKb9JcTxJzO8Hv0GoJYHlM4mGwOeziOQEmJBnMrXEoCyiGJtjUNOUgtk5FBcVcHOZgz9qEbR8lIcdHlwDE3JhdK7BzFIfHSlFfdwhZBmMirrh48ZmGwyYWOBmQn9/ksX1Ryty/BCwDE6bZNCShOLwzrOWAcvgiU9YNMYVBUGwzIHmdzVN21M6YNy/spuDOwFbSlnfZ14ublZxnBc0ZVPAKGCr1xT7OdzMowGEgT/tYnsdXtkDUecFi9n16lt3vPJavfr+Rgjxy6x1fEA1gBBiMm528lDvMV0/uErpCQj7NpXvtr5Syg1CiHOBLwG3CSGW4wauOwsAK73/2UHoxl1tQzvABPzurUt5IUZ5IcVZqxhA0SnudOTEhd3zi4EP9CkubzebG792K03TLqOYaurM0fxj4QLeGj2eL/AMOTTSxvRe66cCfgJJE5/XZJ4J+PCn06zJi7It5GbXfI6ivCPJ9kgQ0zCY3dBKrc9idk6KpVeVQVaT9/sT2Ml8k4vm956TEzDICfRuIp9YuONAlsJQT8BnmQbFA6zqroJKTRsMug+jtr9sAtZIKWf3t1AIcQRwA25G8VUppS2EeIiBd5/a2zYBV0spH9zJ8t/h9nucJ6VsFELMAd5mL9RXSvkIbkYyAHwReFQIUexlLvu2BGz1/o8H1nvTE95vHTTtvbKmjqFUPQTA6jHf49C12zhuxbu0MBqbAIU083RFlOJYmlhhhObiXNrzwkTb2nFMg2Q0gi+dwvH1PpTXBX3kpNNYps1nTwvx9VOLBmP3NE0bQXTAODT9E/ixEOK7wK9w+/yNBg6RUv4NN3FhA/WAEkKcCpyCO2hmMPwc+IEQYi1u38wQcDDQIKVc5dV3LdAihChh4H0pd0kIMR03u/kcbjN6K26Q2JUdrQWmAi8ASCmrvWb/G4UQn8VNtVyFpg0B07deC8DTkVsoN1dyy0Gn8u+Z0/DFDb74zHKi7UnGbKsHR1HU0Ioy4J1Jo/nnzMkc1hKjLp6gKhQkZZmYfoNY2qbtxuLdbFXTtH1hpPRbzKYHvQxBXnbsONzBLqtwA6H/4fbpA7ef4j3Aa0AD7oCRv+33inqklH/EHW18J9AMbAa+T8/p574OHIU7ivl53IB4bwjgBnw1QAtwKXCmlDLhLb8SuEYI0SyE6BpxfQ4QxD1Z9/O4z6OmDRkf7PwaTU4OJbUZGv05XP3IS1Q2xMhtSzB9ZTXF9S0YgKmgrK6F8W0xYo5DfcBPKJMhGvUTUg5tPy/b7bY0TdMGylBqJMbBmjZk6Q+ctluZbc0sH3M7bRQCBsmgRdXkQhzTILc10d2XozEapnV0MbfPn8K0ulZCaZtN+RGW/X7sYFZf04aTfdKV63/GXb2O9cerC4Z9p0adYdQ0TRtifKMLqbj+IGrLAihT0VoYwrFMMAw6cwKkfRaGo4hkbFIGnP/2esrbO0hF0cGipmn7hM4wHmC8E4Kv2Mni+6SUX9yf9dkdIcTvgPN2sniWlHLz/qzPXqA/cNqAvRD5Bc/OnortC1Dakeie356Xw7R3t/HOjAqafCYHf2os53xl8iDWVNOGrX2S+XvSuLvXsf4E9Zlhn2HUAaOm7V/6A6ftkZXf/h8tNy9n9cRK2qM5ZHw+om1JWk0Dp8THt54/ebCrqGnDmQ4YB0gHjJq2f+kPnPa+PPbYYwAsXrx4kGuiaSPCPgnklvQJGE8aAQGj7sOoaZqmaZqm7ZIOGDVN04aZ6n+2cNfMv7DhnuW7X1nTtP1OmUav20igT9ytaZo2TPyu/G5mt8aYl2rEr2xqvrCFW69ewyUbPz7YVdM0bYTTGUZN07Rh4J+5v6M846chWszSUVNYUTyWpBlk/tZabpn+98GunqZpWZTR+zYS6IBR0zRtiPtb2e8gFAbDoLa8kOrCIurC+VQVlbO5pAQrpPjZjEG72JOmaQcAHTBqmqYNYX8pu53R8RS+pANKsXVMMUXNse7lBfEkYkUtk1ti/Pa0fw9iTTVN6zIS+zDqgFHTNG0Iisfi/KP4t0xqayFGhDHtbUxrqmPemk1kLB9p02RdcT4J0ySYcRi3Pca2ugA3nvSfwa66pmkjkB70ommaNsTcO+keMqEcqhYsZMLGbcyprsHyzpk7e1M1m80CLv/sCawaXYzlOFz3yDOcsLKK1miY5Tm5fPnMZ/nNw8cM8l5o2oFLjcB03AjcJU3TtOHp9qm3cce8v5Lvd9g8dgxWMs2GcRVkfFav9arKClk1uhgA2zT5+4JpZHyKRxdN5/GZE/lXySRuWXA/r79SNxi7oWnaCKQzjEOYEKIK+J6U8j4hxARgIzBWSlk9qBXTNG2viTd18sTcPxIMKCYphU2GFyYvJBYMUV9WBsDfQov45FOvEEqnaCWHkliccCpNPOAHYEHjWjZNS5I2LXeZMphcF8c+9V7mnfkRqosKOHNUB3+4bDyGMTL6U2naUKaskfc50wGjpmkjS2sHyPVQWQRbm1EtndibY5inzsecWtqzXlsnvL4Opo2GsSVQVYfz0KvEq+JYo3MgnsbX2oKzpobMW9uxEw4q5UAyScDpxEcCB4OtVFBCK0kzSEglcZSJTQA/aRQ2PlK8VjKPQNqP1Q45didl1NIWzOOtohk4YZPm0eOxUg5WRlFTVILhKBJ+HyjljowuLWT7eIPj173BUnMRpR0mv//TX/m3mMT41kYuf/FJ7jjkHD731jpSpsH/Rpdz+emLefS2u/j+c0+SCXZgZExmrjqDsnicxvwwU+o389KkGTTk5oOTwW87OKaFMk18mRQLtm5m/pZtrCupYHthPsmIxYKGrRxUu5FyMoyqqGBqmY8JJ44icPQ0ADItSTrfqCc0o4DAmOggvQE0TdsXdMCoadrI0RiDQ74NG7aDaYDj9vtLMgr7G48TfvQi/KfNguZ2OPQKWFsDkSBc/2nsr93NZmcOKXIwsKnkXUzaMDEJ4OBgUscMMoQAhxLWEyLGKDpIWj5K7EYUYBPGJoAJ+GjHAA5pWsFrzpEUk6CcNkpopTjZxqrwVB495AgATNtmWlU1uR1xQo3NHN/xPIdteYvGnAJ+e/inKN9ic/f8j/D65PHc+PitHLslhmiYRl18Ms+WnUA8JwJAwFHMaW1nWUkRl3/iVP67cAYAua3t3PiXJRy/dhPtwQC/PGUh1Td8hdsXfZAvn3Ex6YDRfaVz2zT4/d//xPdPOYOnZ8906+c4rC8q5+FpBwEwb2sD5z67hql/fJVTvvAu1ldOZtUhD5OqimHm+pn+zEeJHJQVoGvaAcQZYiOjDcM4ETgLKFNKLTYMQwB5SqmnBlqGDhgHmRDiMuBLwBigGbgftxnafh9lKuCrwAXATGAZ8EngE8DlQAT4nZTyyqzHzAF+BhwExL16XCWlTHvL7wROAAqALcC1Uso/ecuOBZ4EzgWuA0qA/wIXSSl7zv/Rf11/ABwFSOBC3H61PwYeBu4EFgFrgPOklCu9x/iAb3v7Vwa8C1wmpZTe8uO9ekwDMsD/gEullHXe8meAN4AJwElAHXC5lPLR3T232hD336VusAjdwaIB+GnHdsKk//iyGzA+udwNFgE6k/CrfxF3ckmRA4DCopVyLGyCdACQIscLFgFMOigmRIyYWUCZXdW9LYsUijAmCbq+MsJOJ3lGkoBKU0KNV4Kitriku+qOZdGeEyG/o4OizhaO3PwmAOXtTXz1fw9S74zn+OUbKGvq5JNnfg+/ZTJ5SxMff+ptQol0dzYSIO6z8AObSsq6y5/YEuP4tZsAiCZTHLKmnk2FpYyOtXQ/DgNQYFsWS6bP4Z+zF/TUz+zd5X35mBJOf2cj9cXFbL/tNaKTZ5Gqcj/uTixN4/1rdcCoaUOAYRhfBS4DbgO6LgsVB34JfGCg5ehBL4OvGjgFyAM+ihs0XbwXyj0POB0oBRLAU0AhMBk4DvimEOIIACFEGfAs8Ahu4Ho4cCLwf1nlvQAswA0YrwHuEkLMylpu4QZf83EDtYXApQOs69HAWmCUV++bgNuBLwNFwErcN3aXH+I+VycDxcAdwH+EEIXe8iTwFW/f5wKjgV/02eZncAPkfODXwN1CiMgA6/uexWIxPb0vp6dW9AQ/WRzcvn6Zyd5bZMqoXudGy4wvwU8ccLrnBYhjkuxKuuEj1Wu5nwQAQSdNhuxBKe5hVWX9HncwcJSBg4GdddidXNfTHdl0HELpFMo0SYSCvepvOg4REgRVmoO3VHPJcy8RN3wsm1rJi3MnkNuWYOLKGuoCATbm51KVn+fuV9rBn3F/ezYFA2Sy9rktEqSsvZXRbU07PF8Ac2uqKY+19rsMIDeRIpixCSTT5EzIwR7jh6ynPjQtHxhC7w09raf7md5XlNn7Nsi+BpyglLqenoPYKmD6nhRiKKV2v5a23wghfgqMk1J+8r0OevEyjJ+UUj7o3b8EuB4okFI63rzXgPullL8QQnwT+LCU8risMs4EbpBSTtnJNiRwh5TyVi/D+DRQJqWs95bfBEyRUn5sN3X9AfAJKeXsrHl1wE1Sypu8+x/26loohDCANuBUKeVzWY9526vvff1s4zSvrmXe/WeAd6WUX/bu5wDtwAIp5bJd1Xcv0B+4fe2vL8JDL0M4AM3t2KvqSCajmKfMJfjLMzECXiD3yCvwwAuwYAJ84yNwxb203/s2bR15+H0p8pxarHQSO2PiI4WDRSsVgImfBLnUYAAZLFqsckKqHZ+yQZnEySeHGD46SJsG7xTNJh0rIJJyyFOtjGILyjCoCo5lfcVYNpZWEA+ECKYzABi2wyHb3mLB9hV0+iK0JkcT8N46CthYWMTroyfy8sKZJCyDhG1jZJqJBf3U540m11a0+iy2+Uw+tmUt/5o7m7kb6yjd3sDZb69iW1EeUX81n3znZe5feCRfOf2iXsEeSvH155ewcMsW7j3oSGpyC1g5qoTcVJLp9Vsp7kxw+IZGpja0cnhlG+Pu+wSU5NH0wFpaHtlIZFEp5d9coAfYaMPBPnmT/iP//l7H+o+0njtoHwbDMOqACqWUbRhGk1KqyDCMELBRKVUx0HJ0k/QgE0KcjdtMPAn39QgAr+yFomuypjuBuq5gMWterjc9EThCCNGStdxtXXPraAI/AD6FmwVUQA5uBq+L3RUsejqyyt+TunbVrW/9u8oqAaLAY15g3MUPVHr1PRi3SXo+bvO74T2m321KKTuEEOxBfbWh7JNHuDePhfsm2MEZh7m3LrdcRPSWHd8oXQdJC/fN15ef3h8EgHDWtAWIfh6Xbo2xbcpvSaRsSmubaSnMIxkKglL4M2lkxXxkxXxqwwGm1Wzl+PUbAffNbCuTE99dR2VdO5unlGAA98yfxpFb1rAuYfPE+KkAfHDzZpYVlrJo1VYC6UZqRufw3TGCytYWfvT9EyiY82W+jJvK38G3TwPg0zvsWUF/awNQdNZUis6autPlmnagGGJXd3kO+A5ud68ul+ImegZMB4yDSAgxFrgPOAN4XEqZ8jKM/X2/7EubgCellKfuZPnZuM3kJwErpJSOl2EcjE9EA24weoKU8vWdrPMA8BBu5rLNyzA+tr8qqGkD4c/P5YT6b3ff/8XM2xndYjI1voGCuM1f552Ek7G55ciDmF1byRGbthDKZLAxyGvJ0EaISCKJz3HAMPjsW6upz8tlWtrksFef582yCjr8fpb/Zhz+Pudx1DTtgPJV4DHDMD4H5BqGsRqIAaftSSGD37J+YIvivgb1QFoIcRh9f9DvH/cAQghxoRAiJIQwhRCThBAne8vzcAeP1AOmEOJC3OzdfielVLj9EX8qhJiKW/GoEOJDQojRWfVtBWJCiHG4v6w0bUi7bOVFfGLjBTyfO5XGaIiPrHwWFUjRGQjw+rhKTvziZ7jh2COpM3NoI0IKPzmxDGVb27rLOGjTOnKbm1gfKOSff13I0/fP0cGipg0CZfS+DWpdlKrBHUD6KeAc3D78hyilavekHB0wDiJv1O/VwKNAC25g8+dBqEct8EHcQTJVuKO1/4bbTA5wN/AqsA7YCswCnt/f9czS9Zw9KoRowx0w80V63s+fx82IxnAH8jw4GJXUtD1lGAaXrjsfse0q3iyoQFSt5shNqwHYXJDPW2VlmDkNqKxDd0FjO9HWOAaK+nCaD65+lfuXHD5Yu6Bp2hCkXK8qpR5USr2ilHJ2/6je9KAXTdu/9AdOG7B0a5zHpt2PP1LP1YefwdKKcp7/8y9oa5lEKJ5BGdBYFiGQtNk4sZhYsJOrXt7lODNN03rbJ/m/v5X8udex/mMNZw/moJct7OS7Ryk1bqDl6D6MmqZpQ5Q/P8zHai9iefFV3PLEQ5z3kU9z35wjmdGiiLYlSIb8RDs7mViznk1OVAeLmqb157w+9ytwz8v4wJ4UogPGYUgI8Tjuya53IKUcUtfjEkIcBTy+k8XXSSmv25/10bThxjAMSv5+IZkz7+a5B37GqxMPZmveGNqKIpiOzYdXP8tzExYw6YT+xnBrmjYYnCE0SFop9WzfeYZhPAP8hx3PUbxTukla0/Yv/YHT3pNVv3mD5desYFyslU4VJmJ2MCq9nXcrJrCpspxLXvzIYFdR04ajfRLaPVzau0n6zPrBa5Luj2EYhUCVUip/wI/RAaOm7Vf6A6e9L/eW3cP0thbMtINfxSlYcg7jTxg/2NXStOFqnwRyD5U/0OtY//HtZw1mH8Zr+syKAB8GliulzhpoObpJWtM0bRgpuL2Q7RSyePHiwa6KpmnDw9g+9zuAm4F796QQHTBqmqZpmqbtRYN97sVsSqnP7o1ydMCoaZo2DDRvauaqc97CHyjCMg2e/dkLfO2Ps6icWjTYVdM0bYgxDOO4gaynlHpqoGXqgFHTNG2Ia9nWxg3nv0uspJgS28ZAMaWqht+d/xbXvjyg7wVN0/YjZQx6ivH2Aayj6LlAx27pgFHTNG2Iu/eI/5A3qgx/MkEolSa3tQMcRV5nisMvWM/Ld00e7CpqmjaEKKUm7u0y9aUBNU3ThrDfjXuAwpQiVpxPMhRC2VBc30q0Pc6Y5hgf2LydH1y3drCrqWlaFsfofRsJdIZR0zRtiPrjmAeY2NJBU1kRts8CIJDO9FonP5Hm+Vc7BqN6mqYNA4Zh5AE/AI4BSsg6ldCeXBpQZxg1TdOGgA3H/JZNxqW8E/oh/xx/O0+U/oGNk0YTshXFnW3d67UWRHFM93ifsUxqSwpYX17KZy9cNlhV1zStD2UavW6D7FbgIOAaoAj4KrAZ+PmeFKIzjJqmaYMo09pOvOBSKkmjMPAncynavJX/LFhAgaGIOCmm1m0js9xkY/koChvbmLKljpTfwjFNVo/voKK0iNVGAZ3JDJGgPqxrmtbLScBMpVSjYRi2UupRwzAk8Bh7EDTqI4umadogWWV8mbGksbCoZhwZTMppIJctfPLtrWyyJvHfhYvYXlbA7C1b+NgrL7OyoAK/4+BPOgAUJdPM6ojT6rM45XNV1BWYrPzlgAc+apq2Dwyl8zDitia3etPthmHkAzXAlD0pRAeMWjchRBXwPSnlfUKICcBGYKyUsnpQK7aPCSEqgS3ARCll1SBXRxvBWr9wJ/E/PIGfKO2MIkw5SVrZalTQSAEz1BryaQIgancwyd7IIZvzeWD8Mbw2bRrFLc38c+pUPv/kUgBsw+DZceUsL3PPxegATblBSi9rIC+dYlNemHEhm3euiBIJhwZrtzVNG1zLcPsv/g94HreJuh1YsyeF6IBRG9GEEAo4Skr5wmDXRdsH3toIN/wNiqJw7TlQGIW6Fvjen6EjAeX5sLkBPnmEe3voJXjgBZz2FMnna/GnmrHCYPhMiMXds5IpBU7PZWC7ptJE3SZj2rvnZicRFCYGDqrPfBsfSYoBgyCd5JJiK+UkyQeglXwaVC5hEoRI9tlBRWF7O9FYB52REP+aMZtJ1Q08M2M8TZEQ/5sxnrfGjqK0M9VdHztl0xAK0JAXwjAMNjoQ/ZnNhObNbCwpxzTAp2wcBzI+v1dZBYYBKQdfWycZy4L8EJgGftshnbIhYYPjQG4QM2gxJmowuRAOH20wpQD+vQEWlsHz6zO8uzXDx2b5+MVpAQzvfHQPrnb4yyrFQeUG3znUwNzJeepulg4vbVUsnmzwmTm6m702PA2B8zBm+xw9h6XLgOuAAuD8PSlEB4zakCKE8Esp07ubp2kkUnDiD6HBGxBS1woPfgvOuQX+t7z3uo+8Cqk0fObX4Dh0UkGIBnykIbbrzRiAwiBNHhG20d/XgAJMnO71syUpwSbs3bMxaSNDAHAzgg3koTBIEMTEwcHCwMbGR4witobzmbZmE7ZpUlTXgR8HTJPnjhrLm2PKcTI9QWrMZ5I0vSAr5aD8FqZh4KQUG0dVgGHgACmsnoqDGywCBC0yRTnQFAfTAMMg7bMg7UAiAwELgj4cYEu7e3tmS09w/fC7NrS4Qe+vnreZWgxf/UCQN2oVZ/3TwVHw8FpFNGBy6UE7PpN3vePwjWfc5/HhtYpxefDBcTpo1LT3aZNSygZQStUBF7+XQvQn8QAjhLhMCLFKCBETQmwWQvxECGG9zzJLhRC3e+W1CSHeFEJM95YVCyHuEULUere7hRBFWY+tEkJcJYR4WgjRDpwphHhGCHGLEOLvQog24Bu72f6lQoiN3j5tFUJc583vGja6RAjRLoS4zZs/SgjxDyFEqxBiDXDy+9n/PRGLxfT03ppuau8JFgF7lddzYs02dqAUvL7ezZABDgEs9uQ3iBsyvpecger1u9ydtki4yUwMlFdqCY3k0InCh0OAVXlTeLpyDtW5RWzLj3L3B+Zyz7HzIWlS2JLgjNfWkcQgbZo0+H10mgadfbMaChzDwLDMnqCwr76zLRP8fdbvmvbt5ivDVr3uvl2riMVirGtR2Ulb1jSpfl/Ttc19Hl+T2GEdPa2n9+b0vjLEzsNYaxjGrYZhHPl+CtEB44GnGjgFyAM+ClzIe/y1ASCEMIF/4Ka3F3n/L6Anb3M/UAjM9G4lwL19ivkccDmQCzzqzbsQ+CWQ7/3f2fanAdcDp0kpc4HZXn2QUs73VjtJShmVUnbt5/2ADYwDjvbqu1/k5ubq6b01XVEIHzvUnTYMrEtOcacvyYr/vXMXMqUCLjsVplYAEKSFJAUMnIGDH8fLzKk+S1U/87oEaOleapImQwgFxAmQwk8u7jkU070CS4NYKExrJIe0afLTkw/jxalj+ceiadz80UNQwNj6VqJJN5sXt0wUkAE3OPaeE0wDQykUWc3saif/u8TTXvNz1vKu6UQGbKfX6j4DSr0EaihiuZlJ3Kf+ksN85ObmcuJ4g6mF7jpRP5w/2+z3NT17hklB0J1XmQufmB3eYR09raf35vQB4iTcPot/Mgxjo2EYPzEMY+6eFqKbpA8wUsqHs+4uFULcCxwP/P49Fim8W4mUsmsU1nIAIcRo4EPANCllszfvcmCVEKJCSlnjrf9HKeVSbzouhAB4SErZdVH0zl1sP4ObI5kthNgkpWwBXtlpZYUYAxwHTPHq2yqE+CGwZE92WhsCDAMe+ha8uMrtwzjbO//sd86AkxdCZxLGlcDaGjh4MuRF4I2fglxHsLwA+0+vkqlvw5pciFEUhbc3QSrjthNva4SGVmhLQH0rieYEGM2k03582ADYWICJQRowyQAWJooMPtwQ0cGHQScBtuHDIUkOneTjM+KYym1+LqWZGbxDhAYMfLT5iticO4q3iydj2IqkadAa6RmwsqksHwOIOEmeuvNPfHnxh1hTXs68zgSzNm/lj/OnYaVtoqZBWilSPoNIopPi+hbWFFdSnIxRnOpkfbQIJ+AnlElhKOj0Bcnr6CADmH4Tf3MzyUgE2zQoKPCTVxKGjENRnmJOOZww0aAoCJMLTQpDsLROMavYYHNLDi9tsjlzlsnYAjfALgobyPMs3tiumFZoMCa3/5TLnFKDlRdarGxULCgzKAwNfmpG04Y7pdRSYCnwbcMwjgHOBp4yDKNGKTVvoOXogPEAI4Q4GzebNwn39Q+wiwBrACYAdVnBYrax3v+NWfPWZy3rChir+nlsf/N2IKXcIIQ4F/gScJsQYjlwjZRyZwFgpfd/U9a8jf2tqA0DpglHzdpx/oKsy6hWlvRM54bhg+4Pa+vasQxUuJ95fftx+Hfx+K5lXQdc3/KNNC66ndJUHJswPtJeIGqTyjisM6aQ15QkvzVJfrKDw9ZW88pU9617+ppNPHv8bJQBVSXFzLMVo1ti2MB/50zA8ZmcsnQ13/vNdMTUvK4dB8q96Zw+tcu+H9nFXuzacePc4G5UjsEhY3ZsvMoLGnxw3O4DwFE5BqNydKCoDW9DbNBLtlXAStwTd0/dkwfqJukDiBBiLHAfcC1QIaXMB37Djr2Y9kQVUCaEyOtn2Rbv/4SseZP6LAPo3ca183n9klI+IqU8Ebe5+6/Ao0KIrm++vi2FW73/47PmTUDT9qPIvInMS15LRedPaAkHaaGAtDcQJmq0M6qplfLtnYQTaQLK5uf3PcFP//QkX3pjJQUG2D4Lx7Io7IyT8fnIS6ZoClo0JR3SP87j70sORUwtGNyd1DRtSDAMo8AwjIsMw/gfsAE4FrgBKNuTcnSG8cASxf2RUA+khRCHAZ/G/bXxXkngTdzs3leABmAO0CCl3CaEWAL8TAjxGdzA9GfA41nN0e+LN7hmIvAcEMc9OanbGuiqxf0V9QKAlLJaCPEMcKMQ4rO4yaOr9kZdNG1PmeEA8zq/z3rjqyy3FqJsk3UTxuM3HYKdaQrirWwJFEHa4cnDZlLZkYJ4aodyUkqR7ojTeM8enYdX07R9ZIiduHsb8BLwJ+BMpVTLeylEZxgPIFLKlcDVuANLWoDvAH9+n2U6wGLcYO0tr9w7cINTgPNwB8Csxk2Ft7CH537ajQBuwFfjlX0pcKaUsmt45ZXANUKIZiFEVz/Nc4AgbpbzeeCevVgfTdtjk9WvODhzBQdlvsH8jUuZsn41qYZ6kgkfo+ra+NUph9IZDpMMBGgJh3CAjGHQGgwQR2F1dvLMb8fvdjuaph2QJiulTlBK3f5eg0UAQ/UdIadp2r6kP3DagNW9vJUVxz7KdR87ns0TyjhkazMAhuNQ0NJKczDAlPYO3gwH+fujCwe5tpo2LO2TXOCdkx7udaz/7IYzh1bO8T3QGUZN07QhquzwMdSU5LP4tbUYiQRLy3LxxTv4zJLn8KVT5KdsUgq+/cPJg11VTdNGON2HUdstIcTjwFH9LZNSRvubv5e3/zvcpu3+zJJSbt7XddC0wXL21nO5p/Aurr7/GUqIUxprZ/WYUVRXjKKssZXkiRV8YEF/Y840TRssQ6wP416hm6Q1bf/SHzjtPfnp3H9S0pbk3Rnj2FpaRDiRYnx1DVe9ctxgV03ThrN9EtrdMbl3k/SF63WTtKZpmrYffPPt07hg05mMPqKB3O1bOGZxjg4WNW2IUobR6zaYDNfnDMN4yjCM5d68ow3D+OSelKObpDVN04aRKQszTFkYY/HicYNdFU3ThodrgBOBW4DfefOqgZ/jnrt4QHSGUdM0TdM0bS8aShlG4ALgNKXUA/R0i9pIz4U0BkRnGDVN04aJWyv/gl2UQ15rkru++jDpWJzPNe5sPJimaRrgXsm03ZvuChijWfMGRGcYNU3ThglfbgC/MojnhQknbHIDAf5cecdgV0vTtD6U0fs2yB4HbjYMIwhun0bgR8Bje1KIDhg1TdOGgds+/iSJnAjKb3B49UoWta5mQst2WorLB7tqmqYNbV8HRuFeOjcfN7M4HrhiTwrRAaOmadow0LpJoUyD+Vs30OELUhstYGKylrLWZpbd+PpgV0/TtCzKNHrdBothGBbwcdxL4o4DDsO9VODHlFKxPSlL92HUNE0bQv6wpInv/ytDju3ebwdOVLV8IJ0mHg7y7qhxJEw/luPwbtlYxtfX0/iTV+Hbiwa13pqmDT1KKdswjJuVUncACaDuvZalA0ZN07QhIufrtUCAACZTEp0cUteEz1G0mibbSosYW9fKpDWNAGwaW0jKZ7I9t5DcdJxV//dfZvzkQ4O7A5qmAQyFkdHZHjMMY7FSao/6LPalA0ZN07Qh4KoHG0hYIaK2jd80Edsbyc3YZEyDAtshpSCZgYTfR2Eszsy122koDtMRCJA0ArT+dhkba5qYeNfZg70rmqYNLSHgIcMwXga2kHXFMaXU+QMtRAeMmqZpg8y8oh5lBDEsh/bCKG2WyUPhiZy0cTtt4TCm45AwTVZOqOT5g6Zy0d9foKC9k7GtLawqLYeMoi5TwbR7niN99z+xyWBjE1h5C/4ZlYO9e5p2wBnMfov9eMe7vS86YNR2SQhRBXxPSnmfEGIC7sk+x0opq/fxdo8EnpdS7vNPnRDie8AJUspj9/W2tH2rLanwmxD2937btKfcH9TRgDs/Yytak1AQUqxucmhNQHEYJuSbdCShttOhuk1RGIaONIQs2NjksLohg5mB1rjixc1p0mm3U9CmFgcnDXGfIhR3SCobJxoBZWDE06hIiIByUDgE0zb4fWRMk9GxJBWJNIegWBuwaMoPoSx3LGJ7MEBbOAyAY5r4gDSQCPhpiYYZ1d5K3PRh2opJnetZ2LEUCwfoObCrmZdRG6zAl2klYqdot/zk2J20YNCSN4bgmCLyQxA9bQZWxsGcXIFdWUpTQSGRmmZyRCWE/DhNcTpzggRKcwi3dUJhBMPSYyY1bThQSv1wb5SjA0Ztv9rPQecFuMHulH25HW1o+PErDt9/wSHkgwdOM/nIFDegufNth88/4aAU3HqCyTGj4fjb42xtU1hBEzviB8PAl7KpqG+lJTdILBp0I0UHMA2I+sCwMB2T6fVtrCzNA/eUZtCZgRwLLBOUIp5vgFJguP9VTghMgzQwtT7GmtJcdxnQYJlsCOcDUNCWoLQjQX3ID0DaNFFAV+jb1YZ03NLVdBbmsClVgplxCCVs/BkbCweHIAo/BjYGcUwUZckaMuTjpwMDk3eLD2Z+4zuMaaumoy1GkjDhpcu7t2FiUUoOJooUIdooBQwenzaNL5++mLv+9gAfdhoIPf1lzLGF+/pl1bThaQj1YTQMY6cXnVdKPTXQcvRPRE3Thr32lOL7LzgoIJ6BK55zupd941mHjAO2gsufcbjp+RRb29zwy046kHHXDaQz2EAsLwQpB7qKMOg++DumwaqSXDeINLxb2OcGi/Ss1+u/YYByg7HNhZFeXyRtXnCIo2jJQL3pJ9rQQTieYnxbJ21Bi6QBaaUwkmnGb28kVppL9bgSd4c8m/yTcPChCAM+FEEUbkDrhp0ZDCBsJxnfWUU84G43h1YitHWX49bM5z0GAiSwSANwypo1HLx1G1cd9yHU+gbSv3huz18oTdMGw+19bv8A/gPctieF6IBRQwhxmRBilRAiJoTYLIT4iRDCeh/lGUKIHwshtnllVgkhvuotXub9Xy2EaBdCfN97zFQhxDPe+ssAMcBtFQohHhRCNAohWoUQ7wohjhJCHI57kfVJ3nbahRDHeo85VQixwpv3T6Dkve7rnorFYnp6H0z7TQj7egKoqK8nYMzzZ08r8kN9fvlnBXCGwssOZi1XvVc3VZ8Zfe/vQiRl919WPNMdALZbFuOaO1hU20JlW5yKzgSjEkkcyyQVCgBgZTI0l0SxLbeipqNIeQFi1o51T1kks7bpYKqe58TZxdeAAlTW8lgwSH4y4ZaeHxr0111P6+n3O72vDJXzMAIopSZm33BP3v1j4Nd7Uo6h9uBgp41MQogzgTeBKmAB7i+Pq6SUv38vfRiFECcBdwCHSym3CCHKgDFSyqX9lSGE8AHvAk8C3wQqcS9ZNH13fRiFENcB84FPAR3AVCAtpdzYX5O0EGIysAK4CHgAOA74G/D6furDqD9w+8i/Nzhc8ZxDbgBuO8liVon71nm1RvHlJ20cBb863mJ2EVz4cIIVdQ7thsVW2+2ZY9gOc5OdtDgmW0JBVMpLS/pMCJpus7XtMHt7GyvLckn5vN9UHWkIWOAzMVE4Ci+ziBtMKrAcxaiOJBVNHSwrySUTCaAcRSBtY/st7IQNyZ5g8tCWGNM6E/htGyvrGN3k87Fw6zb8thvwhTqSTH23hkAqQ1tRgJManyOkMrhhYDsGjhf0uZJWkFXR2UxvXYefBG1GMYayKaQOMFBAkjAOEQJkSBImbhURswLcd/ACHl80m1tf/A8zp+cS/OOnMCKBffmSatr+sE+iud/O+2evY/2Xlp82dNqoAcMwfEC1UmrUQB+j+zBqSCkfzrq7VAhxL3A88Pv3WGQKdxj/bCFEvZSyjl2fLPRQYALwLSllHFgrhPgZ8IcBbqsYmA4slVKu2c36ZwGvSSnv8+4vEUL8HRgzgG1pQ9iHJ5l8eNKO2bJDKwzkp3sf6h45L7yTUgYSAJX2ue/f7SOaYhm+9neHe1cFMG0bX0eCtII0BmY8DUEfRek0ScNgTCJFSTrDy5WFJH0W82pbGN2eIANEEikCqUz3wJhEThDDUMTyg1jYZFAoHGxMLCzAwcZPhjQ2Brnbb2VhcU+/w+I+9TSA7GfGD0S9Pb7Ku8ElA3iONO3ANsTOw9ifE+npeDMgOmDUEEKcDVwOTMJ9TwSAV95reVLKZ4QQ3wW+B/xVCPEK8F0ppdzJQyqBOillZ9a8jQPc3E2432t3AxVeE/O3pZTbd7Gtqj7zNqIDRm0fKsr1cc+nC7hnJ8vvlzEu+IvDwfEMYzqTvDm6gKrCHAC2RUOcsmIrE2sbmLduC+mcMDFvWagjScq0qMxsZGrbWkIK0vhw6MD+1qlEbjwfH+zQWK1p2oHDMIxe514EIrhJnS/vSTk6YDzACSHGAvcBZwCPSylTQoifMsA+hDsjpfwD8AchRAT4AfAI7nUs+/tFsxUoE0JEsoLGCQPcTgdwJXClEGKUty83AefvYlt9L4cxoG1p2r5yrsjlnIOjTL+khkmOQ4e/pwuxbZnETZi1eRs+R1G2oZFYQRzHMshv6ECZsLm4knbl59jYFYO4F5qmdVHGkBoicl6f+x3AGqVUW38r74wOGLUo7uCneiAthDgM+DSw8r0WKIQ4BDep8RqQBGJAVwetetxAbirQ1Q/yFWATcIMQ4tvAaNyM50C2tRhYB6zBvexuImtbtbiBaJ6UsuuD8QBwlZdVfRA4Fjgd2Fn2U9P2C8MwuPKMALf+1WFSbSuNkwI4psnEulY250fc/oVBC9NRFDZ0dD+uJddPxoqwePtZg1d5TdOGskVKqZ/2nWkYxuVKqZsHWsiQCoG1/U9KuRK4GngUaAG+A/z5fRYbBX4BNACNwEm4g1Lw+ih+H/izEKJFCHGllDIDfASYh9vX8REG1n8RYDLuAJk23KbmONCVZnkaeALY6G3rGCnlOuDjuN2xWoCvs4enFtC0feUzJ5bw6h8r2WwqTnqrilPeWE9xY4xl1xdS0tZOIGnTXBzpXj8ZtKgZX8bY6jr8kdAg1lzTtGxDaZQ0Xd2Pd/S9PSlEj5LWtP1Lf+C09+Tx4jupLikinhcm1JHCcBTtuSFM0+TSl4/DGPwvJU0bjvbJB+fXB/2n17H+K2+evN8/oFkn7H4MOI3e+zoJ+L5SavxAy9NN0pqmacPAB5Z9nL8euwTDdkjkBFBAIhIi0tqug0VNG2KGyCjp273/IdxT3XVRuF22vrrDI3ZBB4zaeyKEeBw4qr9lUsroXt5W+04WPS+lPGVvbkvThqr8ylwwTaLN7Tg+C9syCbQnGXtI7mBXTdO0Icg7STeGYdyjlDr//ZanA0btPdmfgdreDkA1bbiafdYo1txXjQIi7QkCY0xOu3vxYFdL07S+hkSC0bU3gkXQAaOmadqw8YFrDqdx0WMALF78sUGujaZpw4FhGHm4p7c7BvdSuN3hrFJq3EDL0aOkNU3TNE3T9iJlGL1ug+xW4CDgGqAIt+/iZuDne1KIzjBqmqYNI7VfbCRdWMxdX/0LheVJPvrqXmlt0jRt5DoJmKmUajQMw1ZKPWoYhsQdPT3goFFnGDVN04aJP4y5DyevhImbmqioj5PYGuCtvJ/y0vH3D3bVNE3LMsTOw2gCrd50u2EY+UANMGVPC9E0TdOGOMdxeHfOJALxDBvGlAMm47c24Ut1gqwb7OppmjZ0LcPtvwjwPG4T9W9xr5A2YDpg1DRNGwauPfy/fLBqJf847mCe/MBs7l18OB3BMBOTW/BnHGr+tWKwq6hpmmeI9WH8HO6V0AAuw70iWgGwR/1ZdB9GTdO0IS7e2Mbc7Zt4ZdLC7nkdkRC15VFCmxO05gfYdvFLfLRm1iDWUtO0oUgptSFrug64+L2UowNGTdO0Ie43xz7Hi4ccSzrgJ20YlHTG8aVt8lsTvF44l9K2OD4s7HQGy68P65o22IZAVrGbYRgGbpB4NlCilJpnGMbRwCil1F8HWo4+smiapg1hf5x+G6/PPYyD1tVw7NJ11BdG6Mh1Lw34n0XTiapp5KXTVNbW8Xz+7zm288uDXWVN04aWa4ATgVuA33nzqnFHSA84YNR9GDVN04agn96xmYuOf5YH5x3GhOoGjn5nPX5sOqJ+wD3z7txN21g2dhTxnDBrJ43DMP28mnMT6c7k4FZe0w5wQ6wP4wXAaUqpB3CvIw2wEZi0J4XoDOMACCGqgO9JKe8TQkzAfaLHSimrB7Vi+5h3veinpZQ3DnZdNG0kUUrx+roEZ97RRLUdwFI2IcfCMAwObmrCn0mT4wQIVY5n0fptLFqzjeZohEA6g2UrbJ/7BdQRDGIqRSCVJhXw0x4KU97YyOboj/CpdhJkKPv+8RReo68Ko2kHMAto96a7AsZo1rwB0QGjtlP783rRmva+PPU2vLgSTloAc8fDH5bwgF3BukVz+fgcP//eoHhxTZLPvfoE21sdfjP1MOygn/qcfBoSBkZHnNxkgo5gkI5QCMNxcLoaYLqyA0r1THfdV4pQJk0gkyZjWURTCdoDYZKYXPTmMxy7YSWvVE7ml4ecjOEzOGjbNs6Sb/HG2DE8cNBCiBYTTNtkMooMMDqZopgQthUkB4c2n8Xk6p5T5qT8PioaYqyvLKIxL4d3xo/m4sdfZEJdMy3hCBnTpINcIipAEIcKoxn7x0/zxs2rCQdbKUi2UBhvwXLAxk8HUfJoIUEBCQLk0IRDBEWQAO34aQcUBgqFQYYANn5MkvhIYnZ/94BDAMN0MCN+jAmlqNYOlBWASZUYYixGQQTnqLnYz2zAGF+A+dOHYFM9jC7APHQyHDUT5Hp4ZzPkBCHjwJQKuPkCCAf39TtI0/aqIZBVzPZv4GbDML4O3X0af4R74u4B0wHjAUgIYQFKSukMdl007X1b8hac/CM3gPvRQ3DoVH5uTOLyj5wCr8GP33BI2PDYHTdz8so3AaiYuowPff570OGVEQrTGQp3F6nMfnrr9PcFYJokLItEMARAZygCwKyazfzqH3cRsG3OXvYStmHxm2M+zBsTxvHOmApSlptNnFTbSW4ig20YrB8VpbIlxercMPWmwXGNMZRh0Jgfpait092c45DGIr8zzjEb1iGqtlHU4u5EQbyTGCE6CZJHK3kkQEUIqgTj7E2UNm0HwDZMLBwgSYh2OqjAIEgI2M50SmnAQmGTi0mGADH3OQGC2ECCOLmAg0mq56kgBQ7QnoF3NmPgXbC2qg6eesNbyUfaKcVHHB/uPtG6HVZuhrue3vH5fXI5LN0Ir1y/s1df07Tduxy4G/fk3X7czOIS9Gl13hshxGXAl4AxQDNwP24ztP0+ylS412y8AJiJe/LMTwKfwH0BI8DvpJRXeutHgPuAD3jL1gFXSCmf8Jb/CPgocKiUMi6EmAG8Cny8a52d1GMCbjP6xcA3gMnAeCHEscD/ARNxvzr/AVwupezwHvcM8KSU8lohRBD4FXA6eN8t8F0p5YPeukcBPwFmec/frcDNUsqeFET/dXsGeNOrwwlAHfB53O+aW4BxwP+A86WUMe8xxcCNuJc7CgFPA1+VUm73lu/ytfRely8DnwVmAO8CF0gpV+2qrntDLBYjNzdXT+/N6edWuMEiQDoDr63lmXNO637OE94n+Nj173bPO2bDXjhn4S4yCNMbagjYPYeOeds3d08n/W4fxGg8TW4iA4ClFCVtSRrDflYEg5B2WBcKUJGxeXHhVGKRINF4knnrthGxM0QbE2QsH2mr5xDuBnQJWq0o+XYML1wjQ4hQurF7PUv1/E40AIsUGYIYQIR4r6yhItBr3S5BOkgQxZcVMO5cT3mmk8HAxiKdtbwrtNzJoeIt94wgQ+b9pqdH1PS+MhQyjIZhjFJK1Sql2oCPGYZRBowHtiilave0PD3opUc1cAqQhxuUXch7PFdRH+fhBlmlQAJ4CijEDdqOA74phDjCW9cEHgGmAsXAn4GHhRCl3vIfAI3Ab7zg8iHgll0Fi32c420zF6jH/bVxDu4JPI/ybt/byWM/AywCZkop87xy3gUQQszCTXnf5O3nqcBXgE8PsF6fBq736vEX4F7coPFoYAIwHbjU25YB/B3322UO7ps/Bvwpq7yBvJYXAGcCJcAW3GB4n8s+SOnpvTR9wjywvENZKABHzeJDq5d1r5PjxVT/nTa/e96SafN439TOfws9P2E6mwpKAEhaPv4y67Du9XMS7oCUjGX0CpHSlsGK0lzwLiMmC3P5V3Eelau3kfIH6MiPUNbRTsROE0o7GLZDuDOFgUOAJBXUMIfVhIijssI7hWJNwURs73CfNP3dyxwsMoS99aCDUPd6CjBJZJXTI0kUf3d6dnd6vmYcK4DCws4KRN2Sd/G78tBpwBB6v+npETU9wvW9ksvvlFKvv5dgEXSGsZuU8uGsu0uFEPcCxwO/f59F/6xrcIwQ4iHcwOgHXnPwMiHEMkAAL0op23EzjF1uEkJcgRuo/VtKaQshzgaWAi8CtcAP96AuP5RSZr9RHs+aXieEuJWdp6hTuJ1kZwkhXpZSbsladgnwoJTyUe/+KiHEr72y7hlAvf4qpXwVQAhxH27W8yYpZZM375+4zxHAwd7tBCll0lv+baBBCFEppawe4Gt5k5Rys/f4u+j9vGvDybFz4IUfw8tr4Pi5MGMMl9zzDONSy1l/8Fw+NtPiiSrF3yZ/jYI3n6Om1eaPY+bzQauR2vxiatohGYtT2NlBRzBEeySCZdukDGv323YUwUwKv50hY1hE00nagyEaQlFO/ewVHLJ5HS+NmczqskrIOIQSKQpb2+moKCbht9hcFKa4I03S555bcWZTK68U5dPpt6hoiPHBVdVMjHXy6sGTOHpp9rHfQGEQjScooIVRbO9eMsHZSlWonGgwjg+bmM9kXON2GgOlRDMxfE6advJxsLCxiNBMggKSBChnPRAgQ5AgrZiksPFj4KAwyeDDxu81J9vYmBi4GUvHCrt9GPODGNNHQ0MbKhBGTanEOHQ8RiQAR83B/+wGzEnFqJseQq3eBpNK3T6MR86ENzfAsirIj0AyDdNGwzVn7813i6btF0Mhw0jvhgGAY99PYTpg9HiB2OW4w8x9QAB4ZS8UXZM13QnU9ek72Imb8UMIEcbN0n0YN/PleMu6MoxIKWuFEH/Fzbgdt4f9EKuy7wghTgSuwm2WDeKOpNrZRWnvA8pxz9s0VQjxP+DbUsp1uM3Jxwkhzsha38TN3A1E3+eov3ldPwknenXdLoTIWoUEbvN19QBfy+zyO7LK14ajw6a7ty4Xn8hpWYsvmgcXzbPgYycBbtq/t1ze+1sgO1uWXcZk75Yt2GudR19PcfFD7aRiadoDETbmR1DKoaw1xazmZirTLSyfPoZwIgWOg2OAqcAxIKAyWHTQboZRTk+jbrsvRF66nmAmicq0Mr/uBvylRTutcVetBmJXIXR/zVXd/Riz1jEXjHPvLJ67w7cZH//AAGuiadoA7LJL2J7SASMghBiLGxCdATwupUwJIX5KT1Zrf7kctxn2eKBKSqmEEA1kHXOFEMfg9r27A7dpelFXn8MB6A4uhRAB3KbdbwN3eH0ivwJ8s78HSikzwA3ADUKIAuDXXh2OBjZ5ZeyPMwZvwg3wivoLlofQa6lpu/XRRTl8dFFOv8uWPJHm0Z/UMnZLLWe+voI1FSVsGFVEMJ2hM+BnQX0T60Pj8KsMbWEfITuNP24TTLcwNfkTDEv3ONK0waLMIZFh9BmG8UF6Yoi+91FKPTXgwvZy5YarKO6P33ogLYQ4DLdf3cr9XI88IInbTzHgNUcXdC0UQpTj9mu8DHfE03+A37KHI508AdzEQrMXLM7C7XfYLyHEcbh9HpfjXri8A7C9xbcCzwoh/uPVSQHTgFIp5bPvoW67InEHD/1SCHG1lLLR6+N5vJTyAYbOa6lp78tJJ47mpBNH88OFj7C5vAhTKVJ+H2mfBTisC41HGSZJwyLQGaYw2UFzOMTczhsGu+qapg0NdbiJnS6Nfe4r9uDk3fonKCClXAlcDTwKtADfwQ3M9rebve1vA9bjNsVWAQghTNzRvkuklHd62bXzgBOEEBft6Ya8/pJfAm4UQrQDv6H3wJG+ynEHozTjNueOxx2YgpTyHeA04GvesjrgLrKa0vcWb78/ivsL6Q0hRAy3uflYb/lQeS01ba+4eukZLJs4iuKY21sjEbBoKs7vtY4BJP0WhzVfPgg11DStr6FwpRel1ASl1MRd3PboSi+G2sVIP03T9jr9gdP2mJPO8CvxXzLKT6y8gFTIz9gN2xm7pQ6fylDh1LLFKeG0+OcHu6qaNtzsk2juhmOf73Wsv+KZo4ZEG/X7oTOMmqZpQ5zp93HQ1ndwggFSIfe0OFsmlVNXWkhHTpBVORM5etUnBrmWmqZ1GQoZxr1N92F8H7xrLR/V3zIpZXQ/1+Vd3GbivjZJKWfvz7pkE0J8F/juThafIqV8fn/WR9OGq6MarmDtjEdpHtXTHO1LZyhq7qCt1E/e+MJBrJ2maSOdDhjfh6F0reXBDAp3RUp5HXDdYNdD00YC1dLEuM0BmvPzqKhpYsKWGjoK/ORdMiQ//pp2wBopWcVsOmDUNE0bJi6q/Sx/nngrszfYJH0WbZ+ewmn3nDTY1dI07QCgA0ZN07RhJPrLsbQAixcvHuyqaJq2EyMxw6gHvWiapmmapmm7pDOMmqZpQ9yppy9nTHs74Y40VWMm4oQCyB8/xdEXjeH4z03ffQGapu1XOsOoaZqm7TdtTe2cccZyGooLeGLONF5eMIlJ6QwTExk2Ta7k9du2kmgc6JVBNU3T3judYdQ0TRuCPvjxZeRhcXT1dv4XCjM21sGRm7cCEA8GMIqLaCwt4JkZd3PEm2eTO1afVkfThgqdYdQ0TdP2OfGF1WwuLeHD69fSFgqysaiAaQ1N3cvDyRR+2yYdDLJm0mT+d9ADg1hbTdMOBDpg1DRNG0JOuWQFm4vK+cyK15nQWkMwk8F0HJrCoe51bNPENt3Dd3N+HhWJBn474y+DVWVN0/pQRu/bSKADRk3TtCHilw9sZZNZQF48Q6OVS30qj1F1LZy4ZhObI1G2RiIUdrZy0NbVTGyoAaVoM0O8MOMQjt/4OumOxGDvgqZpI5Tuw6hpmjYEfPBzb2I0hTmjqobXp43i7OfWELAdoJVp6xtIEmA81VTQAMDC6nX8dfIxjK1qBeCd3Pmkin7MnOSPBnEvNE2DkdmHUQeMmqZpg+gnp/8Tc0sbxoyDOP+1FXQWBjBTjhcsuiwUACGS3fP8js3MDdtoN3MACLRDPOLj9gl3cdDBPhY+fN7+3RFN00Y0HTCOYEKIKuB7Usr7hBATgI3AWCll9aBWbIgRQjwJvCCl/MFg10UbORKdSZ6rstnYaFO/oZHbNhuo2hTtOVFaIlGm1W0Fn5/V4gTUHJsF1dtJhQ38iTRFnXFWlxcxfXsTKcukKi+fsuYEtZRQQAwDSOEnafQcwk0Fyg5TZAdY90Kc+tG/oCjZRG5bO+FMko7CIP4rT2PCFw/FFw6BqXskadq+ojOMmjaMCCHuAjJSyosHuy7aPvDuZvj0L6CpHa47F845uv/1GtrgnJ/Dii1w8Qks//KnOP/fNq1JuPEYk08EG+GcW2FLIz+67BJubSsmkkpS0dbMq+OnYjqKcc11bCksJenzdxcbTibJ+CwypsXs6s08/KebGdPWxJUnn8WvjziFGdurKYwneWHyNCy7AjsATPCCtITNqvIJoBTEbQBOf2cdXV8xx66v5sEjKvnaa+9Sk1fErYd+iKn1nUzdXouxyuStaROoKh3F7KWbyG+KA5AJWLw6bR4Zvx8ch0DVZuJNIeJAqX87tuNw07MhTv/5n5m5tREfGQqpxyROo1GJg0kyx6ayvQmLBGHquutj42d7ZDT/nTGbtrDNZS/+h+ZglNWFcyhu76QkXk/U7sBHOzZ+Gk48lfJPj8O86k84PpO6mEOHslj7wUP40CsvYZTk4fzoXNJXL8Fcvxmf0Y4xqQzu+xpMG73Tl1zVtuKc/XvU2jrMrxyH+Z0Pv9d3j6Zpe0gHjJqmDU9f+gMs3ehOX/BrOPVgyM/Zcb0f/gWeWOZN/5XPV5zGspg74vjT/3Y49cW/EHl5LbZhcEOyko48d9mGklHuYyxYVzZmh2LjwSB4WYSf/ec+pjXWAnDzP+/lwfkfoKK1kydnzgTAtqyeB2Yc6GptNgywDLAVcX92tjDFff/4DZFMCoB0JkyrOQbHNHl+5kxqy0sAqB5XQlNZEtN2CHQmyFheGaZJe6CQKG0A1KUryMs08sMnHiWRKAFMMgSIUUghDigLsAi2Wzj4UETJ0E4A96TgPlKUd9ZzzptvcO65F3DaqqXkt/mZVVvv1TiCSQOmG3ZS8MQSjKfiYNuYgPdMMukvj7pB6KZ6OPeXqOYAvq7AtLENLr0N/nNVPy+2y7nyEdQzq93p/3sY48NzMeaN3en6mjZYHJ1h1IYaIcRlwJeAMUAzcD9uM7T9PspUwFeBC4CZwDLgk8AngMuBCPA7KeWVWY+ZA/wMOAiIe/W4SkqZ9pbfCZwAFABbgGullH/ylh0LPAmcC1wHlAD/BS6SUsZ2U9eFwK+AuYANrAJOBT7nlYcQ4ixv9Xzcr+rvAF/29uNuYL99smOxGLm5uXp6b0zHe/rzkbFpb24l6gWM2eun2joIZL0G8UzPdMqGTMKd4RgmmffYTGsqJ2taYShFaXt7/yv3/SJx3P6Jd4vZfOb1d4ikMrwxpoyL1nnBouHDSRYTNdz7cceBckAp0hGLWCQCQCDuJ9oco70wCqZJIJ7u3oTCIOhk8Nm9DwsGynvzq17rGih2/Fi464QzaeL+AEWO6rO8Z30TB/psq/caoNIZINB7K52pXb7ukax9Gsj6elpP725aGzjdiWX4qwZOAfKAjwIXAnujCfY84HSgFEgATwGFwGTgOOCbQogjAIQQZcCzwCO4gevhwInA/2WV9wKwADdgvAa4SwgxK2u5BZwEzAemAQuBSwdQz98AS4Ai3K/Ry4GUlPJG3KD1bill1LvZ3n59Hfe5GgU0ADtpy9z7sg9Sevp9Tt/0GSjIcfvi/fgcohNG97t+4OqzYFK5e+fco/nZqRHyAm5i78ZjTPKu+SiU5+NXDmd3VBHIpAmkU0ypr3EfoxT5HTEMpdwmZI8/k+me982Tz2NjQQkp0+KKU86hNq+A7fk5fPINiek43eUA7lHXBGzHjVgNIOKjdkwBa8qKuPq4Q3ls2kz+PWEuDgYZw+jVH8oxTeI+C2yn1wHc9llYtkO0vZ2cthhlia6Mn81YtpExbX57+LFsLQlh4OAjRS4tQNILGxWGP4GJwiSJj87uMNLBIkMOT02ZRll7HXNqt5AKdFIXdQN0w0igCKAAB5OGyQfjXHUWmCYqEiRlWSQtH88fcijKNKEwinHD+VCcR4aou53iXLjh07t83c2rFsO4InebFx2FcdjkwX8f6ulhPb2vKO/nmMr6WTbc6QzjMCelfDjr7lIhxL3A8cDv32fRP+saHCOEeAi4HviBlNIBlgkhlgECeBE4H1gmpeza5lYhxE+AG3CDQ6SUt2eV/YAQ4pvAscCKrPnfkVK2A+1CiL975e9OChiHO5inCnhlN+ufD/xeSvmGt28/Ab44gO1oQ82xc6DxbsjYEPDvfL1Jo2D9byGRglCAE4DmrxpkHAhYBjARan4NqQx3Bv3cmnaItSYotQqpdRT1sTSFjqLFnyGWBKcjSUc4QlNdAieW4LV6g8bCPH4avpA3wqXk19QwqW4jSyMRzEgei5a+xbbSUloDQQy/RX6ik/FtaRzbx+vjykhFAuAofEmHw6u28XJFGQWdCXLqRrOKQoqcag5uegtZtBDbstgydhS2z0d7xCSaTOK3bVCKcKwTQzkcuUniT4cIOgkw4pgqg0OGgg6LS577CwpIYtExoYL66ZOpqKsnPC4EyiZ40FxS67cRnVxOQ16EvPwc/FPKSEdD+HLDHB4Kc4qdQN15PKMKIpQn08QbE0TGF2KvryVlmPjLCxiT4+V0r/wYhs8i4CgSaYejwn5IpcFnYZomwS8dD6mM+3Ua8O2Yfe3DmFGBb9NNqEQaI7SL11zTtL1OB4zDnBDibNys2iTc1zPA7oOmgajJmu4E6rxgMXte18+0icARQoiWrOUGbtYQIYQJ/AD4FG5WTwE5uNnLLraUsj7rfkdW+bvyWeD7wAtCiDRwH/BDKWVmJ+tXAlVdd6SUjhBi0wC2ow1FpgmBATaUhHoapk3DIJDVrRDDgKAbgIT9JuESt5m3Aqgo9gMRxnavHHb/TXPLO7d7fldPvcl9Njxhp1VSSjHnwtUYgTArSkvYVFLAt19ayri6Jko73cEsTVRSnFrJ2hlltEZLuoOqtGWRDATIZDLM2LSGgrYYJbE2qpMTyLc3IezrMM33ntkIZ013PVVdV6vuKtXw+4hE3TWtyaPIfkqBnkDehJDP6j0PMLKe9z2hg0VtqNOjpLUhRQgxFjdAOgN4XEqZEkL8lIFl5vamTcCTUspTd7L8bNxm8pOAFV6QJtkLfQellBtxm+ERQszFbZ7eCNxBz9CCbFvJ+gYXQhjA+PdbD017LwzD4N07ZwAw5uKN/GvmBEQ0wpTahu51HOCks79JZdphQsrtH2mbJoFMBgwDZZqMTW4j5c9hWzSfozd9mgIv4NU0TdtbdB/G4S2K+xrWA2khxGHApwehHvcAQghxoRAiJIQwhRCThBAne8vzgIxXT1MIcSFuX8X3TQjxGSFEV+e1Fm87tne/FpjkZTi73At8XghxkBDCjzsAZhSaNsi23jaRAn+S4pYOsGFNaSE1eTn85NhDeCevmCVFJdQaJuNq6ilo76Ao1oEvkyGvrYPVZZPZGirl8P98VAeLmjYEKK/vserTB3k40xnGYUxKuVIIcTXwKG5T9NPAn3EHl+zPetQKIT6I28/xOtzWrCp6+lHejTtQZh1uU/a9wPN7afPHAdcLIfLoGSV+r7fsNtz+nI1eJrEYN7gdCzzm1fNu4Lm9VBdNe1+W3jKJyZek+cOR8yiPp6gNB6HTHRnsGAarIyEuXFfN8tkT3QcoRU5LJw1FJRQnayhduOPpfzRN0/YGQ6m+p0bQNG0f0h84bbfGXbyC+rJKop1JGrJ6Bs5Ipbj6H88RcWxa8iIEO9LEIiGMZDsXVZ21ixI1TduJfZL+u/K0pb2O9T/+58Jhn2bUTdKapmlDzObbZjF362YyQYsC2yYIjE+lGZ/McPfJH+CZWZNpMwK0RYJsGZ3Lol8ePthV1jRthNNN0gcgIcTjwFH9LZNSRvdzdXZJCHEU8PhOFl8npbxuf9ZH0/aX1+6ewxOPVnHZEz6+9/eXWDZ7Kk3RCA3hINvKisjBIdIe59TzKpj3ET1uS9OGEjXs84k70k3SmrZ/6Q+ctsfOWPwm573+Fml/hKqx5WR8PlIoCkJxvr7kQ4NdPU0bzvZJaPfdxb2bpK97bPg3SesMo6Zp2hD3yGMH4V51Ex577DEAFi9ePIg10jRtV0bitaR1H0ZN0zRN0zRtl3SGUdM0bZh44Oi/07A1Q+iQFOgEo6YNWSPl3IvZdIZR0zRtGLhj4oNMe2E9C6pqmPlIHQ9U3Ek6nh7sammadoDQAaOmadoQt/H5DUyrrmNrQQkbR5ezYdQY/I7Ff8bdOdhV0zStHyPxSi86YNQ0TRviti7+B2MzLQSNNB2REBsrSthWXETI0RlGTdP2Dx0wapqmDXF5CUWYOAtb1jK/bT0rJ4/hicPm8eKcuVx4/IuDXT1N0/pwDKPXbSTQAaOmadoQ9veiP5K2FCHiBJ0Ms2urOXPpKzimSUsoij83h0QiOdjV1DRthNOjpDVN04awoFKEjXjveRm3KTrS1kmLFeH4L26iJppLSBmUtzYQzSR5tqSMtl+PHYwqa9oBbyRe6UUHjJqmaUPUa77rMYuKCSeSrC0sJ+ELMSbWwIsTZ3DMq6uZUVVLxjJ5ZuEkEvlt1OUX8+KEcdTnh8FRBL7TzPYrIxTmBgd7VzRNG+Z0wHgAEUJUAluAiVLKqn28rfOAa6WUE/bldjRtxFGKF0Nfp9QuIJ5fRkduhG+eciGOaXLYinWUtjRjpi1mVNXSmh/h3fnjCfosMn4/pmmysD7G//JC2JZJNOhn2g0JgvVVbPj1FAJ+a7D3TtMOCGrfXHFwUOmAcYQQQijgKCnlC/t4O8cCT0op9XtHGznWbIPVW+HImVAY7ZmvFDz1NlgmHDtnl0W0JhXPrUsx/48PM/bZt6AkivH8KrCg1fLzv8rpTNzWQWWsFoMMESeDnwwp02RrXhm+OFQkGwiSZBERMsTY4h/DY+IgHMsN9F6bOZlLH1nCO1Mm8sohU2mPhmjNCYNhkJdIErRtnLRBpD1FZ8hPczjAhMY6ZrY3cfQXVpAIF7O2KEqn38ek1jrm1NdSH8lnVUkJLdFccjtT5HV2Mrl1G5Fkghcnz6AtGCE/leD0aRazJ4Z5bjP4YwnKOpPkTYhQZ/mpyIGcgMFXF5rkBw2W1Sm2xBSLRsGdbyuKwgbnzYKnN0NF1OCg8pH3ZappI53+0tc07cD2v+Xw4WshlYFJ5SBv6gkaP/9buO1Jd/rSU+EXF/VbRGtSsejeDMf++xlO/dvjgAEoFAoDk3TYZEVkPotb78GPjcICLCCD4Vi0tUykk1xqSDOP14jSQn1uBXYgRTiVoiXH3U4wlcZyHGJ5Udry3aDLxB2RGQsFyRgGr5TnE8sLAWA4iqqScqpyS8iNd+L3KTrzI6AUG0Jj2DCqkqn123ACfpTPR1uuj7bcCNXlJYBy98OAViuHu6sNqIbiziTnLKsiZDvEfRaPzp9ISzgAKH76ms1PjzX4whMKR4FlgK0AFN98BmJp95n544dMLpqrx1xqI9dIGRmdTQeMw4wQ4lLg60AJ0AbcDZzqLV4ihHCAB6SUFwshRgF/AI4BtgM3DnAbQeBXwOlAyHvsd4EXgccBSwjR7q3+ZSnl3UKIQ4BbgRnAW8CSAW7rAuB7wG+AbwD5wO+Bn3h1PxHYBlycnT0VQnwOuAwYC2wArpBSLvGWzQd+CczG/VZ+BfiKlHK9t/wub34C+ATQAVwjpfz9QOqsjTB/et4NFgE2bIfnVsBHD3Hv3/V0z3p3Pb3TgPGlrYq1LQZ/f+G/GN1NUT3/S+Jxzly6FD9p3MOuG1AaKJopoZNcAGz81FJJXsTPI9MX4xgm07bVYGUUjmHy4deW0xqO9Hsi4JRpIkvzaQsHuucpsztiIxaKML6tnqb8fMh6/NrS0fjt/s7nmLWNrPWnNrYRsh0AwhmbyU0x3hhTDEBrCn77lhssQvem3e17m1DA3e86OmDUtGFGf2KHESHENOB64DQpZS5uQPQPKeV8b5WTpJRRKeXF3v37ARsYBxwNXDDATX0GWATMlFLmAccB70optwGnALa3nagXLObjBpIPAUW4Ae0le7Br44ECYBJwJPBVr7ybgELgEaD7khZesHgFcK63/ErgESHEFG8VBfwAGANMANqB+/ps8+PAY159vwr8Wggxfg/q/J7EYjE9PdSm54zrnoffR0dlfvdde9aYnumZo3daztRCg6CpWDom+y3UEy3ZwMbiUm+Ooit7p4AQ8V7rhumkNlqGY5gYCkzHZGrNdj77rxcYs72FeDBAKJnyNqEIJVOkTHhychmbyqIEkz3Bn2k7kLZBwYTmOrYUltCXP5MhYGd2mN+L6qlfQyTUa1FDpGdAjQEsKOs/s5I9d06xMfivu57W0/vQSLzSi6GyDgTa0CaEmAS8ixvQ/VtK2Z61rFcfRiHEGKAamJKVWTsRN/O3y0EvXtbvSuBC4GUpZSZr2bH06cMohDgXNyM4XkqpvHk/Bs7d3aAXb1u/BAqklI437zXgdSnll737s7z9LpBStgoh3gFulFLek1XOY8CrUspr+9nGHOBtIEdK2ellGEullKdmrVOPm8V8dFf13Qv0B26ocRz4xb9geRWcfRSctKBn2dZGuO5htw/jlR+H8oKdFvPUZof7nmnh+9+5lgnbt4NjeyGhYll5Bb9fdArnvyhZ0PwOBgYWChMHA5taRtPAaKK0Mp711IfyeHD2x3EMt+9iXqKdg9dsoN3KYfX40TQWRGkPhwhkbNqiOTTl5nDnQZNIWyaBZJpwe5pUwCIe8DGxcTs5qSSri0aR5yg6gn6SpsnY1nrGtrcSytg8P2EqKZ+PUDpNNJ5kXGs9fpVmVVklreEIOA452BTkBajvdJixrYXxrR1sK4uypryQgAUlEfjREQYfnWJy/auKTW2KWcVwx9uKaACuPMzg0XUwJgrfPcwk5BsZX6LasLdP3oiXfXxFr2P9Lx6aNezf8LpJehiRUm7wgrMvAbcJIZbjNqX21/xb6f3flDVv4wA3dR9QDvwcmCqE+B/wbSnlup2sXwls6goW93BbAHVdwaKnE6jpcx8gF2gFJgK/EUL8MmsdH26AjBBiMm528lDvMV31KqXn+cguH9xm6dw9qLM2UpgmfH1x/8vGFMNvPj+gYo4bZ3Lc+UVw/s07LJuP218DTu73sRVA2dqNrJv5A7bZYbYHRnP86qd5dsrRRFMJTlv5MnV5hfxDHI6Vsclt78RSikQgQDwcImQ7hNM2acskZZhUtidoyg0RzygSmMSCOQSTcV79WpTJFWFvq5X0HCa6+IEIbuJ+V8p2ufSqD/R8N35jUc/8j0zpZ2VNG4FGSlYxmw4Yhxkp5SO4za8B4IvAo0KIYnbMXG31/o8H1nvTEwa4jQxwA3CDEKIA+DVwB26zttPPQ7YC44UQRlbQOKBtvUebgKullA/uZPnvcPs9zpNSNmZlGEfeJ1gbMaypE5meuRvoCeNC1pV0RHPwKYfVo8ZhWz4OXrOeqdXbeHvCeJ5eMBcMg43hIG1pBZk0xDNssyySSQcCUKMM1M2jd75hTdO0AdAB4zAihJiOm117DojjZtsUbhBXC0wFXgCQUlYLIZ4BbhRCfBYIA1cNcDvHeWUv97bTgdsNC287lhBiopSyK4v4T9xm5W8JIX4OzAUuAvbV9cp+DvxACLEWWIY7MOdgoEFKuQrIA9YCLUKIEuCa/2/vvsMkqaqHj39vh+npyXk2zOacCMtdcs5IFFQEFZAgqIgRfogCCrwiIIqIioJIFJGguCCSQTJ7gQ1sYHOanZxDz3S67x9VM9szTNpl8p7P8/RudVV13VO305kbqgcoDiEGlOd3p9Pyf28AkNtYB9ZS0FBNsm1hn02bmVBZyVUnHcPGoJ8zli+jOtlHZjTE4gWLIBKj6io/OekZQ3wWQux54qOweUImvYwsSThJXwlQC1wBnGWMacEZc3iD1rpGa9022/dcIIBzse43gAc/dcSuFQIPATVuWZOAbwAYY9YCfwTe11rXaq2/ZoypxZmpfbb7mDvdfQaEMeYenBnff3XL2wpci9OfBs6km8NwZpG/gZPQCjHiTPrW/pSmJfNW4Wx84ShnfvAqc2o3kEMVadRRkpVJfjjODwrrePKpA5l7QB7rssfw/pci2BvTyJFfeBFC9BOZ9CLE4JI3nNglG17YxDNXrwG/j0ve/3f7uIqQP8B1x51LvLWFP7x08JDGKMQINiBtgd8+e02Hz/rfPzZ7xLc5SgujEEIMY9OOn0IgHMUqRU1w57ys8vQsJm8v5evnS5ezEGLgyRjGPZTWeiVOV3NnW4wx8/qxnInAqm42P2yMuay/yhJitEov3k6wqIBn5hzM3iXrifj9rM6eSCteFn2t558sFEIMvvgonGMpXdJCDC55w4nd8krBXXwyaRqNyUGyG+sZu62SlmwvZ607f6hDE2IkG5DM7ptnf9Lhs/6Pj80a8RmktDAKIcQIMOflL9J81NOkE6XKG+Dkyq5/plAIMfTkOoxCCCGGxNgFhZxS+Q0WL17cfjkAIYQYLJIwCiGEEEL0o9F4HUZJGIUQYhgrfWUtS876HxF/gMy6GuxdhagxKUMdlhBiDyMJoxBCDFOvJN1MKCeb2oxcrFI0BQNM+k4JtY9MGOrQhBA9iI/CMYxyHUYhhBimsrxePC2B9gH0VnlozfGQdt72IY5MCLGnkYRRCCGGoSVffIJqlUNmuAHcy58pG6cgXILX60MuiSbE8GWV6nAbDaRLWgghhqGGxSV4SaLFn8zhpe9h4+kE4iEePmQOT8w+gtP3+w/rpkymwuulwgfv/232UIcshBjFJGEUQohhpqWkDn/cQyTiIS3ejDeSgQewpDB7U5Qv160ktTVCtKKK+PixJPv9HHzhFsLhZszDc4Y6fCH2eKNxlrR0SQshxDDzZtED7B1ZQqGqpi6Q0uGDekpVNWmtESyQV1HD2mASb2em0RRIwpORxV6XbBmqsIUQo5i0MAohxDCyTH2LmWTQSDot/iTSwzXgCUE8CMRpCYZ5c2oR/5k2gdyWCBvTUoh6vZQm+TmgsZkcr5/ANfUUNdWx4bcym1oI0T8kYRRCiCFkQyGWjr2G8lgeqVE/c2kljc2UBfIoTcmgJjWdiqYxjGkpY9+QYXPyQvYvreSYT7YxY2MFpekpfOdLR7EjK41mjyJoLamhCMXJGUz8QRWNNkZTJMaa67KZUpA81KcrxB7BDsxPVA8pSRiHMa213xgT6W2dEKKfNLfC/z0IT7yNrWyk1eNj8aGnseiLk5l89+NQ1QALp8LyzbClsn2mckQpQj4/GZEwbXOXFRBDofASx08V4wlQTybVKOLE8dDky8DG48yKRwmQgccTJugJ449DiyebutQUJpfVkhyJAWmsStqb5fnzAGhKCwAwpqGZL360lkcPWUBONE5MKQ6obWRSqJVWpVielcbG3DSm3gN4w7R/j1knSA9w2MpNTKis429H7E08HIc4EPA6+4bjzv9ehc9aol4PeBQBryIct3gVnDVDEbaKZC/ccriHCRndf1m+VWz55Xtx8lPgtiM85AZH3xerEKORJIwDQGudBvwMOBPIB7YBlwIfADe764PAm8AVxpit7uNeA5YCk4GjgV9orWcDfiACnAY8Bnyzh7JfAz4EpgDHAuXAN3A+8u8AJgIvA+cZYxrcx+QCtwLHA8nAq8B3jDFl7vbvumWOB2qAR4CfGmNi7nYLfBv4OjAbWAlcYIxZ00s9HQm8BJwH3AiMAZ4ELgduB74A1APfN8Y8lfC4M4BrgWlACXCTMeYRd1sRcC+wH5AELAe+Z4z5wN3+M+Aw4D3gYveQfzTGXN9TrGIPcd2jcNdzgPOGSSbGGa/9k99wAVcu2+zkWtur2ndvS3WSrCUpEu6wDsCHBaJ4iZJGFSk04CEKgJc4GdFqWsnAT4jmYJBYAKpjKTw3+yCym5vILqslOeHPw3qVR8zjfGynNDvlfTwulycPnIf1eqj2+8iLRJkUasUCH2ekUufzkVvXAkBtVvBTpxwHXt9rGsQtxOLQEoOsALRdCsRrwe8BpdzIHa1x52yjFh5bC7ip8pb6GG+d2/VXS0PY8rknY9SH2+7Hefw0b5f7CjGSyYW7RV/9BTgAOAbIwEn0SoDfAAe6t0lAJbBYa534iXkhcCeQ6f4P8EXgOZzk84d9KP9rwC+BLJwE8yGcpPFwnGR0FnAFgNZaAf/C+bSf78bVAPwt4XjbgZPcczndjfFiOroAOAvIw0mQf9eHOAG8wJHAAmAOcCLwrhtTLk6CfZ/WOsWN9zic+v0ekAOcD9yltT7cPZ4H+IN7HmNwkuentNb+hDIPB7YC43Cem2u01of0Md7PpKGhQZaH8/KmcjrzxaOkhFs+cweTnxYUn752oocIcXwUZxQwoXUrV51yBU/sfRz3HHQGWyemYz2x9n1Dfi++cBRPJEawOUxxbjq3nHkYecD4cJQWjyKOkwS2ehQ1STtf9mlugtktj4KYdf5P/LLrfL8Xm+q6r+dtlU3tyaKzr/3UPrIsy4O5LPpOycVf+5fWugAoA+YbY1YmrPcAzcCpxpgX3XVpQDVwhDHmHbd1cKMx5sKEx90PTDTGHN3H8l8DVhpjvu3en4vT4re/MWaJu+5WYIYx5vNaaw38D8g2xrS623NxktkJxphP/aSE1vpXbkxfcu9b4EvGmMfd+ycDDxtjsnuJ9Uic1swCY0yFu+4fQKox5mT3fgrQBOxjjFmmtX4GeN8Yc0PCcX4HBI0xnZNYtNbpOK2U84wxq9wWxi8aY+Yl7LPEjfe3PcXbT+QNN5y9vBxOvglad7alrS6YypIFB3Ley+7fUB7ltMZ1w+3p7bBsgTKmkUcxXlo6bG8hh2SqeT3vUILeBq4/defLeG7ZRm5Z/AfKKWKHbwItSX52ZGURSvKzeUIBj8+bgdfjJfEvzuRojBYs05tCrMxII+x12gUaAj7KC9OcnRITQGsJtkTIbgqxIycDalshIwl8HueC4aEoJHl33u8ieUyskl8d4eGHi7pui7DWcvbiOI+vdbqy7z/Jw1fnSruFGFID0hT41fM2dfiQePjBKSO+yVG6pPvfZPf/tZ3W5wMBYFPbCmNMo9a6HJgAvOOu3tzFMbta15OShOXmbtalu8tT3LjKnNyxXQtO9/V2rfU5wA+AqTivmSScVsDuymxKOH5vYm3JYkJs9W13jDHNblyJ8R6ltf5BwmO8wBsAWus84Nc4rZZZOI0t4NR/V7HuarxiNDtmL9h4N3y8BcwGauJ+Ug7Zl/OOKIJ35kNlHSyaDmt3wEsrYMMOmlYU05rkZ2tljGBjA3mNjQQiESpScrA2Qn6oiSTiJFPGjqRsCsLleHHGN9b7s6kM5jC+PsrcupUsz1zApKodbMkdB8DBm5cTw0edN4/0aJT0aJTslhZe2m8+K8bm0+rzEYjb9oQxpqAiFmFDRjrFSX5S/YqcUJiylGRCfoW3phm/itOSkownEiUtZmn0e5hcXElBTRNN1tIUSCLa3IrPo8gJApleZmTEmZmvWF0SpdUq9hrv43NT4aNySPXB5ft52drgDHucldP996JSisdO9fB/ZZCTDFOyRvx3qBB7DEkY+99m9/8ZwKqE9RVAK05CuR7aWxgLcLpw28T5tK7W9ZctOAlTjjHmU+VorScAD+OMu3zOGBN2Wxh1530HyRbgfmPMbd1svxkYCxxgjClJaGGUbybRN+NynNvx+5INtDeTH5LwSyrjcuHIBQCkurecTodJ63Q/gPMXTBs/zoDhgoR18x8xjP/647w6+XDmNy/j4OKlLC48lRkVlXjcxmlf3LLXhi3ce8B8AFqV01LZHPRz+tIVrBg7lqpAJnPrmtkRjfL+fZPxensbJ9g52u74O9z7UsI1wrP6OAFbKcV+Y/pYnBAj1Gi8cLckjP3MGFOutX4C+IPW+gKcBGeau/lB4Eat9SqgFmdixxrg/SEItY0BlgF3aq2vN8ZUaa3zgWOMMX/H+Sbx4CS8Ea31gThjJFcPUbx3APdrrd8F3sZpXVwAKGOMwRln2QzUuAn5LUMUpxC7bMxXNFknTCOW/3s8ngheYrT6vER8HnxhZyyjlyhhPPjjUTYXZJISitCS7ONss4KcqKIhKZlwfTOv/WXSEJ+NEGI0kcEjA+NCnNnOr+NMIHkaZwLG93EStCU4ky7GAqe1zTYeCm6r4uk4LXAfaK0bcLqbj3S3rwauxzmHWuBq4NGhiNWN5wXgEuA2nHGWbZOJ2ppIrsNptKnCmSH9NjBk9SvErkrOy6YJy5bgBMAyrW4rcZ8lSDMBWvAToSItgzOXfEJ6uJW6zACHfbKFjyZP4J2iAq79UpCm348d6tMQYo8WR3W4jQYy6UWIwSVvONEnz6Xew/HNz1POHKzbFdysklA2ynrPOJYdNB5ffYwWn5e35k5BhVp55skFQxy1ECPOgGRzXz5/c4fP+r8/MHnEZ43SJS2EEMOQt7meNb69yE64+GGSjZJEK6FxPmxFLac8ewIzp2cNWYxCiK7ZUXgdRkkYRxit9TXANd1sPskY88ZgxtMbrXVjN5veMMacNKjBCDGCHG9/yDNj7yWztKR9woufCB6gtCCH//vglKENUAixR5GEcYQxxvwC+MVQx9FXxpi+Tr8UQnSS3lRHeTCdvFAjXmLElIc1OWOZuHb9UIcmhOiBzJIWQggxaA6v+wEvJd/BlrxJxJUi4vWSXFeN97FpvT9YCCH6kcySFkKIYUopxXGt3+ekj88g/6h0Tlt5Gt7HJg51WEKIXsSV6nAbDaSFUQghhrnkwnQOf+z0oQ5DCLEHk4RRCCGEEKIfjZZrLyaShFEIIUaA+vJmfnvqu4RT80htaqH4u09x2cYzhzosIcQeQsYwCiHEMNfaFOa+I15kRVE+747NoSrgZf3U8Xz7iLeGOjQhRBdiquNtNJCEUQghhrm79v4378ydyrvj8skpqyOjrIlTX/0YvamUG2f+c6jDE0LsASRhFEKIYey7+z7JU4dpfI1hqvHwj31mct2pB7F4/mQm76hlXEx+bVKI4WY0zpKWhFEIIYap7y78N2tmzeWiNz9m0SfbaQokAZDd3ILXC40pfvyRKN899PUhjlQIMdpJwiiEEMPQtXMe46QdpUyLtLBg+yfsU7adlNYIylqufXkJ+5ZW0pQWIBiJkBOPYR7bNNQhCyFccdXxNhpIwiiEEMNI1avruPLAZ1k+azYbi9K45t+PkdUSZ3xLM3c++xKpkQhjG5oBqE4JUB1M5r7D9uLd65YPceRCiNFMLqsjhBBDqOa+V2m86EGiKRkkRxtZlz2LqUXT2JaWyn/3OpTDP95BIOqMUzx803YO21JCfSCJbdnp/L/PHQTAPqUVvDeliOe+vIZ/PjCdpIB8tAsxlOQ6jMOI1vpQ4A1jzJA8K1rrImAbMMUYs3koYhBCDJwdDZaUaJis8krYVEZJSLE1M4/8j1azoTJGSmMDaWU1ZLy5lLySClqwbMwbS1IoysSmGpKJ0Kr8hAIB/OEYYVJIo5nqlBwCoQDJMYuPMNuyMhirsqlXfqozs6jOKWTRhh0ctnoTt556CusLxzBvawkANYEgF7y3GgVkh1o5fN02Xp85kTW52Vz09sc01qVwt15PsKGZHenpbMzJIDUaIS0cxhuNgd9HXdBDZVYG4xrqyZuRzSfpmdRmpXJYoJXsNAgHkxg/LokpgQhpBSlsqvdQmOnBE/CwtSzC2AlBpvuiJKX6qMJLsg+ykz/9Mby9wRKKWnKTFTnB0fflKcSeZsQmjEIIMVB++EqMX5s4Ka1hNt7yEwqb6vGlplM6aSYHrPqAqUBJagZjm+rbH5MO5FaWAaBQQAopNkJ2SyMKiKoIy8ZMoqAknSg+GoHn5k7jrNVLeG/SGE7evBSawsypWM3f9z6TI5atZZ8tW3hz9gwWbC2mLiXA81OmMrtyZ5njaxsByAy1klXfTEooQsnkfGrGF+CNRtm/tJo350yiSfn50osfkFvbSH1qMh/tO4Xn50zj1RlFeOJxjlhXwnXZmaTVK6oyU0kqjbHf5lJOXbuWurQMQh4PD86cQG1+Gig4ZF0pX1yxjj8evBebxufyyOc8fGHWzhFOFz8f4y8rnFZRj4IHTvLw1bkyAkrsOWKjZGZ0olH7DtZa+4c6BiHEyFPRbPm1iQNw4LZ1FLpJYX5TA6ev+qB9v8RkEcACFi8eYkASOGlie8eU10aZW1JOPOHv9JPWrMYGq6hJSQZaUMTxEOXwTW8CkBpq5dy33sNLnJzmEE/sMwPiTiIWV7AjM5V5Oyr57msfgkeRV9qIVV4AYj4fTZmpLCquYMK2cnLd5DKjqYWcygZenVnkHMfjYemEPObVNFCVmQpA2Odl9dg86tIyAAjG48TSA+B+Cb41o4gW6+GElZsJx+D6t+Pt57SuxrYni+CEe+2bO7cLIUamXlsYtdabgXuBY4BFwCbgK8A84EYgH3gcuMwYE9Va/xU4FsjC6bK9yRjzN/dYF7mP2ccYU661LgCWAtcaY/7SSxwzgHuA/YCNwF87bX/NPdZk4GjgF1rrh93Y98P5BF8OfM8Y84HW2gNUAScbY97WWk8FNgA3GmOuc4+5CviZMeYfWusxwJ+BI4Ay4NZO5fuAa4ALgGzgQ+C7xpiPtda5QDkwwRizQ2t9NPAycJEx5j73sVXAccaY97XWFvg28HVgNrASuMAYs6aXOjoSeAk4z63nMcCTwOXA7cAXgHrg+8aYpxIedwZwLTANKMF5zh5xtxV1V4fu9p8BhwHvARe7h/yjMeb6nmJ1H/uaW09TcF4z5cA3cL5p7wAmuvV0njGmwX1MLk7dHw8kA68C3zHGlLnbvwt8ExgP1ACPAD81xsTc7btVt/2loaGB9PR0WR7Gy7GWRlL8yTRHoDIlnTg7/7KOKYXXOsmQhR5GKbVtVe4yxDwetmZmkFoTJoZzeRy/aiYQi/LstHl8bdVr7Y/ODDXwxNyFvFGUz96b1wJxmn1JfHHFBoLNMeIehYpbLnjvY3x2Z4neiMUTjwNO0kjcCaEpmNQhuqjPS3IkSovf+QpIjURp9nrA2vak0GPjHe57YzuTPl8sjj8Wpyng/F2eF9xZh5lJkOSxhBOmhuYFGZTnTpZleVeXB8pomRmdqK8tjOcD38JJhJYB/wSOAvYGFgCnAWe7+74J7IOTMN4A3K+1ngvgJoUvAo+4LYB/A17sQ7LoA57B+XIvwEl8Luti1wuBO4FM938P8AdgEk7y9CHwlNbab4yJ4yQbx7qPPQ5Y33Zfaz0emIWTsICTeMRwkpjDcRLDRFfiJGqfc8t6A3hRa51hjKly663LsoADcD7aTcLxLgDOAvJwEu/f9VRHCbzAkTjPyxzgROBd4F9ALnAzcJ/WOsU9z+OAvwDfA3Jwnuu7tNaHu8frtg4Tyjwc2AqMw3ktXKO1PqSP8X4N+CXO6+Ux4CGcpPFwnOR/FnCFG6tyz8MC892YGnBeR222AycBGcDpOK+Ji+noAnavbj+zxA8pWR6ey2Ny0nnqDC+L8uOMTVPU5GQT9np5ct7+fOOMS9iWkUOjP8DmjFyq/cluy6LDQ4woSUArEMPia9/ujcOKsUV4ghVkUkq6quBXRx9KWmsLX/rkfV6YNA/cfX+//9H85KST+PnbD3Bg3dsUqtX8d94MJtQ30pLsxRuzxJWH5pQgUY8ipsDTGsN6ILmhGU80hi/USpg4L00Zx45xeSyfPYHqzFTWTS6gOieFsz5aT2F9M0U1jRTtqKUsLciBnxRT0BBibE0jx67ZQnZNOTV+HxtTg8Qbw6hIjGA0yhUb1pG9bw7rT5zFcZMU953oba/DglTF307xMisbsgNwyHh46HPeYfP8yrIsD3SyOFr1dQzjn40xqwG01n/DaWE80BjTBDS5LUUaeKRT8vd3rfWPcBKYVe66bwJLgPcBP06C0ZsDcJKHK40xIWCd1vp2nBa/RE8YY15xl5txkpitbRu11j/FST5muPG8BHwZJ7E9Fidx+ZXWOtO9v8wYU+Umj0cD040xdUCd1vrnwAsJZX8duKWtpUprfQNOonIy8Khb1rHAg+7/1wK/dZOgY4FX3SS2zW3GmK3use4HHu5DPbX5iTGmGdjqPjepxphn3WM9CPzRrYNlwHeB3xpj3nAf+77bMnse8D83hp7qEGCtMeZud/ldrfVSnNdDX37o9h/GmPfcYz8M/Ng992p33TPuscBp5dwPONYY0+puvwqo1FoXGWO2G2OeTDj2R1rrh3Bax/+UsP6z1K3YA5wwxcMJUwLAdLjJ+Ug7y705f4NBWjePTfxQbWtkiJSUs/Wr93DIK0uJKi8hfxJZkRBX/u853iuYxtSKSsY0NBEDwt5k/qyP5vyl/2NaTTlPLTiGj8fOYGxFDeClKd1Pc6oPYlBQ2UBLkpetk8cw6+MSyvJTqW6NESqr5tJ/HcyMadkJ0Uzv4Yyz3P9zOq2b383+TnL79W62njXTw1kzR+2IJyF6FduDZ0mXJCw3AzFjTEWndeluN+/PcFobx+D8sZyK020NgDGmWWt9L/Br4EI3selNEVDead+urlK7OfGO1jrPLedInE+/toSsLZ6XgDu01uk4LabfBc50l491t7eVD7Clh/InJK4zxsTd7vwJCWX9VWudA8zE6Sq+FqeV9licpDJRYp034Yyp74uunpv2wVZu/ZNwvCnAUVrrHyQ8xovTQtqXOuwc667G2/m11dW6xFgDQJl7Dm1acFp+t2utzwF+AEzFeX0n4bSwdlfmrsQqxG7xjy1g2ss/+dT6IDAWqNtczavzbiEjfyyT6uo5c9lySrOyeGPKQh7RpwKwbDwk1dZywkdrKcnJYMb2agCSwzFSG1v4cGIuqrmWGz8+cRDPTAixp+jvWdLn4LSqHQ+scpMmQ8JQH631bJyk8g/AzVrr54wxpb0ctxgo0FqnJCSNk7vYr/PI6ptxPo8PMMaUuIlhfVs8xpi1WutSnO7YUnd84Us4XcbHsLPbudj9fxLOOMeuyt+WuM5Nnie768FJwHJxxs+9YYyJuGV9HqcF9aKeKmAAbQHuN8bc1s32HutwkG3BSfByOrXGAqC1noDTWngm8JwxJqy1/hU7WyiFGJYyJ+dwRtMt7ffHTP8jc7an8eq0ji/dJdMmUFBbzaQdoQ7ro+EY6bTwfxu+MCjxCiF6Fht9DYz9Pks6A4gCFYBHa30hTgsaAO64uceBO4wx38YZl/io1trby3HfxUkWbtFaB7XW03BakfoSTzNQo7VOA27pYp+XgB/hjK0EZ8ziV3H6Zt4AMMZsB14DbtVaZ2itC4HrOh3nfuAqrfVMrXUS8BOchPxZ9xgh4O0uyvoeTrK6tg/nMxDuAL6vtT5Ma+3VWidprffTO5vw+lKHg8XgdKPf6U5+QWudr7X+srs9Dec1XQFEtNYH4oyRFGJE+dH6b5L25WlEW31E3UknzT4PxWnJhCJB5q2t4IOp4/l4Yj6vLphMVZKf/1vdl9E9Qgixe/o7YXwAZ7bsepxWubm4SZfr9zgzYX/u3v8OTqvbz3o6qDEmijPWcS/38U/x6fGLXbkOZ5JMFc7s3rdxJq4kegknKWpL4lbgdHG+7SZ5bc7F6Q7d5p7Tg52OcxtOt/ILOLOojwaON8YkXnujc1mvASns7PoedMaYF4BLcOKvxOmu/Q07h2j1pQ4HhduqeDpO6+YHWusGnD8mjnS3rwauB54GaoGr+XRXvxAjwtk3HsyBR6SSVFfGuwUZvDQhj9TmVo5csRWvtUwpruODBTNYvP9MGrN7P54QYvDElepwGw2Utbb3vYQQ/UXecGKXbF62gy/f2cwnqZn84a+vkN/YAoCZN4GXD5pFld/y4R+KejmKEKIbA5LNHfLN0g6f9W/9ccyIzxplGpsQQgxjk/cex9xVG4n4vNx05oG8P2sc7+wzmdf2n0F6UzNXejb0fhAhxKCKKdXhNhoMm58G1Fo/h3MB6E8xxnR3BYs9jta6sZtNbxhjThrUYHqhtb4G52LmXTkp4VI+Qoge3PfO8YRP/oDXJ43nplMWsXdZNV95eynb01I5xxw91OEJIfYA0iUtxOCSN5zYbb+f8y8mV9US8vp4bO9ZPP7fRUMdkhAj3YA0/+lvlXX4rDd/KBzxzYzDpoVRCCFEz769+gwWL15MAHj8VEkWhRCDRxJGIYQQQoh+NFrG7rH5gQAAPxpJREFULSaShFEIIUaA9csqeexL75AajlGRZDn11KGOSAixJ5GEUQghhrkrFj1LxZQ8Ds1vITkaY+G2jfxySpSrN31xqEMTQnQhOvoaGOWyOkIIMdx9Mn8as+sbWTZhbz7JmcVb0w4mIyfCu4/LJXWEEINDWhiFEGIYu/HAp1i/UFNaNI3z3/mEg1ZtRgFVuck8/ocyDvzitKEOUQjRSXRgJl8PKWlhFEKIYez5qXPYlJpBdnkTM7aUtX8N5Va1UFjTzKPf/d+QxieE2DNIC6MQQgxTG5aUUZySyuUvLeNzK7bgU1EeO2wvKjJSWbhhO/FwjPjD6+C3hw91qEKIBJHR18AoLYxCCDFcPXbREorTUjlibTEA/z5wHm/Mn8qaiYU8euRCHjx6b4pCTWx++MMhjlQIMdpJwiiEEMPQLfveTygpRE5TC4F4DICatGD7dqsUMxqaefCEo/no8iVDFaYQogsRpTrcRgPpkhZ9prUuArYBU4wxmwe4rK8CNxljJg9kOW5Z9wI+Y8wFA12WEG2stWRdV8r4baWkx8O8P20OXhTztldwwf9WMK3Ww5K9ivBjCaV5SWqJM6ekgrWT8ol5PASjMQLKS2NmOs8dfTCtRfcwrqYcv63nwMabUR5pDxBC9B9JGAUAWmsLHGaMeXOAyzkSeMkYM+CvPa31z4BDjTHHDnRZYnRoCUX513VLeIYcphxZRDgliTs/sIRRZPrihMLQggeshVgcfF7AQhwyW0N8zbzLS7PmsDavkLjbqnDEulXgUyzPHU9NSjoAmU3NxAI+GoM51M/IgUgcFCgf3PD423hiCvAyY3M1Y4vG8ciiuZyxfD2pjU2ctHod+TX1bCkspDw3k1ByAOVRLKrYRIPKYWykibD3HHxE8WCJkEQcLz4iKOLE3OU4Cg8WBVg80L7c8efO29pGLDu7pCwQVclEC/IITEnFMz4b7vkWZKd9ulL/8Rbc+SxMKYCKegiF4Y+XwtwJ/f30CTFsRIY6gAEgCaMQQrhe+sK/uWnWIlaOGwurcZJCr5Mm1YQ9TvakFKDAoxKW4fF7/sT5515ISWaWczBrKaitYf2YsRSnZUPEOpmW30NdZhpg249NwAuRGHttL3WTRUdaQ4jDK2t4eWwutxRmM7+2jq+/u4wxpfUctGIrjcEAD594EKcufwdPOI2WDMhuDeEhgNf9ykoi3OEcvcQB8CQkhoo4cfwoLIqYE1snqtOy37bgL9sOZe7KjzbBhj92fNBrH8PZtzvLb63ZuX6/H0HToyCtoEKMGJIw7mG01lcA3wfygHrgAeBkd/MLWus48HdjzMVa6zHAn4EjcL4Wbu1jGQHgd8AZQLL72GuAt4DnAK/WutHd/dvGmAe01vsDfwBmA0uBF/pY1mTgT8ABON9ym4BzgH3cMj0JZe1ljNmotb4Q+AmQDzyN8/0X7Ut5n1VDQwPp6emyPEyX01bvYOVRY3c+YYljjzydxiF1Gpc0vbJ8Z7Lobs8Mh1hXOB6i8U8fo4txTRsKskmJh2j2BJnZuo7ccDWRbdXcu+BLfOvtZRSGwvjCcdrSt7RQK+e8/iZ7Va+ngWymNZSh8KB26+XcdlynnXFX2U1lqHgcPJ6ddfvG6q53bonQsKGY9BlOK+NQP++yvOcuD5TmUTJuMZGydtc/GMTIpLWeiZOMLTLGrNRaZwGzjTHvdtUlrbV+GSepvAAIAk8Ah9DLGEat9TeAbwLHGmOqtNYTgHRjzKquuqS11pnARuA24NfA3sBioKW3MYxa678BTcDlOEnfPKDUGFPeVZe01vownGT0NOBV4FzgL8AjgzSGUd5ww9i/L3ieXwcm8fqM6c6KhBZG4u5T15b0Wdsh6fv7A3/il8ecxNKiie3bA62tzK3cwUdjJzstjAA+t2XSWvAmLLfGIMnLoes28Ke//Z05zRvbj13jyyQQ9bB07HRKVAFTd1S1b3vqGM3RK5czrbSMbEoI0ooigpf69tSvL19dcZLwEMNJHHfjZbpoOrzf6W/KjzaCvnJn3bXJToXqh3a9DCH634Bkdlnfrerwoq/9be6IzyClhXHPEsV5c8zTWm8xxtQC73a1o9Z6PHA0MN0YUwfUaa1/Tt9a/sJAGjBXa/2OMWZbL/ufgpP03WKMscASrfVfgK/0sawxwFRjzGpgeS/7nwc8YYx50b3/oNb60j6UI/YAp91/AsG7V3Fg9WYWnDiBYKqP778coz4MM7Khphk2NVmIWlQ4SjTgd3Ira/nqORfy+eUfEkOxYux4iFlafUlsTcnilNUfUJKawQfjp1FQW8d+W7dTlZLC+1OmgicOSuHxKeLAupxC/rHvXK5/a2fCmBptJUqQSSXltJJGCD/KY3l33+kUj8mhqjTIAaU72JA6jslNxSShiJCJn0aaCOIFkgjhwRLHi5cIIfwkE8GDhzjgIUIM66aLHvdf297m2HYDsF5FOJCBXTiTwIx01IRc+GkXv2u971RYciv87j8wbwKU1kJ9M9x63kA+jUIMudCITw8/TRLGPYjbHfsVnNa/e7XWy4EbjDFdJYFF7v9bEtZt6mNRDwOFwG+AGW5L5VXGmPXd7F8EbHGTxV0t60rgWmCx1joVpxX0x8aYxm72LwJMp3V9LUvsAY67bC7HJdw/c5a3mz0DXaw7pIt1Be6tTXKH+0+/UMWFT1UTT0tj3qYSDtxSRUkwl7DykmRjhLxJ2JhTVg0ZKCCMD+JQHwzijcWoVcmUejPY5Pcyr/nXeIPJ7cfP7Cb6xOkpiSMJuzvbRIquz75LC6fBX7/T172FEMOUJIx7GGPMU8BTWusk4DLgaa11Lp/ugyp2/58EbHCXJ/exjChwC3CL2+19F3AfcDi4I+4/XdYkrbVKSBr7WlYFcAVwhdZ6Ks6YxKuA63ooq/OxJwPdJbNCDKjTj8+l6vhc997O8ZO/mFdGY04GE6tbOX7zcoLRMNVJ6dD+p5Alt6mBiUuLqfPCtOjNyK9KCzE8hEfhb0lLwrgH0VrPAqYA/wNCQB1OohgHSoEZwJsAxpjtWuvXgFu11l/HGcN4XR/LOdo99nK3nCYg5m4uxZn0MsUY09ay9wxwJ3Cl1vo3wALgIqC1D2WdDbwPbHbLDHcqa6LWOskY0zZV9CHgv1rr+4HXgS/jTJiRhFEMK9esPJcDz11LYWGMpuR0pleXMra2mhRChPGRQislLVlsCaRx0QPzhzpcIcQoJ9c02LMk4SR9JUAtTsvcWcaYFpxZwzdorWu01n9y9z8Xp+dpG/AG8GAfyynEScxq3LImAd8AMMasBf4IvK+1rtVaf80dS3kycLb7mDvdffpiX5zErxFYCXyIM3kG4HE39lK3rCnGmNeB7wD3AtXAicBjfSxLiEH1xn2TmVFWybLx2ejitTyj9+VXXzyRtxZOoyY7jTVjx7H/x2so2Luo94MJIQZPV4N/RziZJS3E4JI3nNgl1x38GjPqy2gOBli8t25fv9/qTQRqGjn91pnMO0U6o4XYTQOSzqnvV3f4rLe/yRnxaaO0MAohxDC24Iws0irCNCUldVg/praKWBBJFoUYjpTqeBsFZAyj2C1a65U4Xc2dbTHGzOvHciYCq7rZ/LAx5rL+KkuI4eiLV+3Dbx7chrfFS3ooREMwyPQdZYytrObE/5061OEJIfYQkjCK3dKfSWEv5Wyl4xVAhNjjNI1VjNnawFfefIe0xlYCkVbezM/kjFn5Qx2aEGIPIWMYhRhc8oYTuyUajfLzhf/B77EQaOK6984d6pCEGA0GZgzjD2o6jmH8dfaI75eWFkYhhBgBfD4fNy4/jcWLFwMD+zu4QojPaJSMW0wkk16EEEIIIUSPpIVRCCGGsbMvXk5KeYxoIEBWOEJrUw6nfrd6qMMSQvRk9DUwSsIohBDD1UkXrKbVpvPaggKsUoyra+Cw0iqevCfAqTJBWggxiKRLWgghhqnMiJ8PCrLZd3sZh2zezhdXb0BvKWZsQys3zH56qMMTQnRr9P3UiySMQggxDD3zWhkrMlM5bu1mPplYwFtzJvPyrEl4rGVcXS2tGek8G/jzUIcphNhDSJe0EEIMQ1c8HKY0J53VC2djfc7f9h+Py2dTQTbXvPI4kZhFqVY2+a8k7a3vkL//xCGOWAjRbnQ0KnYgLYxCCDHMNLWE2ZKZRhAobG5pX6+sZfbGYr5/1Bc47BtXcNXnTmcMW4kc+UuWeH46dAELIUY9aWEUQohh5uAflLOoNc6BtQ20ej28WpRHk0dx0ofrKQ5m8NjC+QBszTqIfcq2cOU7L/DBxFksUdewyP5iiKMXQozGFkZJGIUQYhg54Mx32DZ7LmevKyaiFA3KywnLt3LIR+vwKsub08Z32L8+KZk4AaZWNLAybwFedQNZydVMDd0xNCcghBiVJGHcw2it7waixpjLhzqWnmit1wM3GWPuH+ByioBtwBRjzOaBLEvs2eLxOLF4nGXbLG9tjfJXE2VZbQsoL8nWg095iST5yJ01h+SYJeT1UpEapMXnoyQrjRafj+PfW8VBG3bw8pwKVhTlM7OyjMvMe0QIEoxEyW1pIM0Xx9eSSbn6Pn7qeWvCZPzxGPN2bMJjmyA5FXXiXiSftIDUz2v82RmgFMrrHeoqEmIUGX1NjJIw7mGMMZcNZfla69eAl4wxNw1CWRY4zBjz5kCXJUa2lZWWLy2OUdYMPz/Yw7f39XD9syFu+diLwuJJ8tAcS/gCsAk/E2vp/bsh6u7va9vR59wykskIRYh5FI0+5+N4R6aXoooG3svOZFw8DkBhfSO+JIh7vOyYmsOlS1cTe3cpWc2tbPFPJ6B2kBUNoRvXooA4oLAokgmneklvbSHH10JyJI5qaYB/veXcLk0IUSmwll1LGxUWD4o4jM1GlXS6oLjPA14vZKdCJAoZqfDQFXDInI77rdsBX7gNtlXBj8+EK8/YpSiEEANPEsZRQmutAK8xJjrUsQgx0nzv1TirqpzlK16J87lJlv+30kfM6yZ4sU4PUF0kjz39dqyv++1Rn4dmr9dJPIHU1hh54RhJQEgpZlTXMre8EoBN88bgiUaJ+gMkY/E2h9mSPoaIx8++1Rva81YP4COGBzhlzUqSCPVaB77EJLjPLKqtcjoniwDRuHMrrXXuVzXCJX+EVXd23O/KB2H5Fmf5qgfhrANh6pjdiEeIYWL0NTBKwrg7tNabgXuBY4BFwCbgK8A84EYgH3gcuMwYE9Va/xU4FsjC6f68yRjzN/dYF7mP2ccYU661LgCWAtcaY/7SSxwW+B7wNbfso7TWqcAvgJlAFHgZuMIYU+4+5n6cLumL3STzJuDrQDpQBdxujPmdu+984HZgIRACHgGuM8ZEeonrWOA2YBoQBpYaY47VWt8FHAYcpLW+Gig2xszSWvuBW4Cv4jSO/Kan43cq6wrg+0AeUA88YIy5Rmu9zN3lBa11HPi7e85jgD8DRwBlwK19Las/NDQ0kJ6eLsvDbDkciYLbtha3EIu3528Dzlo6FDatupGUaLx9W0Fd4859PQoPFuIWXyzevr7BH+wU786DKuIMK27cifUfbQ13/DLqYh9ZluWBWBZ9J5fV2X3nA98CsoFlwD+Bo4C9gQXAacDZ7r5vAvvgJIw3APdrrecCuEnhi8AjbuL0N+DF3pLFBBe55aQBHwGtwOU4SesCYBzw224ee5x7HgcYY9KB/d1YcRPX14GngPHAQe7+P+5DTA8CdwKZ7mNvcs/1cuAN4EZjTJoxZpa7/9XAKcDBwBRgMjCpt0K01jOBXwKnuPHPA/7tlrW3u9vxblkXu/cfwWkvmggcDlzQh/PpN4kfUrI8fJZ/fXQSRemQ5IVfHuZhep6X70+P4o3H8cXj+FSn9NHanbeu1nW+RS1E4l1uC/k9FDa1tB/Lk3BIj4K9P96+c0XcMmZTDdM+LiN3R3376nFNNaRSSRgfYfyAdRJLwIyZScxt3bSdbm2ppAUiShHtYp/eb05JNjuNLnk8kJ4MyX7ITYffX/Kp+vfddj5MKQS/D679IswY1+PzJcuy3F/LA2f0/dKLtDDuvj8bY1YDaK3/htPCeKAxpglocsfqaeCRTsnf37XWPwKOBFa5674JLAHeB/w4yWZf/coYs8FdjuEmfK5SrfWtwH3dPDYMJAPztNYVbitkubvtPGCZMeZP7v1irfXNOC2BN/QSUxindbHQGFMKvNbL/ucBvzTGrAdw6+eiXh4DTguqcuPfYoypBd7tbmet9XjgaGC6MaYOqNNa/xx4oQ9liVFsvzGKbZf6sNai3OTqV2cGuS3hvnUTurZ9YrFYh21KKaJRZ/RgLA7KA+U1MXx+D8UNiufWxSiv9/LOxmo+akmBSCt4AqRFWoiHw4yLpFIbTGJTVgqzKhvwxi0nvr2G/NIGAi1Rtk/LJquiieyqEH4bYWJzHYGGFvzKkhVuxEeMdMoJ4yVGjAhePISZXdrMDnJJo4EwYZJwEsXWzFz883IJHDiNyJgcMqYWEp83Hm9aEJXsw8YsZKRilXK+8rxeUArrnrPyeLDWYuNxPO42rIVYzBm32HYfdi53120/fxJs/GPP+wghhpQkjLuvJGG5GYgZYyo6rUvXWnuAn+G0Ao7B+aM8FacFEABjTLPW+l7g18CFxpjmXYhjc+IdrfV+OF3SewMpOAlVl3/6G2Ne01pfA/wU+IfW+l3gGmOMwWnpO0RrXZvwEAV9GhN/OnANsEJrXYGTXN/Rw/5FiedhjGnSWpd3v3v7fhu11l/BSbjv1VovB24wxnSXABa5/29JWLept3LEnkN1SlYS77ctt/3v833649PbaabxpDHOPuNzYf/Jfndtoft/eqf/HVO/tobtOVnk1YVZuNppXcyoDeGrTmVbMIXxtoa9o2tJJgxxaMFPJlVYPKxOmUSNP48JDRuYHvs14HzYZO9KJbSdb6f/O68Hpy6Ux5O4AhLrJbE++5IISrIoRotR+FKWLumBdw5wMXAWkG2MycLpwm5/OWmtZ+MklX8AbnbH2fVV5wFKfwc+BGYaYzLc8rtljPmzMeZQnGR2KU4XNDhJ1UvGmKyEW6Yxppt+pw7HXGaMORsowJmHebPW+uhu4gUoxumGBsAdh5nfxX5dlfWUMeY4nDGM/wCe1lqnuJs7D0Mrdv9P7O6ejBDDyMaHZjO2NsTsmno+2n8qFYUZbJuSx4Y543h00UxaUqyTLLqiyksVuWxmMpnN9RxV++32ZFEIIfqLtDAOvAycrtMKwKO1vgCn9e8ZADe5eRy4wxhzvdY6ADyqtT7WGBPbzfLqgAat9USc8YFd0lrvDwRwusJbgQZ2zgd9EPih1vpCnHGVYZzkaqYx5r89HDMJJ0l91hhTqbWuwUkS245bCkzv9LCHgCvdbvwdOBNRev1jRms9C6cl9H84k3Lq6Dg0qxSYgdtNb4zZ7pZxq9b660AQuK63coQYbG/+eQKXfvUTWtIDrNrP+fsmBctp27bz/ILJHPDuGlJiztyzqPVTTw7ltHKUvX0owxZCtJEWRrEbHgDeA9bjtHDNxZn40eb3OOMGf+7e/w6Qi9PiuDu+gdOi2YDTWvh4D/um4UyIqcSZIX087kQdd+zhUcAZON3FNTgTe6b2IYazgTVa60acSSjXG2Ned7f9BtBa61qt9Up33c3A8zjjDzcBW+nYbdydJJyErwSoBa4AzjLGtP347k+AG7TWNVrrtrGY5+IkydtwnocH+1COEIMqOeCjOphMPBbF484Y9sTiTKms5dJ3VlAXy2Nd9gTemDSXLcEgKb8/jKPsT4Y4aiHEaKbsbl17Swixm+QNJ/rk0j8Ws+atECdv2kZLShBvOEp6bR3VBTng8RJTiuCOEq58/0T8yUlDHa4QI9WAtAWqHzd2+Ky3N6eN+DZH6ZIWQohh6E/fHE/WumqCrS0cs2kHeL1snjKBuMdDwY5KcoqLuWzbV4Y6TCHEHkISxmFMa/0czoWuP6Uvk08Gijsz+U/dbL7UGPNIP5Z1N84Fvbsy1xiztb/KEmK42WdHMasL8qnKyebAylq8QJ3XQ7onLsmiEMPZiG9P/DTpkhZicMkbTuySr5/6HqVpmfhRRD2KfdZt4aBrWzj11FOHOjQhRoOB6ZK+plOX9C+kS1oIIcQA+uviAzrcX7z4kyGKRAjRZ6PwmqIyS1oIIYQQQvRIWhiFEGKYi8fjPJZ/H2NDTVTne8i5a/JQhySE2MNIC6MQQgxj8XicN9J/Rzp+yrLGEg1OpPWKMv618IGhDk0IsQeRFkYhhBjGHs/9C6m+bFRIkdkYIqW+lVB2OnmbNg51aEKI7oy+IYySMAohxHAWUQpPGEJ5AYpqq0iKxIjugPKcwqEOTQixB5GEUQghhjFfMImox0dRXTXZjc0AxJSiIpo8xJEJIbo3+poYZQyjEEIMU89OvofJrbXEAhZfNNa+3mMt2yYW8vN9nxnC6IQQexJJGIUQYphqLW8iKRIjJdTCJ+PHEPV4sMC6Mfm0+pNoycoY6hCFEF1RnW6jgCSMQggxDMXjcWbbKsozcshtaUKFYqwoHEN1MJkxDfWMq6pmdnEpJ160lEXnr+aux7YPdchCiFFMfhpwlNBabwZ+aox5WGs9GdgETDDGyLfI8CJvONGr/x3xOzbvyMbn95JRH6aoppL0UIhSfy6p0QhJngiBaJSHD5nB7ccfR4M/CVqijK9rYkJDKxVpybREI7zyk0xmjksd6tMRYjgbmJ8GvK65408D3pAy4tsZZdKLEEK02V4Jb6yGfabAnKL21WUVEdZtCDPtjbcZu3kzzJtA6+pSyl8pRVU1kRmuZEtGATbFy/TSLTRG0vE1hinNzqIiLYjethqFYnNuHo0BP7N2bCOZOAofJan5RAmS09RICvXEgLvOvZrjq7YQb2mlPJBE+Zg0ksJRxm5vppVkGjKTCOUm8d/C6XzrpX9zx4lnEGuJUewPUJaVxH6NzWTF4xz/2zBJrU3g8bAhM0g8BngVzt8tHvAr8CiI43xtehRErbOPAsIxiFtI9jo/dWYteBRBH0Rb48Q8HqzH2XVKpgd/PM6iYIRiXxI7QoppWTA+DSJxSEuC7y30MDXbQ3PE8uxGy5Y6mJYNiwotv/4ApmcpvrWvdHwJMRxJwij6jdbab4yJ9LZOiGFpawXsdyVU1kPADy//DA6ZQ3FJhB/fWEIoZAlEJnHTs4uZXPscLeRSxj5AJqWeQubXvk+ybQEsQWqoYzxZNR4mNKwnGS8KmFVVjaKVTVn5TKoNoQiT19RCK8kkE8VDEgr40hsrmbGtjCXTiygZX4g3Fie/rIqW5FaCLTFyaprZnBtkQtSyIn9v5q/dyAf5EwGIehTrgwF0UwsT61t4e1IOsZiFZnfSTNy6yaEFr5sIKpwBSko569uSw5YYBH3OfglCbYmn+3u5FthQa0F5WNMQaN9vTU3HKr57WZx1F1m+/Izl3ZKd6z3KCQssL2+N8+Tp8tUkRroR36D4KfKuHEG01t8FvgmMB2qAR3C6oWM9PrDnY+YDvwSOA7KA9cA5xphPtNa5wG+A493dnwe+b4ypdh+7GbgPOApYBFystb4MWApMBo4GfuEev7vyNwP3Ase4x9gEfAWYB9wI5AOPA5cZY6LuYyYCvwYOxfmuWgz80BjT4G7/BfBloAAoA35njLnD3TbZLeM84MfABOAd4HxjTMJXmNjjvLTcSRYBWiPwr/fhkDl8uDxEKOT0LrX6A6wcO43JtdupoZD2YeBxLyHSSKaFtlHuydQRI4nUaJi2j1rnK8THxNoGwI8iQpQgHmL4iLbvU1hdRxxYP3MS4UASAOEkP+OKGwgSJoMQKVtbqcnJoNXv45XAWCfBcxM4vzvUyGstMY8HmhP+ZrNuIZb2/Tt8t7WvU5Dsc25dUarn+12IxOGe5XRIFqEtWXQ8v7nXwwghhoC0/Y8s24GTgAzgdOBC4OLdPZjW2gP8GydRXOT+fwHQ4O7yCJANzHFvecBDnQ5zCfADIB142l13IXAnkOn+35vzgW+5ZS0D/omThO4NLABOA852Y04GXgFWAVOAuUAR8NuE463CSSbT3fhu1lqf0KnMs4HDcZLvVOCGPsT5mTU0NMjycF3eezJ4Ez4SF06loaGBKROTOuRC4+oqAEihvn2dxRKkqf0eWCIEiRIgiu00cDVOg5sEWnz4aCaOB5uQtaWpOiJ+X3uyCBAOJJEZaiabJnzESQuHmbtpO9uyMqjJymJqOEIwHicrGmNWKAzAtsyg8+DdbeyIxJxbv7GcNBXGfGpY5c4ampweb18eNq8NWR61ywNmFM6SlkkvI5jW+lfARGPMl3Zn0ovWen/gLSDPGFPXads4oBiYaYxZ566bBawBxhljStpaGI0xNyQ87jVgozHmwj6ew2bg98aY29z7nwOeBQqMMRXuun8AxcaY72utvwDcYoyZlnCM/YC3gZSuWlu11k+4MV2VUDf7G2OWuNu/DVxsjNm3LzF/RvKGG86e/wgWG9h/Opx3VPvqJR82s+yjBuY9/TwHrTVQlEPrhirKticTiyaRQSU7xuSR3tpEXkMFkWiQKOlsLhxPY0qcQzYvJa58lKWnsyE3m/klW8gNxYjjoyItjVg8hZzmBgK0AFFqyMeH4u8HHse6sU5X87yVm1mwdiuZtLTHVZ6VwUNH7M/ycTt/9WVbRjLWp4j4PIQUJKGo93mJtcYhZneOVVRAktfpWraAF6eVMOYOaFRuN7a1kObf2U2N+9ho3DmOZ2crpR/IslFCXh8t1hnrmJMM4ThkJ8NV+3s4f56HtdWW33wQ45Nq2CtfsVc+3PmhZWwqPHaqh4yAtGWIQTMwk16uD3Wc9PLz4IhPG6VLegTRWp+D05o3Fee5SwLe/QyHnAyUd04WXRPc/zclrNuQsK2tU2lzF4/tal1PEjuomoFYW7KYsC7dXZ4CTNRa13Y6hgXGAMVa6ytwWhaLcD4MgsDfeiizKeH4Yk92wr7OrZNFC1NYtDAFLjoPZzQDBICJCfvkdnG4/E73J7m3Nl5gXKd9Su57g8hFD7MjcwZHLjdkVTWQVhWjoLoeD9BEEkEiRHwefnvCAdQnJeGNRYl5fYQ9ipSmFiZVVfPG2AI8sSiHF8X41486lzKQ/L3uMTNH8cfjOn79XLhgoOIRQvQHSRhHCK31BOBh4EzgOWNM2G1h1J/hsJuBAq11hjGmvtO2be7/k3HGNYKTqCZuA2d+ZWddresvW4C1xph5XW3UWh8C3IIzJvI9Y0zMbWEc8X/diT3D2AsPgwsPo/6yx1j2fAvJNVEyGkL4iLsvYg8h5WdHehonrFrN7/W+xFWcrOZmmmMh1j44B6Xkd6aFEP1LEsaRIw1nzGkFENFaHwh8DVj9GY5pgA+Be7XWlwOVwHyg0hizQ2v9AnC71vp8nITrdpxkdSgnhzwD/D+t9TXA74BGnEaa/Y0x/8QZ3xnDqSertT4ZZ9zn40MUrxC7Zf7dZ1OZcgcbxk9i+/gCDl62rn1b2OenZEoeSZEIS++bMYRRCiG6NAqbKGSgyAhhjFkNXI8zsaQWuBp49DMeMw6cCoRwZjbX4sx6TnN3+SrOBJhPcMYu1tLWHzdEjDHNOLOv57ox1QEvA/u4uzwPPAi8j5MAfwFnEo0QI86WzAysVzGuopJt43IAZ+zFpqI8ppaX0RSTIbFCiMEhk16EGFzyhhN9Fm5o5Y2Jf8Ef8VM8Jofa9BTAUtBYz9jyMhaWfJPklKRejyOE6NbATHr5eUvHSS/XJ4/4NkfpkhZCiGEqKT1ALN5CXXYmczbsoCXgpyXgo2xcOtuDhRwsyaIQYpBIwjjKaa2fAw7rapsxJq2r9f1c/t04XdtdmWuM2TrQMQgxkjV5k/BGWnn1wHkEW8PsyM/BG44yu1beOkKIwSNd0kIMLnnDiV2y473tVB32AO9NmU15Xi7eaIyc6kY89TVcVHbBUIcnxEgnXdJ9JC2MQggxjI07oIgVZ+7N1Gc2M7auhuqUFGI0ckHZN4Y6NCFEd0Z8evhpkjAKIcQwd8LfT2lfXrx4MXKdeSHEYJOEUQghhBCiX42+JkYZwyjE4JI3nNgt1+/zLHkNMdJaQjSmBClJT+L/fXACSo2+LyYhBtHAjGG8obXjGMbrAiP+jSoX7hZCiGHsd3ev46dHPUPMHyCrpQU/sKC0hMNXlPLz+c8MdXhCiD2EtDAKMbjkDSf67PTL15K2rYkPx4/lkPXbCKSn0BJIIrumnvkrN9Jq/bR6mrhiy1eGOlQhRqqBaWG8sVML47Ujv4VRxjAKIcQwtOiCtVRnZFE7O5+0lhh51lKRHACgJieTuA3QEEwilCcdRUKIgSefNEIIMcx87cfrKc/IYsu4LKrz09k+PpPivMwO+yRFYszcVsnr06fxeN6dQxSpEGJPIQmjEEIMM+9XBahKTSbmcz6i4x7F+xPyCTaHCLSEmb1qO3mVDaS2tvD7h/7BymlThzhiIcRoJ13SQggxjMy7eCXF+UVMa2pheU4Q3FnQwWic/dZsYFrxdhpbM8iztYyz1Sg8XLLkXf4+poQvl14yxNELIYDReFUdSRiFEGI4aA1HmfH9Eoqnz2BiTRNjQxF822upSAuQ1RLh9A/W8Ln1L1MYLSZMkHJmodxvJY/1s7BpC7/Z+yEue+YkghPyhvhshBCjjSSMYljSWt8L+IwxFwxCWeuBm4wx9w90WUIkMhsaOfo3tUxqirApPxs1Jo+4RxGIWpq8HjJDEQobWjjrxQ9ZULWdDFsFQJQknCaMnRMxl06Yz3eWP405YBOlycl4KluYdmAK857/YXsrpRBC7C5JGMWg0lr/DDjUGHPsIJT1GvCSMeamgS5LDB8ljZaTn4qxsQ6OnQSPnuzF7+2YMEXjlqv/F+f9UstZMzxcvEBx8lMxlpaDHgOfnwr/WG3Zq0Dxq2O8BHyKymbLwgejbGtwjlFUU0lhQy0fTpyGRZHa0kKrLwkL5DQ0UFhfy5T6FlJsCpnhCCtz03lrUh5KKWzcgrXgTYIxeXwcjjOxKUR6dRPZzWEiXi8Rj4eIslR4PeRVNFKTmsqq9FkUhsoZ11BGzBOFuBeAjydMZEveGH5/0Of40yFHMKWqgtOXb2FdUxZ3nvE+vkgjk4pbmFhbyayW1aTEm2n1eJleVQJK4Yl5CNsskqgDT5TNWXlEvD5qklNJi8apCwT4x5wjeW3GLLYUZBKIRzh5/XJuf+lRos0+GlNSmXb5gfh+fPruP3EVdfDd+6CkBq7+PJyw7+4fSwjR7yRhFEKMKl/4d4yPyp3lJ9fCLflxfnqQt8M+d31kud04rXNvbI/z7EZ4fbuz7eWt8PJGCzHL/7ZaClIU1x7m5cuLY06y6LbWVaemsz0nv/2YTcFg+3JFdiaZrR4Cqo6CUAtRpVgyIQc8CqsUeNwEtikKMYsn4GVrSgYABbXNjGtsJRC3oBTbAz5+ftr+XLxiLauyJgAwpq6Ewza+RXl6EZvzxrO+YCp7bd/Afls+4Z/zF/GfuXszp7yYwjovU6tbCFaEGFfTCAQoj07l+Or/fmqIlZ8YXsIQh9nVO9rXF6dmc88RX+XVKfNYPy6TmNdDiCQeWXAQ00u2c92L/4HaBkLXPYP37ANQU8fs3hN3+T3wj7ed5ffWwvZ7IEd+M1uMUKOwVV8SxhFEa70ZuBc4BlgEbAK+AswDbgTygceBy4wxUa31RODXwKE4fVeLgR8aYxrc4/0C+DJQAJQBvzPG3OFum+we/zzgx8AE4B3gfGNMSS9xTgb+BBzglrsJOAfYB7gG8GitG93d9zLGbNRaXwj8xD2Hp3H626J9qJNjgduAaUAYWGqMOVZrfRdwGHCQ1vpqoNgYM0tr7QduAb4KxIHf9FZGf2poaCA9PV2WB3B5R9sry7W2MgJ4O+xT3NDx+ulbamPt+wAdBqxvd/fdXB8HtfPCEs1JAbqlFMmxOP6Y89hWn4ewv4uP25gFD8S9O49bnpZMldfHgromZpYVkxdt4cWJM2jZltweVllGITmtrRS1fsDCyg+oW58HUeeyO2cuW87rM6fT6tt5zJzG0M64vSldjsdXxLo8lRZ/EuWpmVgFMW/HC2tsz8zBeRtBMBqFbVUwdczuPXfF1TsPHApDdSMNfobN60qWR+ey6Du5rM7Icz7wLSAbWAb8EzgK2BtYAJwGnK21TgZeAVYBU4C5QBHw24RjrcJJJtOBS4CbtdYndCrvbOBwYDyQCtzQhxh/AWwFCoE84AKgxhjzmLvtNWNMmnvbqLU+DPg9cBmQA7zoltsXDwJ3AplujDcBGGMuB94AbnTLmeXufzVwCnAwTr1MBib1sazPLPFDSpYHZvlnB6v2hCjZCz8+OPCpfS7Zy0NhirNur3z4zdE+2nqtfQrm5TjLOUH41n7Ox+StR3ghvjPRnF+6FV+009807i9neSNRtqUnUx3wEVWK1EiMydWN7dvb//d7IA6ehOMSt8Q8igM/+ZAHn/gzT/7rQf7z5F9o8u9MaLNC9QSpbb+fEd2ZbK0aW8ik6nJOWL2OiEexeP4U/rX/rPbts5tWAxBNSBst0EI2cfcrIeomxlsz8ghGWrnwwxfxx2Jk17W0PyaltYVvvf0C1m13qJ1eiDp0dod63qXlq86AgN9Zcc5hMH3skL+WZHn0Lw8Y1ek2CkgL48jzZ2PMagCt9d9wWhgPNMY0AU3uuD0NtALKGHOd+7iQ1vpa4G2t9SXGmJgx5uGE476itX4Wp/Xy+YT1PzfGVCaUd3EfYgwDY4CpbqzLe9n/POAJY8yL7v0HtdaX9qGctrKmAYXGmFLgtT6U9UtjzHoArfWPgIv6WJYYAc6f7+XICXFWVMLhRYqMLn6Ra2aOYt3FXrbWw/QsCPgUOy6L824JHDQOsgKKtdWWonRFZrLz+DNnetn+TbhjiSXZC7PzJ1G3tpIV9V621li2lseo8SShYormuKWwsYJyj2Xd2CzSopaG1jBZlREa/H58EYvH6yWmFIFIlEjUi/L7CHk8EI2DtZy9eml7vIcWb+a5fY5k8rYNjGmoZG7pelpJIZlmAOp96RALEbBNHPfJMvbfspGFGzcxpaSEvKpZTKzfQUV6OnGfnw/zi3jRN4XWJNDFW8ltaKQ4t4DC1mbC+fNJ9jawdvIkYslJzFEhPFefStqGam5avYW8/Sey1RMjtbKGw4vipJ7wbTaWRxgbayHn5AXg+QxtEKftD1v+BDWNMGv87h9HCDEgJGEceRK7g5uBmDGmotO6dJzWs4la69pOj7c4yVyx1voKnJbFIpy/gYLA33oor8k9dm+uBK4FFmutU4EngB8bYxq72b8IMJ3WbepDOQCn43Rzr9BaV+Ak1Hf0sH8RsLntjjGmSWtd3seyxAgxKdPDpMye90lPUsxLuPpMQaqH06bvvD8v/9OJ5vh0L7cdnbBibk/j9XL7FGub/Mu2kufxUZOdTmuyj1Vjx3FQ8RYAKoKpPDppAkesf4vmlHT+fMTXSGlt5rSPXiS5NcQbYzWHF6+gyjeO6jr4+vKv4fN/nXE441V6s1en+/t03mFBDpyRUDnsrNwZu3SWvSjMcm5CiGFHEsbRawuw1hjT5feF1voQnLF8xwDvGWNiWusn6IfGczeBvQK4Qms9FWdM4lXAdbQNeOqoGKdrONFkYH0fylqG0wWvcLrXX9BaLzfGvNKXstyENr+L/YQYVBV3T+TuV6u56x91bCjK5bqDT6Q8mEZhXS1/2PdgdqSmcvXhZ3HJyo3s//E6mpOTeHbOUWRW1mOVZXnWJGZcPpVLfnrcUJ+KEGIUkoRx9HoG+H9a62uA3wGNwDhgf2PMP4EMIAZUAFZrfTJwEs6kmc9Ea3028D5OS14dTrdxzN1citPymWSMCbvrHgL+q7W+H3gdZyLOAfSSMGqtk3Am0zxrjKnUWtfgJImJZU3v9LCHgCvdrvsdwK3IWF4xTFx2VA7/fqeZUFkD2wMBfn7s56CxtX27LxLl6PdXEHDHTo6pqaQuxUOwOkLmN2cx56cDfrUqIURfjJJxi4nki3KUMsY0A0fjTHZZg5O4vczO3qbncSaMvA9UAl/AmUDTH/bFSfwagZXAhzgzmcFJSLcBpVrrWq31FGPM68B3cGaAVwMnAo/1sayzgTXurOt/A9e7xwNnBrR2y1nprrsZ59zfxen23orTGivEsPCfa4pQNoay1rn8TpIz2UUBk+ub25NFgMy6FlREEfb70bdJsiiEGDjKWtv7XkKI/iJvONEne1+wnk8Kc4mkJJMWjjKhvoWpdY386JlXKKypwwLvTp+ENx7mzCVnkJoT7PWYQohPGZC2QHVzpMNnvf2xf8S3OUqXtBBCDEPL7p/OSV9YTswXoSJ3AuBcB/FfRxxAUXklTcFkciuqqEv2SLIohBhwkjCKXeZeEHxVN5sfNsZc1o9lfQXnIuBdudQY80h/lSXEcPPcE3tx+skfMJlqirMyqfD5WNDcwpYx+eRW1zF523ZOrLhkqMMUQnQ24tsTP026pIUYXPKGE7vs6n2fw5+SjD8YBOLM2r6FSVtKWbtwCue9dcZQhyfESDYwXdK/7NQlffXI75KWhFGIwSVvOLHbGhpaef6Jpwm3ejj3si8MdThCjAaSMPaRdEkLIcQIkZ4eIJAXpIdfsRZCiAEhCaMQQgghRH8a8e2JnybXYRRCCCGEED2ShFEIIYQQQvRIEkYhhBBCCNEjGcMohBBCCNGfZAyjEEIIIYTY00jCKIQQQggheiQJoxBCCCGE6JGMYRRCCCGE6E9q9A1ilBZGIYQQQohBppTarJSaP9Rx9JW0MAohhBBC9KfR18AoLYxCCCGEEMOBUuo8pdQKpdRypdQ/lVIF7vp3lFKL3OU/KKVWuss+pVSlUip1oGOTFkYhBpFS6nkgD8Dn8+VFo9HKIQ5pWJK66ZnUT/ekbronddOl/1prT+zvg9of+Xa5jdHtnv4lsJ+1tkQpdSPwO+Bs4GXgGGAJcCgQUkqNBSYDq621Tf0Ve3ckYRRiECV+MGmtjTFGD2U8w5XUTc+kfronddM9qZth7yjgP9baEvf+n4Bl7vLLwE+UUo8AVcDrOAnkFOCVwQhOuqSFEEIIIYa3t4GFwMk4yWNbi+Mx7vKAk4RRCCGEEGLovQp8Tik1xr1/CfAigLW2FfgQuBp4CXgXOATYy10ecNIlLcTQ+fNQBzCMSd30TOqne1I33ZO6GX5eUkpFE+7/GHhRKWWBjcClCdteBhYBS6y1MaXUemCTtTY8GIEqa+1glCOEEEIIIUYo6ZIWQgghhBA9koRRCCGEEEL0SMYwCjFItNYpwF+B/YAo8CNjzDNd7Hc6cB0QwPm9gPuMMbcPZqyDbRfqZjzwMM5swXWj+RIhWuuZwANALs5lNM4zxqzrtI8XuBM4EbDAL40x9w52rIOtj3VzPPALYAHwO2PMjwY90CHQx7q5FvgyEAMiwDXGmOcHO1YxskgLoxCD50dAvTFmOnAqcK/WOq2L/UqBU40x84GDgW9qrQ8bxDiHQl/rphEnmT53MIMbIncDvzfGzAR+j3NNts6+AkwHZgAHAT/TWk8etAiHTl/qZiNwMXDbYAY2DPSlbt4HFhlj9gIuBB7TWgcHMUYxAknCKMTgORv3w9v9i98AJ3XeyRjznjFmh7tcB6wGJg1inEOhr3VTZ4x5AxjwXzUYSlrrApxW1EfdVY8CC7XW+Z12PRu4xxgTN8ZUAP8CvjhogQ6BvtaNMWa9MWYpTov1HmEX6uZ5Y0yze3c5Tk9G7qAFKkYkSRiFGDwTgS0J97cCE3p6gNZ6NnAgg3Ql/yG0y3Uzyk0Aio0xMQD3/x18uk72xHrra93siXanbs4DNhhjtg9CfGIEkzGMQvQTrfWHOF/gXSncjeONBZ4GvtXW4jhS9XfdCCE+O631EcCNwHFDHYsY/iRhFKKfGGMW9rRda70Vp2u5wl01EefK/l3tW4BzNf9bjTGP92ecQ6E/62YPsQ0Yr7X2GmNi7uSWce76RG31tsS937nFcTTqa93sifpcN1rrg3AmkJ1ujPlkkOMUI5B0SQsxeB7HvWq/1noGzhX7/9t5J611Ls7PQd1ljPnLoEY4dPpUN3sKY0w5sBQ4x111DvCRO04x0ePAJVprjztO7QzgicGKcyjsQt3scfpaN1rrRcBjwBeMMR8OapBixJJfehFikGitU4H7gX1xLmdxlTHmaXfbDcAOY8zdWuvbgMuBxL/6f2uM+esghzxodqFuvDgtaAEgEygH7jXG/Gwo4h5I7vjVB4BsoAbn8iifaK3/A1xnjDFufdwFHO8+7BZjzKj/+bc+1s2hwN+BDJxJHXXARaP98jF9rJslwGSgOOGhXzPGrBj0gMWIIQmjEEIIIYTokXRJCyGEEEKIHknCKIQQQggheiQJoxBCCCGE6JEkjEIIIYQQokeSMAohhBBCiB5JwiiEEL1QSk1WSlmlVNEAl3OZUuqhhPvPKaWuGsgyRdeUUuuVUhf0cd9BeX0MBqVUwD332UMdixheJGEUQvQbpdRUpdTjSqlSpVSjUmqbUuqfSqkkd/sFSqn1XTyuu/Vfcb+Ir+9i22tKqVa3nDql1EdKqbMG5swGnlIqFbgB+FnbOmvtSdbaW4csqF64z82hQx3HnmAg6lopdaRSKpq4zlrbCtzm3oRoJwmjEKI//QcoAWYB6cBBwPM4F07eHZcC1cBFSilvF9tvtNamAbnAo8BjSqmZu1nWUPsqsMJau2GoAxF7vEeBo5VS04c6EDF8SMIohOgXSqlcnETxbmttnXVst9be7bZa7Orx5gCHAecDY4GTutvXWhsF/gB4gQVdHOvbSqmlndZNUUrFlFKT3ft/dVtEG5RSq5RS5/YQ28+UUi91WveaUuqnCffnK6WeV0pVKKW2KqVuVkr5ezjlM3B+ErLLYyZ0e57vxteklPqPUipbKfVLpVS527L77YTHX+B2L/6fUqrE3ef2xDh6O2+l1F5Kqf+651Hddt5KqWXuLi+4rbz3dlNXKUqp37plVCql/qWUmtjpHG9XSj3pxrBBKXV6d5WUcE7fV0ptdx/zK6VUrnuMeqXUmsTWOKWUTyl1nVJqo1KqRin1slJqfsJ2v1Lq1wl1+H9dlHuYUupNtw42KKV+qJTq8x9CSqmzlFLL3NbwZUqpz3c+p077399Wp93VtVJqs3teb7rrjVJqUVfHSFi3WSn1VaXUOOA5wOs+tlEpdT6AtbYe5/fJT+vr+YnRTxJGIUS/sNZWASuBe5VS5yml5u7KF2oXvgEst9Y+g9NyeWl3Oyqny/vbQARY1sUufwNmK6X2SVh3AfCatXaze/9NYB8gC6dr+H6l1NzdCVwpVQC8DjwFjMdpaT0O+HEPD1sIrOrD4c8CDgUm4vy823vABmAc8HXgjsSEDJjk7jvVjeNU4MqE7d2et1JqrHser7tljQF+CWCt3dt9/PHW2jRr7cXdxPsb4ED3NgmoBBarji3G5wO34/zc413AA0qplB7qYJIb71S3Lr6Dk/zchvOTeE8BiT+leSVwHvA59xzeAF5USmW4268GTgEOBqa45zqp7cFuffzHPX4+cDLOz3d+rYcY2ymlDgYeccvJBa4BHlVKHdCXx/dS15cB3wVycH5H/D8J59XTMXfg/BEWc4+ZZq19IGGXFTivSSEASRiFEP3rSOA14HvAUqBMKXVtp8RxilKqNvGG0zrYTimVjPMF3/al/xfgJPXpSQU/cR+/HTgdOMta+6mxkNbaGuBpnIQKN57zgfsS9vmLtbbKWhuz1v4dWO6ez+44D1hmrf2TtTZsrS0GbnbXdycbqO/DsW+01la7CfozQMRae4+1NmqtfQ7n94P3Tdg/DlxprQ253d234iTLQK/n/TVgvbX2Zmttk3suHVpWe6KU8uDU80+ttcXW2iac18YcYP+EXR+z1r5trY0Df8ZJHGf0cOgQ8HM3nmU4fyQssda+a62NAQ8D05VSme7+XwdusdaucVu7b8D5zfKT3e3nudvXW2tDwI+AxN/N/RbwuLX2abee1uAktj09n4kuAJ601j7nPk/PAv8ELuzj43vyF2vtB9baMHALTt2c0g/HrcdJQoUAJGEUQvQja22ltfYaa+1CnBagq4DrcBM11yZrbVbiDecLOdEXgTScL35wWncqgM6tWP/PPUaBtfZga+3iHsL7K3Cu2x17tBvfU+AkNkqpG5RSn7hdhrXA3jitSbtjCnBIp6T4PpzWre7UAL22DOGMEW3T3Ol+27r0hPvl1trmhPubgSLo03lPBtb2Iabu5AMBYFPbCmttI1AOTEjYryRhe5O7mHgOnZW7yWWbzvXQdr5tx5jQKYY4Tj20xVDk3k+MoTzheFOAczo9n9fjDJXoiw7luzbQsQ521+a2BWutBbbiPr+fUQbO+GEhAEkYhRADxFrbbK29H6fFap9dfPg3cMYjfqyUKsVpQcym+8kvffEi0IrTJXsB8He3NQngHJxk9Cwg201il9H9ZJ0GILXTunEJy1uAlzolxpnuBJ3ufATsVhd4Lwo6de9OxqlP6P28N9NzS5/tYRs4SX6rWyYASqk0oADY1pfg+8m2TjF43PttMRR32p5Kxz8WtgD3dXo+M6y183anfNfUhPJ7ez1B93WdGLfCGX7Q9vx2OK5SyodT920Sk+7O5uO8JoUAJGEUQvQT5Uy+uFk5kz387kSDs3C+eN7YhePMxRmX9nmcRLPttj9OC93ndic+t6vyQeAK4EwSuqNxWlOiOAmORyl1IU5LW3c+ABYqpfZzz/NynFaoNg8CWil1oVIq2W3Jm6qUOrGHY/4LOHaXT6x3HuAWpVRQKTUVp7u1baxab+f9MDBLOZNmUpRSSUqpxBhL6SGhdFvyHgRuVEqNcxPX24E1wPv9dH59cT9wlVJqpjve9SeAD3jW3f4QcKVSappSKojTbZ/4/fgH4MtKqVMTXttzlVJH9LH8B4CzlFInKKW8SqmTcF6DbUMuluIk9qe4r5XPA4d3OkZ3dX2hUmqh23J+JZCScF4fAMcoZ4JXAPh/QOLEq1KcSS+Jr12UUuk477d/9/H8xB5AEkYhRH8J47RePIXTlVUB/BS4wlr7+C4c51LgQ2vtYmttacJtOfA4PUx+6YO/AkfgdIsnJiwP4EweWY/T2jSXHpJca+1rwK+B/+J0hRYCbyVsLwWOwpn5vBmnu/mfOK1K3XkI2NtN6vrTFpwWp0045/hfnIQIejlvd2LEkTgTdrbjJBiJE2Z+AtygnJnHf+qm/O8DBmfW7VacbtzT3AR+sNyGc6mYF4AynCEJx7uzgcEZX/o88C5OPW3FqTcArLUf44wL/B7O812Ok4T2aciCtfYtnLGcv8J5LdwKfNVa+667fQPOxJU/47x3TgSe7HSY7ur6z8Cd7nHPBk621ta52x7BSfo+xOkC34rzPLfFtRb4I/C+29XeNonnHOBVa+26vpyf2DMoZ8iDEEKIoaaUugw4xFrbp9m3fTjeBTgTTuR6eqOQUmozzvP7cG/77sIxA8DHOEn96v46rhj5fEMdgBBCCIe19m7g7qGOQ+y53FnkPY1bFXso6ZIWQgghhBA9ki5pIYQQQgjRI2lhFEIIIYQQPZKEUQghhBBC9EgSRiGEEEII0SNJGIUQQgghRI8kYRRCCCGEED36/3FcznwSL89vAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAowAAAI4CAYAAADgaLi1AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOydd5glRdm37+pw8pk8mxO7LDlTBAEDUUUx54Q5i76+5ghmxZxFRUVBPwETKkoSXzKUkuMubE6zO/HMiR3q+6N6Zs4Mm4Ddnd3Zuq/rzHR3VVc93X26+9fP81QfobXGYrFYLBaLxWLZEs5kG2CxWCwWi8Vi2b2xgtFisVgsFovFslWsYLRYLBaLxWKxbBUrGC0Wi8VisVgsW8UKRovFYrFYLBbLVrGC0WKxWCwWi8WyVaxgtFgsFovFYtnFCCGWCyEOmbBMCSGeJYT4nBDildvRxrlCiK/vPCvH8HZFJxaLxWKxWCyW7UNr/ZnJtmEi1sNosVgsFovFshshhPilEOK9yXSrEOJyIcRDQohrhRAXTfAqzhZC/D0p/5sQIrczbLIeRotl12J/Wsmyw7jiiisAOOussybZEotlj0XsnFZfMv5ar/+wpX4uE0LUmub320ydzwD9WusDhBAdwH+Ay5vKJXAMMAj8E3gt8NMnafkWsYLRYrFYLBaLZXJ4mdb6vpEZIYTaTJ2TgfcBaK37hBB/mlD+T631QLL+bcCinWGoDUlbLBaLxWKx7FDEhM9OpdlDGbGTnIFWMFosFovFYrHsvlwPvAFACNEGvHAyjLCC0WKxWCwWi2WHskM9jJ8DpgkhHgL+CChMvuIuxeYwWiwWi8VisexitNYLNrNMJpPXNy0uA6/WWteEEC3AjcAFSf1zJ6w/bn5HYgWjxWKxWCwWyw5lh+YttgNXCiFcIANcorW+Zkd2sD1YwWixWCwWi8Wym6K17gGOnmw7rGC0WCwWi8Vi2aHs9JHRuxw76MVisVgsFovFslWsYLRYLBaLxWKxbBUrGC0Wi8VisVgsW8XmMFosFovFYrHsUGwOo8VisVgsFotlL8N6GC0Wi2U7ufbOKl/40SYINS1hRGutSuy69Pg+M8MG73pzN8ee3IHjTj3vgsVi2buxgtFisVi2wbU3DvGT3w2wtuZwRz5Lw3HIxDHPHIAjejYxF8013Z186YIejjx/KbHWHHHmdF76gX0m23SLxTIpTL2HRisYLRaLZQJxHPODK4ZY8midq9c5LHFTpLIthAWHQDjQCKjhEAchm1qKCODUviFWtBa5d8Y0cmFIeOVGjjqjm30OKkz25lgsFstTxgpGi8VimcCCjw0wq9qgHmuKtRofXbuC7x6yL1XXBWBeFNNdqZFN+az3sgAMp1LMHRgiFccAlNNpfvO+uwHBtFk+7/j1MbvMfq01WmuqDw7itPqkujK4GXu5t1h2HdbDaLFYLFOSv97T4AMXDlF3HfYfrjCtFoDWLNzYhwNEjrkBzKrWeVp/CQANVGNN7AjKKR8/jhlKp1hXLCA0+Dqi0AhYtyHivFNvomVmhld8YjGzD2rZITbHA5ra1Q3+9rm/EDxawmlotCOIHHBDDQ50lstoLYjQ1HIZDvn6Mcx4wVxKd26ieOocvIz/+HYrAU7OR0cxwrVjIy0WCwit9WTbYLHsTdgTbjfi8zcEfOZfIQCz+svkY1jSmeeVj643r5BoEowPtBX58/xZ7D9c4ZBSdbSNuuMQuA6ZIGC/Tf0s6erAizV1zyUTBMily9AI6ukUke/hBSHpeo3i9DRv+n8n4mXcJ2X70j8t55Z332aEaSOiOBwhYo0TayJPUMt5eEFMphzgjXztREgtk0IA+WoDF02KIHldhkYQ46ERgENIjgYhDv1egaFslrzb4Ni1b8HNpp70PrdYdjN2jitQvGb8tV5fsse7HK1gtFh2LfaEm2RuWxNz6s8q+IMN6oU01bwRP24jYuZAldXtOToGq/T7Hrko5sQNvezXP4SvNT2FPKWUT1ozKiidOMLVmpmlMkJr6r6PAzQch/6Uz3FLloHWxI5D7CXiUGvcICRyBDHgRTF+IwAEXkpwxvlH0rV/G0E5oH1xC0E5ZHjVMFE95taPKwbvHUQLCFxBJozxGjHFgRAviBFA7EA17xF7glQ1IF+LABhsTRH6xobWoSrZRohA4xEh0MQIXDQeIe0M4xIj0GzyW+jL5NmYKzK71M+0yjAaDZ7ADQNylIlwaRRaaPvSyXS87+hdfFQtlieNFYzbiRWMFsuuxZ5wO5kf3Rly6cOaBzdq1g/FMBJSdSAVxBQrddprEdMqDZZ15lnXmgHAqwY4CAJHoKvRWIMOHDY0zLyhGjrJYRRxjKs1EdBRqTGzUmEonUILQTaMyNVq+GFEHMd0DJbwK3Ua+Qyx35QFFIYM5nK09w2B7+JHJvcRrXEagelHa4g1QgAIUkGIF8Y4MdRSDrlySEt/AxAIHeOH5u5XLnpoz9yfYgGpekSmGjLYngYhcKOYaf3lpk2MSRER4NDAYw69o3dRD9N+nTSrC214ccT0ygAhPj4xGSoUKBmhimCIIgIHlwBBjBYOmWyE//wDiFpzhJffS9xXJ02FNBUCL4PrQ6rWCxoCUgh8BBEuNbMfPA/dmid8w8k4xyzEqVaIr7qf6LK7iSPw22Lc6z+GmDcdkfIQ+fQO+jZZ9gJ2kmB87QTBeLEVjLsrUsrlwKeUUr+RUi4AlgFzlVKrJ9Wwp4CU8nXAF5RSCyap/5OAG5RSe/wXvxkp5c8ATyn1xl3Q3R5zwmmtiTQ4Ahzx+EOutUYIMe5/EIPvQBBDyhUM1WNSDmR8B601g3XNQC3GdyCXcsi6puyWNSEPbIJFbWbd/oagPaXpr8E+Rc23/wvHzRK4jubmVdBXh7WDmvsHIAo1NGIII0TWQydevNZyHSIYLKTMRiSiywtCjl01QCntce+cttHtceKY2EnEZT2CSgha011tkI1i0JphIWiNIg6sB4g4JnQcEAKhNS7QVq0xv3+Alkp1ZCfh1epkK3WCTIrIc039OMZrhMakWKMZ/ysKgeeQrtbH7mQj+19rUpUG2hWgoWtNmSjjIiJNphrjR+brNdzmja6jgRjI1CPqGRftGMHY3V8ebX9EMGogwmEag6O2uISkaVAlTQMfFw1oXEJCPNoYwCcYrV8mT50sEYI8JTLUyFAmIg2JrKyRoUGGLMOkaACaFEN41BPR2Z14N31iXDwauIlwFYREeNTJkWUAd7TVCIcqTrIdYL4HISlcQgRx4i/1EMQY364Jv+uk3dhN4egQ4XrmQSMIQMdETh5SPm5cBSdGp9MgPMTcNphWRN+1HD2jC/Hi43BafPjT7TCrHdb1QzYDpx4CzzoUdAw3PIjebxbiOUeaHTZUgduWQlcBegZgqAr7zID2PHQlua4ZHzIpqAeQ8qBcg5acKYtiaISQ9kFr8JNjv6YXOgowXINc2rRRa8BABWa2Q7kOuRT0l01fycMQ5Zppp5CFIDR9ZlPmizTiIY9jGDlXosj05zhmvc1cK3YaO6Y/Kxi3EzvoxTJlkVKeC5yklDptsm3Z0/jFvTHvuDomiCHnwaUvcDhzoblBPDaged4fIpb2Q8aDRgSFFPTVxreRdo3uMsSb6SXefJnWUAtM4yPzWnDJfZERfqMvxRbmZuFp8F3QHroRQ6RBawY9f/wVTgNRTDTUoCES712zNU6TZEv6cDVGLAIIQQpYlvKZXanxrLXruWfmDOpNXsOBTJo5zY0KQej7RF6EE2tEEKKFQESJOBUQpVwaKZ/CUCLgtMYNIjaLEARpb7TecFcaN042zQtpHTAi1K/FBFlzc49cQa7eMJ7FUKMds3/qjks6jvAI6Ug8hAMUaCSScGQvu0Sj/2PSQIwLuMS41AjxxgnGOBFqHiE1MrTSR4RHhIuDRuCQoo5PAyc59gJBjTYy9OIS0cY6GmSo0YlHOWl3xGuYwmeQDJuIMaLJoYKLJk4OeOJbBTx86gicpBeNpo5oem4b2c4YcKMQjQNxAxEYIanx0LEPoUNIBo8BRKUB5KBvA5rlJudz4xD63sc2f9yuumv8YWTsyXGHqwhHGGHXCJ/Yes8+Ama0w6/+ZeZ913wqjbE6pxwCj6yD1b1GgJ7zPPjO38x5mE/BcB1efRL88TaINfz8PfDyE3bYpo3jnJ/Bj/4J+86Av30SFs7YOf08afZ4ffg47PC3KYSU8vHDHS2WJ0gQad5+lRGLYBxt51w3JurOuznmoT4INQwHxrk3USxCs1h8gtRCSCdekpGP2/RpXg7j/3uOEYzNfYfGTZqqhlAN0TE8kM1Qi6GtZLwpqSCiWB27Me7fN8xRg8N0NBrjXMJB0lXHcJlsGDFncMh04ZhQtqM1Dd8flcCh4zBcyBEnAlRoE86OPZfYd4k94/GLUj6ltiKVfAbiGAdN7DpjfSfiVsRj1jixxh3RskDsOTQygkZaUM77DOU9nDikpVyjpVQnW23gxBon0jhaEGRdpjHAdAYZsThLnTQBLg1cAlLU8ZKdWcenTooqaVwCslTxCQnIUCVLkJSPCEyPiFZK1ChSoZUaBSoUiBC4hIl4FET4lClSopONLKZCFzF5AlrQpJP/LuOd8w4ikXNOkwB0MIJPQFIejLtti0Q0imSfjS8DTRZB4vlNajtEuAwntYxUHhOkUbIderSN7WVi/zuMWD9xsQjwz7vGxCJAEI0XiwDX3WfEIpiHuvP/ZDyQtQb0DpvpX/4LBitQqsLbfvhkt2Lr3L4Evvd3CCN4aA2c+/92Tj+WcezRHkYp5fuBdwGzgX7gYkwY+sneqpBSauB9wBuBA4G7gVcALwc+COSAHyulPpnUzwG/AU5IypYCH1VKXZ2Ufx54IXCcUqoqpTwAuA142UidrdhyLPBD4ADgLuCqCeXLgQuBk4FjgLdKKR8EvgscjLm63Qq8Vyn1qJSyE+jBhObXSilPAa4F3qKUulBK6QG9wOlKqdullIuBnwJHA48Bv5jQfw74MvASIAvcCJyjlFoppTwK+D+gXSkVSCnfDPwcOFUpdZ2UcjqwFpiVrLsMeAPwcWAucAtwtlJq3Tb20QLgJ8BxmDvKMuDVwBHAJwBHSjlytT9MKfVYYssngW7gz5jr9pO4wj5xSqUSxWJxt592hSbUY7ezkYG8pVIJ18nt0H3yODTmpudMuJ1ub+jJFUYkjq5n/mWDiEYSdqu4Do9k0+CNeTHn9pSop32m1xp0VxrcMKud/nqEl3JoCSNirRFhxGv7eunQmko6RS6KmFmusKolxyMdeU5ZtoHI8+hpa8WPYzSCbK1GqZCnUK4ggMhxEE3b4mjj8Ys9F6dWHwsNotEiNiJRa0Ss6eypUin41PI+uikdYKSdwHVI65BywSVXD+kcrI16C/1Y0zLcoJZyqadd8kGNEUka4lLHDP7JEtDAR+PjEJGmjsZcTFIENPCokmEkkOsAARkCGM1ndBKfogkVO4ngMwcjxE9CxMn2ExON3ooEFVrJUCEkP7qPQrJkGCQmixFpjWS7Hu+5fvwynXxGgs+bZ6y02f83UjZyS4mAaHQcOU2e1b0SIUYfZjZLEsLe4deoCa96CuKIEW/JE21zZzHxmzYV/I17uodxNfBcoAUjyt4MvHUHtPs64EUYQVEDrgPagUXAKcCHpJQnJnUd4A/AYqAT+C1wuZSyOyk/FyPCfpAIrMuAb2+HWGwFrkzqdwD/A7x7M1XfhhGyRYz40Umfs4EFwDBG0KKU6sUI4JEQ7ekYgTsyfxzmsVkl4vGvwP3ANOBlwDsn9P0t4PjkMx/YBFwhpXSBO5N997Qt9HUacL9SakNTe68EnpHYngc+t5VdNMKXgJXAdKALI/T7lVL/Lym7XilVSD6PSSmfDvwg2ZYO4Oqk311C80Vqd532XcFFZ7q0psATsKAFLnyOO1rncyc6HDcTWlPQnYX2NMwtmrpe4gT0HejKbnN3bJ6MB+WGiXUHkRGPMHbfTwQWcTz2P9JJKDppw0tyFh3AdxBRTHelYTyQKdeUpRyjhIWgkfJ4qLvIqlyae9sL3DCtlT7PQQvjOexNefQX05xUrdKWhJMH8jkGsxlcrZk/VOG5S9dRCMbyuXL1BvlKhc7+QYqVCrgO2nVwhCBqDn/HMV4jwG0EpKtNrlphxIsbxriRxtGQasR0bqzRtb5C14YKmUqEF8T49cjkMAaaajpFoRqSqkaUnRTDboaykxrdNX4jIl8K0A2XGIco+Yx2C4zcfmNcquQIk3mXcDT0W6ZAhUziK9SJR9LY7xE0Sa6RA0fSxvjneVPa5DlNxKTTJMY86rg0SDFEmoFE0mUwl6sUGnf0pUCbybbFDE8KYTS/cfMI6miyTT7DsRKHMh6Do95HIx7HLDf5nxPXezzN9bc7oXl71YbA5BsWM9vb8th6r3sGfPm1Y8uyKThk7vgHtdMPhwNmm/qtOfjGG2Gf6TB/Gszvhs4inHMmzO2CWR3wq/cBO+F6dfQi+OTLoL0Axy7G/8obnnSblu1nj/YwKqUub5q9U0r5a+BUjMfpqfCNkcExUsrLgK8A5yqlYuBuKeXdgARuUkqNCrKE86WUH8V4/P6ulIqklK/GCKibgPXAedthw/OBMvBVpZQG7pBS/hx47YR6P1VK3ZlMV4F7msrqUsrzgHullDmlVAW4BiPWLkr+fxr4jpRSJPP/UkrFUsqnYQTnh5VSVWCJlPIbwAXJfnGAs4GzlFJrkmUfAPqAY5VSt0gprwNOk1LegBHa5wAfwnj+TktsaeY8pdSmpK1L2D7x3wBmAAuVUg9O2P7N8QbgsibBfpGU8h3b0c9exSsOcHjFAZt/npxTFNz62id36Yi1HjeAphrE+K6gtxozPe9SbmiWD0Y83JvhgE6YWTB5fgN1WDcc8+gArBuGhS3wpyXw50c1w1Hi5Qgw/xuhSaBMJyOaoxhRj0hFMQf2DlPxHKqew6aUS9xkS+x7NHREI+eRqQYcsr7Eg/k00Uid7MiAD0PguvRlM2hhcgSLUYxuGmjiRxFOGG7GXwUN3ydXrQGadKlKIRomdEyYPU75o54bJ4xGE/v9eoQbG79FphZR9wWuEKQqYwIs8gRRyhw3JxZUsx5B2sELNG4pwkPjJpl8DTz6yZMmIMIlxZitLiF69PYQN+X5OU3axQjaBmkcAloYSKQjhHgmFzBx3Ec4OOgkZKyJcEbDwzEOefqoUcBFU6Q/saGOQ4hDiEcdo/4jYlJAYzQfUidtCCIzcCVpt5nRZw0cGrQlbdeS8LTZPuF4iDntsGkQvCxkfPRwA90I0J5vHjDau2BWG2LdABw6D1qycP8qOGge4pzn4Q4Ow22PwIYhWDTDDHo54zDIZWDdIMxoQRw4FwbKiH2mj4mx/hKs6jXtFbPmISjlQ77JC74lmgegbG35yHzyS0REsRkgM5GPvfSJ9fOBsx6/7Ds7wm+zDb7wGvOx7DL2aMGYCLEPAgsx25LChGCfKs1h0ArQk4jF5mXFxIYscD5wJsbDFSdlIx5GlFLrpZS/xwimUya0tSXmACsSsTjCss3UW948I6VclNhzXGLHyPrdwAqMSPuFlLID2A+4HCMaD8eIuN829d+TiMzN9d8NpJuXKaWGpZQ9jIWUr8F4/C4HBjDe0h8lofFTebzHsnm/lxP7t8WHE/uvkFLmkz4+ngj5zTEHUBOWbW6/WnYCE0dbZ31zA5qeN+IunxIc3O1xcPf49dozsE+rwwmzx5a97MDN93HxAz43r4kYqMLvH47xgoh62mVZV46Tl20gG8bc191CtS+klE7CW1qbpMsghqBBTcPyQpZDh6s8Vkgz1J4F1+G26W08p9JDJo4ZSvmjArGSTjFzqEQ9ZcK6hVFPYbK9SZg99FyClA+xxq81cKIIL4rRQCOXwW80EI0giYqaUzdC4AcxsQO1jIsXxNQyLuW8S1vJvLvRiTROqMEf27+hKwgK5hIfpiEdenjJ64JGZG2QjDEe8fJ5xIS4NMjRzhBuIixNucAlTnx0449jjMsgbfg0Rj2WPgEhHtG8abhz2yh+6FhE7xDRt65BP7wREcYIEeO1O7j7ziQ9VEWvGSQuC+LYxyEgTPyWcTqDs6gd/7BuePGxuAfNhOvvI/zUH8yv0nQU4ftvRjz/SETKRUwQNs3WbsvxPdGZ94RDiWccte06HRMube1F83kybE7EbW75yPzE/0+1H8tewx4rGKWUczGevZcAVyqlGlLKr2M8f7uSD2LCqKcCy5VSWkq5iabrjJTymcCbMPmGP5BSHqOUKm+2tTHWAPOllKJJNC7YTL2J4vPHmNzAw5RSvVLKQ4B7m+y5ARM6fw/mFTmBlPIa4MUYkfmWpv6nNXkmJ/a/Eagny5Ym21nAhK9XJXWuwYR/XwJcnXhbb8Dknc4A/r2NfbBNlFIbMUL8HCnlQkxY/iPAZ9j80Nw1PH4/jm6DZc/ntQc5vPYgc3O7+HGl+/Dn/9R5yz8i9HBAa88w5Xza+NYiPS59bdh3qXgu7cn7GQcyPmtTGS5cNJujekvMCkJSiajTQCAE3YNDaMZe6p2u1QHT7MquTtI6Jlerky8NoWOTlxgLQSwwr1zJ+8zer8BR79qfGUe0I1yBlzaX6TiKaQwFXHHm1YhHhhDCoZz3SQUxGiMY/YYJ12shiCdc3SNvTPpooJJ3KJTNi2bcJNNQIEgnkrBMHo+IGEF6NEwMKWqJ91CTmptHOwJv3SbSjTp6Wp6On76E9AsO2vIBesuxT+RwbplD5uC99zk7pi2LZYczFbIWx7PHCkaggLl+bQQCKeXxwOuBB3exHS0Y4dQLpJJwdNtIYTK447fA+4FfAf8AfoQJjW6Nv2IGr3xYSvkt4FCMmKtvhz1LgAEpZRcT8gCTgTc3Y0LDn0kWXwv8GlivlHokWXYrxiP5VSnlRzCDUz7Y1E4spbwI+LyU8gGMB/EbwEPA7Umdx6SUq4APNG3vtcDngVu3QzRvEynlK5P+lgODmBD1SIxuPTBPSplSSo0M9/s18A8p5S8xgvVVGKFsBeNewguPTvPC5IdIbnqgxnMviwgaETOGa/TkM1TEmCclEpBxBOt8dyx86Lk8kM8gyjXmNMwo3FAIVre1kA8C+vN5Qtdl7voevMh8FTXQUquSCwLqvk8pn2X+DIfX/OYE/Mz2XYYd1yHTnubltzwfgGA44PJ9L6eeMkHmVBial3VH5kXfXt3kWmpXIGI9+lOAIQ61jEsqNJl9uf1biFaXicoBEOESEOPSSDIR8wQEuHhEOB4sWPlevJk2B8xi2dvYYwWjUupBKeVnMR6lFPAvjDA7Yheb8k3gKIxXbwD4NkmYOMnzuxi4Sin1i2TZ64C7pJRvUUr9fEuNKqUGpJTPA76PEXZ3YYTmm7dhz/9gcjiHMINBzsd4D5u5BjOyeiSP73rMCO/RnFClVCilfEHSVg9mlPQFmIEuzX19BbgDE56+GXjBhFHq12C8q/9qmv8Oj89ffLIcidnGTqAEXJHMA1yKGdCyPjkWRyql/i2lfB/ws2SdvwD2nQx7KScelGEoeWwKojyv+tgabgmz9KTTRMBjKZ+T+oZ4uNg0MlxrakLwcCZFVzQ2XMRBE7kuQZIXtq67k9zqtTixpuG7eK6AaUVe95n9WHDQUxdcfsEn95Mc2WtrFO8uUF06gNfToJpxwXMQArKDdcJEkNZ8l1reZd67D2TR/x6K6wj8dvuLKBbLzmAqjpKesr/0YrHsptgTbg/g2R9cT28FXB2zpC1Hv+ePveYniCCMcDQ8fWiY1iQPcWHfANkwZF1LESEEfqNBsVxhnt/gxDcu4PCXzd3hdl5xxRUAnHXWZgYeAGEthHqM15ra4X1bLFOEnfM6THH2uGu9o3+1x2vGPdbDaLFYLDuLf35zBn+4qczfHg5xl9ZZXw5ZVsg2vdLP5B2WHIcT1m7AT0aeRkJQ8Ty8RgMhHE557yLOOKtr0rbDy3jwBN+wYrFYdgR7vD58HHudYJRSXgk8fXNlSqnCLrblfsz7CyeyQil18K60ZXdFSjkPeGALxb9RSk0caW2x7BBecmKelyRvW12+tMLV/63w2X+HrMtmRn8/OgX0FPJ0lytooDeXI9sIaKs36F6QmVSxaLFYLDsSG5K2WHYt9oTbgwmjmCM+3IMuRxxQKpMNQ+5tLdLVCDhicJB3fHYh+x3Zusvs2VZI2mKxbJOdFJJ+04SQ9C/2eJfjXudhtFgslieL5zrc980Zk22GxWKx7HKsYLRYLBaLxWLZgWz5V8v3XKxgtFgslr2ETT01LvrlevKtPs88uY39F+cQYurd2CwWy47HCkaLxWKZwpSGQr710QdZubJOqtGgUA1oeC7X/KubgWKeX3xpOnO6/ck202KZYky9BzErGC0Wi2UK8/kX3cqMDUOcUG7gxCFh2mVjLsNgymNDS4FXn7uRG34wa7LNtFgsuzn218QtFotlijI4FJIZqLLfo73MWF+iu6eK34jortRY3tJCe61B13Cd089+jCsvemyyzbVYpgx6wmcqYD2MFovFMsVY81iZH779btqGq0wfrI16BgSQqkeUihkObDRIBwFrWluZW6vzqyti2o6tcOSiLBl/6oXTLBbLU8MKRovFYtnDufa9t7Ly6nWEUUxfIU/QmiMfxfzgpMMoDNf5yq/+haMhFlDNegxNa2dWtQZAJghZncuyJuNzzrnrWDK7nd+9o8Api3xSrhWOFsuTY+qdO/bF3RbLrsWecJYdQtyI+PXbrqR8W0CYSjGYy3DzPrOYM1QiG2nWt+bZ1NGOF8cMBTEnLF3LvKEhhtoLDLQUSAcB+SCEOCZdqxP5HhcduogNbQUO2TCIF2u01uxTKlMTDvdMb0NowTfe2cLpB2cne/Mtlh3FTlF2oXjruGu9p3+2xytIKxgtll2LPeEso8S1kMGrVjD0yCDV2zcxePtGaPFx5xSY/ab9WfO7x+i/ai2Dvks97ZFqRAgHhNZUUj4DuTR3LpxF4AhuWTyH999wJ25yTX9sZjdD7W0AlD2XXt/h0N4hVrUUGcikQWsW9g0QOg6qq4XTH17OXfOmM7sW0RaEAAx4LpVUilQUUYhjSq5DplqnJQxZ1lIgak+zUBY55sgciztdDux2KaT3+PuiZe9ip3xhA/G2cdd6X/90jz8xrGDcRUgplwOfUkr9Rkq5AFgGzFVKrZ5Uw3YyyW93/0sp9bXJtmVrSClD4DSl1PU7uSt7wk0Sum8YHIc4DBEre9H3riRuK0BfBWa1IsIY7bkE9/cQ/ns5jXs3Ek1rJfvixXB3D1EuA9OK1O/vpbGuhNs7jDO3DXH0fLh1GcHtqyAG75i58KyFDP/uEYg0jh/SWFEn1C7oBjEudVKASwTURYpIO2gPar5PodbA1ZpImC+Lr6HuO6ydXiByHSLPAa3JVQJWz2jHS7lUfI9/LprDq+56eHR7N7a3sGbm9NH51qESYTrFg50do8u8KMINQ/oyKe7OZ2lkfeYGAfv3lVg0UEY7Jvux3/d4uLuFTYU0izcNceyqjQRC8J/pXZTSPg+25vG0Zu5QlftzaaKUh0+MF8VEYUQ9m6Ylp/nRC7OIOKI1BQs6PfZtd0h5duylZVKxgnE7sTmMlp2KUuq5k9l/s1CfTDueMnEMl90CtQa88iRIb+a9edfcDY+sgziCtf3w7/thXhccOh9uehDmdkNHETb0w80PwUAFzjgC/vsYbByCA2dD7xA8vBaiGBwHprfC0YtgdgcMVWFmO/z+ZljbB8U09FdhFzx0ahw0AkGEoFl1j4iNOKkHAoHGJSYNCDQCh4gYgcClTg4NpBnAIaZOCxF5ADL0kyGkTp71LMRb1kt421ryVNAIepmOxgE0KepkH+tF/HspmpA2hvGps+Y2j/ptA4R4aARZauRpIAjIEOISUiXLKqZTFz6xdtE41FMO6SAa9RC6GnrbM6QbEcVyQKHcoK8jZzZXCKpZH5H1iRyHNHDM+l76s2naq3UCx8FrhObYCIETx2zIZmiPYrw4JkyEYC4IaA0CbivmKWVSUEizlAyPthV45UOr6K4FAKxvzXLH3E4AlrUXyDUiAhzatKa9WueAwWEeK2a5qyVH6HngCRqteRoAlQDKIY3eiNf9qoL2XRCQ8iJCIYhjc9RwBaSEOZShsRtPmEPsOBBrELE55gL2bxeEWrNxGHIeBEKQEZrBAPI+iFjT14CMgNktguNmO9RDWFGCBa0wpwgbKoKzFsF1K6EjA+cc5dCde/x9/cbVmgd6Nc/dRzC3Zdfc9+/fpLlxjeaEWYJDu/d4rbEXMvWOmRWMlieFlNIFtFIqnmxb9gre+RP46dVm+pIb4B+fGV/+k3+aOhO5+WH43U1bbvei68emNwyML4siWN1nPpujr7Itq3cYgnjc5ddMu4y/KI/U0QhCIvLEpHEIkzKPiBQeMQ0ylJhLCyuIKIy2EJDHox+fGjPYgEuISwBo+pmWiEVjQYjLAC24xBQoU6eNOuAgSBGRIsKlwRBFSmRJNdnn0cAFCjogJqBEBqEd9IR7TOwIBlozFMsBkeuMCkCA5Z2t5F13VGB2Vut86eRjWNg3yPp8jo/8+z+09g9S6B2gvVrnnkXzuGtmN8V6Ay0EndUqc4ZKbGxtoc91wR3z9Gkh2JRNs8ZPsTSXAVcgohid1FnVmmdaqQ5xTEe1RjqKObI3YMZwlUundUJnbmwjsh40YsJ8htNWb2JaucbSQo7bZrZDyjPiEIwgHA4Ttach645uKwCOoPlNcA8PApGGGIbqmO9rygVHMBwx+iDTQDA0oHlwUwy+Wf/mdUm5gF/dP9bFr+6PePBNLvnUWL+XPxLz8r/EaGB6Du4+22V6fueKgbt7NMdfElELIe3CTa92OXrG1BMglj0LKxh3IFLK9wPvAmYD/cDFGO9W9BTa1MD7gDcCBwJ3A68AXg58EMgBP1ZKfTKpnwN+A5yQlC0FPqqUujop/zzwQuA4pVRVSnkAcBvwspE6W7BjASaM/lbgf4FFwHwp5bOAjwP7AGXgL8AHlVLlZL3rgWuUUl+QUqaB7wEvAjLABuATSqlLk7pPB74MHJTsvx8C31RKbdWFJaV8FfBZYA5QAf6hlDpbSnkFMA/4mZTyx8DNSqkzpJRF4PvAWUAJ+MwWmt59+MsdY9P/vAsaAaT8zZfvNTxeQo4vjTBS0wMCwE2CwJBhmAifGJcRv+TElgQaj2B0Lk+JEi1JCVTIjtaOEXQwRIhLjD/ahhGnPl7iGR1pq0pudN5J6kW1kDglCFyBozXlXIpa1scNY0pZn3rKJdOI0ELQm02xqZhFhxGtiTB6sKOVcirFvTO6KdQbRGHExQvnse6IA+kqV3j/zXfx4Ozp9GczABzcM0wmjHDimEX1Bg/VPMh44AjyjZCKcLm/mB61OjdQo9yZIx1EzClV6XM98nGMH409M3bXAyPyhuqmLbNzIONxeM8A+w0MAyD7h1hXyLCybUys4wgjGsPYiNft+clC0eRvjpM2Hlee/Bd682VNrCrBw/1w1Fgknyse1aMe7Q0VuH295qxFO1e8Xb1CUzNppNQjuGqFtoJxD2Mq/pa0TR7ZsawGngu0YETZmzEC66nyOozI6gZqwHVAO0a0nQJ8SEp5YlLXAf4ALAY6gd8Cl0spu5Pyc4Fe4AeJuLwM+PbWxOIEXpP0WQQ2AoPJsjbg6cnnU1tY92zgGOBApVRL0s79AFLKg4C/A+cn2/k84L3A67dmTLINvwbeo5QqAguBnwEopc4CVgJvVUoVlFJnJKt9G7N/DgIOwxwrdzu3/ylRKpWe3PQJ+481cvQiSvXa+DonHLATrN29ePxTQ7yFaXOxjsg0rakTcWgQgEudgEJyYdc4BKQZGl1/Yo8OMXnKCOKkv7EbQpS0/fibhCZKwunj29JNNczftA7prJfpjMsMtGcYaknjRDHdfcMIVxsxJAQCaKsHuJHmWycczoWHLqYvhMMfWcNZDy7ntEdX85yHlvHp5z+DdS0m1L4pn+P2OTNw4ph0FDOtVmd5awtXzJ7OlZ1tZF3BwrDBoWs2ctpj63nmyk20VmvjbJ4zWAag7jmszad5OJ/hgXyWDdkxUbkkn4yeDiOcSgNRDWCgCkA6Gv/cnPKYoPOTVxx7jhGN25Pq0FxFsOV1tjNtojML+7aNPweP6qiPTuc9zWFdxugnfS5vx/TxMwVOInAFcFhrdaf1tbdPW7Yf62HcgSilLm+avVNK+WvgVGAzscInxDdGBsdIKS8DvgKcm4SD75ZS3g1I4Cal1DDGwzjC+VLKj2KE2t+VUpGU8tXAncBNwHrgvCdgy3lKqfVN81c2TS+VUv4QeMMW1m0ABeAgKeUtSqlVTWXvBi5VSv05mX9ISvn9pK2LtmFTABwgpbxLKdUH3LClilJKB3gt8LyR7Uj2z4u30ccOoVgsPrnp33wAvv93qAXw3uc+vs4nXmryDR9YDUEIq3rhzsegqwgHzoW7lpnp9gIMVuDu5VCtw+ELYMl6KFWhq2Da7y+POd3SPuw/y+Q+DlagIw//eczUcYUJCe4CdJKLOBJ2HruVRiRJbkCULHfR+AhiNBpBgEOdkCxOkuFoPIEOmgImRFzDoUGMR0g68RPWiRA4xAg0DTzS1HAIqZElxCXCAzQ+ISEOPnUc0sR4CGIKDNNGlgFaEo+lsV8QU8chhQl1ZgkJEaQJcTQs6u0lchyi2EjZoUhAe5O60pqfnXg4Nd/jwWkd9Jx4GJ+48U6OGRgE4DvyQALfhTAcWyeT4unLVkMU4cUxK6d3kcpn8aKIOUPDHOi4hI5geTrDUMYjHYV0hQGbPJ9cFLFqRqtpRwhUdxup4Qa+43BHZyuttYAh32WZZ24pM4OIwd4KgTDyOoo193S2snCwTGsjZHUxy2PtRfP9cZID2oggn068hBpqoRGPglGxTBgbre4JWtOC2NVUG4nG9ARCx0Ra4LmmySAy35qCD8fNcygHsGoYunMwr8U4Qk+dBzevha6s4NwTHFrSAtJj59c5x+Xoaom5b5Pm5fu5zG81x+FJn8vbMX3SHME/X+Zy7QrNs+YKnr1Pfqf1tbdP7zymnofRCsYdSCLEPojxcnlACrh1BzS9rmm6AvRMyB2sYDx+SCmzGC/dmUAX5vJaxHjtAFBKrZdS/h44BzjlCeYhLm+ekVKejgnpHgCkMZ66ni2s+xtgOvAtYLGU8lrgI0qppZiQ9ilSypc01XeAVY9vZgylVEVKeSZmv39RSvkYRmBfsoVVuhM7m7dj2db62C3IpeEjW9G0QsBbT9919uxiBNsKQD9+uQsQx0Rr+qC/QqoWEF10C3puO96j6xF3LCfuqcBhc/FecjTxukGi399BGDo01pehXKY2cw7xUIgYrhHnUrgHd8Pdm/CqVQrdaegfxE05VBsum8IWfCLSsgtWlHH6SgzSShCZkPggKbLUcYkpMkiNIg3yeGhioIZHGpfUyMAerVnW2YEXQhxrcpU6lWwKR2tczTivmUBTKebG7wffhVgjghi5sZ8DqzVm9fQlAXVoL5UZOHgxL1q5BgEMp1M8Nq2LmY0GQ75H3fXYt1blzHUbWd1W5C+ZttH2dRjTEkTMrtSouYKq57I2mwEBaQFlAR1hRBnoz/mQdhkOYx5d3MKJMxxy7Xle5ce86ECXl+3vIYTAnJYjpJ7Q92Nn85oDd30w7rT5DqfN3+XdWixbxArGHYSUci5GEL0EuFIp1ZBSfh3j+duVfBB4BsazuVwppaWUm2i6l0opnwm8CbgQE5o+ZiTncDsYFZdSyhTwJ+AjwIVJTuR7gQ9tbkWlVAh8FfiqlLINk0d4YWLviqSN9zyBbR1p93rg+mQgzgswIfjblFKPMjFWCZswns4FwKPJsgVPtE/LHoLj4M7tgrlm1j120WjRZi9+nzlr3OzO8kNorQmHGoi0y6bfPMSmSx8jfqzC8GpwgwAn7RB05GndUMUPNA1HENUcqr5H5AqquTTv/Ned/PwZh+NqzVtuvIeUL6jnTBj+5fcs5RdHH0At7fH8FWs5bOMA+eEK6OR0EIJUGOEAD07v5qANGynUG/hRZEY5A47WDKZ8LjtwHvv3DfPsJetZ3ZKlFwcviGkNIqZXKjhFn1x3mt+90mPxggyFzNbE1a7w7Fgsk89UzGG0gnHHUcB4xDYCgZTyeEz+3YO72I4WoI7JU0wl4da2kUIp5XRMXuP7gV8B/wB+xJbDyFsjhXEL9Cdi8SBM3uFmkVKegsl5vAeoYgbJjCQ2/RD4t5TyH4lNGtgP6FZK/XsrbU4HTsIMrBmUUg4kRSPtrsfkKwKQhOQvAc6TUt6X2PGVJ7TVFstTRAiB32o8ajPeeggz3nrIE26j2lvnmGf9ibhPEKYctCMYaC8igDn9JX560iHguXTUanT0DZIbNqPaNRC7Lms7WqmlfGopn3jDRgLXYVXKZ3U6RWsQMr3RYEk+Q60Rs8bzOGawTMdwlTPP7mLa7CIn7pcik7Zp8BbL3oI923cQSqkHMSN1/wwMAB/DCLNdzTeT/tdiPGgVkvBrkr93MXCVUuoXSSj6dcBpUsq3PNGOknzJdwFfk1IOAz8AthQKBhOO/jVmBPQ6YD7w9qSt+4DnAx9IynqAX9IUSt8CDvAeYLmUspTYcLZSanlS/gXgdVLK/uQl4mDE8jLgIeBe4ArGBKbFskeQ7UxT/FKO1h9nmfvGxSyfO52aEFANWNVawEtGL1+/cCZOYyyXUQC3LJzLnYvmAZAJAkqZDL+bO5vbs1naB4d4wZw6Xz1vFg9/fzp957fzyPemc/El+/Hr3+7Pq5/TyamHZqxYtFj2MuwvvVgsuxZ7wll2GFdccQUAZ501PpR+85/WcfEPV3DZ8QfSUgt4zR0PM3OjeZ9mxfc499TjeOnKDbhoOio1Vra30a9j9j84z0ff1MHsGenH9WWxTFF2Suy4Lt417lqf1j/a42PUNiRtsVgsU4wTXjSTQ09s59ifrODf9wesmdFN4HukGiG3zptBd63Bvr39CGAonWKFB34hw3c/PnOyTbdYpgQ2h9Gyw0nCpE/fXJlSqrC55TvRlvsxYeKJrFBKHbwrbWlGSvkJ4BNbKH6uUmqLr9GxWPZWit0Zzv7U/vzkfWs4dMMQPV0dhALumNPFcx5djQBCIViXz3L9BfNJ+7vkVaQWi2UPxYakLZZdiz3hLDuMLYWkm6k1Yt7w+fXEy0q01UJund1Fby7F4RsGWDAwzP98c1/2X5DdVSZbLLsbO8UVWBPvGXetz+gf7PEuR+thtFgslilMJuXw+8/PAuC/dw1T/0kPcW2IY05q5a2vnEchbz2LFotl21jBaLFYLHsJRx1R4Nc/2qWZLhbLXslUzGG070WwWCwWi8VisWwV62G0WCyW3YzS3Rt58Kw/E26q4QqopVIc8MczKR7ZTdoBt2hfe2Ox7N5MPQ+jFYwWi8Wym3DPmb9n6X9qOA1By5DAiTPkqBEFLv96/U10D5VwnBiBw38PW0x2YZo5L6lPttkWi2UvwApGi8VimWQe/ctKlr35n3iD4Bd8Fg+toz9f5K75C/BCTW64hh9ErOnoJPR95vVvIIo1PatbWPk9wVYGSVsslklgKuYw2tfqWCy7FnvCWUZZ/9WbueUby5i5sR8HgSamxWngml/1Y3lXB49N76Y4VKWSz7B23jQQArRGPvAwA9ksj86eRfexnbzrqwdM7sZYLHsmO0XZVcQ54671Of3dPV5B2kEvFovFsotZ/cdl3CPOZ8nH7iddqePgIhCAOyoWAdrLFTrXlkBratm0EYsAQuC4gpOWPML0gX76b+nhgvMenZRtsVgsewdWMFosFssupO87t7LuJX9hgCJxJiQfhqSI8IlJERM0OTz6Cjn8ekQ95ePX6+QHS2QqVbLlKg3H5V+HH0aQSpGt1lD3B/zmW8sAaNQjotg6sy0Wy47DhqQtll2LPeH2RvqGKH3xn/R98142MJM0AX1dDo+2zmLx2l5aq80DV2I8YgbyWdYU2pjRU6KRchmcAWu6Z4J20EIQpDwa2QwAVddloJjHjWPKWlN3XTblc5TSPjpoEADzNg7wwPxZ7Dffo15M8dxDU5xzUoYo1rjOHh8ts1ieLDvly18W7x93rc/r7+zxJ5kVjBbLrsWecHsRYd8wA12fJnZjROjTTxshaTYV0zwybQ4CyNYDDlq9MVnDfD0E0MChgQ/AijltDLVk0EDseSAEoecy3FqgmvJZ0dVJlOQ2NtCU0mlycYwGVuXTLE/7xL7HvFKNAMGg57Au5aN1DK4DaRdizdEdEd88K8Mz9rWv7bHsNVjBuJ3YUdJ7EFLKHwOhUuq9k23L1pBSLgW+oJT65WTbYrHsaHQYEf/ieqIbH6K6LsQ9fgGp5WsJfn87q5lJxS3QXh/AiyL66CaVbWVGtY8+OhimFRCsbOscvUtV0z4rO4rs27eRBmkEEAPr2ouIEOoZj6EW40kUgIhjtOvSUqlwxLoV/PGY44iEQAsQQuAjKETRaL5jZ63Bf1sLtNcaOBrSaKYFEW6s6XEd6lpD1oNGzH/WwjMvbICug+eAA57rEMcxse8lBgh8D4g1BReOm+fQnhE8OgCHFiNSWYdcymFOCzxzDkQa9m2DwQa0pR16KjGtGYdpOdNuEEPKFQgx/n6qtX7cMotlz2HqfXetYNyDUEq9czL7l1JeD1yjlPrCZNphsWw3198PH70E8hl43xnwnp/CQBmOWki8tp94+TDgwllH0Lh7AL2yD6Hr+FTwqAERI16/GAcjx2IEHi6QxaFx9X3U8FiR2Y+Gk6HmpFjTMovTB/7BLL2cejVLH4uok2bkJpJuRDgx1H2X2BFMLw3jEFPHpa8lSymbQWvIN0JywyHZXEA174/btAN61jB3oJd6KkUsxhLSBeBqbTyOgGovQj0gnpjTmPaoayCKoRIYldqeAccBraHSANcj9AV4PsTaLHccAgAH+jX8Y6XxbALcvsEdHcU9+l8zKjTRUdJ5lHxGjN5xN1cHsymjm+lA2oMzFsCcguCn92pSDlzwbMGp8xzecVXMA72awTpsqsJBnfCPl7l058Zs+tk9MT+4K2Zxm+AZc+DC+zSL2gQ/Od2hIzv1hIHFsjmsYNwNkFIKwFVKhZNti8UyZYhiePE3jUAEuPE+CBKRctPDmMtfHgD9l3uALAIHB/CoIpoFDeAgEKNSpI5DjAukKKOBmfUiaW1O4aXZ2Qy7RTrDXgaYg8bBJ6BKFg3M3lACBJEjcLyQQhAQkSL0YDCfBQRtfTWydWNDZtUQSxa3U8+mKbfkCdI+1b4M62mjc2gIEWTpbymM+jSCJrsHHAdiTcl1qDiCXKwJgY0pDzI+VBp49YCwmDZiEYyAS/tQDaEO5D1ImbA1zfmOIylNEwVf02jucY6WXeAxjCfM12OoN+CyR2BE/JeBV/9Vc/bBMZc+Ml5I/7cH3n9dxCXPN7fHh3o1b7/KhPfv6tFc+oipd2ePpiMT85Mz3J25OZY9lKn4Hsa9TjBKKZcDPwNOBY4BlgGvBQ4GPg90A5cC71RKhVLKXwCnAW3AKkyo9ZKkrbck6xyhlOqRUk4D7gI+rZT6+Tbs0MAHgNcnfZ8spcwDXwL2A0LgWuAcpVRPss4vMSHptyYi8wvAm4Ai0At8Qyn1vaTuIcA3gKOAKnAx8BmlVPO9ZHN2nQacDywCGsBdSqnTpJTfB54OPE1K+TFgjVJqfymlD3wVeB3mWv2trbU/oa/lPIFjkawzD/gmcBLm6n8F8L9KqVJS/iXgVcA0YAPwPaXUt5OyBUkfbwA+DswFbgHOVkqt2167nwqlUolisWind8W0l4bBytjOD8cLwGZE8jHOMM3jZQfJa29GGF8e442KRYDuRj8t0SABGRwiSiJDiy4jgEFyjFx63ViTboy1tWJeF0OZLIWhGl40JmTcWJMrNXhs8Xyq6TSdvYPctM+B5KslOgZLtA0N8yia4WyWoXSK0HUJBKxI+QhXoGNNLARL0x771AKWp3wiDcQxbqwJUz5uNSJKJTmNMCYGgSRuvMX9tycSxrB2KAQev10bShEjx2h1XwXN5nM6N1XN/93mO2+nn/C0ZfvZW1+rczbwbqAduBv4I3AycDhwKPAC4JVJ3RuBIzCC8XPAL6WUBwEkovBq4OJEOF0CXL0tsdjEW5J+CsCdmGf592KE0qHALOA7W1j39GQ7jlNKFYFjE1tJhOu/gT8As4GnJfU/vh02XQR8F2hN1v1Csq3vBW4APq+UKiil9k/qfwx4PnACsA+wAJi/PRufsN3HQkqZAa4DHkj6OgiYw/h99ABGTBaBtwFfllI+e0KfrwSekWxfHnNcdwnNFyk7vZOnsyn4zEvMAt+FN508Wk42lXgQjSjSLRlixwiEkBSa1OjopJH/MRE6kZOa8eFhh5BmEZmNKlSYRi8LqVPgH8cezS9OPp1/HH8k/yfHv2DbZ2SEtCbwXWLPYag9y4YZhdG+KxmX1qEAN4hYvGQ1Bz+wggMfWknLQJ1ls2Zw34K5VLNZYtclcl0EkNIwI4joCCLwHVJa0xJqVqRTRI4DrsCvh6Oh68gRZIYbiUdQQ61JYLsjYWbGhORIuFnr8eJyhInLJnmA5Yws7Nc+Nv/uw+G8k1K0m/TQ0ceBtAvnn5IarXfKvjleuK8p7cjAyXPN8vYMfPRYcwvdbb7zdvoJT+8szLVi7DMV2Os8jAkXKKUeBJBSXoLxah2vlCoD5SRXTwIXTxB/v5NSfgh4FkaYALwLuAO4HfAxAmd7+bpS6tFkOiIRfAnrpZRfAy7cwroNIAMcLKXcmHghe5KyNwB3K6V+ksyvkVJ+GeMJ3JY4amC8i9OVUuuB67dR/w3AV5RSSwGS/fOWbazTzHYfC4wwFUqpzyTrVqWUnwZullK+TSkVKaV+09T2dVLKv2E8mP9sWn6eUmpTU59vfQL2WvYkzn05vOt0SHnQXoCvvwFW98MBsxAbh3BW90J/FefZh+EO19H3r0NUhyEWxPeuoHH3eogiRNFF9DSIOnJEv7wVp14hhYsmpk6emBQZ+ohJUSZLRJ6ALAE+IWl6W/P0tHWMmvXcu2+lGuYoiD5ms4KheDYNiuzXs4475ywADaXWNEtzHThRTGt/HRC0DQzStWlwtJ3WwQr5RgMNDOWyZuFI/iBGz/lBRJsrGMilaYQxhDG5IKQSayamNc7v28iRS1Zw09yDWdVaBK0xEW1twtFignBsREaMk4hHtPFQCsdMBxEZ38HzIIzMb9k0NLT6gq6sJoygEkHeF5y1CIYasKZsVu2tQSM0A2eGGlBMw7PmwvJBaM3AnKLx8M3Mw8oh6M7C7BaYkReodZqBOsxtgX1ajf94VkHgOrC0X1PwYVbRiL1Vb3fpr0NLSrN8EPbvEKS9sRu8IwR/fKHDmmFoT0POZ3Q6n5oaQsBi2R72VsHYHH6sAJFSauOEZUUppQOci/FIzcBcEvMYDyAASqmKlPJnmDDpm5VSTTGwbbK8eUZKeTQmJH04kMNclgubW1Epdb2U8hPAp4DfSylvBT6hlFIY79uJUsqBplXMz0hsmxcCnwDulVJuxAi6b2+l/pzm7VBKlaWUPVuu/ji261gk0/sA8yZsF5jjMgMjjM/BeBbnYLY5i/H8bqnPclP7lqnI9Lax6fai+QDM6sCZNSbinEIajlswVveUg8lurr0fv2HcbGpCcRaIb3iQ6JxfUr1nPWv8WRSHhkcF46L1qykGIbO8uymG5aSNZaznYEqFPBtndFEcKJGr1Ah9F3yXIN1g7fxpuI4gSLn4SXi9kjO//pKJQoa0xhWCbBRRdV1qjsOalAeRpjjcYIZoUEp5tNUDHvJcqAZEAlKugwY8rVnXUiDdvi+vP63Ic/f1OHqmIJs2t4lYa5w9ZNTyWYu3XLZfx/htyKcE+RSA4LBpm19HCMGcpqvEHHvFsOyF7K2CcXt5Ncb7dAbwgFIqllIqmtK4pZQHYETlDzHhzysTz9z2MDFR6nfAZcDLlVJDUsrnY3L0NotS6gLgAillLrHhD8A8YAVmNPPzttOO5jbvBl6Z5EieBFwlpbxHKXXdZuwFWIMJQwOQ5GF2b6bejmAF8IhS6uDNFUopT8R4UU8FblNKRVLKy5iK7zew7NY4Tz8Q586v4gMtwLyf3cYjn/0Tde2zcMM61jKdVj12OvUxg5WZbspkiF2XSjFPplrH0RonjFly4FxytQaVdIq7DlvErDW9tA2WyFRqzHt0HUsXz8aLYxqOg9DgRjGrchm8KCIXazxMyHlD1mNdPkW60mCmH3HUwWnu3wBfOi3Fiw7b+rsX9xSxaLFYdg5WMG6dFszgk42AI6V8I8b791eARKhdCnxbKfVZKWUa+K2U8jSlVLSFNrfV3yBQSgZ3fGxLFaWUxwJpTCi8DpQYe0/FRcD/SinfjPGuNTCibj+l1D+20mYKI5L/ppTaJKXsx4jEkXbXA/tOWO3XwIeT0PFa4GvsvNzYvwJfTDyr3wOGMXmexyql/ojZfxHmeGkp5fOA52KOkcUyaeTfehxHvvU4AEpPP4/4ppiH/IM5NL6LId1ND4toqQW0rFrP+ultrO/qYrC9lTnLN5BuhKyf4xIJQW9bC6HnsXzhTEQ0nSPvfIjpG/pZO6uDgUyaTK3O88+eznW3NnjaQjjn9dNIeYJqqClmmk/L/OTsCItlL2Gq5C02s7cOetlefgXcBizFeNIOwgz8GOEHmLzB85L59wGdGG/fk+HtGI9mCeMt3JrQKWAGe2zCjJA+g2RwSOLhPBl4ESZc3I8ZTLJwO2x4JfCQlHIY+AvwWaXUv5OybwFSSjkgpbw/WfZlTH7grZgRyCsxnsAdThLuPwVzHB7CiOtrMYOSSOy4CCOiNwEvw2y3xbLbULzhs7R+5Him1XqoiwJl0dFUKnjpf//OS2+9kn0fXk22HuJomLt6I/1tLcTCaaoJaG1uTELQPVTigssO5lUv7OaCL8/mY2/rJpdx8DwxQSxaLBbLE8f+NKDFsmuxJ5xllA2zP427boANeh/AwSVgXxRrOJQ+v0hvukgmDHlg/3k8On8mkRDUPQ83iljw2FraB4ZZP2capVyKD/7mCDqm25/0s1ieIDvFFTgkPjTuWt+iv77HuxztY6fFYrFMEtPXfJ70ii9Tmu6TpZcsgwhiXAJaghrTh0u01mp09w8B5hdcCrU6x9/2EPlayJJD9qGWcvnC1cdZsWixWHYqNodxJyGlvBLzouvHoZTa7MjnXYGU8rXAT7ZQ/A6l1MU7sK8fY17ovTkOUkqt3FF9WSx7KsW5BY5f/z4AHpz+Dfp75pJhgAiXOJWmt9BC7AgWr1yFpyMqdZeBjjylQppseZhDPzi4jR4sFsuuZirmMNqQtMWya7EnnGWrbLx9HeWTv01npYfeXAv/nvd0aAhqGYeCgK5nzuKM7x2LcARXXGFeonDWWWdNstUWyx7LTlF2g+LD4671rfr8PV5BWg+jxWKx7EZ0HzuT7vJXAfOC0AWTao3FYnkyTEUPo81htFgsFovFYrFsFSsYLRaLZQ8iiDRRtLl36Fsslt0HMeGz52ND0haLxbKbUy6H/Pk7j/LjhxwOWtvLMY+uZfn0do58P+gA4jDG8ezzv8Vi2XnYQS8Wy67FnnCW7aJUjvjbVZv4zaWDDAmHx2Z2EHgeG7MpTr9vGW+/7i4eWjiNtnKFVBzxqhueQyrvcs1Rf4ZVJVL1Bvu870D2/dYzJntTLJbdmZ3i/usXHx13rW/XX93j3YxWMFosuxZ7wlm2ShRp3nDeev7VK3BjTSRg/0bIvFodB1iXTXPdzA5+/ou/0/AdBFDNZ2jtLVOo11k9v4vYdZkx1MOJK/6DqGtWpeZxyPUvJ/+0uZO9eRbL7oYVjNuJjWFYLBbLbsQr3rucS0tp1qVSrM2kaYliZiViEWBmtc7CoTIb5nQSeQ5oTUffMMKF0PWYtWKQeUs2EQ1n6HM6yVNlXmMFa064gPvE+fRf/MCkbp/FsjegEeM+UwErGC0Wi2U3oGddndNf+yC9YYoIaIk1xVjTk0rRWq2NVdSa5y9dTa2Qo1rI4cYaLWBBXx/d5WHa+qq0DNaZvrbEpvo00gwzkzUs5mH2YSnB637NMnEeQ+/6A1F/ddK212Kx7FnYQS8Wi8UyibzwU2v4WzVHBHjTZ/CswWHycYxIvBKx4zAMtFdrhI5D1+AQ6TBCA8O5LAOtLZSKWaqPriI1HDB75dgvvxTjMhnqgIcAcgwSksahAT/+J/0/voGWez9K6pAZk7DlFstUZmp4FZuxgtFisVh2IYNVzeeur/HwJs2/lkdUGoXRWE8YxzyQ8fEQjLw4R2hNR7lCOyDiGC+MqKZ8OjYNMXtNLwCbOlt5eOFczrz5dlwEAR4uIfN5hBgxGkoSQIRDG2sYZA5ZSuhDP8wwPo2OVto3fRMhpt6NzmKxPHWsYLRYLJadTCPS/PDmGt+4qk6u1GBVW4F6HKM9F7SRhtMbIQdVa2gE96QEWmvaq3VOXb6axes3Evoe5WyG9dM6qaVSbGhrhRhmr+ulq3eQlfO6WdS3kRhBHY8cw3SzgTt5GkVCstTJMoSLJqCDDGXybAQgBeT6SgTO64hIU3OzxGceTdtXTsM9cC5YEWmxPCGmSt5iM1Yw7kKklD8GQqXUeyfbFotlb+OejRrfgXlFuGWtJojhhNmC1rSg3ND8c7mmJQVHTYf/btDctk6zrB8O6dTcvkHQntU81Cdo9SHnaa5eEVNvwCGFiExWcONqTR0HXEG6WuOQ3rW01Kss7ZzBqrYuivUY4fus7s7g91bwYjOIMs6nCDUcMlBLLsiao4eraCGo6Zh55QpaCIYzaYJsmloqZTZICNbO6GD2ul6qmRSt5QqhcPB0TJaAFHUCfFII8tQBaJDFBLOztDJIRBqX+kjwG58GDh5eVCO64mbqV/yXGBggRZZhUgSkqOAQMeoWTXnErovTkkM88yDiUoiuNND1BnE6j3fYTML5cxCPrCZ10kI4bC6xWo17xHScWx6EjA+vfxakfXhwNfFtj6If3oR4xzNxFnTtui+IxWLZKva1OhbLrsWecJPA//4r4pv/Mbu+Iw19Rj8xLQfXvNzh2ZfFrCubZb4DwcQfUolicMTmPW0j11AhzHQjwnUhclwAuocH6csXiFwPtEZUAvymwSZR1idqz3D6ko2joWMNpKOIznoDR2tCIdCOw4z+AYbyOWLH1OzqG2SflRsY6Cri1UPmL1uH74TMLm2iu7qeJdlFTKuV6dTDANQR1CiigRRV5vEQPmU0jOZMahwiWohwCckCUMVhLbMJySDQzOAxZrIiqT+2pgbqFMlQAqBMNzXaqZNB45CmQooGIPAZIkOvWXdWO7znufDJS8w+IUtIAf/OT+AcMX97D7PF8mTYKa7ATeKT4671XfqLe7zL0Y6S3gFIKYWU0nprLZbdkCjWfOe/Y9fuEbEI0FOBL92qR8UibEYswpbFIpjlI2VCQModFYsAGwuttFYro+U646GbmtIpFxyHYc8hxojFGGhvBOYCLQSbUh5LsinEcIVFy1fTNjBES7mCq2PWzumikkmRLlUZLGbZlC9yz7QF/Kd4BGW3hbWZDiIEghDQrPbaWO51scHppEGRIWawrXtmiRZCsjgYYbmBhQQYT6dI5CbJ33QiFgGy9AIOzlhG5mhdj8pYr2v74et/GdvdVBFooo/8Yat2WSyWXcceJ3KklMuBnwGnAscAy4DXAgcDnwe6gUuBdyqlQinlL4DTgDZgFfAFpdQlSVtvSdY5QinVI6WcBtwFfFop9fNt2KGBDwCvT/o+WUqZB74E7AeEwLXAOUqpnmSdX2JC0m+VUgrgC8CbgCLQC3xDKfW9pO4hwDeAo4AqcDHwGaVUsA27fgm4QAC8BCgDHwIeBH4KHAAo4LVKqbXJOjngc8BLgVbgduC9SqmlSfmrgI8D+yTt/QX4oFKq3HRMLkiOyXHAcuDtSqmbt2HrAszxeyPwUWA+8G/M8fwo8GbMvfPzSqkfNK33dODLwEFAP/BD4JtKKZ1sy2+AE4AcsBT4qFLq6mTdNwKfAr4LfATIA78H3q2UirZm746gVCpRLBbt9C6crpSHmdeSZdnY4OFxHNS5+eXjGNNEmynTY4JRa4j1OHHZVh2mL1ccq+86hNMKLFzTz7KuInEhDbGm4jhsbEnTn0/RVg+Yudp4IR/Lprm+vQhC8NCh+/HJf9/BouVraKR91s2ejh+GxjhPkESe0Y4gdh3cUFN3UpTIMpshVrgLCIQPwKCbpxS3MEwHNdJ0sxKAiAwaQZ0MLlDHZzjxNI4h0FvwN2ic0SE78WiQ/fE7L8bHXNpACxD7TIP+4aTUSNPgkBn4yZLd4btkp6fetGX72VM9jGcD7wbagbuBPwInA4cDhwIvAF6Z1L0ROAIjGD8H/FJKeRBAIgqvBi6WUvrAJcDV2xKLTbwl6acA3Im5XL8XI1oPBWYB39nCuqcn23GcUqoIHJvYSiJc/w38AZgNPC2p//HttOtlwOVAB0YQ/zTZ9hcD0zG3v/Oa6o8IyeOBGcBtwF+TfQIwCLwGsw+fnnw+NaHPNwPnYATn1cCvttNWMEL1JGAesCDp/1HM/nsT8G0p5TyA5Nj9HTgfs5+fh9nnr0/acjD7bTHQCfwWuFxK2d3U3/xkPyzCPHS8HHjVE7D3SdN8kbLTu276by9xeeliwasPEJz/TMEBHbBvG5z/TMGnT3D57smCuUXYrx3edRgsbDX6S6DxdGxEoNaYU0dDHJt5raERQ5h8AOoh6JiOyhDz+nsop9KPF5uew9MGh4ldD+oR1GIGMj5LZxTpbcnwaHeRh7tM6HhFJjUqQAeyaZZ3tgIQuS6pMMQJQ1LVGuV8djThIVUPydQDnCgmXYvIJMJMTMiIcIhpZSMRRdZzAAEdaLKAwwAt3MmBPMIC2hmmjY2Q+EC7WI1PLdkbDg1cIlwCMpSYSYMcARlqtJEWA3heSErUSBcD3AM6cboysGAmFLIwrRXxy/fBHz+KfvkJRNkCgd8Bz9iX3DdfvVt8f+z01J22bD97nIcx4QKl1IMAUspLMB6p4xOPV1lKeT0ggYsniL/fSSk/BDwLGPm5g3cBd2C8aj5GbG4vX1dKPZpMRySCL2G9lPJrwIVbWLcBZICDpZQbEy9kT1L2BuBupdRPkvk1UsovA1/FCL9tcZ1S6m8AUsqLgB8Bv1ZKrU6WXQa8LZnuwojB+UqpDcmy8zDe0+OAG5VSVza1vVRK+cPExmZ+opS6P1n/Z8AHpJStSqkt+HXG8XmlVF+y7l+B5ymlfpqUXSml7AeOBFZiHhQuVUr9OSl/SEr5/cSei5RSwxgP4wjnSyk/ihGGf0+WVTHe2ijZnmtJvi/bYatlD+TATsFlLxwLE3/omPHl7zva5X1HP/V+wljz3/WCOXnNmsFWHukt8v6rI3ordUj54Jln9GylQU8uTXu1QX/GhHbXtWTGeSb7syliIegKQpYlyzJhyPRKnVomjUDQtmmAbKWK0OBGMelGAwEcvHE1i4IHgYhNTKMl8fgtiNZSJ01N+MyJe8jSoEAvdbIEZKmTwyMANN2so5tV0J3Ge93TKS9YTGdQI3fyQvwj546zNRmGg4t5Yhxh5ImzsJ37T/z+Q7hJOxbLnowdJb37sK5pugJESqmNE5YVpZQOcC7GCzgD8/ydx3imAFBKVRKB803gzUqpyhOwY3nzjJTyaExI+nBMOFSwhWulUup6KeUnMJ6630spbwU+oZRSmNDviVLKgaZVBNt/HR3dP8n2jVtGsn+S6X2S//ck9UbwgbnJdp0OfAbjhUwndvQwnub2RzLCihjv5Hbbm9i2bkL5RHtPkVK+pKncwaQbIKXMYryPZwJdGJdIkaZjDvRMCD+Xm9q3WJ40niM4dpa5rM5qhWPmwWuPHF/nJZfX+ePDHlfN7YJaBGg6ag0G077xZDoCN47Zp9+cRvuXa7T3DxJrkOs3IlI+hb4hvCAi9Bzz84BA5DoM5zMI4GG3m8NW3QJAmgprOYQInzwlDo8eQiS+xgCHjXSSpgLU8A9pI/X7j+AeOPtx29a2c3aZxWLZQ9hTBeP28mrgrcAZwANKqVhKqWgKEEkpD8CIyh8CX5ZSXqmUWr+d7U9Mj/8dcBnwcqXUkJTy+cAVW1pZKXUBcEGSd3cuJpQ6D1gBXKOUet522vFUWJH8XzxBdAMgpUwBf8Lk+12olKpKKd+LyYucDFYkdrxnC+UfBJ6ByadcnuQ1bmIqvnbfskfyh5emx817Hx8idgUt9ZB+18FB8/z/PsKCwTKlrnbyscZ3XMpohosF9n1kBV5kLj0ijhnNLGp640XFH8s5HGA2dfIADNKJz2r66SBFhVk8wqDogledRMtnT0PsP2vnbrzFspdgPYx7Hi2YwScbAScZ8HA48FcYHexxKfBtpdRnpZRp4LdSytOe5ACIFoxHrZTk3H1sSxWllMdivHW3Y3IfS5iwNsBFwP9KKd+MyatsYHL79lNK/eNJ2LVFksE+lwA/lFJ+QCm1RkrZhskJvTqplgb6E7F4ECZncLL4IfBvKeU/gH9gvMb7Ad1KqX9jjkEdM4golYSj2ybJVotlm9S/UORFPylx64qQrlJE1RFcN38OBw4Oc/yQGQSS0Zp6yqerWhsViwhwY3DqIfmgQj3OUC2YIPCi/hXJL7xoKhOc53V8elNFFjVWMSBPpOOOD+7S7bVYLHsme+qgl+3lV5gBFEuBNZhRtTc0lf8AE1odGQDyPsxAiXOfZH9vx3g0Sxhv4aVbqVvADIjZhBE3Z5AM1Ek8nCcDL8KEvfsxA3sWPkm7tsXbgIeB66WUJeBezEAQneQEvgv4mpRyGLPPLtlJdmwTpdR9wPMxOZbrMMfvl4yFnL8JDABrMQNnKkxIHbBYdidcV3DFu1vY+NUOHvp0kVc9sIxTN/aRbvIYDqZTdFaq1NNp4ubX+2jI1iKmVfo4ed0tHLHiEU5ecQuH9C9lCUfzAE9jgG7ixNuRZYiS14asvZ8OfYEVixbLTkNM+Oz52Bd3Wyy7FnvCWbbKHXcP878/GaQYxHQO1yiGIf3ZDNNKw6SjmEKpTLFUppZJ0zJYpmvTEABd4TpmVdcjqmn64+mkiPCIR19zU8kLDrv7bHKLWrdhgcWyV7FT1FyP+My4a/00/bk9XjVawWix7FrsCWfZLo7/4Hp6hMfCTUMc2j/IQC7H9HIFd+QbpDXT1vZQqNQIXJfZh+SIr1pLJeXRXqmRrQVkozqZhVlmX/Z8Oo+cManbY7HspuwUIbdhgmCcPgUE41TPYXzSSCmvxLxv8HEopbb3LRE7HCnla4GfbKH4HUqp3erVMFLK+zHvPZzICqXUwbvaHotlT+HWb44IvC4uP/sm8lcr/rN4f+rZLFoIUrU6Q7kcg615Tj2rkxP/9yAA4igmGmzgd2Qmz3iLxTLlsB5Gi2XXYk84y5Pm1ivWctV3luH6Du/6xVHcdMdVAJx11lmTbJnFsseyUzx/68Vnx13rZ+jzrIfRYrFYLLuG48+axfFn2VffWCyWXY8VjBaLxWKxWCw7kKn4Hsap/lodi8VimfIsvWwZXz/per74gtvo66lPtjkWi2UKYj2MFovFsocS3lhB/6jOz2UP5WldAJz3hvsQ+xb59vf3m2TrLJa9GethtFgsFstuwJUvvZb+y1MMdeaY3t/PYfc8wgGPLKcjrDNXreL01y3hln/3TraZFotlimA9jBaLxbIHUL53A2uffgm6HLLmgOmsH87TWq0xkM9RHCqDEKRrDQr9ZR6YO42jNvbx5QsEr1lS41VvnT3Z5lssexVTMYfRCkaLxWLZTelZ+Hk2LcsQI6iSRpAhQhPdH1HoqDPUksHRMRrQaBCCyHMoeD79rSnksrWs/s8w1832OeW50yZ7cywWyx6MDUlbLBbLbkYcx6wU5zK0zCdNDHhk0AgihsgSa4d62sOJNW4UI7RGC6hnUlRa8gBUPI9rDpjHw/vO5J/fX80rX/0w0z/cSy2IJ3fjLJa9AD3hMxWwHkaLxWLZTdBxzNDzfkT5H2twyJIipEIWnTzbu+jRaT+IcZJHfi+KwffYOK0dV2vWZdJcNn8GWghumDWNfYdLHDZU5p23PczXTqzTOH0BX/jiPpO1mRaLZQ/ECkaLxWKZbLRmoPX9FErraCGiBRhmNlVaqJAdreagyVGlQhYn1kQjBUJQ8tMAVB2HR4o5tBjLoXqsvYV1nQXytZBQO/hL6pz41pVEx3Zy69vzu247LZa9BJvDOMWQUp4E3KCUmpQjK6WcA6wC9lFKLZ8MGywgpQyB05RS10+2LZa9Ax3FNN5yAeLSG3ArNRqkKBLhjklA0gzjAA4hfXTSIIVHxEJ6WcZMojr0Z42Y9MKITC3ise5Oquk0rfH4IFghCKjmUqxuyVEINDNKASet72XddWWKK2czDOAIDprm8P0zUxw/1yXr24wli8Uyxl4tGC1TGynlcuBTSqnfTLYtlt2cx9bD+34Gj64385GGV58En3s13PIwvOxrMFiBfabDqk3owQoBGTQurhfjhTVGMpU0EOMR4eFRG+dniPEIyeEzhI9HDwsp00qBXqbz2DiTKhSo0oEgxidEJKHoMgUcoHW4TiYKCVyHYrXBvfu3EScx6kWDJbK1Kvd1tVNLeyweLHN7LsONc7s5Y8lahoCBQpa5tQbHrdjEtTO7QMAD6zWnXKpBREBoNkYI0Bompj66SVmy1XkBhTREEczPxhww08P3Be86wuHQLvjibTFrh+G9RzpMy8KXbo5xHfjUiQ7T81PPG2PZ25l632krGLeClNJXSgWTbYfFYtmJaA3P/DSsnvDOws9fCu0F+MhFECaev/tWAuZWkKJmlo3oqmQ1AbiEuISP68ohJEUdEAzRQYmupInUuHqB8PjuM1/Kis4ujnnsMU6/84GmUkFPa458LcKJNK4rWDmri/8evA86jlntQ9FJ43keRwxWSEUxvtZUNwxwz/RWrp3ZOSpjWxxNlPFACyiHEGgjllMO4294AnRsRKPGDJd0mjyQgaasodwwVTfVXf5TAtD8YUnEixfDr+43Vf+0NGJWWnP/JjN/5wbNja+3tyKLZXdnl5yliafnZ8CpwDHAMuC1wMHA54Fu4FLgnUqpUEr5C+A0oA0Tsv2CUuqSpK23JOscoZTqkVJOA+4CPq2U+vk27FgM/BQ4GngM+MWE8uuTthYApwBfklL+JrH9aCAF3AN8QCn1HymlA/QCz1NK3SylXAg8CnxeKfWZpM0HgHOVUr+XUs4ALgCeCWwAvjahfw/4BPBGoB34L/B+pdR9UspOoAeYq5RaK6U8BbgWeItS6sJk3V7gdKXU7VJKDbwHeBNwAHA/8Eal1EPb2EfPAq4B3pDs5xnA5cB7gW8ALwOGgP9RSv2hab0XAZ8GFgHrMMfs4qRszpb2YVJ+LvB04DbgrUmTP1JKfXZrtibrvgr4LDAHqAD/UEqdLaW8ApgH/ExK+WPgZqXUGVLKIvB94CygBHxmW33sSEqlEsVi0U7vTtOV+uPFYkJw4/34I2JxByAgGbSix+U4xRMuxX885GRuX7QvAH896ij22bCRGRtL5IKQbz37aRSHQo5eZryhy+Z08/B+86g7gj8tnoVGcMrKTaNthY7AjzSuI9Apl1ohBcMBeA5DrWmajIBquGXHSLMi3lq0Wo8vH2rAPRvH5vurmtLw2Px9G/Xkfwfs9F47vbOYijmMuzJJ5Wzg3RghdDfwR+Bk4HDgUOAFwCuTujcCR2AE4+eAX0opDwJIROHVwMVSSh+4BLh6O8SiB/wVI5ymYYTPOzdT9c3Ad4HW5L8D/BCYjxFP/wX+kHgfY+BfGHELcDqwdGReSjkb2B8j7AAuBiKMkHkGRhg282GMUDsz6esG4GopZYtSqjfZb5vtCzgOc8lXTe29EXgp0IUR3t/b2j5qwgWehTkuBwLPAW4F/gR0Al8GLpRS5pLtPB34OfABoANzrL8vpXxG0t4W92FTn88AVgKzMN+FT0gpT9yakUn/vwbeo5QqAgsxwhSl1FlJe29VShWUUmckq30bWAwcBBwGvDDZ3l1C80XKTu8m0/kMvOhYHofr4P/PC2B+1+PLGHtVxtZemTGxjhGLMSBoYSNZBjC3Fj2uncFcYXT6iMdW0jpYY1Mhy++OO5j/zJ7NfxbMYEZlDdOr61iwupeT/+8+2pf1UPE9vCBiVcpjk+ca7aY1dUewpDNpM+2BI8xn3PYKyLiJqk2saf4/ops1NKVaGpqbcoAgHl33mBnwjsPFaJUT5wjecOjYCm86zJn874Cd3munLdvProwDXKCUehBASnkJxsN4vFKqDJQT754ELp4g/n4npfwQRsCMxGXeBdwB3A74GIGxLY7DeA4/rJSqAkuklN/AePyauUwpdV0yXcGIjpUjhVLKTwHnYETHAxhv3KswwvY04CvA16WUrcn83Uqp3kQ8ngLsq5QaBAallOcBVzX1/SbgqyNeQCnl5zAet+cBv036Og24KPn/aeA7UkqRzP8rEbEjnK+UWpm09UvgieTyfVIpVQFWJscmr5T6W9LWRcCPkn1wN/B+4DtKqRuSdW9PPLNvAP4vsWFr+xDgEaXUj5PpW6WUd2G+Dzdtw84AOEBKeZdSqg8jsjdL4hF+LcYjvD5Z9lHgxdvaGZYpzuUfgb/cDkvXQ0se1vebHMbFs+Ch78M3/wLLe+DEA4038if/JErn0Oks3mHTEKUaLF0Ly3rQ9ZAQD4FAEIwKQQcXjYMmwkGgiZnFA0m5Syh8fG0yYF54//XcOu8w8pWIN/zrJgTQWQZfreKE2zaQIqDouFR9n7mDfUS4zF3Ty2VP2598LaLsupRd6B4Y4qRHlrF0ejulg2YZQ7Q2n0YEsTbCMdbmI0QiBjUEIYQxpF0cNHkfwtihAXgOuCJiWt6h6MfMLgr2axW05x3KDc1BbbC422EogGfNFeR8wbEzNOvKmlPmCdIuvPZgjevAM+fZwTWWqcdUefdiM7tSMK5rmq4AkVJq44RlxeSmfi7G2zgDs9/zmLA1AEqpipTyZ8A3gTcnwmZbzAF6JtRdtpl6y5tnpJRdST/Pwng8RwTZiD3XAN9OQp0nY8TTS5Lp05Lykf4BVmyl/7nNy5RScRLOn9vU1y+klB3AfphQ8acxXtrTMKKymeZ9Xga297Fqc8dmqMmuipSSpvb2AU6WUn6waR2XRLxtxz6caOt22ZvYcSbwQeCLUsrHgG+MpC9shm4gzfhjvLnvgGVvw3HgRcdvviyTgk+8bPyyT75sixdPgXmK3V7i13wL/dub+O1Rz+f5D1xHsT5Mx3CNCy77Ohvd6ZSYPlo3iHxA08kwTqzJ1CMCHAYo4GrN6665lz+ddNBofb/eoFitc8C6Xhb0DBK5glVtRWjLgCPIVBqk6yGFDFzy+jTPWJjejIU7hiOnC45sckWesmDqhewslqnM7vho92qMV+2lQLtSqg3jxRq9ukgpD8CIyh8CX05yA7fFGmDaSBg1YcFm6k0cC/hlYCZwnFKqhTHxJgCUUo8A6zHh2PVKqbUYYXc6JmdzRDCuSf7P30r/q5qXJeJ5QbIcjADrxOQm3pAMyLkG4yE7rqmvXc0KTJ5mW9OnqJQ6Mynf6j58KiilrldKvQATdv8C8Bsp5aKkeOKx3AQ0GL/fF2CxTCLOJf+Dqy/jtNcs5o8HvoALj3oDPSygrrPkwsposDoSgtA3p4xo8l+MTIdCcOiaTWSTnEsvijh43UYTQU6neO+NdzO/dwhiTUepxlnZMoMfTzPwxRZWf7plp4pFi2VvwySajH2mArvj0LQWIAQ2Ao6U8o0YD9pfYTRv7VLg20qpz0op08BvpZSnKaUmZtY0cytG2HxVSvkRTK7cB7dSv9meCtAvpSwAX91MnWuADwEXJvPXYgRtmsTLppRanYR2vyalfBOQ5fEDLn4JfERK+X8YL9hHMcfob0kbVSnlzUlfI+tei8njW5+I18ng25g801uBmzHexUMBoZRSbN8+fMJIKacDJwHXKKUGpZQDSdHI92A9JuwNgFIqStIhzpNS3gdUMSkEFsukM+uDx/OW5IrUk7uBUrWLKnnKZJjDSm7vOpAhP0d+qEFvPUdXUCESgrv2W0CVFLOW9dI9VOFpa3vpz6c4eM16CjpmxYwuNhRyLO1u4aa508kPltn4pTaciTmMFovFshV2Rw/jrzCjZZdivHIHMT4v7QeY0cLnJfPvw3jdzt1ao0qpEJPreFiy/h94fP7i5vgMZpBML2Z07808PuX7GowoujqZvxeoYUbmVpvqvQYjIlcl23TRhHbOx4SVr8KMoj4FOEMpNdRUZ2Jf1wM5Js+7iFLqKuBtGPs3YcLL3wJGMve3Zx8+GRyMt3W5lLKE+W6c3fQS9C8Ar5NS9kspr0yWvR8Thn4Ic5yu2EG2WCw7jGmVrxE/dz9ylOiglzXM4ZiN95MJawwXfda1tHLj/vty5YlHsnpmN70zWym15yhnU1QKGTrrDfJhyMqONlbms/zxwAXc19HOR47QDH+l3YpFi2UnMxU9jELrqZiaabHsttgTzrLdBBuGGXrNJay+ro8MAfNYT59oZT1dPLjvQlbPHhvBXegZ5j8HLqC3JUc5jkHDS2+/m9vnzuT8y4+iu7g7BpQslklnp6i55eLL4671C/TH93jVaK8gFovFspviTy/Qee3b6Uzm60t66dg4TKE1T/2oyxhsyVEqZMmXqrQPlXjafY/w34WzCTyXg9as58GZ3Xz70qNos2LRYrE8RaaUhzEJOz59c2VKqcLmlu+NSCmHt1B0g1LqubvUmG0gpfwE5mXmm+O5Ta/y2VOYOiecZVKprB7iuiP/QJYyt+1/8OhvxfSnfVZn0gwX0vy/3xyMZ38T2mLZGjvJw/iVCR7Gj+3xHsYpJRgtlj0Ae8JZdhhXXHEFa69yuXPNPNakHDblMrSUavzue/Npn5GfbPMslj0BKxi3ExunsFgslj2YWWdEnH36gaxcUmGf/XL46V32w0UWi2ULTEXPgBWMFovFsoeTybjsd6j9uTOLxbLzsILRYrFYLBaLZQcyVV6l04wVjBaLxbIH8MW33UP/Q0PM7h9gOOfzwJxpvOK14KW2va7FYrE8VezwOYvFYtnN+doH72fNJodwWjurFs9Hrt7AJ6/4Fw9/2af3X/a98xbL7sZUfHG3FYwWi8Wym3PHoxEpR9Cf8VnaWeSiU07kwlNOYsGmfoIrBd84+M+su3nDZJtpsVimMDYkbbFYLLsxbzrzdo7dOMzd+8zkd4cvIHIc8vWAn9yoWLiph9e96WUsmd7FNy8b5JIHHuOZb1042SZbLHs9U8Wr2Iz1MFosFstuykteeBfHru6l0KhTj0Mix1yyW8sVTlqxlNgTzB40PzW/tqOVFz9Y5KPPuWoyTbZYLFMUKxgtFotlN+TLR/2TZ6zdSLWQpppPc+zajbhRDMDn/nw1Lpo5g0Nc8Ls/01qtAdCfyfKNQ4/jnadcTWN9ZTLNt1j2avSEz1TAhqQtFotlN+MDZylmZDx0NHarcYFX3PYg1TSc8Miq0eXZIGTaYIlBx4NGxPMeepj/veF2embeyAOdbew31yH6zOnM2reV7KGzJ2FrLBbLVMAKRovFYtkNCIKYH55zN/eviOkIQq7bdx9OfnQFKZ1kQzUijt7Qx+nqLqphhgJ1BDAoshz4wHqWH57Dj2N+8Pe/kYkDIlwKWvDsE1/BOz57Ky+89wHWtRZYd+wCzrroZDIzWiZ5iy2WqczUy2Hcq39LWkp5EnCDUmpSjqyUcg6wCthHKbV8MmzYGUgpPwWcppR61mTbshuy955weyhBoHFdcJzHXybqjRjPFWgNnieIYk0UQ8oT1GoRjXpMA0FLWrBx2TAlXB5cE/Dg9ZuIH+pnCWnCWDCvp8RAIUMxbDCvbxCAh7ra+dPh+1FKuaSiGEdrvnLF9URRzP5L+vB0jCBmIJVDa4ehjM8Vx8zix9f9AQHEOAxRoEaGHA0AIhwEIRlKeNTRxGSo4NKgL1OgpVZibbGVlkqZjigAYmLipD0ftz1NXA+4a8Z8OtMxC706TGsD14EjFsABs+CAuRBFUK6D60I2BSKG2Z1w1wroLsJB86CQNfUGK6YNi2Vy2Cn3/yXi6+Ou9Yv1h/Z4BWk9jJbtRkr5RuBTSql9J9sWi2VXcOll/fzligHyeYf//Z/pLF6cASCKNF/5YS/qv2WyOsZz4ODnd/OFB1yqIbyis87QXSUANuU8Trv7UVqjgMgR/OPABRzWWweRJ+84lLIp1uxTIBCCA+5/ZLTvBf1DrClkoUmo3jF/LktndjNnfi8vuPVB0kEIkUlFb6kFvFvdMXr3c4hJESCaUtU9GkxjOSKpFRPhYvIfp9f60MCi0qZxTzUu5inHIYT+gFec/SH+dMixuFHERb/7Pq+59iZT8aq7n/yOXjAN7v8O5NJPvg2LZTfCjpLey5BS+pNtg8VimRx6e0P+/JcBtIbh4Zj/9/v+0bI77q5y211V0nEMGsIIvqQ0ww2IYvhtT4pICBCCE1dsoDUKcAA/1jzj0TU81N1K7DhEjjMq3nyt2ZTPARALQSmXJdsIRvucO1Bi0cAgz1qyjJoX89PTDuPjLz5xnLgbSudHp2ME/525D3858EhunrcvVc8jdoLR/gAc6uO2WTT9FxPmHTQbCy386ZBjAYhcl++e9NynsIebWN4DP79mx7RlsVh2CrvEwyilXA78DDgVOAZYBrwWOBj4PNANXAq8UykVSil/AZwGtGFCtl9QSl2StPWWZJ0jlFI9UsppwF3Ap5VSP9+GHYuBnwJHA48Bv5hQfn3S1gLgFOBLUsrfJLYfDaSAe4APKKX+I6V0gF7geUqpm6WUC4FHgc8rpT6TtPkAcK5S6vdSyhnABcAzgQ3A1yb07wGfAN4ItAP/Bd6vlLpPStkJ9ABzlVJrpZSnANcCb1FKXZis2wucrpS6XUqpgfcAbwIOAO4H3qiUemgb+6g9sfEUzPdjNfBOIAR+DKSklMNJ9ecrpa6XUj4POB+YB1wPLN1aH019nQs8HVDAmzEPMF8ELsccm2OAR4DXKaUebNpHH0n20bRku96vlFJJ+anAl4D9EpuvBc5RSvUk5dcD/8Ec4zOSffpBpdSft8fmp0qpVKJYLNrpPWDa8wSOA7EZmIzjjv2iShTWmIjP+AEqI2Irch1ixp7O655LOjRtOVqjm+peceBC9t3Uz2xt2njVktVUHU0DkKt7cIBsGHHi2g04seaWmdMIcjH5ckw56/PPww/h5ng2R6xew6yeCsvaZwCwsdDCumI798zdl3fes2a0R42LIHzctmyJYr1KS7XCUNYI24V9Pdu97jZpM2J3so+7nd67pncW1sP41DgbeDdGCN0N/BE4GTgcOBR4AfDKpO6NwBEYwfg54JdSyoMAElF4NXBx4gG8BLh6O8SiB/wVIzCmAS/DCKGJvBn4LtCa/HeAHwLzgRkYEfcHKaWvlIqBf2HELcDpGLF0WtLnbGB/jGgBuBiIMMLqGRjR08yHgTcAZyZ93QBcLaVsUUr1Jvtts30BxwExRnyN8EbgpUAXRnh/b2v7qMmGXLK9bcCLgdVKqVsw++sxpVQh+VwvpVwE/AEj0tqSffa27ehnhGcAS5LtfR1GeP4cI3Y7gAeTNkc4D3gh8BygE7gQ+EcidAHqwHsxDyGHArOA70zo82zgG5hj/H3gV1LK3BOw+UnTfJGy07v3dGury1ve1EVnp8uihWne/Mbpo3VOPLaDF51RJN3mk8oIpnV7/OA5HodNF+zTLvjUIRF5EYOOuXrRTHoyWUq+x4Z8lttmd7No0xBObPIS87UafSmXe4o57mktkkqlcJN+2sKIgzcOcNzajWSiRLDGMSI24vTZjzzKwYM9LAg3cXBpHe+/5jaeftcGFixvUBatjEMLVrZ3Ag0iBA2yVOng/xYcSCjE6Os/YgQB7rjXgYxM54KAv134ZV5w/x287dZr+MEft3rZ3TrFJNzuOvCcI+F1z3zCx8hO2+mnOm3ZfnZlDuMFTV6iSzAexuOVUmWgnHh+JHDxBPH3Oynlh4BnAQ8ky94F3AHcDvgYsbktjsN4lT6slKoCS6SU38B405q5TCl13f9n777jIynrB45/ZmZ7Nj253OV65Qqdh87RBVEQFSwICigo/lSwN7ChgoIVO6KCFFEQxVNBpIPUh3LAwXG9l/Rkk2ydeX5/zCTZhCs5rqTc9/167StTn3lmN7v73e/zPDPBdDewJngQ1P0K4FJgZlCf+4H34we2JwPfA36glCoP5hdqrZuD4PFEYIbWuh1oV0p9Cyi+yu6FwPd7soBKqSuBi4C3A38KjnUy8Mfg79eAnyqlrGD+oSCI7XGt1npNUNaNwC2DeJ5y+IHYPsALWusl29n+/cAzWuuesu9TSv0dGOz1O5ZorW8Ipu9RSjUD/xnwv3JrMG3hP/dv11qvCPb5nVLq0/jP0S1a68eLyt6klLoGP6gs9met9RNBmdcDP8J/PXeiE5YYjY47rpTjjtvyl8uH31fBh99X0W/Z+47tmYrB+4r3q+2dyhUM+c48a19P8cQT7bzweIq56xqprEjS7Az4DW8MuZCDsS3yto2Vd0lkctieId6doyyVw7UsnGDwooVhYot/Ie9Yvp3WkjgtyQQ1XZ0sq6sgG7JJU46DIYfL6poSZm5qodtUAAXyYc//iWzKCOUymGpDblwlNfksXn0NzsUnckw2xzGbNsDEavjxD8GyoKYcomF/WggxKkc37smAcWPRdDfgaq0bBywrDZp5v4mfbRyL/7yXUPSJq7XuVkrdgP9F/2Gt9WCuUDsBaBiw7cotbLeqeEYpVRMc53j8DFpPQNZTn/uBnyilSvEzppcB7w6mTw7W9xwfYPU2jj+xeJnW2gua8ycWHesPSqkq/CbXv+IHjQcEx/rTgPKKn/MuYDA/q67FD8JvAsYppf4JfFFrvbUb1U5gwHMWnMNgA8aNA+a7eeP/Sk+9a4AksCBocu8RDuqBUuoQ/GznAfiZUivYZ4vH1Fp3KaVgcM+NEDstErKIVESYfXg1sw+vhs/0rXv8iVZ+c22ajnCEsDGU5PJUtHSQ7Ojm9WkT2DipkrZIiMNeXMq8pi4yoSgrymuY2daIG/Q6zFoOEeNiG9h33Sb+dfBk/jt3DgevWcdnHv0n3PZRIu89hKhjs+8O1Fs6vAuxdxuOnwHn4GfVzgIqtdYV+Jmf3p+uSqnZ+EHlL4Grg76B27MeGDOg6XHKFrbzBsxfDYwDDtdal9EXvFkAQQZuE/BpYJPWegN+YPcW/D6bPQHj+uDv5G0cf23xsiB4nhIsB7+Juhq/ufYxrXU+KP9d+BnUne41rrXu0lpfrrXeF7+P6Xj8IBLe+NyAf14Dz2Pg/K7ShB/4nqy1rih6lGitvxdsczt+t4FZwet1zm6qixC73DFHVXLz3w5gclmWdCYNmTQVzR2koiEWTarj5aoy7plUx7fecQy3HTEXgK5wlE2U00gpi6qqufPA6ThWN6kYrJgc55N/O5E7/noIX37mHUzM/ZjEOYdiDcxkCiF2KYPV7zEaDMdPjTL8wQqNgK2U+jB+tgiAIOC7A/iJ1voT+P0S/6SUcrZUWJGn8LN731dKxYO+d58dZH26gValVBL4/ha2uR/4PH7fSvD7LJ6H3wfvMQCt9Tr8ASHXKKXKlFJ1wNcHlHMj8EWl1CylVAS4HD8L/K+gjDTwxBaO9Wn8YHV7zcfbpZQ6Qyk1J3g+O4EMfr9L8APjMUqp4iv+3g4crpQ6RykVUkqdDLxzZ+uxJVprg98f8QfBACaUUkml1KlKqfpgszKgHUgppSYBX94ddRFid/raDQdyxJwoZd0ZLOCBfaeRDTm8Xt43Cvpf+/tXt3Lyhs5QDGzD1JYUJ768gU2zxnBo+rO8bdXHiU7yu/da0lwshNgJwzFgvAl4Gn9Ax3pgLkHQFfgF/sjWbwXzn8LPun1zW4VqrQv4fR33D/a/izf2X9ySr+MPkmnGHyH9BH0BVI/78QOVniDuZfxA64kgyOvxASCKnzF8DL8vYrFr8ZuV78MfRX0icIrWumMbx3oYv+l1V12TYjqwAOjAb2pOA18K1j0UHHelUqpNKXWc1noZ/gCirwNt+A1sN7D7fAO4G7hbKdWBP2DmEvr+lz+Kn6FO4b/Gd+zGugix21xyzb7cPWMSmUSURC7Pc/UVfQNfgJpUmliqQLTLxVgWUc+l2Ymz6q2zOHbxR4ew5kKI0Zhh3Kvv9CLEEJA3nBg0zxg+dN4iZqxu5LEZE5jT0smjk8ZigNOeXsoJC4Mu0cYQIc8hL76LinlVQ1pnIUaY3RLNvWr9pN9n/Vzz6REfNUrAKMSeJW84scMun/8oldk82bK+LthlmzsYu7KZhw+awsz2Zj71+Kk4ZZEhrKUQI9JuCeQWDQgY542CgHFU3RpQKXUP/oWg30BrPXCk7F6r6MLbAz2mtd5Ft24ApdR84J6trL5Ka33VrjqWEKPZjI/uw+KbVlFm3N5L18RyORbOquGoD7dw7oVnDHENhRCjnWQYhdiz5A0n3pS7FzTz0M+WY8IOjbEItcfVcvLUZwE44wwJGIV4k3ZL5u8V66f9Puv3NZdJhlEIIcTud+YZ1Zx5RnW/ZQsWDFFlhBB7HQkYhRBCCCF2odEyMrqYBIxCCDFCrPvWY7x44ypS5UmO+fFhQ10dIcReRAJGIYQYAZ6J/ohs2KbCjTJ5bRNNb11NxwE1lH2tfKirJoQYYDR2VpeAUQghhrlV336CiFsgmfMIk/cXujBjYSubPQkYhRC733C804sQQogi7Vc+yj7uCkwUGuIlZG3/TqipsiT2uc1DXDshxECj8U4vkmEUQohh7PG33EGJ5/BU6UFsLK0gkvPYVAKV2S4eP2gudetayW7sIjquZPuFCSHEmyQZRiGEGMasBzbR5NXSnEgQzRV6cxUt0RJaS5OsnF7HLfP/u80yhBB71mjMMErAKIQQw5CbKbDQuZaW0jI2j0/QUZKgKt1NXVcHYbeAZRlKct0UQiEyVVHOP/u5oa6yEGIUkyZpIYQYZrpfbWDTvF+TcWqJUiAbCzG1sYWxXf5dPcszacrsjbz93gX86pjzWVY3jqNXvcLHzmwnE6qhsSZGyLb59bcmUD8mNsRnI8TeR0ZJixFNKTUBWAtM1VqvGuLqDCtKqWXAd7TWNw51XcTea8NR19HxdAPrSidSSS0hFyzPbwhKZrO924WMocZtJEaW+cue5NGx89lQNpWqbpu7plUwMZvlkA1ruewTHfx1+nRwDTVWns5wlJKExcE1kLQKHDA1xpeOjxANO0N1ykKIEUICxlFCKWWA+Vrrx4e6LsOJUuph4H6t9XeGui5idDEFl9zNL2DSeaLnH4JVEuldnvnts6TuXEJk+RoSkyLk17bDmlbSXgKPMAaDIUuXEyXixjA4tNkJ1odqcEIllHekAYe8ZWNnDJUdnbTHo5RmcwBE6EJPncvz4w7AMzae7RDJuSwfW0EiFKM5FOOumeW8WpYgUihwwppF3HeAImIMdneWV5e6tJVEeXS9y71/b2RTIsLKWBSMgbANjg225c8D2LZ/x92erliugZwHjgVhy98WCzBgQyxkYwMxx+BlXDwDFx7i8JOTwuRcw02LDJ6B8+dZtGbgz68bqmKGZa3w8FrD3Gr49jEOtYkt9/1a02H46xLDzEo4fbr0rBLDz2jpt1hMAkYhhHgTuj56F7k/+P0Gc7cvpOzRSwDo/vCdNNy8ghjdJGiE1RDCkCGBg4ODhwG6KcNxI1h4WECFl2YjhoIVoTkSJl7IkbRSzHFXU9HYwgbm4RLCAHccO5/OZCkAkWyOknSaxfW1vF5d0Vu/COAYQ64sxkvTpnPOMw9z275H01CRIOQaCiGbTgDb4qQVjXRWl9EYDftBouX5hcQdsIIvvlBRYObgB4s5D0JF2UnjPzIFf7a7NQ85F4CfPuKyrtMv469L/UD0b0thcQus7uj/3D62Hu5e5rLyow6xUP8v3pa04YhbXTZ2+fO/OhkuOVCCRiF2NwkYRxil1KXAZ4AaoAO4CXh7sPo+pZQH3K61vkgpNRa4HjgO2AxcM8hjTAFWAhcAXwImA48A5wbzHwY84Nta618U7TcfuBqYC7QCvwR+pLU2SqkEcAtwFJAAlgFf0lr/N9j3AuAK4Drgi0AJ8Bfg/7TW7nbqezJwLTAdyAEvaq1PVkr9HJgPHKmU+jKwXmu9j1IqDHwfOC84jx8P5nkRolj+P0t7pwuPrcKk81jxMPl7l5CjhEoae9dbWHhFH7cWkCOGQ9+/to0hZFxcy8FgMYtl1BX8MlqowyPk5/AsqzdYBMiHQ9BtOGDtapZUV/Yuz1ngloQgHmJjvIa/H3o0pDzIFCjE+urSEQ0DkHRdGgn3BYgAeQ/CTpBBHMDayjLP9GUic0Vv3bzHo+sM6ULfovtX+8nKLdnUDSvbYU51/+UvN9EbLAL8Z5XhkgO3XIYQQ2f0ZRjlZ9kIopSaBXwPOF1rXQrMA/6htT4g2OQUrXVSa31RMH8r4AKTgGPxA8AdcRZwTLD/FOBpYDlQD1wI/EQpNSmo21zg3/iBWy1+EPtJ4INBWTZwFzATqAb+BPxVKVVbdLzJQB1+4Hco8B7g/YOo5x/xA81yYDzwHQCt9SeBx/AD26TWep9g+y8Dp+MHr1ODc5s8qGdkJ6VSKZkeJdPh46f1zjuHT8SKh/3lJ0wjTI4Mid71BoNNobcjvAEcChSCjCFAhhB5bAxgWy51bl/AGSoOLI0hmsv1rSu4TFzTxDGLl1DmurSGHRqjIWZsfp2KQqZ3u+5oDGwLyzPEcn1R29TWLjpDDhuikaLa9RRu+9lEz/Q1T4M/bcxWgsai6XDRV0zI5rAxBY6f2LfBsROgPvnGIgBq4lBtd/bO9zz/86qhJtZXlyPHZN+wjUzL9GCnxeBZxmzl550YdpRS04BFwPnAv7XWnUXr+vVhVEqNB9YBM7TWy4NlbwHuYzuDXooyjIdprZ8Nll0DvF1rPa9ouwbgYq313UE2L6G1/nDR+s8Bp2mtT97KcZqAD2mt/x1kGK8DKnsyikqpO4B1WuvPbOd5WYWfvfy51nrTgHUPM6APo1JqKfA9rfXvgvkS/IzoR/fAoBd5w40SJlcge8OzmO480YsPwy73RyObbIHMz5+k444lRNesJTEhQn5VKzR20E0phjDgEaWddqsK14QwhMkRIml1sDg6k6wdYX76SRLGD/gMOVqppYV68oTZXFbKk2o2loFYNktVSyc13S384pSTebkszsZ4lEghz/mLn+D3R52Eazt+tq87T4XjEctDayKMMVDWnaMtGqLgOGAbP+Vngn6JERsI+jL2RrtBu7Nr/HVh2/85aAV9GC2I2DYWELYMXtA+/YGDQvz2rWHSecNvXza4Hnx0f4umNNy22FARNSxpgcfWGWZXwTXHO9Qnt5ylWd5m+PNivw/je/aRvIfYKbslFfic9at+n/WHmI+P+JSjNEmPIFrrFUqpc4GPAzcopV4CrtRa37eFzScEf1cXLVu5g4fcWDTdPWC+Z1lP29hU4ESl1LuL1tv4o7JRSsXxs49vw29O94J9izOMDQOan7uKyt+WM4GvAi8rpRqB67XWP9nG9hOAVT0zWuuuIPgVYtCsSIjY/x35xuXREPHPzSf+ufm9y3pydwPvxVJ8F+jutS3878xbmPjaEmq600TI0E2MleXjeLlsOnPXNWMbAI+KbAeJTF9mLRMP86eDjuSxseUctrmdmOuRdmz+PeEQ5i9poKEkwoZYmLZomJLuPLOqDV3lFrXlDje8o4Sxyd35VRDuNxcPW1x6cN93Z0kEvnL4jn2XTq+w+OoRI/77V4gRRQLGEUZrfRdwl1IqAlwC3K2UquaNmav1wd/J+M3I4De97i6rgd9rrT+xlfWfxW8WPwlYFfRrbGIX/LrTWi8E3qeUsvCb0O9TSr2ktX4QPzAdaD1Fz0WQYazdwnZC7DGJiVW85flLAUgvb6ZrxrcxREjly4gVcuRCDol8jum8QEm2g5aNDi+P2xfXsnh21lScfIHzXlxGVyRMzislVmJz+zdqGVMbHeIzE2LvMxqbkiRgHEGUUvvgZ/IeBdJAO/7/pQdswu8f+DiA1npd0Bx7jVLqQiAOfH03Vu+XwCNKqXuBe4N6zQJqtdaPAGVAFmgGIkqpLwEVO3vQIHA+B/iX1rpJKdWK/3z0ZCo3ATMG7HYz8IXg+dmAPxhI2rXEsBGfXk341S/RMvc77NO9mMO6W2m0x9EWriKe9/tfnbLyIeobNvOvfU5gbFMLY9NtXPa/04a45kKI0Uq+JEeWCH7QtxFoAy4FztJaZ4DLgSuVUq1Kqd8E238AiOI3Cz+GPzhkt9Bav4I/kOTTQf0agBvpy9z9KKjzBvyMZzdFzcI76X3AYqVUJ/AP4BtBkAr+CGillGpTSi0Kll0N/Ad4Cr+Zfg39m+6FGHKhOeMYY35Bo13HhshkHppwKM9MmMN9Y08MLsQDdt6mLJdj7IZmCRaFGEZG472kZdCLEHuWvOHEDnms7NdkYrAu2ddr4phNTxHOG16JHoCV8Jjzv7OZNnNgD0khxCDslmjuWevX/T7rDzWXjPioUTKMQggxjM3vuIQuN963wBg2FmaxKHIAtjHkLSRYFGKYMQMeo4H0YdxLBc2zW7r24OriS+cMB8HI8N9sZfXHtNa37sn6CLGnzTqrniV/20w2HKIylSaed7EKaVIlYazrq7dfgBBC7CRpkhZiz5I3nHhTHqj8HaVt+eCOzYasZbNhUozEz6o444wzhrp6QoxUu6Wp+CnrN/0+648wH5MmaSGEELvfSa0foeKG+aydUMqaKUnqLp9F4mdVQ10tIcReQpqkhRBihJj1kXnM+khfj5HXFywYwtoIIbZmtIyMLiYZRiGEEEIIsU2SYRRCiBGieXM3D535X1paXEIYvIIhWxLhvwsX8pYrDhjq6gkhAqOxs7oMehFiz5I3nHhTnvryU2z69TLCOZdI3qW9NE5naZhCxMF1bEJ5w6raSkoLLpc8cCxl5ZIPEGIQdkvb8RPW9f0+648yHx3xbdTSJC2EEMOc6xqarl9MuGAoSRewCzaVrVnqNqZJx6J4xhAmzZTGJsKFLD99x5P86NsrhrraQuy1RuOdXiRgFEKIYe626X9mTHsn07o244b6vnwieZd8OMyaijKyTgzPsUl2pana3Mr6p1o5/UPLSHW62yhZCCEGRwJGIYQYxpZO+CFTVneQ9hI0UkG2xOld114S5YbD52BhwAQPIJ7Lk3YcJjZ1cPH7X6S1PTdU1RdiryQZRiGEEHtEvi2Ljl9Dbr2LR4gk3UxmE3Pb19I2LsLDh0zmI587ndcm1tIci2IbsA1YBl6ZM41saZJ0ZRn7Nqd418dWkc97Q31KQogRTHpFCyHEMPPq0b9h1Ws2JaFSamikhTy1tGDj99BXm5ZTkenitB8u5uenHM7Ezq7efS2guyQGgAM8Omcaz1WWMvkLLfzkAzHee1hyKE5JiL3KaBzdKBlGIYQYJlIfu4Vu63ymP/kwB6QX0phM0h2KMY1NOBgyRHGxKZgIE1pTVHelueLvj9BYXtJbRiYaJh/qywU0RUJ0Og4bIxEuuz1LyeXtVH21lefXZYfiFIUQI5RkGMVeTSk1AVgLTNVarxri6ojRrisNoRD5b/0VbnkE1jUHI5xt0pQSIU2UNBiozHQwdVMr3SRopooIOepoJUcEhwIQBsAxhiX142iPJ5jR2kFDXRWt0QjJfIGWcIgXK0vBtsAzZFybsLFJRcOc+Jsc1a3NFCybzkSYdx8Qpr46xLsPCDGlwqEkYtOV8YhHbCKh0dEHS4g9ZbT0WywmAaMYtZRSBpivtX58qOsiRokHX4bP/J6mbkNDGmZtWo/juVjGb4IydgzLywKGvB0h5OX9ASmBDJU4ZAiRBmxsPFxC5CjDpYQELb3bbmQyecLkg8AwR4QOSmipLCHelSVRyGMbuOuw/Xi1rpJy22JlRRkGaAk7NEfCbI6FMeFgkEwI2koiYPlfZO2JMNXpPJsNZK0Qt79icEMeV2oDlgu4kHX9Nm7bEA5ZuI6DZ1n+8rCN7ViUOBANQ0ceoiGLX55scd7cvoE5QojRQQJGIYQYDGPgPddCSyc1QM0bNrCxvExvXiHivXFkcoxWAAqUEMbvd+hQwJClQLTftiHyeAN6DXm4NIcS5KvLsI2HsQr8ff9ZuLZFiesParGAukyWhWMr2KcpxdTONP8bU0Eq1hcsAhy6ppn1yRhTO3K87jjkLMjFI/07X4UsyHvgQT4W8jOVADEH0i5ezCGVg5TnL8/l4IJ7DGfOMJRGRl+GRYjBkgyjeNOUUquAG4CTgEOBlcC5wDzg20AtcAdwida6oJSaBPwIOAb/I3wB8DmtdSoo7yrg/cAYYDPwM631T4J1U4LyPwR8BZgIPAmcr7XeuJ16XgBcAfwC+BxQDvwGuBq4HngLsAG4qDhzp5S6GLgsONYK4Eta6/uCdQcA1wXn6gBPAZ/UWi8P1t8YLM8A7wG6gCu11r8ZxPN6KfAZ/O/vDuAmrfVXlVILg03uU0p5wO1a64uUUmOD8zgueN6u2d4xdqVUKkVpaalMj8Tp9g5KU5ktvKo9Bv8V4RIO8oY9LCws0tQQp4kcCepoYlWynvJOjzRRknSwOllHPhQiGwnRWFtJTaqduvZWltRWUrAsQsZgAF1fxTHrmgl7fvR3TEMr94yvhZAfgNrGMLMlxeS2Ll4pLyNiIGvZfrQ52N76PdsNOGnXQHNbJ6VjhtFrJ9MyvZVpMXgy6GXPOh/4P6ASWAj8DTgBOADYD3gH8D6lVAx4EHgVmArMBSYAPy0q61X8YLIUuBi4Wil16oDjvQ84FhgPlABXDrKek4EKYFpwjE8B9wDXBnW/C/hDz8ZBsPgl/AC4ErgcuEspNSPYxADfDOoxBegEbhlwzLPxg+Kq4Hg/V0pN3lYllVKzgO8Bp2utS/ED0n8AaK17bqx7itY6qbW+KJi/FXCBSfjPzQXbfTZ2oeIPKZkeYdMV5fCD88G2cR2bTKh/yAcGE4SBpndJ8VrIUUqOUgwhsiTxcHCJ4xIjR5QMVbQyjQYm8rGzLuThg6cxniZmsJ6xpCgpZHEti4UHzGTltHqePWAOp6zaQAG4d3w1KxNRjPHwHLs3WASIuR5giGRzHLi5lXctXUddOku04FIA8rYF8RA4RdGfhZ9d7Jm26LvWY86DqN13YkXH+r8DYMqYYfB6ybRMD2J6dzEDHqOBZBj3rOu11q8BKKVuww+wjtBadwFdSqmHAQVkAUtr/fVgv7RS6mvAE0qpi7XWrta6OOB6UCn1L/zs5X+Kln9La91UdLyLGJx0sK8HLAyydc9qrZ8KyroF+IpSqlxr3Y6fWbxSa92T1fu3Uuoh/Azod7TWLxWVnVVKfQt4WSmV0Fp395yD1vofwfRdSqk24EBg9TbqWcD/GpunlFqttW7Dz15ukVJqPHAiMCOod3tQl/sG86QIwaVvhwtPxHFsCsbCZLNY6RzYYGVdGF+FeWIxVjyKu2IzmYZuCusaKC0NY55ehr0xA0kL94nX6TJlNJaMpysaZmbjSkJYGMKsiY0hkgnz4MzZzNnYv/ttXaaLSKPNM6G+PoLd8SRX/esR1lVWUJ/qYuE+05nb2MFr1aXMaU5RsOD5qjLIu+TiIcqyOSam0nQ7NotKS2gJwcRshi7bxS5Y5OJhqkotDit16cpbVJbZ1FkuB9e51E6IkSkYJpQ6zK21aeyGipiF60FHzhALQXVc8hBCjEYSMO5Zxc3B3YCrtW4csKwUP6s4KQiaihlgLLA+aIq9GD/zaAFx4LZtHK8rKHswGoJgsbheA+tOUF57UN9fKKWuK9omBKwDUEpNx89OHh7s0/ODq5a+gHBgU/l266u1XqGUOhf4OHCDUuol/MB1awHghOBvcRC6clvHEOINSuMAfo/DksgbVlvH7QuAc9hMSgas6wnzwkACP53ew2RyZEsvZHqmnRamcOiy9Vx/zBGctmgx9e0pMkRIEyOWLzDv9bUsnDcFgOqmTgq2YUprO3bBo7Kjk0LIoTxbYH0iygNjq8g7Dvu2pFjmJPjfmErWY3N4eY4nvlRNvDr2pp+K+qJ3aGl09PXZEuLNkj6MYk9ZDSzRWs/b0kql1NHA9/Ezik9rrV2l1J28oTfRHrMa+IbW+o6trP81fr/H/bXWzUqpfYGX2QX11VrfhZ+RjACXAHcrpaqDzOXAloD1wd/JwPJgesrO1kGIXcGKRYjlb4V8nnjkMn5x163cpI7mX/vuw9ueXoFbiNHzlpm7ZA2hgku8O0M0k2bTmAqypQnwDFM2bCbqFnihroZHxlaTd2wwhpAxTCvJ8/KXKrBtuXi3EGLHSMA4PP0T+K5S6qvAz/D7/NUDh2mt/waU4ffDawSMUurtwGn4g2aGwo+BbyqlluL3zYwBhwBNWuvFQX2XAm1KqRoG35dym5RS++BnNx/Fb0ZvJ+hRFWyyCZgJPA6gtV4XNPtfo5S6ED8r+3WEGE7CYarML2lf1sIh6s9Ma28hRoYmaskTxsMilHeZ9/paVtRX0FYaJ5bOEs7lqV/XRTydZ0ayicpD0rw0roJ2J8KEzjQfOTXCJ8+oHOqzE2KvMFr6LRaTzibDUJAdOxF/sMti/EDoAfw+feD3U/wj8AzQhD9g5G97vKIBrfVv8Ucb/wFoBdYAX4PegaCfAebjj2J+DD8g3hUi+AHfRqANuBQ4S2vdM5T1cuBKpVSrUqpnxPUH8FsT1wZ1+eMuqosQu1T5jCqOXHguuZChoaQKhzx5HFxsTM/VHKN9A2+cgkc8nQegpDNH1eYUH3h5BeNaU3zuPUkJFoUQO8UyZjTGwUIMW/KGEzvES2V4etr1dJokyeZC7/JlU2poL4+RSKUBCBUME9aketf/+8iZ/P2Aafzy4xWcsn9ij9dbiBFit3TlesC6sd9n/UnmghHfqVEyjEIIMYzZpTEOW/8JSjIpQlYO17bojIXpLovSXZ6kbUwFbbUV2F151o+JYTkuJpnnqXnjWfaregkWhRC7hPRh3MsEFwR/dSurb9FaX7In67M9SqlfA+dtZfVcrfWaPVkfIYaCE3EoTBhDeN1G0uEo09o2UbOsgyfnzqY7GqW0qZPUhARHrFtGS30JkatO5fHzpg51tYXYa43GUdLSJC3EniVvOPGmPf/5J1n/+6XYIY+qbBd5y2J5sgI7GeKMB06narxkE4XYQbslsrvfuqnfZ/3J5vwRH0FKwCjEniVvOLHLLFiwAIAzzjhjiGsixIi1WwK5+wYEjKeMgoBR+jAKIYQQQohtkoBRCCFGsGzBomVjGjfvIi1GQgwPxrb6PUYDGfQihBAjkOd6tH+ygxnr23gxdCsdJVE6SqJUn1LP2284ZqirJ4QYZSTDKIQQI8yrx93O6+GrsOIxFs6aQtpEiaag3YvwwrMpVj8y8NbsQog9yVj9H6OBBIxCCDGCLP/xc2xY3MjjhxzI4mmTSLbksA1gDDM2dzCtsYMnznuIlx9pGOqqCiFGEWmSFkKIEcAYw+2n/Ivsqx3U2QnOfP5JQp7HU+VzsAwkCjkayhP87oj9aC0vYc7VK/j5jBIqx5cMddWF2OuMln6LxSRgFEKIEeDVxLc5LBMhQh4sDzCsqawhEeqkxS6npM3wlbOPZVmdf8/oNVWlnPvZ1ZwQ6eILNx86tJUXQox4EjAKIcRw1dHNfUfdQEdXkn28EhwrzeZEKRgPSuNkXYs1iTEA5GIObSUxjmlqI+oZXkvGeefzK1g8cyy3/2Qp7//0zCE+GSH2HmYUdvgbhackhBAjW+OaLhZM+z2vjv0Bk5a28Gr9DP54wgm8VDmJpRX1dJREOWjzYjqcZO8+uUiI09duZmp3lvpMjhMbW4lkC5RtaOPLy+N86HNLWbIhO4RnJYQYySTDOIwppVYBV2itb1FKTQFWAhO11uuGtGJCiF2ukPN47ojfsaQjzuQ1LYwLebTkxpJzQxz1xPLeX/d2SRY3YXHb5FMwRb/5M5EwjuPgBvOWZVMbbubu6TN538pGwsbwg0+8zho7Q0sygTu5hi+/v5r3zA3v8XMVYrQzjvRhFEKIvceiNdCUgqP3wTy1hMySTqyDJhPLtpF/bDnus6uIvH0uvL6Bwu1Pket08awE7gnzKNgQemAx0cZNhE2azlA1ngshK023V8La6jEsrJ9DzorTmiih3HTzzqUvsnT6fJ49bH9mbtjI/itXkyPEOqoAixK6OKB7KQtqj8GzbMAQ8lzWjathycQJJLvS5KMhjGVz+PLXmL/iNRrKSnlxylzCuRxjcgXuH1/P6olVeNEw711g4K4MGI9x6QzzGtuIFXI8UV9Da6IEY1uEC3nClqEqClPqIkxLtzHJznLOuyYyt8ZmVbthRZvhsHEWycjo+5IUQvgkYBRCiC254b/w0V+DMTChms3rquhgDPAYNayiivWEAe64H4BI8DDA5j+HKRCnQJhyurBxqShswgIKJo5DOc0l45m4Ik2yq51C2OKo/P08PPMo1lRPAuCVqZMZ19xCbUeKKHmyRJjBclaW11OT7mJSRwvdoTCv1I6jLVFGXXMHkXQD90w+iI5oFLe1nA8CHnnWVJRSnkkzvqObVCSEFwuDZQGW/9ezOWhNB/s2pAAozbXwpwPLwbLIh0PkgW5jWLcJHrdrwBh++5MmPnpKFddqQ6YA82rgyXNDlEYlaBTCG2ajpC3LegvwfmCMMeYMy7IUUGaMeXCwZUjAOMSUUpcBHwfGA63ArfjN0O42d9x2mQb4FHABMAdYCLwXeA/wWSAB/FprfXnRPvsCPwQOBtJBPb6utc4H6/8AnAxUAGuB72itbwvWHQ/cD5wLXAXUAP8BPqK1Tm2nrt8E5gMa+DB+v9rvAn8F/gAcCiwBztNavxbsEwK+GJzfGGARcJnWWgfrTwrqMQsoAA8Al2qtG4L1DwPPAVOAU4AG4LNa67u399yKvciv7/ODRcBb10oHs3tXtTGWKtZvcTcLsClgsInThh00Evd8feRJAhYpk6S+y3971OQbiJCl4PRvHnYdB9ey2FBTRsZ1mNdu4eJw4Oa12Ph1C+dc5qxoJRsN8eAxs7n4tRVsikf57b778oFXXuSmww9nY2U5y6vqOXhdM03jqoJgsV+FmdTe1bsoG3H6b1O8LYBlsbm8kl8t9INFgEVN8Ng6w9umD68vSiH2dpZlfQq4DLgBODtYnAauA44abDky6GXorQNOA8qAM/GDpot2QbnnAe8EaoEM8CBQCUwHTgQ+r5Q6GkApNQZ4BLgLP3A9EngL8JWi8h4HDsQPGK8EblRKzS1a7+AHXwfgB2oHAZcOsq7HAkuBsUG9rwV+B3wCqAJew//H7vEt/OfqrUA18HvgXqVUZbA+C3wyOPf9gHrgpwOOeT5+gFwO/By4SSmVGGR937RUKiXTI2V6n/reZZZlCNE3YCRChm2xgmAuT+wN62zyAJTn+gK0ULDsyFVPU5FuA6CiPUVbSYJ7DzuElw+aRnsyRoMZz7i2dG+wCFCW9evVMKaMpOuSDjnctt8MupMxzrjwIywaM5Zl1UmMZfHcxBoIDfjYdw0YWFXRN4Am4zi9wfLW2K7H+JK+37Uh2zCtwg8Wh/y1k2mZHuT07mLs/o8h9mngZGPM9wAvWLYY2GdHCrHkZvXDi1LqB8AkrfV73+yglyDD+F6t9R3B/P8B3wMqtNZesOwZ4Fat9U+VUp8H3qa1PrGojLOA72utZ2zlGBr4vdb6l0GG8SFgjNa6MVh/LTBDa/2u7dT1m8B7tNbzipY1ANdqra8N5t8W1LVSKWUBHcDbtdaPFu3zclDfW7ZwjNODuo4J5h8GFmmtPxHMlwCdwIFa64Xbqu8uIG+4kaKjG772J2hoh/ceRe7Gp2h+Fez9JlDlrcZ+cCGmOwdVJdid3VjpLAbIkiRLKR4WBZKUs54IXbiE8AjhkCdLBSsrJrIiNJlQ2qa7NMSpTfeQLHTi4vCyfRgPHnYQqfKy3uoc+fSrzGrbBBhCFLAxeMBmKum042yqK2PdlBpemDCGW/fte9uGLI9CPAL4QZ6xwNj+N5iTzWFZFoVQCNvzOHBjCyHP44Vx1eRDjl+ARfBf6//rRr0C8UKeMye6XPf+Cn6sDYuaDB+aZ3P6jKH/ZhRiB+2WlPg/ym/t91n/jvZzhyz1bllWAzDOGONaltVijKmyLCsGrDTGjBtsOdIkPcSUUufgNxNPw389IsBTu6Do4pvJdgMNPcFi0bLSYHoqcLRSqq1ovYWfNUQpZQPfBN6HnwU0QAl+Bq+H2xMsBrqKyt+RuvbUbWD9e8qqAZLAgiAw7hEGJgT1PQS/SfoA/OZ3K9hni8fUWncppdiB+oq9QVkCfvqR3tnIu45ge5+sFhAPHgMVf9gmgHnBg2yOjuseYcN1U6Epi3FLcNwIldl2UvgBY3mqg9nta/CIABYFQrSHYuQKEfK2w8qJFVgWVG9soT4awTIGEzQpT27rpmrdJmIFQ13B0O1mWFRfQ1M8QSJfoL7W4uzyFInxlcx8dzVnzIps5yz7r//G0dvZXIi90DC708ujwJfxu3v1uBQ/0TNoEjAOIaXUROAW4N3APVrrXJBhVHu4KquB+7XWb9/K+nPwm8lPAV7VWntBhnEo3hFN+MHoyVrrZ7eyze3AnfiZy44gw7hgT1VQiB0SjVD2hbdQ9oW3AJBd18Y/Tr6d1SWlHL38f0Q9w4S1aRImQzc2HiEMUFloo4GxLJw1gUTGbyK3gJkbmjhycxtrknHKcwX2bW7j4v/8k2V11Tw4czp33qSIlw4MCisRQoxanwIWWJZ1MVBqWdbrQAo4fUcKkYBxaCXx+5E2Anml1BHAB/H77O1JfwQ+p5T6MHAbkMMfEDJLa30vfv/KQlBPWyl1AX727p97uJ5orY1S6qfAD5RSF2mtlyqlksDRwMta6w1BfduBlFJqEv4vKyFGhOiECt6z+BLO8gx3ntzJM14JF617AQtI0I3BIm/ZJEyG18bGcaLgZS3soHtROhFjv43NTCj3E+b7blrGjScezc23H8rHhvC8hNibmGGUYDTGbLQs61DgMGAS/sDVZ4wx3rb37E86nAyhYNTvN4C7gTb8wOZPQ1CPTcAJ+INkVuGP1v4bfjM5wE3A08AyYD0wF3hsT9ezSM9zdrdSqgN/wMwl9P0/fxQ/I5rCH8hzx1BUUoidYdsW733w3fzg4VMJf+kImiJJ8oTwgJBxyRJj9qYNnPjKIlrGVpIqL6G1toKuRIyXyuM8X5lkbdQj0tHNzbfLvaSF2JsZ39PGmDuMMU/taLAIMuhFiD1N3nDiTVl83fN4X7yXhJejJRynLOMR9vx/p02VFdx/4AEkU2kmbF7HHw88kNV15fy6fiNHfGvQV80QYm+0W3KBf6v5U7/P+nc1nTOUg17WspXvHmPMpEGXIwGjEHuUvOHETrll8i1YbpjprY2M6+4AIBMK0xQuJRc3zGxdx/poFX869FB+8uixQ1xbIYa9vSFgPG7AonH412W83Rgz8JJzWy9HAsaRRyl1D/7Frt9Aaz1wNPCQUkrNB+7ZyuqrtNZX7cn6DAPyhhM7xRjDXfU3kzcOs5qbSBZy5AmRCdkkC50sqann6VlT+c7/jh/qqgoxEuyWQO6vtf0DxrMahy5g3BLLssYC9xpjDhz0PhIwCrFHyRtO7BIbH1mDfdL36bCrcEyBLlOC65aw5ODJvPe5dw919YQYKfbWgLESWGWMKR/sPjJKWgghRqBxx03inz89julfepUuYiyrm8qYSw7kvV+Yu/2dhRC71XC6DqNlWVcOWJQA3sbWW/+2SAJGIYQYocykOMv+dAhnnHEGBw51ZYQQw9XEAfNdwI+Am3ekEAkYhRBCCCF2oWF2HcYLd0U5EjAKIcQIs3l1F38+8wFmNK1hTdkYvvyDR7n0xkOon1oy1FUTQgwDlmWdOJjtjDEPDrZMCRiFEGIEWfNKO/95133MLTTy4qSZrC+vZsq6TfzhrMf44tOnEA7L/RiEGGo993IfQr8bxDaGvht0bJcEjEIIMYL8++x7SVWU8vH9DqMtGuHo5nbWHTSPo15Zwg0H/4uPv3zGUFdRCDHEjDFTd3WZ8lNUCCFGiNTiVppr6vjjvDksKy+lEArhlpaQDYd46KC5pKMx/u/qDUNdTSH2ep7V/zEaSMAohBAjQMtdy3jx4N/TVFlOzvI/usvofxG5F2ZMZv1zLUNSPyHE8GRZVpllWT+yLOs5y7JWW5a1puexI+VIk7QQQgwz+dZOXqn7LQaPyvwmUk4ZzdRR4UX4yD8f5YzSEn5+xAGsr61gbkMzsUKBFbXV5G2batflrRcu494/zBjq0xBirzWcrsMI/BKYAFwJ3AKcB3wB+OuOFCJ3ehFiz5I3nNiiQls3m/b/KYm1rYBFG0mStBHCYhlTMTiUkO3dfm1lGZvLS+kui5OPRcjbNmtqq0hbFjftN4MvT0hx5SXjhu6EhBgZdktk96cJf+n3WX/OuvcO5b2kG4A5xphmy7LajDEVlmWNBxYYYw4ebDnSJC2EEENs41E/J135BcrWNlDAZi1jWRmr59GaQ1hWMok0cbwB32sFx8ECwrkCAGHPI5kv0F4S58iNzVy1sZTKL7awrNkdgjMSYu9mrP6PIWYD7cF0p2VZ5cBGYIeaIaRJWvRSSq0CrtBa36KUmgKsBCZqrdcNacV2M6XUBGAtMFVrvWqIqyP2AoUVTXTMvhryeSwKQBl54tjAGiaSJ4TBJpZzWRerZt+u9Ti4dJHAw6a5LE5LSdwvK+QAkI5G6YjHGJvNMymdY0p3hr/PrGfmz3MAOK5LNAr/eLfDIZPCVJTIx78Qe4mFwHHAA8Bj+E3UncCSHSlEPjHEqKaUMsB8rfXjQ10XMcz94h5Y8Cy0dML6Zih48O4j4Orz4G3fhhdXQTIGs8dDcyesbQTHhkgYWlLgGrJWiBZ7PHghKr3NREnhYeP/wDcYLAzwwIx9GVdawv4tr+ARwqOEAgkA4mToiFTQGY8CYHuQDYUoL+SpoJNO4pSmbcbaKdqjcV6ZO42Q59ERi7C5JMaUzgwAtZkcFZk8HeURyHu4WHRn4D3XdxOJ2bQkYyQzBTodm3wiAq7nd5iwAAyEHDCGiOcStg0ZO4xtIO4YomELy7aIOHDYOItvH20zt2braZQbX/H453LDMRMsPn2INGyJ0W8YXIex2MX0Nb1fBlwFVAAf2pFCJGAUw4pSKqy1zm9vmRC71J1PwCd/+8blv/4PPPIKvLben0/noLFjq8WkzRhcrxKAZkoYyyIcCoDXb7vjl60EbLKUk2IcJvgozuHQQilpO9Jv+5zd91GdI0Qinyfc4VGIhJi+aAN/nj+XJRWlHNCe6t0ua1usr0pCyIaQBc1+pjFr2RTSHvkKh9ayMHhBVysPiPrZSowBywLLImfb5AA8g+tB3rUgB9gGbIt1Sw1Pb3RZ8zEHewtfkg+s9rjwXv/8/7rUUBOH8+ZK0CjEHrTaGOMCGGMagIveTCHyrt3LKKUuU0otVkqllFJrlFJXK6WcnSyzVin1u6C8DqXU80qpfYJ11UqpPyqlNgWPm5RSVUX7rlJKfV0p9ZBSqhM4Syn1sFLqJ0qpvyulOoDPbef4lyqlVgbntF4pdVWwfGGwyX1KqU6l1A3B8rFKqX8opdqVUkuAt+7M+e+IVCol08NwOvvyKrZqbfPW1w1QINo7bbApbPU3uU2BOGmq8X/4+0FbA1VkiRLOeVhBIGcsKMn7g106SNBNBOPA2tJKmseV0V2f4Izlqzhz2SqWJROsSCZYWZ7gznmTcEPBR7xjQ0kYXIPleX2JxL7KglO0ZAezI+s7YVNLZ+988XP70sZMv22XtJg3bCPTMj1U07vLMLsO4ybLsn5pWdYxO1OIBIx7n3XAafiXcDsT+DBv8tcGgFLKBv6Bn94+NPh7AdDzjrwVqATmBI8a4OYBxVwMfBYoBe4Oln0YuA4oD/5u7fizgO8Bp2utS4F5QX3QWh8QbHaK1jqpte45z1sBF5gEHBvUd48oLS2V6WE4Hf3gCVBTxhuEHfjcO964fCtKaKYnmxihkzCZLW7XHfMwOBj8gSsWHgZDhjDgN0Mn2gu0VJewalItaxnDEuppJUkIj5Qdx1g2HRXx3jJntKeYkcnRnoizoryUTcl4/4MGAahj/KYlY/sf/5br+d8ErvEzi9D3F/xg0pg3jiUtmj9vrkV99Zaf2/ftG2d80p+ujMH7Z9tv2EamZXqopvcSp+D3WbzNsqyVlmVdbVnWfjtaiDRJ72W01sXXXXpBKXUzcBLwmzdZpAoeNVrrnlFYLwEopeqBU4FZWuvWYNlngcVKqXFa643B9r/VWr8QTKeVUgB3aq17borevY3jF/C/uuYppVZrrduAp7ZaWaXGAycCM4L6tiulvgXctyMnLUaZGePg1Z/Cy2sgV4DWFDSl4KwjoL4aTj8EbnwY1HSYWO1v8+JKqEhCRQKefB1SGWKegVfbSbcViDd1ks6WEkl3AxYuYbopwwDryxJMcxsozRvaGU+WOBupIUcEYxsMNq21CdIlUVZNGcv+i9dTksnih5YOVh4wHuFcgVw0RKw7S8GywPjBalWmQE1TF021JQAkUmnGbGihuSSJG7FJlcWIdWZJdmWIeS7rqpLg2DiuS4lxmVrmESuPE2pqY3aFx9gZVbSnIWobxictkjHIFCzKYzC9wuao+q0/tfVJi5fOd3ix0TCv2qKuZOjTLULsTYwxLwAvAF+0LOs44BzgQcuyNhpj9h9sORIw7mWUUufgZ/Om4b/+EbYRYA3CFKChKFgsNjH4u7Jo2fKidT0B46ot7LulZW+gtV6hlDoX+Dhwg1LqJeBKrfXWAsAJwd/VRctWbmlDsZepLYcTt/KjW830H8VOO6Rv+pxjAf+XywS2LAzEgunq4K/74ioKH/4TmRdcKmhlOi9T6rWxOTST9lQZG6PVhCMe+RKbcKZAPshAWkA6EcLOuZS0dRHL+P0TT3jhde49fD8KFnSWRrDzLqGuHFOtHK/cMGULtSrZ5lPiNwjsvKq4xYmTJFAUe49hNuil2GLgNWANMHM72/YjTdJ7EaXURPyrvH8HGKe1Lgd+wc5duHQVMEYptYX2PNYGf6cULZs2YB0MHBGw9WVbpLW+S2v9Fvxvt78AdyulEsHqgRfKDkYvMLlo2RSEGALOgVMY+/xXmGGuIBzqJAS4RIkVMtR2p9h/zSre9ez/mNK8njjZ3r5QnfEwqUSYDbUVLB1fx+o6PwQd055iSksbdW3tVDR20nyRIfvdMl75zq4J/IQQI49lWRWWZX3EsqwHgBXA8cD3gTE7Uo5kGPcuSfwfCY1AXil1BPBB/F8bb5YGnsfP7n0SaAL2BZq01huUUvcBP1RKnY8fmP4QuKeoOXqnBINrpgKPAmn8i5Ma+gLOTfi/oh4H0FqvU0o9DFyjlLoQiANf3xV1EWJnTMl/n3xTisbaq2knSQiLEC5ZbEpo41fz38LJL61gXXkl2YhDJhxm4YyJFEL+x3g+FGJiUysTOrtYURJn0XerqCiVj3ghhsIwuFh3sQ3AE8BtwFnGmLY3U4hkGPciWuvXgG/gDyxpA74M/Gkny/SAM/CDtReDcn+PH5yCf8/KFPA6fiq8jR289tN2RPADvo1B2ZcCZ2mte0YbXA5cqZRqVUr19NP8ABDFz3I+BvxxF9ZHiDctXFNKvbmKOearTEt9hvHrLmW2+So1K79CRXMXn/3gaawYU4Fnh0iVxHuDRYCG6nJaasppi4Z513l1VEmwKITwTTfGnGyM+d2bDRZB7iUtxJ4mbzjxpt059zaaTBlNNRVUNbbwkJpHNupfs3H2uk38fe4kDl22hlsXHDrENRVixNgtucA/TPtrv8/6C1ecNbxyjm+CZBiFEGKEOPvVD9Aadohm88RzedTSVcxes4EDV60l7hY47fW1fPlngx70KIQQgyZtFmK7lFL3APO3tE5rndzS8l18/F/jN21vyVyt9ZrdXQchhovDj69h859XkU1Y1LR0kMxkaSlLsraqlPlvK2e/KdHtFyKE2K2GWR/GXUKapIXYs+QNJ3ba9fssoKy1m0wixKr6GpaMryWMx0137DvUVRNipNktod3vp/dvkv7w8pHfJC0ZRiGEGGE++voZAPz5zn8y2+rg0rceQ1XJTt3hUwixCw2n6zBalmXh39HtHKDGGLO/ZVnHAmONMX8ZbDnSh1EIIUaoRNRQEkGCRSHEtlwJfAS4Hv+WuODfJvhLO1KIBIxCCCGEELuQsax+jyF2AXC6MeZ2+rpFraTvRhqDIk3SQggxQlnXNjP+mTaWZa8i6nTTVOow89nPkJxRMdRVE0IMHw7QGUz3BIzJomWDIhlGIYQYgQoFl8qn06SypWxgDG1uNaF0jFcP/8VQV02IvZ6x+j+G2D3AjyzLikJvn8ZvAwt2pBAJGIUQYgT6+lEPU8hFsDAkyJEnzKryCayNTGH5ydcPdfWEEMPHZ4Cx+LfOLcfPLE5G+jAKIcTo9vj1r1LtwKI5E2itSxDGxcEwobGdvO3w8muJoa6iEHs1Y1v9HkPFsiwHOBv/lriTgCPwbxX4LmNMakfKkoBRCCFGkHxrmjXXvsSycWN45qDpFPent41hUnYt1d5GOu5bMnSVFEIMC8YYF/iRMSZjjGkwxjxrjNn0ZsqSQS9CCDFCGGM4/WPLKTvqCLAtMIZn5k5nbFMbkYILkRxHNj+JBbS/7VVM9gYsRy65I8SeNgxGRhdbYFnWGcaYHeqzOJAEjEIIMQJ0dmY55f9W0Fg/lgPbu/yFlsXK+lr+ePp8ZqzfhGMKLMqPoy1ewX4bF5Ev+w3zF59DeGLl0FZeCDGUYsCdlmU9Cayl6I5jxpgPDbYQCRiFEGIYau3O85tbNvPkP1fRFalicmcLR6Rcql9bz4vzZmAbw8SGZmrbO3As8BybbChBqrQMgMenHcUBrct4afoNlE6MMmPJJ7Ed6YUkxJ4wlP0Wt+CV4LFT5F7Sg6CUWgVcobW+RSk1Bf+ClxO11uuGtGK7mVLqHuAhrfU1Q12XUUTecMNQc9pQFoGCZ9jQCVMrLHIuZF0IWfDUBpeY489vSMETGwxzq2BDl8WcamhIQ0MKJpaDXpmlcX0HS0PlNKRtOgsuLjbJXJaC7ZAxFpbtYGyD5YHBBteA64JjY3setd05GkIhjAehsEUhEeXs55dhh0IkMjlmr9nAO5c+wcTOTXRRygPTD2NjTSXxQprTl97LuNRmXq+diZUqoyKdASxsuomTIkwHECZHkgIhWomRDHUSMQWcpIc1qYrQvpNxTZhIDOxIHquyDG+/abgFCCcs7DEleIUw9gHjsFc3QlsKDpgOFSXQ1g01pVt+oltSUBqH8A7kKjwPWjqhuhSGVzOfGB12yz/Vr+f9o99n/SWL3jHi/3klwyi2Smt92lDXQYjdyRjDef/2uO01Q3kEUjnwgLIIuB50Fba4kx+4GPPGrxpjwIqCWw05C2yLhFegOxqmMxzG9jycbAHXsyFsYSI2FDywDDg2dOYIlUfY7AGpHE7EIZ4uMH9NA+2V5RjLoqUMjl2xkH06lwGQoJPDV7xMYs1m4l6GMtcf+Di34XXamECaKr9qRHHoAJJEaSEMOHhU4mIV0nRRSlP7ZOpf3oD9ciOQxaEbC/9XjiFJBJcCIfIkAZsITUA2OHkboiWQLcCJ8+DfX4BouO95Of86uPkRqC2De78GB0/f/gvU2gknfgNeXAkHTYUHr/SDUiGGu2H048ayrBO3ts4Y8+Bgy5H2ib2QUspRSslrL/Z6T2+E217zEwHtQbAI0JHbSrAIfV8EW/pC6Ddk2Z+2ipLKnm0zsbMNHMsPED0DBdOXd46HyYUdKHjEoyHcWIRUSZxn66r6daIvRPonqldUTmB5/hBecY9iM+OL6tNzRoY4aVxKyJOkQBlOcLYWDuCQJEUlzdi9lYnS8xVhASE6sbDwu0PZgIvTGyz6xyAbPGkPLoK7n+tb9dxyP1gEaOyA79z5xuduS/7woB8sArywEm4c9HebEKLP7wY8/gHcC9ywI4VIhjGglLoM+DgwHmgFbsVvhnZ3okwDfAr/Po5zgIXAe4H3AJ8FEsCvtdaXB9sngFuAo4J1y4Avaa3/G6z/NnAmcLjWOq2Umg08DZzds81W6jEFvxn9IuBzwHRgslLqeOArwFSgC/+f6LNa665gv4eB+7XW31FKRYGfAe/E/8bYDHxVa31HsO184GpgbvD8/RL4kdZ6m02wwTGeD+pwMtAAfBT/O+on+NeNegD4kNY6FexTDVwDnBLU5SHgU1rrzcH6bb6WwevyCeBCYDawCLhAa714W3XdFVKpFKWlpTI9TKbLIsneDNruUtXVRVc03jsfy+X6MpMDD2yM/yiJ4Kb7ItbGWJSyTS1kbcO5z/yHiu4ULeESqvJdNMUriLf0bGmxyppFpdXAyorJTG9ZhyGKweoXuBocIP+GuroUj6g2AyrYU2mvd96wjfa8cv9akP5zHu/LygbrBvMaZaI2sa2WOfT/PzI98qd3l+HUh9EYM7V4Prg24xWAXIfxTVoHnAaU4QdlH8YPsHbWefhBVi2QAR4EKvGDthOBzyuljg62tYG7gJlANfAn4K9Kqdpg/TeBZuAXQXB5J/CTbQWLA3wgOGYp0Ih/1fcPABXA/OBxxVb2PR84FJijtS4LylkEoJSaC/wbuDY4z7cDnwQ+OMh6fRD4XlCPPwM34weNxwJTgH2AS4NjWcDf8b/J9sW/Wn0KuK2ovMG8lhcAZwE1+KPGfjbIuu6U4g8pmR766bk1FtedaLNPFRw/EcYmIGLDEePg6PEwtdyf76cnqPNM3/TAdcb4Tc2eoTlewsFrVzK+rYVjl73G4oqxflbRNf473i7at+ASSWWJYBib7sve7dPeScgYPv3o33nP4ud5y5qlxPPw8yPO4ftvuYhspO+3f1uijN8c+GEemjwfhwwVrKOSdYSKbhubJUoBBwO4GDopYR1TyBOnQAiDwSLdGzJ62LjEyRPGI49NBgsXl2gQUloQDsM+Y2HWWLj8TDh1/77nfJ/x8IuL/b9vOxi+/8FBvUaxS06DS06FmePg46fCh47f5f8DMr13T++Ngmszfhf44o7sJxnGgNb6r0WzLyilbgZOAn6zk0X/sGdwjFLqTvzA6Jtaaw9YqJRaCCjgf1rrTvwMY49rlVJfwg/U/q21dpVS5wAvAP8DNgHf2oG6fEtrXXzBznuKppcppX4JbG2IfQ7/ZuVzlVJPaq3XFq37P+AOrfXdwfxipdTPg7L+OIh6/UVr/TSAUuoW/KzntVrrlmDZP/GfI4BDgsfJWutssP6LQJNSaoLWet0gX8trtdZrgv1vpP/zLvYinzzY5pMH757fzgXXw7ZKeGb9FCYloUAlty/yuOM1l6qOdjYua2BZ7QQsD+K5LFPbN/N69XimNaSZkMlRn86yIhalq+DRhKE+1Qb4QdwG6pmrN5OcaHj6oBmoF5aDBasmVRPPpRmX3cCiujnMbFpOwQuzOjqGAnGSuRSeE6ZkWgXVcyuxPns6yTl1JKvKsLbS78rCj2t36gvj42/1HzvCceBXH9uZowoxJIbZdRi35C30NRcMigSMgSAQ+ywwDf95iQBP7YKiNxZNdwMNQbBYvKw0qEMcP0v3NvzMlxes68kworXepJT6C37G7cQBZW3PquIZpdRbgK/jN8tGAQe/SXhLbgHqgB8DM5VSDwBf1Fovw29OPlEp9e6i7W38zN1gDHyOtrSs5yfh1KCum5VSRZuQwW++XjfI17K4/K6i8oXYZULBZWyOmNgXkH7xGP/h9zoZM2CPujeU0bC4gXde2cyklg7+N3Ee01s20WKq2cB4wgWP6Ss3MXnlZsCiYNnMXLyJA83rJNlIjiq6KKNs7feZO0GuxSjE3siyrH7XXsT/8Inhd80aNAkYAaXURPyA6N3APVrrnFLqB/RltfaUz+I3w54ErNJaG6VUE0XdhJRSx+H3vfs9ftP0oT19DgehN7hUSkXwm3a/CPw+6BP5SeDzW9pRa10Avg98XylVAfw8qMOxwOqgjB3653uTVuMHeFVbCpaH0WspxC4xZvYYnrhtDMYY3v7+MiobXLpiCaat6O24iI3/bRAzOWaxGhuLV2IHYgo5Dsl/dcjqLsTeyljDqsffeQPmu4AlxpiOHSlEAkaff40Iv19fXil1BH6/utf2cD3K8K9R0QxEguboip6VSqk6/H6NlwE34Y9y+hVbb0belgh+pq41CBbn4vc73CKl1In4fR5fAtL4/3BusPqXwCNKqXuDOhlgFlCrtX7kTdRtWzT+4KHrlFLf0Fo3B308T9Ja387weS2F2KUsy+Lff57H+86Go5esIRt2iOZdMmGHpw+ZASGHg19fRrQxj4dFLJ9lbuHyoa62EGLoHWqM+cHAhZZlfdYY86PBFjKsQuChorV+DfgGcDfQBnwZPzDb034UHH8DsBy/KXYVQHAZnFuB+7TWfwiya+cBJyulPrKjBwr6S34cuEYp1Qn8gv4DRwaqwx+M0orfnDsZf2AKWutXgNOBTwfrGoAbKWpK31WC8z4TP+v6nFIqhd/cfHywfri8lkLsFrf+aTaNZUkaahOsqi/jd2ceQdvYCtpqSnn4iP1ZUlnPk/UzmLnm0qGuqhB7LWNb/R5D7OtbWb61Qa5bJHd6EWLPkjec2GlNLzfw/Km3c9/4fVk7YwITM30jqg99fhEeLuesPncIayjEiLFbormfH3xvv8/6Tz7/1j0eNRZdsHsBflKnuA7TgK8ZYyYPtjxpkhZCiBGmZr8xbBg7hYMb13D3wbMZl8kSAtL5AtVNXcy65fihrqIQe7VhMkr6d8HfGP6Ygx4G/yorn9qRwiRg3AnBvZbnb2md1jq5h+uyCL+ZeKDVWut5e7IuxZRSXwW21uv+NK31Y3uyPkKMFhc8/w6erPoZp738Oo9OnciEVBeXPqRJVYSY9K5B3HZPCDGq9Vyw27KsPxpj3sxYh36kSVqIPUvecGKXufOauyj9cSuhTIGCcQhNinPSS9IULcQO2C2pwJ+p//T7rP+UPnVYpBx3hmQYhRBihIrOCZO7fgynnnHGUFdFCDFMWZZVhn+nuOPwr/HcG7waYyYNthwZJS2EEEIIsQsZy+r3GGK/BA4GrgSq8PsursG/EcegScAohBAjVMfzBVo+l+Evc+9iw6Mbhro6Qojh6RTgLGPM3YAb/H0f/jWKB02apIUQYgRacPZ/4ckC9c3d5KIhbvvSEuranuKDr717+zsLIXarYXDtxWI2/o03ADotyyrHv2byjB0tRAghxAiz8rUs4zZ34NoGPJdZr65nzbixbFzcNtRVE0IMLwvx+y8CPIbfRP0rYMmOFCIBoxBCjDBLFrYTdi1SpRG6ExG64xEa65KUd6a4+9wnhrp6Quz1hlkfxosJ7hqHf2vhNP5th3foUjvSJC2EEMPY125t4b5XCnzqtCjnHVsOwNNvuxe1sQXHGPK2zcbyUhzXI5L2yCXDQ1xjIcRwYoxZUTTdAFz0ZsqRDKMQQgxDn7s3zYzPNPK9xVGeiZdy/iMRJl/WwA+O+Q9Tmttxgmvohj2PklyOfMjG9jwKtsNzU38zxLUXYu82nDKMlu9iy7IetCzrpWDZsZZlvXdHypGAUQghhpk//KeD392fpj0cpqory8SmLpKpHGvLkzw0diKvTR8PgItFFofmyjJieZfmylLqGlp5ya4l81rTEJ+FEGKYuBL4CHA90HPdxXXAl3akEGmSFkKIYeQfr6W57D95ygse7SGLyoJH1rHpCIfAg3/PngLxCMnuHONWt2IZGLuuncWzx3HUE4vBMow362jb73Eskydx3FRK77sMQs5Qn5oQe42hzioOcAFwkDGmybKsXwXLVgLTdqQQCRjFNimlVgFXaK1vUUpNwf8nm6i1Xrebj3sM8JjWere/65RSVwAna62P393HEmKg1zbn+efiAtfc24XnRIhk8qQiYbK2R9Tzm51ztg1FX0CxVBcN1RXUr2rtXVbdnGIOmiqvmUarjoJbSRibhocyNIe/SxmtOGSInzGNyD++sMfPUwgxZBygM5juuWVhsmjZoEjAKPaoPRx0XoAf7O7QtabE6LHgtQIvbvA4c67D/uMGl2F7aJXLdx7MMrPa5hdnRHEGXE/tZ0/mue4Fj5k1Nn86M8Q/Xivwjf95rE1beFh4ngEDljF+lsG2wPOIdBVIZnLst76ZlybX0pqMQt5AwQMb7MpybGOY252j2/PosCxysRAmb5HMub3lRQouM9s6mbN8NQXLwmBhG8O0llXUmCYMFrWmlW5cGphMgRgeLtBEnHZY8BxZ60I84hhcskRoiZUSL7RQV2jGRKM45x5JblErhYpqIleeTrilEZ5dBm8/BA6e/sYnreDC7x+Alk74yElQW74LXj0hRq5hlmH8N/Ajy7I+A36fRuDbwIIdKUQCRiHEqPSnF/N84M9ZAK55FF66LMHUqm13217W6nHSrzoxBcODwPJGj/9elOhd/+unc1z6oAfREMvWwIzrCzRlAGtAMOpYvT/jAch45LBoiUV5ZEY9xEJ+D/KIDcaAZeEVPLyMy6KyBNFUFkoiYFl0hh06S4CQzf4bmpm/oYnZm1spbcuyMVlGNOfiuC4xkwbAEANCJMgwkWV0UUWYHBZQoJIoDWRJ4BGmQBgLi+pMAQcLBxey3ZjfP0g7s4ENdP33N1R5ywiRg6vugud/AHMm9D/fy34Hv7zXn775EXjpR+BIE7gQw8RngZvwL94dxs8s3scOXlZHBr0IlFKXKaUWK6VSSqk1SqmrlVJv+tNeKWUppb6rlNoQlLlKKfWpYPXC4O/rSqlOpdTXgn1mKqUeDrZfCKhBHqtSKXWHUqpZKdWulFqklJqvlDoS+DUwLThOp1Lq+GCftyulXg2W/RP/Zux7RCqVkuk9NP3wSrd3vjMHer233X0fWe1hCn2hnl6b77fNPxcXINz31vCDxQGZhC0lFryi8NEAlgEn+Pi1LD9obM9CpoCbccmF+jdBV2TyHL6+lflrGqjM5gjlXRacdDD/PPNQ/nX6waTKEixNTqfbilP8se7g4lAoqpKDR4IwqaCixZXtyx9YGBwKQd0tCsT96UyO9CMvveF54+FFfcW8upbOFRveuI1My/QwnN5dhsMoacuyxgIYYzqMMe/CH/ByBDDdGPMuY8wOPRESMArwR0udBpQBZwIf5k1epynwFuB84HCtdSlwGPB4sO6A4O8+Wuuk1vrbSqkQ8E9gETAGOBu4ZJDH+gKQACbjX4j0XcA6rfWTQRkrguMktdYPK6WmA3cBVwXbX4d/UdM9orS0VKb30PSpM/sCoIoYHD7R3u6+p0yzccJ9H4vHTg/32+bsfUOQ6wtEJ5TQPxgE+qUWg0vfECr6qLWDQM0MCCKLZu3ifYGC6+EYw8rKMkJugUUzx7NpbCUAmXiE12eNo3lMGU/VKVaXju3dL08UM+Bj3iKPwQoO6BWtyPROeli4QQBphSCMn70kGSN+0oH9nhMATu1bxkFTSU6rf+M2Mi3Tw3B6lBt4J5dfG2OeNcZsejOFSZO0QGv916LZF5RSNwMnAW/2Ym45IAbMU0o1aq0bgIZtbH84MAX4gtY6DSxVSv0Q/xIAgzlWNbAP8ILWenu3Ono/8IzW+pZg/j6l1N+B8YM4lhhB3r1viAcvirFwo8fbZ4eYVLH938cTy2ye/3SS7zycY3a1xbdOjvRbf8EhEcKhPD/WLvPGOlx/aogHlrtc8ZjL4g4LF4u852HyBscDLHBDNkQswh4ku3MkCgWaiJONh/t+shsDjgWuHyTGbcjZFmTyYAydBjaFHSoti854nO5I/3p1l0fxWj2WVk/n9dqZ1HU1ctLaRwnn/bAwj0WENA4ZPFzygEUrCXJ0WhW0xEqpcA3xQhivLEn4khOpeKmBQlUNka+eitPUBM8th1MOhJn1vMEPLwA13e/D+MHjpDla7PWGSR/GgZU4fmcKk4BRoJQ6B7+PwzT8/4kI8NSbLS/I5H0VuAL4i1LqKeCrWmu9lV0mAA1a6+6iZSsHebhr8ftk3ASMC5qYv6i13ryNY60asGwlEjCOSidMD3HCFsZobMv+Y23+8v7YVtefe0CYcw/om3/bPiHets9gP0oTb1hijOHuRVkuv9fj1XabqGfocMHxPNy825t57Abqu7rIhcOEjKGqLUUmEiaRyTBx3Sb2XbWJeK5AazLO65PH8Ej94Rzc+ArGLoAJ89JYRVV3E4d+fDYlX3t37/GrgsdAkeDhGwPz5279tCwLPnDsIJ8DIcQeYra/yeBJwLiXU0pNBG4B3g3co7XOKaV+wCD7EG6N1vp64HqlVAL4Jn4z8CT6tYH1Wg+MUUolioLGKYM8ThdwOXC5UmpscC7X4nfm3dqxTh2wbFDHEmJ3sCyLd+4b4537+kHqc8synPDzbuIFjybP4AWZimYnRC4aIZHJYWybqWs3EHJ7/sUNsZzf57CyM01tWwdTmltZGpvEYT8/jpIPHMbE4ZHxEGKvYOxh8X4LWZZ1An2ZxoHzGGMeHHRhu7hyYuRJ4jeMNQJ5pdQRwAeB195sgUqpw4Ao8AyQBVJAT8evRvxAbiZ+30nws5mrge8rpb4I1ONnPAdzrDOAZfh9NTqBTNGxNuEHomVa645g2e3A14Os6h34Kfp3AlvLfgqxRx0yI8aPzna58s/dOCGn91dP3rb4x7RxHLumkX0amoN+iD7HM/3ansY3t1B///nsf/QWmo+FEHuLBuD3RfPNA+YNO3Dxbhn0spfTWr8GfAO4G2gDvgz8aSeLTQI/BZrw/0FPAd4XHC8NfA34k1KqTSl1uda6ALwD2B//H/wuBtd/EWA6/rWkOvCbmtP03e7oIeC/wMrgWMdprZfhD6r5Ov75fga4YWdOVohd7aJjSvjA2xKUe17v4JeQY9GW95iZb2fWso2UdKZx8i7hbIHS9gypWJRsyGHdmApK5lVQI8GiEENmOIySNsZMMcZM3cZjh+70YhmzS5u4hRDbJm84sUNueDbLHU9n+NoJYY6Z5/eB/OzRj7L/+gYieY9Q0SjtjrIormPzsVffMVTVFWKk2S3R3PePf6zfZ/2XHp4/LNqod4ZkGIUQYhi76NAo//lkeW+wCPCduw+jsbyEbKSvV5FngevYJDu7t1SMEGIPGg4Zxl1N+jCKN0UpdQ8wf0vrtNbJXXysrd3v8jGt9Wm78lhCjASJmhh1bWmmb9xMzMnRGi2hoyTG2PYspzx31lBXTwgxCknAKN6UPRmo7eoAVIjRYML+CZpS5Yxx25jXvp5cp8Py/WcSH1sy1FUTYq83WrKKxaRJWgghRqATF7yV/JfiLJlezYtnHU1Nwxc48fn3DXW1hBCjlGQYhRBihIrODRH9VojTzjh5qKsihCgiGUYhhBBCCLHXkQyjEEKMIJ/4SydNty4hjk0sW8cpSxfznWvv5/KHT8IaHneXEGKvJxlGIYQQQ+KeBxuZe9Fq7no6Q+PYMYQN7LuxkY0lVXS7Ie4acxv3HfO3oa6mEGKUkoBRCCGGuYt/sJmz7wtDLERlJkd1zmX/NRtwjMEGJrWnyCQivNaeoLM9O9TVFWKvNxqvwygBoxBCDGO3/G0zf94Q4i1LV7MxWUJ3PEZTOETeKfr4Du7YFS7kWXDwzt7ZUwgh3kgCRiGEGKYeWJrmMw/b5F1DSbZAWyJGxnFoC4e5f/YMWuMxsrZNvDsPQFtpCZVdLaz86ZNDXHMh9m7G6v8YDSRgFEKIYWjGVxs5+WaPplCIaK5AIl+gMp3DDu4dvbGijDvU/mxwkpS052gsL6O+rY2xDWFuvbGd5f9cMcRnIIQYTSRgFEKIYcR1PaZ/fhPrInHozhPLu1jxCIumTmJeSyeT2zop70oDMK6lgyNXraGrLMwfD5tHRbaDGqeBs5c8x8OXaZqf2TjEZyPE3mk09mGUy+oIIcQwsLTZ5f1fWM7HH32RzzsO15x8BJM60zw+ro76dJaQMZS4Hg4wfWMTJzy7mNr2LkJ4TEm3cPmDj3Lc2pdxjKGs0M2czCaeOXMBM9o3MKPz61i25AeEEG+eBIyjmFJqFXCF1voWpdQUYCUwUWu9bkgrNswope4HHtdaf3Oo6yJGt/a0x4vrctzyYIpNq1p50iqnKxyjvLOTxuoq7vvbI9S3dQIwtjXFpz5wOp5j0x1yiHoGJyhn+cQ6Dnl9DfWtKaLkSKYzHLRqFQ6m91iJXJYnJsxmcbyO/D7/oMbr5KC1KwjZNqVH11J38SE4EytwZtXi1JYPwbMhxOg1WrKKxSRgFKOWUupGoKC1vmio6yJGrn/86mX2+fpt5ByHj591Hv+bOqN3VDIGLAtiIUi7Vr/l/fR8d2RdLM9g4hUc3N3CjEIbNV02mZDDIzUWtanu3l3qOrtpikYA2BQNMz7sMDZX6F3/+pRxjG9vpaqtIzhkiKVV9cxs2UDecuhsL2FOajMr6+Ocu0LjmhD3zDqUJdPHU9GV4siPPEeGKGMKjeyfewljWeRt8NwEITJkqcDCI04DNh4WFh4hWhlLt1VBNJym9qJpWB+cD6d+FzozuEcegPPgl+i+czFtX30YuypGzS1nEp5buzteGiHEHiRtFEIIsRWbugxHfO56pjc1MGfzRm74843+CsvyH7aFMZDuieN6lhcnF6yi5VEHgwV5w4v10zh+eRvHrtzIEWs2g2Vxx+H7AtAWi/D104/FwYWIAyVhXqktpbQ7jeV5YAyvTBvH6xPq8IKDtdlxliYnsdap45nwPDrsUixg2oZuIp5LU3kpTx+wD40VFTgpiw47Sc4Osy5Sz2anDscYYq4hQicZqjGE8YiSZgw2YGFwyJOkDdeE6c6V0fHLF+Ad12B1dGJ5BZz/PUf+xw/RfMEC3NXt5F/YTMvH790zL5YQw4hnWf0eo4FkGEc4pdRlwMeB8UArcCt+M7S7E2Ua4FPABcAcYCHwXuA9wGeBBPBrrfXlRfvsC/wQOBhIB/X4utY6H6z/A3AyUAGsBb6jtb4tWHc8cD9wLnAVUAP8B/iI1jq1nboeBPwM2A9wgcXA24GLg/JQSr0/2Lwc8IAvA58IzuMm+n+971apVIrS0lKZHiHTbe0p6gv53tcvkc+xU4q+OBL5PFVp/yLbm8oSFEIONx9zIDccMo/GcZW4YQdcz/+vBrLRMCvKYxy55FX+O30ON91yN1XpNAZIEaOJMsa2pOhy48RcFyyXbMjBC24X2BmLUwj5H/mO6/WrVqHoq8DC8MaIlwHrfQYbCv0/akxnFvJ95RdSmd7p4fCayrRMF0+LwZMM48i3DjgNKAPOBD4M7Iom2POAdwK1QAZ4EKgEpgMnAp9XSh0NoJQaAzwC3IUfuB4JvAX4SlF5jwMH4geMVwI3KqXmFq13gFOAA4BZwEHApYOo5y+A+4AqoA4/oM1pra/BD1pv0long4cbnNdn8J+rsUATcOzgnpKdV/whJdPDf3p2fRkPf+EDZJ0Q3eEwnz4z+O3R2/Rs+jc/m4Ft0fjrjfEfWT+4cozLFx66i1VlCQDGt3URzRVYXVNGS2WpHyxCvwAT4JXyJD896AganDCm6MAeDuGwx4pxY+imBBuwDUQLLslIFx4WkzdvpryjC4Bl08fihv2yqwqtjHPXY4CukEOWUqK0BBX3iNGMG4SJLmHaqQYgQhdlbxkLN30SEwphgMKUaUS+cBLlVx0PtoVVEaP6x6fs8tdFpmV6V03vLgar32M0kAzjCKe1/mvR7AtKqZuBk4Df7GTRP+wZHKOUuhP4HvBNrbUHLFRKLQQU8D/gQ8BCrXXPMdcrpa4Gvo8fHKK1/l1R2bcrpT4PHA+8WrT8y1rrTqBTKfX3oPztyQGT8AfzrAKe2s72HwJ+o7V+Lji3q4FLBnEcsZd6x3ePxf3GkbjY3Bm2ac96xEMWmzsNZRGbkqiFbVlkC4bV7R6JkMFyLLrbczTlQnS2ZtmnxvBCg81jS7P8d5VhaSHM9YeewMmvvMCdM+aQcsKE27sYbzuE8y6vJyO9Tdsl+QI526a2o4MNRAFoKknw9zmz+MjzL/HauIk0lpUzdmMrs5duIGuFsIJY0jKGxjEVvBqvp76pkc/96xZemjKDnF1gZn2KeE0cd1Y9zkVfg7oyCq81ka4uZUxljEh9OSbvYi/fiJkxAbejG7s0xphEBC9bwHYsiPv1If8XTFeGcEkMgPKvHE3Z546AkI1lj44vSyH2dhIwjnBKqXPws2rT8F/PCNsPmgaj+AJu3UBDECwWL+v5mTYVOFop1Va03sLPGqKUsoFvAu/Dz+oZoAQ/e9nD1Vo3Fs13FZW/LRcCXwMeV0rlgVuAb2mtC1vZfgKwqmdGa+0ppVYP4jhiL+ZEwr0jlCtj/tTkiv7bhCIWc2uLGm3Kej5e/YEr06bAWYcli/Yox0/I+/70RCeX3JWmyraJ5QpkIv7+BzV0UN+VZbMpsKE22rt9RyzOY/vMYsmMKQCsnFLHsY8uYtOYCsavacYyELZzJFoyHLb640RK/X37jvhGFZPHUjFw4cEzsAC7LNa7yA6/8avDKon1n484b9hGiL2FjJIWw4pSaiJ+gPRu4B6tdU4p9QMGl5nblVYD92ut376V9efgN5OfArwaBGmaXdB3UGu9Er8ZHqXUfvjN0yuB3+P3VxxoPTClZ0YpZQGTd7YeQuysc45Kcs5RSRqWtfDu77zGmpqJrB1TQavjMg5YW1UBYRtcg2Vb/PugebQ2NjM5uIi3G3JYP76KFdPqWDajjtMff4rpvzuKynMPG9LzEkKMDtKHcWRL4r+GjUBeKXUE8MEhqMcfAaWU+rBSKqaUspVS05RSbw3WlwGFoJ62UurD+H0Vd5pS6nylVH0w2xYcxw3mNwHTggxnj5uBjyqlDlZKhfEHwIzdFXURYlcYM6OKx288mLJcmnhrN68lS3koGWdtPAqREMTDmGiIrGOxIZHABP0mLc9j2fSxGMsiVCjQ8dljJFgUYoiMxju9SMA4gmmtXwO+AdyNHyx9GfjTENRjE3AC/iCZVfijtf+G30wO/kjkp4Fl+Bm+ucBju+jwJwLPKaW6gCeB2/CDQoAb8Ju+m5VSbUopBz+4/RmwANgMjAEe3UV1EWKXeeW6Sfz+NI9y16W5Oklprm+0drjgEvYMG0vijFu3geqWVsrbOyhLdWLnckSTFidetacbGoQQo5lltjSqTwixu8gbTuyQn9+ymSufdziirYtm26Yd//qPkzo6mb2pgbjrUZvNYRybgmVR07yZC18/Z6irLcRIsVvSf5ef/kK/z/rv/vOgEZ9mlAyjEEIMY588r44TmjZR3dDE5M4Mk41HzHFoqKrg0bmz+M9+syEDq+vG4LitHPjVg4a6ykKIUUgGveyFlFL3APO3tE5rndzS8qGilJoP3LOV1Vdpra/ak/URYij8+Y/78pOvv0r+b8uYs6qFfx6+D3rWRADGdnSxanodVU1raY5VcND5s4e4tkIIM+LziW8kTdJC7FnyhhNvmut6XHTJq0RWtrOkpoK6zlbiHXlKQ1G+88d5lE0oH+oqCjHS7JbQ7qtn9G+SvmrByG+SlgyjEEKMEI5j84ff7ts7v2DBAgDOOOOEoaqSEGILRsv9o4tJH0YhhBBCCLFNEjAKIcQI5W4skH8mh/Gkp4MQw4lch1EIIcSQ81yPv038LRt+Eqfltih3jruNfHZrd8MUQoidJ30YhRBiBMms6+QTH3iR2n0PprM0AcDUZRv586w7OG+1XH9RiOFgtGQVi0nAKIQQI8gvT7qfQ12PVw6e07ts/aQamitLhrBWQojRTpqkhRBiBInaBWo7u4lkc73LLGNoL0vwqTP0ENZMCNHDs6x+j9FAMoxCCDFCPDfr10xvtdhUUs3MJatprqkglHfJx6NUNbbSHYnwz5tWc/r5k4e6qkKIUUYCRiGEGCHcjSlSiQlE8i6uk2fcxiaMZbG5rpql+0zBKbg4P32d148q49rPv8oj4+vZFC+jpODyzfcnueTIxFCfghB7hdF4pxdpkhZCiBHg+am/Ym20noJjUwiHSXZlqeroJB91qOroINrVRVNpgiXTJqCP+w8nL32Gj7zyLOO7s1jG5mt/6eaAS5Ygd/cSQrwZkmHciyilJgBrgala61W7+VjnAd/RWk/ZnccRYrRb/817abv6UTaWTiESy/PA4QeSi4SZvX4NFz32b5q7ylkw+zAy8Rgl6Qzd0QivT5+Ml6/jloP2I2f8e5+FXVifqKbkax3EohYtXysb6lMTYtQyu+eOg0NKAsZRQillgPla68d383GOB+7XWsv/jhAD5fJw/0tQUwpt3RCPwPy5vauz9yzCu+IvhFPt2G6OdEcBrzWDcT0sLCxcmpwxVHjtlJsUYKikhHZ7DhNaO/jv0QczsbkFC1hfVYuu3pcJnRvJJkuoTXXh2Tamqxs36fBI3SQa4hEquvsGx0zpTLMqUkoqFsb6boa6llaqst0sqR2L63kQCoExEHHYv9xjcrXDg+sMtV3d2LZDSzJOCI9Dx1r83yE21XGb7hw4Fhw/xebp9R4taTh5qkXYGX1fmELszeRLXwghdgXXhVO/DQ+/Eiyw/MdX3gVXnUvmN48RveTH/fIOJYDBAVws4PnoIbw0dh/yYZuxnU2cvuk+XnMOosGuAaBghXr7EY1pT9FtoiysnEUhHMZYYGy/dMdAfTbP/6IhcrkCkYJHZTbH1Eya56rrIBi1uXlsDZsHjuAseJAp8JIV4qUu/2hd8VKq2zpx3RxtiSj3rIV71gJ4kPfANRwz0ebxdX5z91unWfz7/SGsUTI6VIgdNVpGRheTgHGEUUpdCnwGqAE6gJuAtwer71NKecDtWuuLlFJjgeuB44DNwDWDPEYU+BnwTiAW7PtV4H/APYCjlOoMNv+E1vompdRhwC+B2cCLwH2DPNYFwBXAL4DPAeXAb4Crg7q/BdgAXFScPVVKXQxcBkwEVgBf0lrfF6w7ALgOmAc4wFPAJ7XWy4P1NwbLM8B7gC7gSq31bwZTZyG2aHVjUbAIYAALbnwYrjoX8+N/bbGRysIFwMNiccUM8hEHgE2ltaztGEdHru/6iuGcSyHqf2yHCi6RXAHX2ETTOTLxiJ8dDL6oPNu/JVlzdQlx12XOxjTry0t61/sH30KNQrYfNNr91zWXl1CSyb1xe8cC1/DEes8/X+DeFYbNXTA2ua0nTAgxksiglxFEKTUL+B5wuta6FD8g+ofW+oBgk1O01kmt9UXB/K2AC0wCjgUuGOShzgcOBeZorcuAE4FFWusNwGmAGxwnGQSL5fiB5J1AFX5A+387cGqTgQpgGnAM8KmgvGuBSuAu4A9Fz8PFwJeAc4P1lwN3KaVmBJsY4JvAeGAK0AncMuCYZwMLgvp+Cvi5Umq3X4sklUrJ9GidrqvAqynlDfadSCqVwhw07Y3r8Ps6GcDGEDL5fussLGq9ht75MU0tWJ6H5XlMWr8JbBfLGKa+vpGa9a28UlPBxmSc9SUJNseizEl1EgpZpBMRHpw+DssYP6jcFs/4weKAzUIFl5DrbekEAKiI9u0wrsRQFfenh/x1kWmZ3sb07jIa7yVtyYi5kUMpNQ1YhB/Q/Vtr3Vm0rl8fRqXUeGAdMKMos/YW/MzfNge9BFm/y4EPA09qrQtF645nQB9GpdS5+BnByVprEyz7LnDu9ga9BMe6DqjQWnvBsmeAZ7XWnwjm5wbnXaG1bldKvQJco7X+Y1E5C4Cntdbf2cIx9gVeBkq01t1BhrFWa/32om0a8bOYd2+rvruAvOFGs5dXw0//CbEIZApQGoMrzobqUjCG9HFXE3psIQ4FLAzGDxNxAYc8rU4l/x13AulIlBmplcxvfIYCNsvteZSZdu5Qp2Js/3e+5Xok2ruI5gpM3NTK9959LPcd7P9mKsnk6Y6GMJZFXSrN5mQMLIsD1rcSz3s8O6ESt6ePoRf8S+ZdP+PoehB2wAUnauFiEc4XOGj5Rp6ZMxEMhCzD8RNtZlRaFHIe8bDFZYfaXP+i34fxc4c7zK4ZHV+SYtTbLf+ol539ar/P+p/eOXfEvyGkSXoE0VqvCIKzjwM3KKVewm9K3VLz74Tg7+qiZSsHeahbgDrgx8BMpdQDwBe11su2sv0EYHVPsLiDxwJo6AkWA93AxgHzAKVAOzAV+IVS6rqibUL4ATJKqen42cnDg3166lVL3/NRXD74zdJbSA8JsQP2mww3fGLL6yyL+KNf7b8o+OsEf2uAcwCWrKfx0ytp/V8F6W6bNRVVJHMl2J7BDdqFQgUPjCGezzEm28UPb7+Xa7qO4eb5B9IVDfX1UyyNE80XAIvq7jzrSyKUN7bRVRLlG8eH+dTRMZLR7TU2hfEbALbE6Z36/onSaCUEyL2kxTCgtb4Lv/k1AlwC3K2UquaNmav1wd/JwPJgesogj1EAvg98XylVAfwc+D1+s/YW2qRYD0xWSllFQeOgjvUmrQa+obW+Yyvrf43f73F/rXVzUYZx9L2Dxeg0azy1//5C7+x44MHoLxmzoY2WmlIsoKKpk1QyzLSmVr9vkTF8ccHj3HH4PCwgHQkDEC24TFu8gddqK3mwuoSvHgXfPb18CE5KCDGSScA4giil9sHPrj0KpPGzbQY/iNsEzAQeB9Bar1NKPQxco5S6EIgDXx/kcU4Myn4pOE4XBD3z/eM4SqmpWuueLOI/8ZuVv6CU+jGwH/ARILsz57sNPwa+qZRaCizEH5hzCNCktV4MlAFLgTalVA1w5W6qhxB7zAnpj7MocQVLM3NxQzZW2COdKCUXDpHI+X0f847Naa8u4dVYKS111bi2TaErz7qKMsoKBdp/UDvEZyHE3sEbhekJaT8YWSL4Qd9GoA24FDhLa53B73N4pVKqVSnVM9r3A0AU/2LdjwF/fEOJW1YH3Ay0BseaDHwUQGu9BPgV8IxSqk0p9UGtdRv+SO33BftcF2yzW2itf4s/4vsPwfHWAF/DbzcDf9DNfPxR5I/hB7RCjGiWbZG2S0h05OlMhGmuLKN5XA1PHbAPraUJUvEoV73zOA5Z28jiG6bR8N1ymr9dSvuPquj4aQ3tP5FgUQjx5smgFyH2LHnDiTfNK7g8EbmepZNrcUMO66eMwws5YAzPjK3gyFeW8HV9+lBXU4iRZLfkAj/xvsX9Put/8efZIz7nKBlGIYQYIeyQQ3siwriODhzXY8LKDURT3WRCId764jKueOptQ11FIcQoJX0Y91JKqUX4Tc0DrdZaz9uFx5kEvLqV1bdorS/ZVccSYm+w38+OYMXH/kfXlFI211SSi0UAiOTy2CHJAQgxHHijcIylBIx7qV0ZFG7nOGsAud+DELvIpAvnYQour/1wDV6dHyCG0lne++CpQ1wzIcRoJj9HhRBihJl88f68/9m3UtXSxJiNm7jkJzOoHhsb6moJIQKj8U4vkmEUQogRqLI0xKzL/Xs7T5xbNcS1EUKMdhIwCiGEEELsQqPxOowSMAohxAix/odPsuj7L5I1YcY0t2H/bCrepMhQV0sIsReQgFEIIUaAFep6FjVHWDXJv6dzc1U1+39qBQ0froYzhrhyQoh+vFHSb7GYDHoRQogRYN2yHGsq6nrnU8k4nokx8fcbhrBWQoi9hQSMQggxzP1n4i2sT9Tg5N3eZQUDCw6exdqyum3sKYQYCjJKWgghxB7l5VzsVAdtY+qJpLNYnkfetrn83ceTjkY4btFKXp+9gJUTx2Bsw8vVZRx+bA1XXzJmqKsuhBhFJGAUQohhbMl+vwQ3TCoRoSaVJpzNEwLe/tpK5q1t4hi9mrDrMXNtOz9920F4oRBrH1jP0c90cd3FZRxyZPVQn4IQe53ROEpamqSFEGIY85Y0E+qK8L99JpHI5ojn8qweV8WxKzew34oGwq4HQEl3jnlN3YwhRGtZDeVOmMt/1819DzYO8RkIIUYDCRiFEGKYWlJyBREMJHKc/8BLTGrqYL91m6lNdQNgQh6ldBKigGfB2uoyNsVjvdkN27L4yp0Fqj7bxE1Pdg3hmQghRjppkhZCiCFmPI/8iiYyt2kyi5t46MlGpjZ6TOxO0x5L0hYrxwJemDCO1eNK2WdjM3bM4YimV0mSI2c5/OrAE9hUXYYDpG2HqPFwgJhrqM0bPn9Xjgv/a1OazTG7FsIVUW57V4hJ5fI1IMSuZhh9bdLySTGMKaXCWuv89pYJIYaG6UhTOOM6eG0jzlv3wbr+I3gzPo21vgEAqzyGFbKhrRvPhbZojJVlM5jZtpJ4IY1jCqScJJvidTj5OOOza/AiLodFqpjYtYEQLrUZhzXR8ayqGsMXLziZ7lgE2/O477qfkcz7twaMGJeTX1/MQ4fu61fMsshhU57Nss/GzbTU14EXx1TE6SiPs2ZzN/b6DAcvtWiNhPFiIUKeIdyVw7NtsiURwgWXyvY0bixEKhbGcz1UV4qZkTz3VtZSW2pzz3scJpX3NVQVPMPX/+fxwmY4Z47Fh+ZJI5YQo4UEjLuBUioJfBN4N1ALrAU+BjwHXB0sjwOPA5dqrdcE+z0MvAhMAU4ErlJKzQbCQB54B/Bn4OPbOPbDwPPAVOBkoAH4KGABPwEmAQ8AH9Jap4J9qoFrgFOAGPAQ8Cmt9eZg/WXBMccDrcCtwBVaazdYb4BPABcCs4FFwAVa68XbeZ6OB+4HPgR8GxgL/BX4JPBD4GygA/iM1vquov3eCXwNmA5sBL6jtb41WDcBuAE4BIgALwGf1lo/F6z/JjAfeBq4KCjyV1rrb2yrrkJsSeGc3+I9ugoA7+aFhB77PM76TX0btHf3TtrA6vLpHNi4CMf0XR6n3O0k2hnCI0KcDuI5qMj1NR+HcBmX3kimsYS3Precu46eg2fbvDC5jkOCwBQgnLOwPQ/P9oM0D6jY3MhDk8azqrzUr0NLGm9skk0VCch6YAxh28JzbAoOFMpjYADLIh8JkY5HGNPSTabGocuDp0oreCpkQxYas3Dy7S5LPtYXFP5YG65+2gDwn1WG2f/f3n3H2VWUDRz/zW3b+ybZJJseElIgASb0EkLvKiqgdETAgoLCS5EiIFVREREVkA5Kkya9hhJgCEmAENJ73d73tnn/mLObu5ttJLt7s5vn+/nc3XNPmznntuc+M3NuvmLPwf0v0yJEZ+TC3aKr7gX2Ag4BsnGB3jrgj8De3m0EUAI8r7X2J2x7NnAHkOP9B/ge8BIu+PxVF8o/DbgZyMUFmA/hgsYDccHoeOBCAK21Av6L+5iY7NWrGng0YX+rgaO8YznBq+OPaOlM4ESgEBcg/6UL9QTwA9OBXYAJwJHALK9OBbgA+z6tdbpX38Nw5/eXQD5wBnCn1vpAb38+4C7vOIpwwfPTWutgQpkHAiuBIbjH5gqt9X5drO82qa6ulul+NG2XlbKZwm6ooCP1/pQWwWKTGCko4s334wnNWRao8ueigNNfn0dq2DUwDK9Zx+z8IirIYg0DKQtmU5oWoDbopzIlwKcDMokEfFSkhBL221RVtfl/3LY4BhI+6GJ+Nx2MxsDXel3YULv5fnV1NcurNt+3wIoqm/THSKZluqNp0XXKWtv5WqLLtNYDgQ3AZGPMlwnzfUAdcJwx5jVvXiZQBhxkjPnQyw4uNcacnbDd/cBwY8yMLpb/NvClMean3v2JuIzfnsaYT7x5twI7GWO+rbXWwLtAnjGm0VtegAtmhxljVrdRxu+9On3fu2+B7xtjnvDuHwM8bIzJ66Su03HZzIHGmE3evP8AGcaYY7z76UAtMNUYM1dr/QLwsTHmuoT9/AVIM8a0DmLRWmfhspSTjDHzvQzj94wxkxLW+cSr7587qm83kRdcPxJ7aBbRMx4ACyoYw3/t0fiufLA53LPQYroqlInFT264ssV+GsiikQIyWYufMHVkUkYx6VSyIjSM1aFh3k4s83dOYXzdEqauWEdpuJjaaC6PTRtPoDCdOw+a4tbzAUpRUFXLPvOW8eLoEe7iwRlByApBY8xFj9a6ADHN7/43RN3/kB8VtwzeVEMoEmP1wEyi9VH86QHy6hopyUwH4Mp9FTccuLmh6rMNloP/E6OyESYXwvun+MlO6X+ZFtGv9MgT9NTTl7V4r3/4wVF9/oUgTdLdb6T3f2Gr+QOAFGBZ0wxjTI3WeiMwDPjQm728jX22Na8j6xKm69qZl+VNj/LqtcHFjs0acM3Xq7XWpwAXA6Nxz5kQLgvYXpm1CfvvTKwpWEyoW1XTHWNMnVevxPoerLW+OGEbPzATQGtdCNyOy1rmsjmpMqCdun7T+grRzH/a3vj2HIH9cBHq6CmogTnYo6cSve5pVHYK/jMOhEgMPl4ExXmk3v8eG5eUYqsUGfV1VAVDlJOFiofIC1dSE88k7Ivz5uDdmLKmgSoGEokG8fvjWAVpjRGmfVHP6kGjeLNoJ7CWSDDA1Opy1vkj+OKWuH9zlrA0O4MXdhuHvyZMLBSAoB8VjVFQGyaqIIalOugns6KBVAtB4gQDEIjFGDfAz4jRaew+0k8cxcoKH8dn1jN8cJCZdX7G5sEeg1s2Uu02SLHoHD/LKmGXQkgL9vnPSCGERwLG7rfc+78TMD9h/iagERdQLobmDONAXBNukzhbamted1mBC5jyjTFblKO1HgY8jOt3+ZIxJuxlGHXrdXvJCuB+Y8xt7Sy/CRgM7GWMWZeQYZRPLtEj1PjBqPGDN9+fOpLA0xe3XOnwqSgg5cxDGZYwu9C7tXYSsHTC7XzQmMmc4tEc8/4yAl5zcGlWKtGA99atmvot+hlcUcPRX63ko5GDKMlKdRlFa8mvC1MR9DOuphYbCvD1ZfkolbqVRxtqrl97BqQrBqRv5e6F6Cf644W7JWDsZsaYjVrrJ4G7tNZn4gKcMd7iB4HrtdbzgQrcwI4FwMdJqGoTA8wF7tBaX2OMKdVaDwAOMcY8DmTiGrg2ARGt9d64PpJfJam+fwLu11rPAj7AZRd3AZQxxuD6WdYB5V5AfkuS6inENhn91cWMspaBWfexbFguw9dVoeKWmN+/uSkZWvxO7QGLVjK0Psy6nEzWZKcxoLaROZkpzPtlGpMGSxJdCLH1ZNBLzzgbN9r5HdwAkmdxAzAuwgVon+AGXQwGjm8abZwMXlbxBFwG7lOtdTWuuXm6t/wr4BrcMVQAlwGPJaOuXn1eBc4FbsP1s2waTJTprXI1Lmtbihsh/QGQtPMrxLZQShGwNYQzgqwemkNldirWp0irjxKIxNlQVEBlXjaRYICQP0w0vYFnJhbji8UZU1pDScjPuj8MYNLglGQfihA7lDiqxa0/kEEvQvQuecGJb6T0zZXM/MFbbMrJIqcy3JxZHNRQwoq8gawbPID0eB01yse84cMZWl1PeWoKP758BHtpySoK0YkeieZOPmN5i/f6xx8Y2eejRmmSFkKI7VjBjOEM3bCJncuXMi9/YvN8BRy5fBZ/GXI0R0xUhM7RHFQeY+8jB+Lz9/nPJiH6NNsPr8MoAWMfo7W+AriincVHGWNm9mZ9OqO1rmln0UxjzFG9Whkh+qjdK3/O/Nw/khZpoD6YirJxhtevI9NWU6/CTL1XXkpCiJ4lAWMfY4y5Ebgx2fXoKmNMZudrCSE64s9OAX+EnNIGJoSWkherIiUW5vPB+YwtLe18B0KIXiWjpIUQQiTFuFW/ZFHxn1mriliXlUdNHqRvijD07znJrpoQYgcgAaMQQvQBKUVZTI7+hlhdIyrgxxcK8Pzzzye7WkKINvTH35KWgFEIIfoQf7pcIkcI0fskYBRCCCGE6Eb95dqLiSRgFEKIPqiypIHn/zqIlVmZPHjf50wYHOC6uyYku1pCiH5KAkYhhOhj6moi3PTtj3hq0jjKUlPwx+N8XlHFtbE4Pr/8gJcQyRbrfwlG+WlAIYToS556ZgM//PFSFhbkUpbq+jPGfD4y6sJ863tfJLl2Qoj+SgJGIYToQ2b+bQWvFxWS39DYYv4By9Yzbck6GqojSaqZEKJJXKkWt/5AmqSFEKIPqFxby1EXr+SCucv49uvzUBbqIzC7eACjyqtYMaqAeZmpmDO+4tmnd012dYUQ/YwEjEIIsZ176/GV/O6JamYsWU9xaQ0+6+YfuXAtRSEf45asxm8tcaV4ffJonr13OSecMzKpdRZiRya/9CKEEKLX1C4p46Jz57AqfwDx3CxGlVdSkxKktCiPsrxMFowZzICScvzWRZA+a5mwoYwFt61mxhGFZBXLL3MKIbqHBIxCCLEdiK7cyLxj/kXxF4tIJ05pWi7nnXgur8zYD2UtO5dWsnpgOq/vOYFB8Tj+WIzhm8qoCQawgAL33+8nLT3Ajd/+iFG7pvLje/dL8pEJseOR6zBuR7TW+wMzjTFJeVS01sXAKmCUMWZ5MuoghOhFtQ1QVgPFBaAUbKiAgB/CEXjnC2pLaqkNhCjcWIJ940tUeTWqpp76qgZUY5RP8kaQXVtDZriB94ZO4KBVy0mrC1FOIT5/A2NjXzIVP2EyaSCHSCyHV8aPBuCn73/IwYuWMGvEcCIpIYJV1Xz3nQ8prKqmPhTk+T2mMnhNORn1YfLLVrNueB7pKsC7JenMmf4Bq/IzSYlFmVRSzpDBIdYWZNCYnUrOhAL2CdUzanQGw/cupKImxhdf17HzuHQG5ARYVREnL03RGLVE4zAoq+1xkhtqLUEf5Kf1vw9JIYTTZwNGIYToNbO+hqNugIpa+O4+sNsouPJRFzh6zcHpQAYuy5cYVqV7/1VujMnlawhYy7DFH7IsfRSVDAUU2bFGFKkABGkkTAbZ0Xqy6xs4YOkyrnnldQD2XrqKN8bUUJWfRWFVNQBp4Qj7frmICt/m5udgJMbsXYaysDCXEp+fvZev4zuzFlGTk0ZjY5T8ZbX8+bBpLCvLIRiNcdb9s9m74lMemDyGdyaPwvdmjD0zG5m1Ok5aAGJ1EYhZbjg2nUsOTWtxaq7/MM7V78cJ+OC+I3ycNkkuviFErJ+MjE7Ub1/ZWutgsusghOgnbn7GBYsAT34IVz/upr1gEWhugGrvY2KfNYsJeOunxKIUVVc3r51GXYv9+IkQjMe575GnmLR+Q/OycnKYsmQ1k79a3mLfUeWjqSYNqUHenzSC/+46hvlDCthYlEtuTQOxoJ/GDHfdxvlDC1lWmANAJODn6X0nkbGmkro0tzxuFbNWxwGoj0LE7wfg2v/VEY1tPubGqOXaD9x60Thc9X683VMohOjbOs0waq2XA/cAhwDTgGXAD4FJwPXAAOAJ4HxjTFRr/S/gUCAX12R7gzHmUW9f53jbTDXGbNRaDwTmAFcZY+7tpB47Af8E9gCWAv9qtfxtb18jgRnAjVrrh7267wGEgHnAL40xn2qtfUApcIwx5gOt9WhgCXC9MeZqb5/zgWuNMf/RWhcB/wAOAjYAt7YqPwBcAZwJ5AGzgV8YY77QWhcAG4Fhxpi1WusZwBvAOcaY+7xtS4HDjDEfa60t8FPgLGBn4EvgTGPMgk7O0XTgdeB07zwXAU8BPwP+AHwXqAIuMsY8nbDdt4CrgDHAOtxj9oi3rLi9c+gtvxY4APgI+JG3y78ZY67pqK7etm9752kU7jmzEfgx7jPzT8Bw7zydboyp9rYpwJ37w4FU4C3g58aYDd7yXwAXAEOBcuAR4DfGmJi3fKvObXeprq4mKytLpvva9IDszQ+iz0c8Ow1feS3fhG11P5NK0qmhjkxqyGIgTf0QFVFSiKOYumIje65cSV0wQHokCkBdIEilSkOlWtLjjZTmZLIyP5/02jApjTEqc1IpyUhtUVZ9ShCVENxmNrS8VmMwGsMCNSHve3arqLdp27x0RX1dTfP5aairIScljfIGt16hl3xM+uMl0zLdxeme0h9HSXc1w3gG8BNcIDQXeAY4GJgC7AIcD5zkrfseMBUXMF4H3K+1ngjgBYWvAY94GcBHgde6ECwGgBdwH+4DcYHP+W2sejZwB5Dj/fcBdwEjcMHTbOBprXXQGBPHBRuHetseBixuuq+1HgqMxwUs4AKPGC6IORAXGCa6BBeoHe2VNRN4TWudbYwp9c5bm2UBewFxwCTs70zgRKAQF3j/paNzlMAPTMc9LhOAI4FZwH+BAuAm4D6tdbp3nIcB9wK/BPJxj/WdWusDvf21ew4TyjwQWAkMwT0XrtBad7Wn/WnAzbjny7+Bh3BB44G44H88cKFXV+UdhwUme3Wqxj2PmqwGjgKygRNwz4kf0dKZbN253WaJb1Iy3YembznNNUXvPhru+ym+F66EfcbD1JFQkInFvYDdzQ1CSbzVB4LcOe1QlucUUBsIMXPYTnw6eAxj+JoxfEUWNZRQCDSgqCWNjcSJk0EtKTZCRqQRRYw8KqgNhEApKkIZrE3NZ/7QYtLrwqCgMdVPTFl2W7GRzMYwADm1DYxdWwYxS0ZFHb5IjJGbKjnsqxXk1DYwsLKOC16bTca5k5kcq6W4rIpJsTr+cEwKewz1cegYHwcUK/YeGeCJc7JanJ+c7Cye/ZafvQfDjOGKh4/2bx+Pl0zLdBenRdd1tQ/jP4wxXwForR/FZRj3NsbUArVepkgDj7QK/h7XWv8aF8DM9+ZdAHwCfAwEcQFGZ/bCBQ+XGGPqgUVa6z/gMn6JnjTGvOlN1+GCmJVNC7XWv8EFHzt59XkdOBkX2B6KC1x+r7XO8e7PNcaUesHjDGCsMaYSqNRa/xZ4NaHss4BbmjJVWuvrcIHKMcBjXlmHAg96/68C/uwFQYcCb3lBbJPbjDErvX3dDzzchfPU5EpjTB2w0ntsMowxL3r7ehD4m3cO5gK/AP5sjJnpbfuxl5k9HXjXq0NH5xBgoTHmbm96ltZ6Du758H4X6vofY8xH3r4fBi73jr3Mm/eCty9wWc49gEONMY3e8kuBEq11sTFmtTHmqYR9f6a1fgiXHf97wvxtObdiR5SfBU9c0nLeBzc1Tyrab4oGSAMuAmwkQvzdr5m8tJzH7/ia5WlZzFg+m8x4NYo4C3OGMLC2EaIhaskkg0ZcztFJIUxOvJZar79jOOBj9aBcMurrSW0ME0cRSUmhxCp+99CbrM1K4/OifL5/885MPWRIizr9PPHO9YcAcGyrel+8f6jTU3NAseLDH0p3eCESxXbgUdLrEqbrgJgxZlOreVleM++1uGxjEe7LdQau2RoAY0yd1voe4HbgbC+w6UwxsLHVusvaWG954h2tdaFXznRcBqspIGuqz+vAn7TWWbiM6S+A73jTh3rLm8oHWNFB+cMS5xlj4l5z/rCEsv6ltc4HxuGaiq/CZWkPxQWViRLPeS3Q1a9EbT02VQn1qtNak7C/UcDBWuuLE7bx4zKkXTmHrev6Tevb+rnV1rzEuqYAG7xjaNKAy/yu1lqfAlwMjMY9v0O4DGt7ZX6TugqxTVQwiP+QyeQdAhece8AWy8fGLas/30T5Fc8Sm7mO1cEBDK2ooSQjjeKachbkFBEKw6rifNLDEdYV5RHOTOfD3cbzZUEG+y1YQUEcPi/MY8qy9dzw+dEEgv22q7oQohd19zvJKbis2olAnjEmF5fFag61tdY744LKu4CbvL6BnVkDDGxqRvWMbGO91j2ubwIGA3sZY7LZHLwpAGPMQmA9rjl2vTFmLS6wOwyXlWoKGNd4/0d0UP6qxHle8DzSmw8uACvA9Z+baYyJePv/Ni6D+jrJsQLXTzM34ZZljDnaW97hOUxCXWuB/Fb1TfP6oQ7DZQtvAAYbY3KAvyaprkJ8YwGfYuSUgez24rnoqqvZv/SXfPnT/fjVt4+iPDWb3x49ne//+GSqBmWzflgBmwbk4UORHYmxc0U9d8/Yg2gsyhHzlvOTZd+WYFGIJImplrf+oLvfTbKBKLAJ8Gmtz8Zl0ADwAr4ngD8ZY36K65f4mNba38l+Z+GChVu01mla6zG4LFJX6lMHlGutM4Fb2ljndeDXuL6V4PosnorrzzcTwBizGngbuFVrna21HgRc3Wo/9wOXaq3Haa1DwJW4DNeL3j7qgQ/aKOuXuGB1YReOpyf8CbhIa32A1tqvtQ5prffQm1N4XTmHvcXgvoDc4Q1+QWs9QGt9src8E/ec3gREtNZ74/pICtFnHXvHwbx973h+e/B+XPfKu/zo/Y+b+0bGEy7dkRqN0xAKEGgIc/ZT+yStvkKI/qm7A8YHcKNlF+OychPxgi7PX3EjYX/r3f85Lut2bUc7NcZEcX0dd/W2f5ot+y+25WrcIJlS3OjeD3ADVxK9jguKmoK4z3FNnB94QV6TH+CaQ1d5x/Rgq/3chmtWfhU3inoGcLgxpiphndZlvY27TFuysosYY14FzsXVvwTXXPtHXPAFXTuHvcLr43kCLmP4qda6GvdlYrq3/CvgGuBZoAK4jC2b+oXoc3wBP/9+cT9uPmYGY9ZVEwhHXX+funoslpiC94YXMmpTBfnpPoZNykl2lYXYocWVanHrD5RNuNSCEKLHyQtObJNb9niFcUtKWT1qANVZacSjMawvTnl6KnNHDuGNf4zofCdCiCY9Es3td8H6Fu/17/+tqM9HjdLBRQgh+pBfvHcI88YPYV0oRHZ5NbkN9eTVNZIejXFkY0myqyeEwP3SS+KtP9huroWgtX4JdwHoLRhjMtuavyPSWte0s2imMeaoXq1MJ7TWV+AuZt6WoxIu5SOE6KLUtADXfDSdXxz+EXUqQjBuiSsf5ekp3PDAHsmunhCin5ImaSF6l7zgRLf51ZHvU5mWSVZtA1f+fQKFo7I730gIkahH0n/6JxtavNebuwb1+TTjdpNhFEII8c1M/2kZUMZxxx2X7KoIIfo5CRiFEEIIIbpRf+m3mEgCRiGE6GMql1XxyPEvU69SSNsZkASjEKKHScAohBB9yJwnl7L2J//jqNoNpEfrWVE2gDt2tVw471vJrpoQwhPtfwlGuayOEEL0JY/fvJA9N60mqy6OP5zChDVrmVi9hnsu/izZVRNC9GMSMAohRB9x7+1LOGjDUmDzr6mGSSO/qpKif8yjoqoxeZUTQjSLolrc+gMJGIUQoo9Y82/D/uvmsiktq3newqLBLAmNJKs2zLP7vpjE2gkh+jMJGIUQog+48vpFnDf3fRanDWOZbwjLQ4NYmlLEC+P2xOKnpCCDnLUVya6mEAKIqJa3/kACRiGE6APscytQvggNDZkEG+KU2hxy4uu47IO7OKDsHUIqTDQ1jdqv5ecBhRDdT0ZJCyHEdqyuqoGzvjeH7PQM5ofGEq/PwY8lL1bKeBYAkEUt00s+oJJi1u68gsCj32bUKeOTXHMhdlwRuQ6j2JFprYuBVcAoY8zyHi7rVOAGY8zInizHK+seIGCMObOnyxKitUgsjk/BZa+H+WJ1lDlf1FKZmY6KRxhYWc1uS9Zx6cxPSYnGeHnkOHR1KTVZQeKxNGzN5t818xMjQIx0GlE/uJcHfjuGokgl+//pCNIOnYAvLZTU4xRC9G0SMAoAtNYWOMAY814PlzMdeN0Y0+PPPa31tcD+xphDe7os0b9d9EaUl5ZaRmQr9hyqiMRhVLZiWaXF74OyBssTX0NFI1hrsYC1QNz7OdmY3fwr4n4FsTjEYpASxG/jxFDg85NfF6V8UB5WKYiGWJ6WwT8efpX8+gYAjlqyhNnDisGvKCeVl9IPY0hFA4F4nHBKnCG1NSgsleRjCbAoZSc49y322XAXETJJoZwUqoEgFh+KBvxY4lh8bA4+497/5j5LORmow6eAT7ljOnI3OPVAuOtlKK2G8w6H4kL48Gt49mOYNhZO3KfnHxghtlORZFegB0jAKIQQHfj5q1HunAeg+LrC8uoqvODPbrmy8v5Yb9qvXOQY8dYN+VzQFfCB9YNSxJrCMmupTAthfd42KFDgaw7fIBL0u30Clf4A+26qxW/dvlOjcTJZQzoVNKaMJq1yNDmRBuoYxII0P8PrS4iQQYDlpFBDhBwC1KHYsjO7v9V9KmuxT3yw+eIgT3wA/3wNZi109x+dCU9dAtOvgnDUzXv8Yjhp/y6fZyHE9k0GvexgtNYXaq2Xaa2rtdZrtNY3aq3neotf1VrXeE20aK2LtNbPaa0rtdYLgSO7WEaK1vofWuuNWusqrfUirfX3tNZDgJcAv1dOjdb6DG+bPbXWxpv3HjC6i2WN1Fq/orWu0FqXa61na63Ha61PAq4ApieUNdrb5myt9RKvbg8Bqd/kHG6L6upqme5j0zPXsNnW9EtKjCs72Tzm97kyvHImbVjFbtWzqQspakIBrj14H9ZkppNV08BfD5jaHCxu3r3FR5yBkbWEIrHm+RWhzOY1wmS4WJbGb3R1uC3Wnb968/TSDTS8PHtzsAjwwdfA9vM4yrRMtzXdU+qUanHrD5S1bXxLFv2S1nocMAeYZoz5UmudC+xsjJnVVpO01voNoAo4E0gDngT2o5M+jFrrHwMXAIcaY0q11sOALGPM/LaapLXWOcBS4DbgdmAK8DzQ0FkfRq31o0At8DMgCkwC1htjNrbVJK21PgB4FTgeeAv4AXAv8Egv9WGUF1wfc8uHMS57L+6COGtd5GSV+9d65abPBZs4bSEcd/MCXnYRXDO1wmUcm96HEz5YfHVhvvfFJzz+xF8BaPAHOOjES1iSV8TNr3zAj79/GLe8/C7fmvcV4YCfNYXZHLr+ZXzEieHjvwNOxOclJ4vqyxhVtxGLpZCFBAgTIZcgFV0OGhMPCYDjp8Fzn7jpaWNdRlFfCuU14PfBS7+Bw6Z2ce9CJE2PRHO5vyht8fZQ8eeCPh81SpP0jiWKe3FM0lqvMMZUALPaWlFrPRSYAYw1xlQClVrr3+KCrc6EgUxgotb6Q2PMqk7WPxYX9N1ijLHAJ1rre4EfdrGsImC0MeYrYF4n658OPGmMec27/6DW+rwulCN2UP+3j5+hWfDU15ax+Qpd5KMqAjvlwqJyyApBeUOch7+ErytcH8Z4HOojlnDMYptCS5+CqEVFI6h4nHgw4AWeMVKjYZRSNKSkEFcKGmLQYDlh5hrqSSeNOlJiMYbX1hBOr+Wo1bM57aMhfDplIovHjyXq9xGMRjnoyTcJ0kgdAxhZu47PBw5lXMVyJtYtIUoqIcqIKIu1IRR1RAgQIEojfvyuJyU+IIYPiyLozWPf8aijd3cnJBKD6ZPd7flPoKQKvrcvZKbBp7fB6/Ngt1GgxybpERMi+er7fHi4JQkYdyDGmKVa6x/isn/3aK3nAdcZY9oKAou9/ysS5i3rYlEPA4OAPwI7eZnKS40xi9tZvxhY4QWL37SsS4CrgOe11hm4LOjlxpiaDsoyreZ1tSyxgzp1sp9TJ285f/rwpikfF+y2LSWkEo3FWVke49aHNjHkxQ8YU7qCL8buzKCqfRlav558W82mtAwuef918qJV3PnO41x64o+pT3U9KlLCUT5Onc5OEcPG1HzC8UYOOSLIsLv/r9PS01rd36IPY3uOm9by/qhBcO5hXd1aCNGHSMC4gzHGPA08rbUOAecDz2qtC9iyda2p59YIYIk3PbKLZUSBW4BbvGbvO4H7gAMhoQd/y7JGaK1VQtDY1bI2ARcCF3p9FJ8FLgWu7qCs1vseCbQXzArRKwJ+H6MLfdx90RC46Lstlv3q4NcZZBv4zQdvs99a9/0mQJzvv/8+z+ztRiNP//Rz/nvIrlzw8jImbboWf1qw149BCOGE+8nvRyeSgHEHorUeD4wC3gXqgUpcoBgH1gM7Ae8BGGNWa63fBm7VWp+FS0Jc3cVyZnj7nueVUws09cBfjxv0MsoY05TZewG4A7hEa/1HYBfgHKCxC2WdBHwMLPfK5HhzKgAAMuhJREFUDLcqa7jWOmSMCXvzHgJe1lrfD7wDnAzshQSMYjv2h7cOpfinq3n545Y9LnZev5qf//dlACpS0ohFxzFk/dUSLAohup2Mkt6xhHBB3zqgApeZO9EY0wBcCVznjTT+u7f+D4AU3MW6ZwIPdrGcQbjArNwrawTwYwBjzELgb8DH3sjm07y+lMcAJ3nb3OGt0xW74QK/GuBLYDZu8AzAE17d13tljTLGvAP8HLgHKMON/P53F8sSImlu262O+ybuQZ3fXYC7zh8iih+wxJRiQVER/poa0gtbNzALIXqdanXrB2SUtBC9S15wYqv9bef/0JCezeh1a5myaRWZMZc4t8DVR32HzGCE257dO7mVFKJv6ZFwTl1U1uK93v4xv8+HjZJhFEKIPmLGLdNYO3ggb+++Gyq2+e07jiIYiXHjk3smsXZCiGZN11NNuK5qXyd9GMVW0Vp/iWtqbm2FMWZSN5YzHJjfzuKHjTHnd1dZQmzvxp8wirI71+EjyJepQ5ncsAo/cd4s2okjjs8jGJQcgBCiZ0iTtBC9S15wYpvMf2M9v7q3ksaaMNOWbKQiLcT6MVk8+++pya6aEH1RzzRJX1zeskn69rw+n2aUr6NCCNGHTDykiOfuH8OFR6RQMi2V8WfWS7AohOhx0iQthBB9TDAU4Fs/HYf/+a+TXRUhRFv6Sb/FRJJhFEIIIYQQHZIMoxBC9BHLFlZy06+WkhWLkRaJkrFfBpP3qE12tYQQrfW/BKMEjEII0RdU1ce49eIFLC0oZENqCuMrqpn0vmXh21E4Ltm1E0L0d9IkLYQQfcD/nTyb2UOG8sbQQXyRn8NbRYWsyMqiMjWPZ856P9nVE0K00P9+6kUyjEIIsZ2rb4yQW1vHpDXr+Sw7gwtmzWPSxjKsgrRwhPqvYjw+cBknrf8hytc/PpyEENsXyTAKIcR27iffmcugmghRn4//M18wIh6jLicDZaE+FKIuJZXGtBReLPgXqx5bmOzqCiH6X4JRAkYhhNie3f9SJcW19SzNzSKoFHnhCADxYIBIShAUxH0KpRQWxdozXmKZupxIWX2Say6E6E+kSVoIIbZjNz1XQ9GwwVRkZTF5U+kWy61PEYjE2JCTxfwheSh/nGPmx4kW3E7eOeMovOd7Sai1EDu4fpJVTCQBoxBCbKcyrijHFmazZGgBqdE4CktufQMDauuIBINk+PyEGsJElGJFViZ1eZYbn34NBVgVpeHez1j/wHsURf6c7EMRQvRxEjDuYLTWdwNRY8zPkl2XjmitFwM3GGPu7+FyioFVwChjzPKeLEuISCxOwKdojMYhHgeleG9VnKe+sny0Ns7a0hglUR+xgI+iqjrCqSlMKatlQF0Fy3MyWJmdjh0+lIxYjPHl1ey+7GsyoxFCsTivjx/Bzf97ujmxoWwAiDAwupqY+i4xfDSSBgQIE0Dlp6NG5hGYMpzU70whkBlETRkBgM1IhWDA7UspsLZf/nKFED2n/71eJGDcwRhjzk9m+Vrrt4HXjTE39EJZFjjAGPNeT5clxL3zYpz/apxYHE6ZqHh/Layo8hZaC7bVBgrcTNcrPr8+SmY4Tiw3FYD1eVmkRmNkR6KMqK4ntz7MZ7nZhH0+UsIRRq7fSOXAbLLXlQEwfdECatN8UN60+xgpVHsd1X34iROiGoAIaZSWFZBStoHM2XPgX8/RVBuAWnIJUU+QxubqxgjiI9Lch98qRcSXyob8qeT/6ztkHDOm+06mEGK7I4Ne+gmttdJayxcAIZLk56/HicZd0PXofLs5WGyLwmXsEm5l6SmszE3fvI5P0RAK8PaoAVSkBCkPBl2gBuy/ag0Z8RipCkoH5lBct4arPn6IDEoIBjaRQQmZbKCeAZQxAosfCNL0lh+kniBRMqjYYjCnAjKpIERji3kBIsQJJmQwLaFYPfmb5rP+9P9145kUoh/oh6OkJcDYClrr5cA9wCHANGAZ8ENgEnA9MAB4AjjfGBPVWv8LOBTIxTV/3mCMedTb1zneNlONMRu11gOBOcBVxph7O6mHBX4JnOaVfbDWOgO4ERgHRIE3gAuNMRu9be7HNUn/SGutgBuAs4AsoBT4gzHmL966k4E/ALsD9cAjwNXGmEgn9ToUuA0YA4SBOcaYQ7XWdwIHAPtorS8D1hhjxmutg8AtwKlAHPhjR/tvVdaFwEVAIVAFPGCMuUJrPddb5VWtdRx43DvmIuAfwEHABuDWrpbVHaqrq8nKypLpfjjdOoHYoXaad4PRGJGAv8U8qxT1QT+hSIw6LBv8Pv46YSwz1mzgkHUbiQb8RNLqAJi2dhkA6xlBlIEA1JFHiAYyKafpkyuOD1D4iLVZD0vbn3FtHaMCiMaTfv5lWqa3Zlp0nWQYt94ZwE+APGAu8AxwMDAF2AU4HjjJW/c9YCouYLwOuF9rPRHACwpfAx7xAqdHgdc6CxYTnOOVkwl8BjQCP8MFrbsAQ4D2erwf5h3HXsaYLGBPr654ges7wNPAUGAfb/3Lu1CnB4E7gBxv2xu8Y/0ZMBO43hiTaYwZ761/GXAssC8wChgJjOisEK31OOBm4Fiv/pOA57yypnirHe6V9SPv/iNADBgOHAic2YXj6TaJb1Iy3b+m/zjDR9M1s78zTjE0k/ZZu/m/d8tqCLPHmnJSGqO4VKVbJ7s+zJz8TEoyQtRjsV6w+ebQQTRYy8B1ZZTER/FKwaFU+TOJ4mcDRS2Ki+PHYoniJ0o6dQyingwqKWoOAm3CrZZcogSa7wPECOAn0mL9CEFK08cy8J4jk37+ZVqmt2a65/S/FKNkGLfeP4wxXwForR/FZRj3NsbUArVeXz0NPNIq+Htca/1rYDow35t3AfAJ8DGu3ej4b1CP3xtjlnjTMbyAz7Nea30rcF8724aBVGCS1nqTl4Xc6C07HZhrjPm7d3+N1vomXCbwuk7qFMZlFwcZY9YDb3ey/unAzcaYxQDe+Tmnk23AZVCVV/8VxpgKYFZ7K2uthwIzgLHGmEqgUmv9W+DVLpQlRIfOn+rn/Kl+rLUoL6izdnNOLhq31EfipIf8lNTEqAxbfHF44EvFzKVhviq3LMwKkVYfpjE1REZjlF031ZDXEKU+EuaIjxdy394TqMxxkWgwGiOrqoaG1AANKX7ilX5mZe1NQUUdcYJY6lFYoiiq0sM8tdP+VMUz+d7nHxMiij9QSWCQonrsVKJH7UEwLUTG0AzUToNJC4XwDc1HRaOQnY6trMOfl+kyo95gHQUElWJYMk62EKLXScC49dYlTNcBMWPMplbzsrTWPuBaXBawCPfFPAOXAQTAGFOntb4HuB042xhT9w3qsTzxjtZ6D1yT9BQgnaYuSW0wxryttb4C+A3wH631LOAKY4zBZfr201pXJGyiAP+We9rCCcAVwOda60244PpPHaxfnHgcxpharfXG9ldvXm+p1vqHuID7Hq31POA6Y0x7AWCx939FwrxlnZUjxDehEpqbE6eDfkXQ7xp1irIDzTnAGwYCBze9FWe02NeEc8soSw1y5wPvEorGKF5fyQ3H7UmD38e35i8jJe4C0syaMOn1UepUBv5QgJxwPfX4aCSFSEqY3Wv/zlnNez2z02No/SJX+QkZGZ80TAnRqf6RVGxBXvk97xTgR8CJQJ4xJhfXhN38dNJa74wLKu8CbvL62XVVvNX9x4HZwDhjTLZXfruMMf8wxuyPC2bn4JqgwQVVrxtjchNuOcaYjhramvY51xhzEjAQOM87phnt1BdgDa4ZGgCvH+aANtZrq6ynjTGH4fow/gd4VmvdNHKgdZerNd7/xObukQixnfrqn8MZvL6cUDQGwLCKGm597gMu+uJrRkcampuzM2qauhUr6lKDhAjTEIqSdcJAdm/oSi8SIYTomGQYe142rul0E+DTWp+Jy/69AOAFN08AfzLGXKO1TgEe01ofaoyJbWV5lUC11no4rn9gm7TWewIpuKbwRqAamnvBPwj8Smt9Nq5fZRgXXI0zxrzcwT5DuCD1RWNMida6HBckNu13PTC21WYPAZd4zfhrcQNROv0yo7Uej8uEvosblFOJCxKbgtL1wE54zfTGmNVeGbdqrc8C0oCrOytHiGQ68ugBlL+aRl51PXGgPD8dC0RTgjQEA5RkZzFo/ZLm9QNEqfSH2GftrwgUZLS7XyFED5IMo9gKDwAfAYtxGa6JuIEfTf6K6zf4W+/+z4ECXMZxa/wYl9GsxmULn+hg3UzcgJgS3Ajpw/EG6nh9Dw8GvoVrLi7HDewZ3YU6nAQs0FrX4AahXGOMecdb9kdAa60rtNZfevNuAl7B9T9cBqykZbNxe0K4gG8dUAFcCJxojGnwll8JXKe1LtdaN/XF/AEuSF6Fexwe7EI5QiTN/509gAcOmshfjtb87NwjWDkkl7qMdBrS0whnpBGKQ151Hf5YjLRIPbvcMJkDoj+VYFEI0a1UYqdsIUSPkxec+Mai0RijLiljTUE2e67eyPGLVjUvqwj42W3uYtIrGjmh4ewk1lKIPqlHcoHq8poW7/X2psw+n3OUDKMQQmznAgE/o0srSa9rJK8uTCxhMM2Y0k0MPi5fgkUhRI+SPozbMa31S7gLXW+hK4NPeoo3Mvnv7Sw+zxjzSDeWdTfugt5tmWiMWdldZQmxPXvtn6PY58L1rMrO4rNojNEVVaREIhRXlDH9n6cnu3pCiER9Pp+4JWmSFqJ3yQtObLVHXynjD0/X0xgIEFGKIwJfc9ghFRx33HHJrpoQfVXPNElf0apJ+sa+3yQtGUYhhOgjfnBEPj84YvP955//KHmVEUK0r52f/+zLpA+jEEIIIYTokASMQgjRx5S8uZSPDn+SxgUNna8shBDdQJqkhRCiD5mZ81dWDiuiJphBxj2NpKzbCFXJrpUQor+TDKMQQvQhawYV4mv0MW7RGkI19dRnZfBi9n3JrpYQIpFqdesHJMMohBB9RKQuQsznZ9jKTSwaUoj1OtbXB/xJrpkQor+TgFEIIfqIWUPuYtdKqEkNNgeLADagiMfi+PzSaCTE9qGfpBUTyLuLEEL0EVkNYRSQ21BHXl0tAL54nKHllbxV3N619IUQYttJhlEIIfqANbe8S2V2GgWbolj8jCwtI6suTEa4gYy6GPOLByS7ikKIJv0vwSgZRiGE2N5Za/ns7i/Yt8QwWC2hKi3KsuwBVIXSWZeZT0VqOiVp6bx9k2neZmVZhJrGeBJrLYToTyTD2E9orZcDvzHGPKy1HgksA4YZY1YntWJCiK0WjcTYdPe7xC9/kmNqqwBLHuvYlLEHKIUvGscXs9QHAgyuruCx1ws5e+0G/HFIj0ZZmprCxLINVOVn8fylAxg7NC3ZhyTEjqEfZhglYBRCiO4wdznc/yYrdppA6ZSJ7Dw1k/RIA1VXPsGqBSUMjVSTO38lq7ILWDJhAkN9jRS/NgtfYxiFDx9RGlQq1ir8KkDMH0FZKCkcztjaClYzjDgKq6DRl4o/Eie1KooCwsEATx8wjaLGUm6Y+QxZDWVceMJZhOJ+TH4R8aCf8Q8obCCMaowRt0Cg6RNNARbiFgJ+dzcahzig3LyMFMhJUVgUewyC4vQ4766Is6ZWEVM+hmQrijMBH1y8h48B6YpllZYjRirSAvDCUktuChwyYnOjVkPU8sISS2EaTB/uY1G5xay3jMiGFVWwxyDFuPx++KkrRB8lAaPoNlrroDEm0tk8Ifqd9+bDgVdhinfl4Wl7Yt9cw6DBQX752O1kl1YwicbmVYtLKxm2bCmWAHGCWOIECAOQYWsIU8iK/HzGla7ktZ32ZvKG+XzBHtSSQyHlpNpGshpqaYylNCcxQpEYo9aXs2T0EJ7NG8LJs1/i5pcf5eSTfwblDeBXxOuikBXCpgZccKiUd404BdZCOA6BhF5K4TgE3EdEbSPURgEFLywDGuJgcfshxsJGHwsr3LZvrtzcDL5zPhSlw9teO8e1+8I1+/qIW8vhT8aY6c3/+W6Wez+31EWbw1dSA/DuSX6mDZagUfRF/e95KwFjH6K1/gVwATAUKAcewTVDx7ZhnwOAm4HDgFxgMXCKMeZrrXUB8EfgcG/1V4CLjDFl3rbLgfuAg4FpwI+01ucDc4CRwAzgRm//7ZW/HLgHOMTbxzLgh8Ak4HpgAPAEcL4xJuptMxy4Hdgf99nyPPArY0y1t/xG4GRgILAB+Isx5k/espFeGacDlwPDgA+BM4wx677Z2RPC88i7YC2fFU/GKhc4bVgXYT1ZjKasxaqb83p+IoRIpb7FMh9hqtOzoBQyIjUMqCpjPvkMYiPj+RoFDK5aw2eBCdSQA0DMpyjLzWjez+eDd2K/Be9AWYPbacxCLAZVjZCXllAJtfl/KCFY9Pug9aUdbULlAz5I7B8ZjUNwyy7xC8rcrcnjC+Jcs6+PNdU0B4sA//naBYtNxQA0ROHZJXGmDZZrTAqxPZBBL33LauAoIBs4ATgb+NHW7kxr7QOewwWK07z/ZwLV3iqPAHnABO9WCDzUajfnAhcDWcCz3ryzgTuAHO9/Z84AfuKVNRd4BheETgF2AY4HTvLqnAq8CcwHRgETgWLgzwn7m48LJrO8+t2ktT6iVZknAQfigu8M4Lou1HObVVdXy3R/nN5nPADFFZu/c6SkQGF9Je1nGix+4sQS3oYtECfA+qxCALIbagkQJYMq8ihr3lMKjeRG68FvqShIY92oXIorylBxF8TttHE51+997JZFxixE4i6jCJv/Ny1LnE5cRqvDaL3M1/YxZoegOGNzYLlLvosKB6bD0IT5E/ISv/Nu3veErM2/lb3dPNYy3a+me0w//KUXZVu/8EWfobX+PTDcGPP9rRn0orXeE3gfKDTGVLZaNgRYA4wzxizy5o0HFgBDjDHrmjKMxpjrErZ7G1hqjDm7i8ewHPirMeY27/7RwIvAQGPMJm/ef4A1xpiLtNbfBW4xxoxJ2McewAdAelvZVq31k16dLk04N3saYz7xlv8U+JExZreu1HkbyQuuv7r9WeIPvsu7E/an5KBp7HV4AcPWraTqrH/SWFJFVkMNKfWNrMvI5cuhIxlXtoFhJRsJk44igp8olgCNKkBZRi6fD5tAXl0lA2o3kF0eptQ/iHHh5YB7ElWSyQvjDqQ6K7O5Cp8PHMBHxQUsyUijNpCyuW4KF+QF/ZAS2JxBjFkX7FkL9VHXDhz0QdTr0+hXbrkC/AqFIisEmTbGhlpLzLplKugjLagI+uCknWF8vmJZJZw12Ud+Kvx5dpzcFMUl0xTpQffpuaTC8pfZcQrTFL+epnhuseXd1Zb8VJcY3Xeo4gcTJKchelyPhHPqmvoW7/X2t2l9PmyUJuk+RGt9Ci6bNxr32IWAWduwy5HAxtbBomeY939ZwrwlCcuaUinL29i2rXkdSWwKrgNiTcFiwrwsb3oUMFxrXdFqHxYoAtZorS/EZRaLcW8GacCjHZRZm7B/IbbOxSfgu/gEpifOGz2e7IW/b7HaEO/WJLXVboJAJjAciL42l6+//RjP7DqDXRavpCxcS4AItWSTTjXBWLTFtsfP/JK6g6ayZkwGtV6gF/Ar4taiLPxgUpxzNUwbHSS1jSbkrvtmHx1/PHjLZuUxuYo/zdg8//s7K76/8zZUSQjRoyRg7CO01sOAh4HvAC8ZY8JehlFvw26XAwO11tnGmKpWy1Z5/0fi+jWCC1QTl4EbS9laT178bQWw0Bgzqa2FWuv9gFtwfSI/MsbEvAxjn/92J3Y8gcOmMKlmCjvXRfgo924qKWxeVudLYcTKShr9KYRDAfIrq9k00HLMhUNIeaeKz2pSGDUsyFO/lgt6CyG2nQSMfYd30Qo2ARGt9d7AacBX27BPA8wG7tFa/wwoASYDJcaYtVrrV4E/aK3PwAVcf8AFq8kcHPIC8Dut9RXAX4AaXMJmT2PMM7j+nTHcebJa62Nw/T6fSFJ9hdhm/vQgDbsOIDp7DQFrWVg8mHljR+CLW3adv5JBJZUsHJ7JWUtOB+CUwwuSXGMhdnD9MEUhHUT6CGPMV8A1uIElFcBlwGPbuM84cBxQjxvZXIEb9dzUKepU3ACYr3F9Fytwo4uTxhhThxt9PdGrUyXwBjDVW+UV4EHgY1wA/F3cIBoh+rQZ5mTmFQ3h07EjmTd2BChF3O/j67GDqU0JEIvLr7oIIXqODHoRonfJC05stf8OepA1AwqoLszG+tz3/VBDmKySVZz95akEtqlfohA7pJ4Z9PLbhpaDXq5J7fM5R3l3EUKIPmL6+8eTVd1AwfpyAuEIwYYw2WVVZNSmSLAohOhR0oexn9NavwQc0NYyY0xmW/O7ufy7cU3bbZlojFnZ03UQor/IHZvLwLIqqlNTyaiuJxCJU5sVoD4gwaIQomdJk7QQvUtecGKbvJd+KzW+gVjrozY9QNSn+O5X3yKQn5bsqgnRF0mTdBfJ11IhhOhD9q+7lGGZJaQ11DCotpSMezIlWBRie9MPf+lFmqSFEKKPmbT+1wA8//zzSa6JEGJHIQGjEEIIIUS36idpxQTSJC2EEH3QLd+aRdn5jYTPrOLpvSXTKIToWTLoRYjeJS84sU2uumkpda9uQOVk4AOCDRF2+2gh9Tlw2vJTkl09Ifqanhn0cl1jy0EvV6f0+ZSjZBiFEKKPOP+4t2l8dT7WCxYBIqlBGkdFSasP88ZlnyS1fkIITz8c9CIBoxBC9AFHnrqYkC+XhSMmYVt9AO2/ZDZjwyuoePBLpNVICNETZNCLEEJsx77zp1I+WQGZOVn4UkJkRGNkNIQJxKKkxhrYb8nHBKuyGAAMqFjJm4Pu5pCNFyS72kKIfkYyjEIIsZ16c3Ejny+KMbamntxojBJ/gLfzsqlrbGTQ+hJyNtVQ15iNTfjun1PbQGNtOIm1FkL0RxIwCiHEdurWixaQbePMysngo6x05qSnUAXcM3EsJWkpANQ3ZBJNeCuvDYa4b/dnKV1Vm6RaCyGkD6MQQoge99nKRoZfuI7o4HzKgn4afD588Xjz505jIMCivBwAovEAS9Rg1qp8lqlBxGtC7Ld0BWsm/o7FM1cn7yCEEP2K9GEU2yWt9T1AwBhzZi+UtRi4wRhzf0+XJURbquqjPD6zhtteLCe13kdlajr7bKoiJxKhPh+Wp4SI+xT+uDegxVomriwlo7oBG7BEVJAygljAKljDQMY0VvHZuY/xcupADl84h5TidFLuPI2iw8aD6icpDyFEr5GAUfQqrfW1wP7GmEN7oay3gdeNMTf0dFmi/6lqtPzyrThLKyw/maqYXwpvrrIcNsJHegCeXRJnn8GKGw/w4VPw2w/i/HexpToMUwcqilLiPDmrnsyGCLnVDcweXoivIQ7VDeRFYuQB6zJSaAj4OXjRQq599SVuS83hmcn7EstvZHhNHQAHrSthcVY6G0MhIoE4wZjlnE8XMmFdOXGl2FCYQcUAReHaalLro83BYHa0nOnLlrEifzi1mfnMDgxj/+/cQbx2A2HSiZBJkAh+avCpKLXBdN4cNYUZK+cS8WdS7h/IsPAyUooz4Z0bYG0Z8XPuJra6mi923ZvLT/0uU8akceMBPvw+CUCF6O8kYBRCiDZcPjPOv75wGb2ZayxNyb2Zq+PN68xcbRmZY8kKwW8/3Hw5m6WVlmA0TiQznY2ZkJGVDlYRr2rAF40zPBJlbmE2caUoqqjhvDfnsy4wCqJAQIFqeWmcnHicGr+iPphCOMXH//baiYLqGp7efSdSozFOWLCMhvQgA9ZUk1PeQGa8lkK7EV84Str6aiz1jN1UToAIPiyp1OIjiCJKkDBYyA7XsPv65RCHgvr1pFNPLYWkLFoGR1+PXVOGb1MVPmDyW69yWF02v/7u8YzMsVwwVQJGIVroh1l8CRj7EK31cuAe4BBgGrAM+CEwCbgeGAA8AZxvjIlqrYcDtwP7435h5HngV8aYam9/NwInAwOBDcBfjDF/8paN9PZ/OnA5MAz4EDjDGLOuk3qOBP4O7OWVuww4BZgKXAH4tNY13uq7GmOWaq3PBq70juFZXDfhaBfOyaHAbcAYIAzMMcYcqrW+EzgA2EdrfRmwxhgzXmsdBG4BTgXiwB87K6M7VVdXk5WVJdN9YHpN0zMUmoPFtiwtbaQwM2WL+RH/5i7ijQG/e7bF3XjmmFLEvQ+U0SUVJHYnH1JawX16d076fDmZkShf52ayNC2VMZEwFcTIqmpk6cAcbj94d+pCQQDqggHOm7OA9SNzKa5ZREZdI34iWAItRlDHCSXUUKGIkyg12kB1SibZjTX4iRD3to1vrESVVDev5yPKkMoqAFZX2206zzIt08mcFl0ng176njOAnwB5wFzgGeBgYAqwC3A8cJLWOhV4E5gPjAImAsXAnxP2NR8XTGYB5wI3aa2PaFXeScCBwFAgA7iuC3W8EVgJDAIKgTOBcmPMv71lbxtjMr3bUq31AcBfgfOBfOA1r9yueBC4A8jx6ngDgDHmZ8BM4HqvnPHe+pcBxwL74s7LSGBEF8vaZolvUjK9fU9ftIePDBePMb0YRmS76ZHZMC7PTQ/JhAv2SOW0Sap5Obg31nxiAChrmbiuzM1MCxFWChuHwvpGABYOzKMu6Afct6vsyno2ZqXx173H8+d9JvD0+GHEInGW+ILEq8Oc9+Kn/Pz5T5qDRYDyVC9gVYqs1FrGsooImcSJ46eheb3KtCAx/NSTS4Q0omQS9z4G4ig+G7IrRdUbsShqKSSDjVjAd93JcMm3mutY6R/EXQfty5BMOGcXX9IeI5mW6W2d7jH9cJS0ZBj7nn8YY74C0Fo/issw7m2MqQVqvX57GmgElDHmam+7eq31VcAHWutzjTExY8zDCft9U2v9Ii57+UrC/N8aY0oSyvtRF+oYBoqA0V5d53Wy/unAk8aY17z7D2qtz+tCOU1ljQEGGWPWA293oaybjTGLAbTWvwbO6WJZYgdy0DDFih/72VAL4/OhMQZLK2B0LvgULC6HkTmQGXKfBvPP8rO0AmLWUpimGJoV4J8fhakrD6NPyOPJJbCo3E/tRgXrw9Q2KpSN05CquPvQ3dl59UY+GTWEL0YVgbXEfT7qggrKGyDkp6iihpqUIP88YBdue/JdPi8q4K2dh6OsZcZyNxo6q6GOIVUlAKzKGkF64zoWDigmHMphU0YmuyxbwMassVRm5LF+QA67blxKZkMqNhSgdNwwxh82Av9ul1KSPZCK3GzGrFuGmjAMRg5EAfacGcRWV5M2sZi/+TNaHL8Qon+TgLHvSWwOrgNixphNreZl4bJnw7XWFa22t7hgbo3W+kJcZrEY9x0oDXi0g/JqvX135hLgKuB5rXUG8CRwuTGmpp31iwHTat6yLpQDcAKumftzrfUmXED9pw7WLwaWN90xxtRqrTd2sSyxgylIUxSkuel0H0wesHlZ4jRAelB58zYHUOfuFQKvGXi/cU1z03ANBC1Kwn3vgfLqCLtcWcKG9DRSI3Fq4nDVG4ZjP19KQ8DPnTN2xwLXPTWTpQNzSW+MQJolnBLi4DVzSI1GAIhHAzw35UDO+/j0Lh3r8ITpQu/G1PwW66hxQwmMcx8ck7u0VyFEfyEBY/+1AlhojJnU1kKt9X64vnyHAB8ZY2Ja6yfphuS5F8BeCFyotR6N65N4KXA1tOo05azBNQ0nGgks7kJZc3FN8ArXvP6q1nqeMebNrpTlBbQD2lhPiKTIywqy+o7BPPteFTffV0Z2RR3Hfr4UgNRojDM+/JKalBR8wNiNFVhgbUoWgUbLZzk7Mbi+hK+GFDA9o6TLwaIQQnRGAsb+6wXgd1rrK4C/ADXAEGBPY8wzQDYQAzYBVmt9DHAUbtDMNtFanwR8jMvkVeKajWPe4vW4zGfIGNP0+2UPAS9rre8H3sENxNmLTgJGrXUIN5jmRWNMida6HBckJpY1ttVmDwGXeE33a4Fbkb68Yjt0wv7Z/O+VTaStKCfi8xGMu+8/KwtzuHf/XTn7rTnss3oxQ1hFVl0e89MnQq2f90dP5sBxpQx55tIkH4EQO7B+2FNDPij7KWNMHTADN9hlAS5wewM3UhlcP8UHcYFdCfBd3ACa7rAbLvCrAb4EZuNGMoMLSFcB67XWFVrrUcaYd4Cf40aAlwFHAv/uYlknAQu8UdfPAdd4+wM3Alp75XzpzbsJd+yzcM3eK3HZWCG2O3dfN5r3Rw/hj0ftxZdDCnh/7FB+c4jm0/wcrj9yKpOUYRCr2bXmc8Y1LqA6M5WaVMWuz5ya7KoLIfoZZW0H14sQQnQ3ecGJb+zuF0r591NVzMnMpMLvRlTvuX4pH/37xuZ1vs4dxaVHncvfhixmyO+PTVZVhehreiQXqG6KtHivt5cH+3zOUTKMQgixnTv/2AJuv6KIfTaUgPcl/4v8IaxPcYNSLPDEbgcwaeUaCRaFED1C+jCKb8y7IPj8dhY/bIw5vxvL+iHuIuBtOc8Y80h3lSXE9my3ndL478PjOeXk+dRFLXusXs8GJuBnLW+OncS/J+/JnNsGJbuaQgjol30YpUlaiN4lLzixzf5+/SKWvVtKXk0tEZ8PX2OMX7ywDxlFGcmumhB9Tc80Sd/cqkn6sr7fJC0BoxC9S15wots899zzKAXHHXdcsqsiRF8lAWMXSR9GIYToo1Sf/wgSQvQV0odRCCGEEKI79cMvc5JhFEIIIYQQHZKAUQghhBBCdEgCRiGEEEII0SHpwyiEEEII0Z2kD6MQQgghhNjRSMAohBBCCCE6JAGjEEIIIYTokPRhFEIIIYToTv3wqvqSYRRCCCGE6GVKqeVKqcnJrkdXSYZRCCGEEKI79b8Eo2QYhRBCCCG2B0qp05VSnyul5imlnlFKDfTmf6iUmuZN36WU+tKbDiilSpRSGT1dN8kwCtGLlFKvAIXJrsf2JhAIFEaj0ZJk16MvknO39eTcbb1+dO5ettYe2d07tb8OfOMco9c8fTOwh7V2nVLqeuAvwEnAG8AhwCfA/kC9UmowMBL4ylpb2111b48EjEL0op54Y+oPtNbGGKOTXY++SM7d1pNzt/Xk3PWIg4H/WWvXeff/Dsz1pt8ArlRKPQKUAu/gAshRwJu9UTlpkhZCCCGE2L59AOwOHIMLHpsyjod40z1OAkYhhBBCiOR7CzhaKVXk3T8XeA3AWtsIzAYuA14HZgH7Abt60z1OmqSFENuDfyS7An2YnLutJ+du68m56x6vK6WiCfcvB15TSllgKXBewrI3gGnAJ9bamFJqMbDMWhvujYoqa21vlCOEEEIIIfooaZIWQgghhBAdkoBRCCGEEEJ0SPowCiF6ndY6HfgXsAcQBX5tjHmhjfWGAg/jRgcu2lEv46G1Hgc8ABTgLqlxujFmUat1/MAdwJGABW42xtzT23Xd3nTx3B0O3AjsAvzFGPPrXq/odqiL5+4q4GQgBkSAK4wxr/R2XUXPkwyjECIZfg1UGWPGAscB92itM9tYrwa4GvhBb1ZuO3Q38FdjzDjgr7jrs7X2Q2AssBOwD3Ct1npkr9Vw+9WVc7cU+BFwW29WrA/oyrn7GJhmjNkVOBv4t9Y6rRfrKHqJBIxCiGQ4Ce/Dx8tYGOCo1isZYyqNMTOBHv8Vg+2V1nogLsP6mDfrMWB3rfWAVqueBPzTGBM3xmwC/gt8r9cquh3q6rkzxiw2xszBZbsF3+jcvWKMqfPuzsP9inJBr1VU9BoJGIUQyTAcWJFwfyUwLEl12d4NA9YYY2IA3v+1bHm+5JxuqavnTmxpa87d6cASY8zqXqif6GXSh1EI0e201rNxAUxbBvVmXYQQPU9rfRBwPXBYsusieoYEjEKIbmeM2b2j5VrrlcAIYJM3azjuVw7EllYBQ7XWfmNMzBvcMsSbn6jpnH7i3W+dcdwRdfXciS11+dxprffBDU47wRjzdS/XU/QSaZIWQiTDE3i/YKC13gn36wUvJ7VG2yljzEZgDnCKN+sU4DOvn2KiJ4BztdY+r5/Zt4Ane6ue26NvcO5EK109d1rracC/ge8aY2b3aiVFr5JfehFC9DqtdQZwP7Ab7nIclxpjnvWWXQesNcbc7WU1VgApQA6wEbjHGHNtMuqdLFrrnXGXN8kDynGXN/laa/0/4GpjjPHO1Z3A4d5mtxhjdvifb+viudsfeBzIxg3aqATO2dEvD9PFc/cJMBJYk7DpacaYz3u9wqJHScAohBBCCCE6JE3SQgghhBCiQxIwCiGEEEKIDknAKIQQQgghOiQBoxBCCCGE6JAEjEIIIYQQokMSMAohRCeUUiOVUlYpVdzD5ZyvlHoo4f5LSqlLe7JM0Tal1GKl1JldXLdXnh+9QSmV4h37zsmui9i+SMAohOg2SqnRSqknlFLrlVI1SqlVSqlnlFIhb/mZSqnFbWzX3vwfeh/E17Sx7G2lVKNXTqVS6jOl1Ik9c2Q9TymVAVwHXNs0z1p7lLX21qRVqhPeY7N/suuxI+iJc62Umq6UiibOs9Y2Ard5NyGaScAohOhO/wPWAeOBLGAf4BXcxZC3xnlAGXCOUsrfxvLrrbWZQAHwGPBvpdS4rSwr2U4FPrfWLkl2RcQO7zFghlJqbLIrIrYfEjAKIbqFUqoAFyjeba2ttM5qa+3dXtbim+5vAnAAcAYwGDiqvXWttVHgLsAP7NLGvn6qlJrTat4opVRMKTXSu/8vLyNarZSar5T6QQd1u1Yp9XqreW8rpX6TcH+yUuoVpdQmpdRKpdRNSqlgB4f8LeC19vaZ0Ox5hle/WqXU/5RSeUqpm5VSG73M7k8Ttj/Ta178P6XUOm+dPyTWo7PjVkrtqpR62TuOsqbjVkrN9VZ51cvy3tPOuUpXSv3ZK6NEKfVfpdTwVsf4B6XUU14dliilTmjvJCUc00VKqdXeNr9XShV4+6hSSi1IzMYppQJKqauVUkuVUuVKqTeUUpMTlgeVUrcnnMP/a6PcA5RS73nnYIlS6ldKqS5/EVJKnaiUmutlw+cqpb7d+pharX9/0zlt71wrpZZ7x/WeN98opaa1tY+EecuVUqcqpYYALwF+b9sapdQZANbaKtxvkh/f1eMT/Z8EjEKIbmGtLQW+BO5RSp2ulJr4TT5Q2/BjYJ619gVc5vK89lZUrsn7p0AEmNvGKo8COyulpibMOxN421q73Lv/HjAVyMU1Dd+vlJq4NRVXSg0E3gGeBobiMq2HAZd3sNnuwPwu7P5EYH9gOO4n2T4ClgBDgLOAPyUGZMAIb93RXj2OAy5JWN7ucSulBnvH8Y5XVhFwM4C1doq3/eHW2kxr7Y/aqe8fgb292wigBHhetcwYnwH8Affzj3cCDyil0js4ByO8+o72zsXPccHPbbifsXsa+FfC+pcApwNHe8cwE3hNKZXtLb8MOBbYFxjlHeuIpo298/E/b/8DgGOAnwGndVDHZkqpfYFHvHIKgCuAx5RSe3Vl+07O9fnAL4B83G+H/y/huDra51rcl7CYt89Ma+0DCat8jntOCgFIwCiE6F7TgbeBXwJzgA1KqataBY6jlFIViTdcdrCZUioV9wHf9KF/L3CU2nJQwZXe9quBE4ATrbVb9IW01pYDz+ICKrz6nAHcl7DOvdbaUmttzFr7ODDPO56tcTow11r7d2tt2Fq7BrjJm9+ePKCqC/u+3lpb5gXoLwARa+0/rbVRa+1LuN/83S1h/ThwibW23mvuvhUXLAOdHvdpwGJr7U3W2lrvWFpkVjuilPLhzvNvrLVrrLW1uOfGBGDPhFX/ba39wFobB/6BCxx36mDX9cBvvfrMxX1J+MRaO8taGwMeBsYqpXK89c8CbrHWLvCy3dfhfsP8GG/56d7yxdbaeuDXQOLv5v4EeMJa+6x3nhbgAtuOHs9EZwJPWWtf8h6nF4FngLO7uH1H7rXWfmqtDQO34M7Nsd2w3ypcECoEIAGjEKIbWWtLrLVXWGt3x2WALgWuxgvUPMustbmJN9wHcqLvAZm4D35w2Z1NQOss1u+8fQy01u5rrX2+g+r9C/iB1xw7w6vf0+ACG6XUdUqpr70mwwpgCi6btDVGAfu1Corvw2W32lMOdJoZwvURbVLX6n7TvKyE+xuttXUJ95cDxdCl4x4JLOxCndozAEgBljXNsNbWABuBYQnrrUtYXutNJh5Daxu94LJJ6/PQdLxN+xjWqg5x3HloqkOxdz+xDhsT9jcKOKXV43kNrqtEV7Qo37OEludgay1vmrDWWmAl3uO7jbJx/YeFACRgFEL0EGttnbX2flzGauo33PzHuP6IXyil1uMyiHm0P/ilK14DGnFNsmcCj3vZJIBTcMHoiUCeF8TOpf3BOtVARqt5QxKmVwCvtwqMc7wBOu35DNiqJvBODGzVvDsSdz6h8+NeTseZPtvBMnBBfqNXJgBKqUxgILCqK5XvJqta1cHn3W+qw5pWyzNo+WVhBXBfq8cz21o7aWvK94xOKL+z5xO0f64T661w3Q+aHt8W+1VKBXDnvkli0N3aZNxzUghAAkYhRDdRbvDFTcoN9gh6Aw1OxH3wzPwG+5mI65f2bVyg2XTbE5ehO3pr6uc1VT4IXAh8h4TmaFw2JYoLcHxKqbNxmbb2fArsrpTawzvOn+GyUE0eBLRS6mylVKqXyRutlDqyg33+Fzj0Gx9Y53zALUqpNKXUaFxza1Nftc6O+2FgvHKDZtKVUiGlVGId19NBQOll8h4ErldKDfEC1z8AC4CPu+n4uuJ+4FKl1Divv+uVQAB40Vv+EHCJUmqMUioN12yf+Pl4F3CyUuq4hOf2RKXUQV0s/wHgRKXUEUopv1LqKNxzsKnLxRxcYH+s91z5NnBgq320d67PVkrt7mXOLwHSE47rU+AQ5QZ4pQC/AxIHXq3HDXpJfO6ilMrCvd6e6+LxiR2ABIxCiO4SxmUvnsY1ZW0CfgNcaK194hvs5zxgtrX2eWvt+oTbPOAJOhj80gX/Ag7CNYsnBiwP4AaPLMZlmybSQZBrrX0buB14GdcUOgh4P2H5euBg3Mjn5bjm5mdwWaX2PARM8YK67rQCl3FahjvGl3EBEXRy3N7AiOm4ATurcQFG4oCZK4HrlBt5/Pd2yr8IMLhRtytxzbjHewF8b7kNd6mYV4ENuC4Jh3ujgcH1L30FmIU7Tytx5w0Aa+0XuH6Bv8Q93htxQWiXuixYa9/H9eX8Pe65cCtwqrV2lrd8CW7gyj9wr50jgada7aa9c/0P4A5vvycBx1hrK71lj+CCvtm4JvCVuMe5qV4Lgb8BH3tN7U2DeE4B3rLWLurK8Ykdg3JdHoQQQiSbUup8YD9rbZdG33Zhf2fiBpzI9fT6IaXUctzj+3Bn636DfaYAX+CC+q+6a7+i7wskuwJCCCEca+3dwN3JrofYcXmjyDvqtyp2UNIkLYQQQgghOiRN0kIIIYQQokOSYRRCCCGEEB2SgFEIIYQQQnRIAkYhhBBCCNEhCRiFEEIIIUSHJGAUQgghhBAd+n8JU9RmNlfCIwAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "%time result = taskGraph.run()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "

Shap Summary, Train

" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "display(HTML('

Shap Summary, Train

'))\n", + "result['train_shap_dot.summary_plot']" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "

Shap Summary, Train

" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "display(HTML('

Shap Summary, Train

'))\n", + "result['train_shap_bar.summary_plot']" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "

Shap Summary, Test

" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "display(HTML('

Shap Summary, Test

'))\n", + "result['test_shap_dot.summary_plot']" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "

Shap Summary, Test

" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "display(HTML('

Shap Summary, Test

'))\n", + "result['test_shap_bar.summary_plot']" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We run the XGboost performance metrics again for 100K samples:" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "466eb1ad1c874a63a7ddb328120012ef", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "GreenflowWidget(sub=HBox(), value=[OrderedDict([('id', ''), ('type', 'Output_Collector'), ('conf', {}), ('inpu…" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "taskGraph=TaskGraph.load_taskgraph('./17assets/parallel_xgboost_performance.gq.yaml')\n", + "taskGraph.draw()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "taskGraph.draw(show='ipynb')" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 12 s, sys: 2.22 s, total: 14.2 s\n", + "Wall time: 2min 34s\n" + ] + } + ], + "source": [ + "%time result = taskGraph.run()" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train R-Squared: 0.6353086806309562 Test R-Squared: 0.2309644451467247\n" + ] + } + ], + "source": [ + "print('Train R-Squared:', result['train_rsquared.out'], 'Test R-Squared:', result['test_rsquared.out'])" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "train_infer_df = result['train_infer.out'].compute()\n", + "test_infer_df = result['test_infer.out'].compute()" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Train')" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "pl.plot(train_infer_df.portfolio.values.get(), train_infer_df.predict.values.get(), 'b.')\n", + "pl.xlabel('true')\n", + "pl.ylabel('predict')\n", + "pl.title('Train')" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Test')" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "pl.plot(test_infer_df.portfolio.values.get(), test_infer_df.predict.values.get(), 'g.')\n", + "pl.xlabel('true')\n", + "pl.ylabel('predict')\n", + "pl.title('Test')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Hyperparameter Optimization\n", + "\n", + "When data scientists are building machine learning models, there are a few magic numbers that are included in the model. The example numbers are depths in the tree, the learning rate, etc. The parameters that define the model architecture or training process are usually referred to as hyperparameters. They are magical because there is no good theory about what number to choose. Commonly, the hyperparameters can be searched to find a good set of them that results in the best model performance. The process of searching is referred to as hyperparameter tuning.\n", + "\n", + "There are a few popular Python-based hyperparameter tuning libraries existing: Ray Tune, Optuna, HyperOpt. Each library provides a set of search algorithms and schedule algorithms that is easy to use.\n", + "\n", + "Inside the `greenflow` project, we implemented a Context Composite Node that can flexibly expose the hyperparameters that are interesting for tuning. The Context Composite Node makes hyperparameter tuning easy to do by leveraging the hyperparameter tuning libraries. Inside `greenflow_gquant_plugin` project, there is a `GridRandomSearchNode` that can do random and grid search with Ray Tune library for the hyperparameters. First, we need to initialize the ray tune environment." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'status': 'ok', 'restart': True}" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import IPython\n", + "app = IPython.Application.instance()\n", + "app.kernel.do_shutdown(True)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "
\n", + "

Client

\n", + "\n", + "		\n", + "

Cluster

\n", + "
    \n", + "
  • Workers: 8
    • \n", + "
  • Cores: 8
    • \n", + "
  • Memory: 503.80 GiB
    • \n", + "
\n", + "
" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# run this cell if you need Dask\n", + "from dask_cuda import LocalCUDACluster\n", + "import dask\n", + "dask.config.set({\"distributed.comm.timeouts.tcp\": \"90s\"})\n", + "cluster = LocalCUDACluster()\n", + "from dask.distributed import Client\n", + "client = Client(cluster)\n", + "client" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import cupy\n", + "import cudf\n", + "import matplotlib.pyplot as pl\n", + "from greenflow.dataframe_flow import TaskGraph\n", + "from IPython.display import display, HTML" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-15 00:41:37,157\tINFO services.py:1263 -- View the Ray dashboard at \u001b[1m\u001b[32mhttp://127.0.0.1:8265\u001b[39m\u001b[22m\n", + "2021-09-15 00:41:37,161\tWARNING services.py:1749 -- WARNING: The object store is using /tmp instead of /dev/shm because /dev/shm has only 21474639872 bytes available. This will harm performance! You may be able to free up space by deleting files in /dev/shm. If you are inside a Docker container, you can increase /dev/shm size by passing '--shm-size=22.00gb' to 'docker run' (or add it to the run_options list in a Ray cluster config). Make sure to set this to more than 30% of available RAM.\n" + ] + }, + { + "data": { + "text/plain": [ + "{'node_ip_address': '10.31.229.54',\n", + " 'raylet_ip_address': '10.31.229.54',\n", + " 'redis_address': '10.31.229.54:6379',\n", + " 'object_store_address': '/tmp/ray/session_2021-09-15_00-41-35_558667_3283/sockets/plasma_store',\n", + " 'raylet_socket_name': '/tmp/ray/session_2021-09-15_00-41-35_558667_3283/sockets/raylet',\n", + " 'webui_url': '127.0.0.1:8265',\n", + " 'session_dir': '/tmp/ray/session_2021-09-15_00-41-35_558667_3283',\n", + " 'metrics_export_port': 55764,\n", + " 'node_id': '65eec786e51d3b1759a45c5a78a16a7b72a95659a19c9cb4a09bed95'}" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import os\n", + "os.environ['RAY_OBJECT_STORE_ALLOW_SLOW_STORAGE'] = '1'\n", + "\n", + "import ray\n", + "ray.init()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Following is the workflow to run HPO. As a simple example, we will search the `num_rounds` and `eta` parameters in the XGBoost model. We use grid search for `num_rounds` and random search for `eta`. Click on the `GridRandomSearchNode`, you can see how we configure the search space." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "75287aa559de4e6b93d0141e3c7b19fe", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "GreenflowWidget(sub=HBox(), value=[OrderedDict([('id', 'xgboost_train'), ('type', 'ContextCompositeNode'), ('c…" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "taskGraph=TaskGraph.load_taskgraph('./17assets/hpo.gq.yaml')\n", + "taskGraph.draw()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "taskGraph.draw(show='ipynb')" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "get best {'eta': 0.13169625125573148, 'num_rounds': 100}\n" + ] + }, + { + "data": { + "text/html": [ + "== Status ==
Memory usage on this node: 38.3/503.8 GiB
Using FIFO scheduling algorithm.
Resources requested: 16.0/40 CPUs, 4.0/8 GPUs, 0.0/472.52 GiB heap, 0.0/20.0 GiB objects (0.0/1.0 accelerator_type:V100)
Result logdir: /home/avolkov/projects/gitrepos/cuquant_local/gQuant/plugins/hrp_plugin/notebooks/ray/exp
Number of trials: 3/3 (2 PENDING, 1 RUNNING)
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
Trial name status loc eta num_rounds
search_fun_b089e_00000RUNNING 0.110481 100
search_fun_b089e_00001PENDING 0.436578 110
search_fun_b089e_00002PENDING 0.263365 120


" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[2m\u001b[36m(pid=3617)\u001b[0m Port 8787 is already in use.\n", + "\u001b[2m\u001b[36m(pid=3617)\u001b[0m Perhaps you already have a cluster running?\n", + "\u001b[2m\u001b[36m(pid=3617)\u001b[0m Hosting the HTTP server on port 39009 instead\n", + "\u001b[2m\u001b[36m(pid=3615)\u001b[0m Port 8787 is already in use.\n", + "\u001b[2m\u001b[36m(pid=3615)\u001b[0m Perhaps you already have a cluster running?\n", + "\u001b[2m\u001b[36m(pid=3615)\u001b[0m Hosting the HTTP server on port 43543 instead\n" + ] + }, + { + "data": { + "text/html": [ + "== Status ==
Memory usage on this node: 39.5/503.8 GiB
Using FIFO scheduling algorithm.
Resources requested: 32.0/40 CPUs, 8.0/8 GPUs, 0.0/472.52 GiB heap, 0.0/20.0 GiB objects (0.0/1.0 accelerator_type:V100)
Result logdir: /home/avolkov/projects/gitrepos/cuquant_local/gQuant/plugins/hrp_plugin/notebooks/ray/exp
Number of trials: 3/3 (1 PENDING, 2 RUNNING)
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
Trial name status loc eta num_rounds
search_fun_b089e_00000RUNNING 0.110481 100
search_fun_b089e_00001RUNNING 0.436578 110
search_fun_b089e_00002PENDING 0.263365 120


" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[2m\u001b[36m(pid=3617)\u001b[0m start new Cluster\n", + "\u001b[2m\u001b[36m(pid=3615)\u001b[0m start new Cluster\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[2m\u001b[36m(pid=3615)\u001b[0m [00:45:55] task [xgboost.dask]:tcp://127.0.0.1:46190 got new rank 0\n", + "\u001b[2m\u001b[36m(pid=3615)\u001b[0m [00:45:55] task [xgboost.dask]:tcp://127.0.0.1:35911 got new rank 1\n", + "\u001b[2m\u001b[36m(pid=3615)\u001b[0m [00:45:55] task [xgboost.dask]:tcp://127.0.0.1:44300 got new rank 2\n", + "\u001b[2m\u001b[36m(pid=3615)\u001b[0m [00:45:55] task [xgboost.dask]:tcp://127.0.0.1:45880 got new rank 3\n", + "\u001b[2m\u001b[36m(pid=3617)\u001b[0m [00:46:00] task [xgboost.dask]:tcp://127.0.0.1:37901 got new rank 0\n", + "\u001b[2m\u001b[36m(pid=3617)\u001b[0m [00:46:00] task [xgboost.dask]:tcp://127.0.0.1:45805 got new rank 1\n", + "\u001b[2m\u001b[36m(pid=3617)\u001b[0m [00:46:00] task [xgboost.dask]:tcp://127.0.0.1:36136 got new rank 2\n", + "\u001b[2m\u001b[36m(pid=3617)\u001b[0m [00:46:00] task [xgboost.dask]:tcp://127.0.0.1:42137 got new rank 3\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Result for search_fun_b089e_00001:\n", + " date: 2021-09-15_00-46-02\n", + " done: false\n", + " experiment_id: b0ecd396a12d4797b6e9dcfc2cdb55df\n", + " hostname: dgx04-contain\n", + " iterations_since_restore: 1\n", + " node_ip: 10.31.229.54\n", + " pid: 3615\n", + " test_rsquared.out: 0.20886621780068043\n", + " time_since_restore: 259.37074398994446\n", + " time_this_iter_s: 259.37074398994446\n", + " time_total_s: 259.37074398994446\n", + " timestamp: 1631666762\n", + " timesteps_since_restore: 0\n", + " train_rsquared.out: 0.7299008371376237\n", + " training_iteration: 1\n", + " trial_id: b089e_00001\n", + " \n" + ] + }, + { + "data": { + "text/html": [ + "== Status ==
Memory usage on this node: 55.5/503.8 GiB
Using FIFO scheduling algorithm.
Resources requested: 32.0/40 CPUs, 8.0/8 GPUs, 0.0/472.52 GiB heap, 0.0/20.0 GiB objects (0.0/1.0 accelerator_type:V100)
Result logdir: /home/avolkov/projects/gitrepos/cuquant_local/gQuant/plugins/hrp_plugin/notebooks/ray/exp
Number of trials: 3/3 (1 PENDING, 2 RUNNING)
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
Trial name status loc eta num_rounds iter total time (s) train_rsquared.out test_rsquared.out
search_fun_b089e_00000RUNNING 0.110481 100
search_fun_b089e_00001RUNNING 10.31.229.54:36150.436578 110 1 259.371 0.729901 0.208866
search_fun_b089e_00002PENDING 0.263365 120


" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Result for search_fun_b089e_00001:\n", + " date: 2021-09-15_00-46-02\n", + " done: true\n", + " experiment_id: b0ecd396a12d4797b6e9dcfc2cdb55df\n", + " experiment_tag: 1_eta=0.43658,num_rounds=110\n", + " hostname: dgx04-contain\n", + " iterations_since_restore: 1\n", + " node_ip: 10.31.229.54\n", + " pid: 3615\n", + " test_rsquared.out: 0.20886621780068043\n", + " time_since_restore: 259.37074398994446\n", + " time_this_iter_s: 259.37074398994446\n", + " time_total_s: 259.37074398994446\n", + " timestamp: 1631666762\n", + " timesteps_since_restore: 0\n", + " train_rsquared.out: 0.7299008371376237\n", + " training_iteration: 1\n", + " trial_id: b089e_00001\n", + " \n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[2m\u001b[36m(pid=3615)\u001b[0m /home/quant/miniconda3/lib/python3.8/multiprocessing/resource_tracker.py:216: UserWarning: resource_tracker: There appear to be 24 leaked semaphore objects to clean up at shutdown\n", + "\u001b[2m\u001b[36m(pid=3615)\u001b[0m warnings.warn('resource_tracker: There appear to be %d '\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Result for search_fun_b089e_00000:\n", + " date: 2021-09-15_00-46-07\n", + " done: false\n", + " experiment_id: b24df7326b29455fbf9cf74afdbc2296\n", + " hostname: dgx04-contain\n", + " iterations_since_restore: 1\n", + " node_ip: 10.31.229.54\n", + " pid: 3617\n", + " test_rsquared.out: 0.26244257268797777\n", + " time_since_restore: 264.0155813694\n", + " time_this_iter_s: 264.0155813694\n", + " time_total_s: 264.0155813694\n", + " timestamp: 1631666767\n", + " timesteps_since_restore: 0\n", + " train_rsquared.out: 0.4799151971363568\n", + " training_iteration: 1\n", + " trial_id: b089e_00000\n", + " \n", + "Result for search_fun_b089e_00000:\n", + " date: 2021-09-15_00-46-07\n", + " done: true\n", + " experiment_id: b24df7326b29455fbf9cf74afdbc2296\n", + " experiment_tag: 0_eta=0.11048,num_rounds=100\n", + " hostname: dgx04-contain\n", + " iterations_since_restore: 1\n", + " node_ip: 10.31.229.54\n", + " pid: 3617\n", + " test_rsquared.out: 0.26244257268797777\n", + " time_since_restore: 264.0155813694\n", + " time_this_iter_s: 264.0155813694\n", + " time_total_s: 264.0155813694\n", + " timestamp: 1631666767\n", + " timesteps_since_restore: 0\n", + " train_rsquared.out: 0.4799151971363568\n", + " training_iteration: 1\n", + " trial_id: b089e_00000\n", + " \n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[2m\u001b[36m(pid=3613)\u001b[0m Port 8787 is already in use.\n", + "\u001b[2m\u001b[36m(pid=3613)\u001b[0m Perhaps you already have a cluster running?\n", + "\u001b[2m\u001b[36m(pid=3613)\u001b[0m Hosting the HTTP server on port 41438 instead\n", + "\u001b[2m\u001b[36m(pid=3617)\u001b[0m /home/quant/miniconda3/lib/python3.8/multiprocessing/resource_tracker.py:216: UserWarning: resource_tracker: There appear to be 24 leaked semaphore objects to clean up at shutdown\n", + "\u001b[2m\u001b[36m(pid=3617)\u001b[0m warnings.warn('resource_tracker: There appear to be %d '\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[2m\u001b[36m(pid=3613)\u001b[0m start new Cluster\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[2m\u001b[36m(pid=3613)\u001b[0m [00:49:16] task [xgboost.dask]:tcp://127.0.0.1:35082 got new rank 0\n", + "\u001b[2m\u001b[36m(pid=3613)\u001b[0m [00:49:16] task [xgboost.dask]:tcp://127.0.0.1:32975 got new rank 1\n", + "\u001b[2m\u001b[36m(pid=3613)\u001b[0m [00:49:16] task [xgboost.dask]:tcp://127.0.0.1:33483 got new rank 2\n", + "\u001b[2m\u001b[36m(pid=3613)\u001b[0m [00:49:16] task [xgboost.dask]:tcp://127.0.0.1:37499 got new rank 3\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Result for search_fun_b089e_00002:\n", + " date: 2021-09-15_00-49-23\n", + " done: false\n", + " experiment_id: ff2c2c6358314ff2944a719b3da70f07\n", + " hostname: dgx04-contain\n", + " iterations_since_restore: 1\n", + " node_ip: 10.31.229.54\n", + " pid: 3613\n", + " test_rsquared.out: 0.2440717036000372\n", + " time_since_restore: 196.79628109931946\n", + " time_this_iter_s: 196.79628109931946\n", + " time_total_s: 196.79628109931946\n", + " timestamp: 1631666963\n", + " timesteps_since_restore: 0\n", + " train_rsquared.out: 0.656421922676001\n", + " training_iteration: 1\n", + " trial_id: b089e_00002\n", + " \n" + ] + }, + { + "data": { + "text/html": [ + "== Status ==
Memory usage on this node: 47.4/503.8 GiB
Using FIFO scheduling algorithm.
Resources requested: 16.0/40 CPUs, 4.0/8 GPUs, 0.0/472.52 GiB heap, 0.0/20.0 GiB objects (0.0/1.0 accelerator_type:V100)
Result logdir: /home/avolkov/projects/gitrepos/cuquant_local/gQuant/plugins/hrp_plugin/notebooks/ray/exp
Number of trials: 3/3 (1 RUNNING, 2 TERMINATED)
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
Trial name status loc eta num_rounds iter total time (s) train_rsquared.out test_rsquared.out
search_fun_b089e_00002RUNNING 10.31.229.54:36130.263365 120 1 196.796 0.656422 0.244072
search_fun_b089e_00000TERMINATED 0.110481 100 1 264.016 0.479915 0.262443
search_fun_b089e_00001TERMINATED 0.436578 110 1 259.371 0.729901 0.208866


" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Result for search_fun_b089e_00002:\n", + " date: 2021-09-15_00-49-23\n", + " done: true\n", + " experiment_id: ff2c2c6358314ff2944a719b3da70f07\n", + " experiment_tag: 2_eta=0.26336,num_rounds=120\n", + " hostname: dgx04-contain\n", + " iterations_since_restore: 1\n", + " node_ip: 10.31.229.54\n", + " pid: 3613\n", + " test_rsquared.out: 0.2440717036000372\n", + " time_since_restore: 196.79628109931946\n", + " time_this_iter_s: 196.79628109931946\n", + " time_total_s: 196.79628109931946\n", + " timestamp: 1631666963\n", + " timesteps_since_restore: 0\n", + " train_rsquared.out: 0.656421922676001\n", + " training_iteration: 1\n", + " trial_id: b089e_00002\n", + " \n" + ] + }, + { + "data": { + "text/html": [ + "== Status ==
Memory usage on this node: 47.4/503.8 GiB
Using FIFO scheduling algorithm.
Resources requested: 0/40 CPUs, 0/8 GPUs, 0.0/472.52 GiB heap, 0.0/20.0 GiB objects (0.0/1.0 accelerator_type:V100)
Result logdir: /home/avolkov/projects/gitrepos/cuquant_local/gQuant/plugins/hrp_plugin/notebooks/ray/exp
Number of trials: 3/3 (3 TERMINATED)
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
Trial name status loc eta num_rounds iter total time (s) train_rsquared.out test_rsquared.out
search_fun_b089e_00000TERMINATED 0.110481 100 1 264.016 0.479915 0.262443
search_fun_b089e_00001TERMINATED 0.436578 110 1 259.371 0.729901 0.208866
search_fun_b089e_00002TERMINATED 0.263365 120 1 196.796 0.656422 0.244072


" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-15 00:49:23,325\tINFO tune.py:561 -- Total run time: 463.69 seconds (463.33 seconds for the tuning loop).\n", + "\u001b[2m\u001b[36m(pid=3613)\u001b[0m /home/quant/miniconda3/lib/python3.8/multiprocessing/resource_tracker.py:216: UserWarning: resource_tracker: There appear to be 24 leaked semaphore objects to clean up at shutdown\n", + "\u001b[2m\u001b[36m(pid=3613)\u001b[0m warnings.warn('resource_tracker: There appear to be %d '\n" + ] + }, + { + "data": { + "text/plain": [ + "Results([('grid_search.conf_out', ), ('grid_search.test_rsquared@out', 0.2718288848038828)])" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "taskGraph.run()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In above simple HPO run, we see more rounds in the XGBoost training help to increase the test R-squared score. HPO is a time consuming process, GPU make it possible as we reduce the time to run 100K bootstrap samples from days in CPU cluster to 4 mins in DGX station. Feel free to add more hyperparamerters and increase the number of trails in above workflow." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Scale to 1 million Samples\n", + "\n", + "As the last part of this notebook, let's scale the computation to 1 million bootstrap samples. Ideall, the computation should scale linearly. We use the same taskgraph but increase the number or iterations 10 fold." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'status': 'ok', 'restart': True}" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import IPython\n", + "app = IPython.Application.instance()\n", + "app.kernel.do_shutdown(True)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "
\n", + "

Client

\n", + "\n", + "		\n", + "

Cluster

\n", + "
    \n", + "
  • Workers: 8
    • \n", + "
  • Cores: 8
    • \n", + "
  • Memory: 503.80 GiB
    • \n", + "
\n", + "
" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# run this cell if you need Dask\n", + "from dask_cuda import LocalCUDACluster\n", + "import dask\n", + "dask.config.set({\"distributed.comm.timeouts.tcp\": \"90s\"})\n", + "cluster = LocalCUDACluster()\n", + "from dask.distributed import Client\n", + "client = Client(cluster)\n", + "client" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import cupy\n", + "import cudf\n", + "import matplotlib.pyplot as pl\n", + "from greenflow.dataframe_flow import TaskGraph\n", + "from IPython.display import display, HTML" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "26b4b6490a424a9689625b6a863965ff", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "GreenflowWidget(sub=HBox(), value=[OrderedDict([('id', ''), ('type', 'Output_Collector'), ('conf', {}), ('inpu…" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "taskGraph=TaskGraph.load_taskgraph('./17assets/parallel_xgboost_shap.gq.yaml')\n", + "taskGraph.draw()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 2min 14s, sys: 19.2 s, total: 2min 33s\n", + "Wall time: 17min 38s\n" + ] + }, + { + "data": { + "text/plain": [ + "Results([('train_shap_dot.summary_plot',
), ('test_shap_dot.summary_plot',
), ('train_shap_bar.summary_plot',
), ('test_shap_bar.summary_plot',
)])" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "%%time\n", + "taskGraph.run(replace={\n", + " \"parallel\" : {\n", + " \"conf\": {\n", + " \"input\": [\"bootstrap.in\"],\n", + " \"output\": [\"merge_target.merged\"],\n", + " \"map\": [{\"node_id\": \"bootstrap\",\n", + " \"xpath\": \"bootstrap.conf.offset\"\n", + " }],\n", + " \"taskgraph\": \"notebooks/17assets/full_workflow_xgboost_performance.gq.yaml\",\n", + " \"iterations\": 250\n", + " }\n", + " }\n", + "})" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.10" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/gQuant/plugins/hrp_plugin/notebooks/17assets/all_feature_simplified.gq.yaml b/gQuant/plugins/hrp_plugin/notebooks/17assets/all_feature_simplified.gq.yaml new file mode 100644 index 00000000..59fb9f76 --- /dev/null +++ b/gQuant/plugins/hrp_plugin/notebooks/17assets/all_feature_simplified.gq.yaml @@ -0,0 +1,145 @@ +- id: '' + type: Output_Collector + conf: {} + inputs: + in1: merge_features.merged +- id: all_feature_computation + type: CompositeNode + conf: + input: + - all_max_raise.logreturn_df + - all_max_drawdown.logreturn_df + - all_data_distance.in + output: + - all_corr_feature.out + - all_data_distance.cov_df + - all_data_distance.distance_df + subnode_ids: + - all_max_raise + - all_max_drawdown + - all_data_distance + - all_max_drawdown_feature + - all_max_raise_feature + - all_mean_feature + - all_std_feature + - all_corr_feature + subnodes_conf: + all_max_raise: + conf: + negative: true + window: 242 + all_max_drawdown: + conf: + negative: false + window: 242 + all_data_distance: + conf: + window: 242 + all_max_drawdown_feature: + conf: + name: all_max_drawdown + all_max_raise_feature: + conf: + name: all_max_raise + all_mean_feature: + conf: + name: all_mean + all_std_feature: + conf: + name: all_std + all_corr_feature: + conf: + name: all_corr + taskgraph: notebooks/17assets/feature_computation.gq.yaml + inputs: + all_max_raise@logreturn_df: log_return.out + all_max_drawdown@logreturn_df: log_return.out + all_data_distance@in: log_return.out +- id: load_raw_csv + type: LoadCsvNode + conf: + csvfile: notebooks/data/pricess.csv + 17assets: true + inputs: {} + module: investment_nodes +- id: bootstrap + type: BootstrapNode + conf: + offset: 0 + samples: 4096 + partitions: 200 + inputs: + in: load_raw_csv.df_out + module: investment_nodes +- id: log_return + type: LogReturnNode + conf: {} + inputs: + in: bootstrap.out + module: investment_nodes +- id: aggregate_time_feature + type: AggregateTimeFeatureNode + conf: {} + inputs: + in: time_features.all_corr_feature@out + module: investment_nodes +- id: merge_features + type: MergeNode + conf: + column: sample_id + inputs: + left: aggregate_time_feature.out + right: all_feature_computation.all_corr_feature@out + module: investment_nodes +- id: time_features + type: CompositeNode + conf: + input: + - all_max_raise.logreturn_df + - all_max_drawdown.logreturn_df + - all_data_distance.in + output: + - all_corr_feature.out + - all_data_distance.cov_df + - all_data_distance.distance_df + subnode_ids: + - all_max_raise + - all_max_drawdown + - all_data_distance + - all_max_drawdown_feature + - all_max_raise_feature + - all_mean_feature + - all_std_feature + - all_corr_feature + subnodes_conf: + all_max_raise: + conf: + negative: true + window: 12 + all_max_drawdown: + conf: + negative: false + window: 12 + all_data_distance: + conf: + window: 12 + all_max_drawdown_feature: + conf: + name: max_drawdown + all_max_raise_feature: + conf: + name: max_raise + all_mean_feature: + conf: + name: mean + all_std_feature: + conf: + name: std + all_corr_feature: + conf: + name: corr + taskgraph: notebooks/17assets/feature_computation.gq.yaml + inputs: + all_max_raise@logreturn_df: log_return.out + all_max_drawdown@logreturn_df: log_return.out + all_data_distance@in: log_return.out diff --git a/gQuant/plugins/hrp_plugin/notebooks/17assets/feature_computation.gq.yaml b/gQuant/plugins/hrp_plugin/notebooks/17assets/feature_computation.gq.yaml new file mode 100644 index 00000000..e36fbc7a --- /dev/null +++ b/gQuant/plugins/hrp_plugin/notebooks/17assets/feature_computation.gq.yaml @@ -0,0 +1,88 @@ +- id: load_raw_csv + type: LoadCsvNode + conf: + csvfile: data/pricess.csv + 17assets: true + inputs: {} + module: investment_nodes +- id: '' + type: Output_Collector + conf: {} + inputs: + in1: all_corr_feature.out +- id: bootstrap + type: BootstrapNode + conf: + samples: 10 + partitions: 4 + inputs: + in: load_raw_csv.df_out + module: investment_nodes +- id: log_return + type: LogReturnNode + conf: {} + inputs: + in: bootstrap.out + module: investment_nodes +- id: all_data_distance + type: DistanceNode + conf: + window: 242 + inputs: + in: log_return.out + module: investment_nodes +- id: all_max_raise + type: MaxDrawdownNode + conf: + negative: true + window: 242 + inputs: + logreturn_df: log_return.out + module: investment_nodes +- id: all_max_drawdown + type: MaxDrawdownNode + conf: + negative: false + window: 242 + inputs: + logreturn_df: log_return.out + module: investment_nodes +- id: all_max_drawdown_feature + type: FeatureNode + conf: + name: all_max_drawdown + inputs: + signal_df: all_max_drawdown.out + module: investment_nodes +- id: all_max_raise_feature + type: FeatureNode + conf: + name: all_max_raise + inputs: + signal_df: all_max_raise.out + feature_df: all_max_drawdown_feature.out + module: investment_nodes +- id: all_mean_feature + type: FeatureNode + conf: + name: all_mean + inputs: + feature_df: all_max_raise_feature.out + signal_df: all_data_distance.mean_df + module: investment_nodes +- id: all_std_feature + type: FeatureNode + conf: + name: all_std + inputs: + feature_df: all_mean_feature.out + signal_df: all_data_distance.std_df + module: investment_nodes +- id: all_corr_feature + type: FeatureNode + conf: + name: all_corr + inputs: + feature_df: all_std_feature.out + signal_df: all_data_distance.corr_df + module: investment_nodes diff --git a/gQuant/plugins/hrp_plugin/notebooks/17assets/feature_computation_composite.gq.yaml b/gQuant/plugins/hrp_plugin/notebooks/17assets/feature_computation_composite.gq.yaml new file mode 100644 index 00000000..68a1ab20 --- /dev/null +++ b/gQuant/plugins/hrp_plugin/notebooks/17assets/feature_computation_composite.gq.yaml @@ -0,0 +1,141 @@ +- id: load_raw_csv + type: LoadCsvNode + conf: + csvfile: data/pricess.csv + 17assets: true + inputs: {} + module: investment_nodes +- id: '' + type: Output_Collector + conf: {} + inputs: + in1: all_corr_feature.out + in2: feature_computation.all_corr_feature@out +- id: bootstrap + type: BootstrapNode + conf: + samples: 10 + partitions: 4 + inputs: + in: load_raw_csv.df_out + module: investment_nodes +- id: log_return + type: LogReturnNode + conf: {} + inputs: + in: bootstrap.out + module: investment_nodes +- id: all_data_distance + type: DistanceNode + conf: + window: 242 + inputs: + in: log_return.out + module: investment_nodes +- id: all_max_raise + type: MaxDrawdownNode + conf: + negative: true + window: 242 + inputs: + logreturn_df: log_return.out + module: investment_nodes +- id: all_max_drawdown + type: MaxDrawdownNode + conf: + negative: false + window: 242 + inputs: + logreturn_df: log_return.out + module: investment_nodes +- id: all_max_drawdown_feature + type: FeatureNode + conf: + name: all_max_drawdown + inputs: + signal_df: all_max_drawdown.out + module: investment_nodes +- id: all_max_raise_feature + type: FeatureNode + conf: + name: all_max_raise + inputs: + signal_df: all_max_raise.out + feature_df: all_max_drawdown_feature.out + module: investment_nodes +- id: all_mean_feature + type: FeatureNode + conf: + name: all_mean + inputs: + feature_df: all_max_raise_feature.out + signal_df: all_data_distance.mean_df + module: investment_nodes +- id: all_std_feature + type: FeatureNode + conf: + name: all_std + inputs: + feature_df: all_mean_feature.out + signal_df: all_data_distance.std_df + module: investment_nodes +- id: all_corr_feature + type: FeatureNode + conf: + name: all_corr + inputs: + feature_df: all_std_feature.out + signal_df: all_data_distance.corr_df + module: investment_nodes +- id: feature_computation + type: CompositeNode + conf: + input: + - all_max_raise.logreturn_df + - all_max_drawdown.logreturn_df + - all_data_distance.in + output: + - all_corr_feature.out + - all_data_distance.cov_df + - all_data_distance.distance_df + subnode_ids: + - all_max_raise + - all_max_drawdown + - all_data_distance + - all_max_drawdown_feature + - all_max_raise_feature + - all_mean_feature + - all_std_feature + - all_corr_feature + subnodes_conf: + all_max_raise: + conf: + negative: true + window: 242 + all_max_drawdown: + conf: + negative: false + window: 242 + all_data_distance: + conf: + window: 242 + all_max_drawdown_feature: + conf: + name: all_max_drawdown + all_max_raise_feature: + conf: + name: all_max_raise + all_mean_feature: + conf: + name: all_mean + all_std_feature: + conf: + name: all_std + all_corr_feature: + conf: + name: all_corr + taskgraph: 17assets/feature_computation.gq.yaml + inputs: + all_max_raise@logreturn_df: log_return.out + all_max_drawdown@logreturn_df: log_return.out + all_data_distance@in: log_return.out diff --git a/gQuant/plugins/hrp_plugin/notebooks/17assets/feature_computation_simplified.gq.yaml b/gQuant/plugins/hrp_plugin/notebooks/17assets/feature_computation_simplified.gq.yaml new file mode 100644 index 00000000..a73715e8 --- /dev/null +++ b/gQuant/plugins/hrp_plugin/notebooks/17assets/feature_computation_simplified.gq.yaml @@ -0,0 +1,78 @@ +- id: load_raw_csv + type: LoadCsvNode + conf: + csvfile: data/pricess.csv + 17assets: true + inputs: {} + module: investment_nodes +- id: '' + type: Output_Collector + conf: {} + inputs: + in1: feature_computation.all_corr_feature@out +- id: bootstrap + type: BootstrapNode + conf: + samples: 10 + partitions: 4 + inputs: + in: load_raw_csv.df_out + module: investment_nodes +- id: log_return + type: LogReturnNode + conf: {} + inputs: + in: bootstrap.out + module: investment_nodes +- id: feature_computation + type: CompositeNode + conf: + input: + - all_max_raise.logreturn_df + - all_max_drawdown.logreturn_df + - all_data_distance.in + output: + - all_corr_feature.out + - all_data_distance.cov_df + - all_data_distance.distance_df + subnode_ids: + - all_max_raise + - all_max_drawdown + - all_data_distance + - all_max_drawdown_feature + - all_max_raise_feature + - all_mean_feature + - all_std_feature + - all_corr_feature + subnodes_conf: + all_max_raise: + conf: + negative: true + window: 242 + all_max_drawdown: + conf: + negative: false + window: 242 + all_data_distance: + conf: + window: 242 + all_max_drawdown_feature: + conf: + name: all_max_drawdown + all_max_raise_feature: + conf: + name: all_max_raise + all_mean_feature: + conf: + name: all_mean + all_std_feature: + conf: + name: all_std + all_corr_feature: + conf: + name: all_corr + taskgraph: notebooks/17assets/feature_computation.gq.yaml + inputs: + all_max_raise@logreturn_df: log_return.out + all_max_drawdown@logreturn_df: log_return.out + all_data_distance@in: log_return.out diff --git a/gQuant/plugins/hrp_plugin/notebooks/17assets/feature_computation_workflow.gq.yaml b/gQuant/plugins/hrp_plugin/notebooks/17assets/feature_computation_workflow.gq.yaml new file mode 100644 index 00000000..495527e6 --- /dev/null +++ b/gQuant/plugins/hrp_plugin/notebooks/17assets/feature_computation_workflow.gq.yaml @@ -0,0 +1,164 @@ +- id: load_raw_csv + type: LoadCsvNode + conf: + csvfile: notebooks/data/pricess.csv + 17assets: true + inputs: {} + module: investment_nodes +- id: '' + type: Output_Collector + conf: {} + inputs: + in1: merge_features.merged +- id: bootstrap + type: BootstrapNode + conf: + offset: 0 + samples: 4096 + partitions: 100 + inputs: + in: load_raw_csv.df_out + module: investment_nodes +- id: log_return + type: LogReturnNode + conf: {} + inputs: + in: bootstrap.out + module: investment_nodes +- id: distance_node + type: DistanceNode + conf: + window: 12 + inputs: + in: log_return.out + module: investment_nodes +- id: max_drawdown + type: MaxDrawdownNode + conf: + window: 12 + inputs: + logreturn_df: log_return.out + module: investment_nodes +- id: max_drawdown_feature + type: FeatureNode + conf: + name: max_drawdown + inputs: + signal_df: max_drawdown.out + module: investment_nodes +- id: max_raise_feature + type: FeatureNode + conf: + name: max_raise + inputs: + signal_df: max_raise.out + feature_df: max_drawdown_feature.out + module: investment_nodes +- id: max_raise + type: MaxDrawdownNode + conf: + negative: true + window: 12 + inputs: + logreturn_df: log_return.out + module: investment_nodes +- id: all_data_distance + type: DistanceNode + conf: + window: 242 + inputs: + in: log_return.out + module: investment_nodes +- id: all_max_raise + type: MaxDrawdownNode + conf: + negative: true + window: 242 + inputs: + logreturn_df: log_return.out + module: investment_nodes +- id: all_max_drawdown + type: MaxDrawdownNode + conf: + negative: false + window: 242 + inputs: + logreturn_df: log_return.out + module: investment_nodes +- id: all_max_drawdown_feature + type: FeatureNode + conf: + name: all_max_drawdown + inputs: + signal_df: all_max_drawdown.out + module: investment_nodes +- id: all_max_raise_feature + type: FeatureNode + conf: + name: all_max_raise + inputs: + signal_df: all_max_raise.out + feature_df: all_max_drawdown_feature.out + module: investment_nodes +- id: mean_feature + type: FeatureNode + conf: + name: mean + inputs: + feature_df: max_raise_feature.out + signal_df: distance_node.mean_df + module: investment_nodes +- id: std_feature + type: FeatureNode + conf: + name: std + inputs: + signal_df: distance_node.std_df + feature_df: mean_feature.out + module: investment_nodes +- id: corr_feature + type: FeatureNode + conf: + name: corr + inputs: + signal_df: distance_node.corr_df + feature_df: std_feature.out + module: investment_nodes +- id: all_mean_feature + type: FeatureNode + conf: + name: all_mean + inputs: + feature_df: all_max_raise_feature.out + signal_df: all_data_distance.mean_df + module: investment_nodes +- id: all_std_feature + type: FeatureNode + conf: + name: all_std + inputs: + feature_df: all_mean_feature.out + signal_df: all_data_distance.std_df + module: investment_nodes +- id: all_corr_feature + type: FeatureNode + conf: + name: all_corr + inputs: + feature_df: all_std_feature.out + signal_df: all_data_distance.corr_df + module: investment_nodes +- id: aggregate_time_feature + type: AggregateTimeFeatureNode + conf: {} + inputs: + in: corr_feature.out + module: investment_nodes +- id: merge_features + type: MergeNode + conf: + column: sample_id + inputs: + right: all_corr_feature.out + left: aggregate_time_feature.out + module: investment_nodes diff --git a/gQuant/plugins/hrp_plugin/notebooks/17assets/full_workflow.gq.yaml b/gQuant/plugins/hrp_plugin/notebooks/17assets/full_workflow.gq.yaml new file mode 100644 index 00000000..17dce593 --- /dev/null +++ b/gQuant/plugins/hrp_plugin/notebooks/17assets/full_workflow.gq.yaml @@ -0,0 +1,258 @@ +- id: load_raw_csv + type: LoadCsvNode + conf: + csvfile: data/pricess.csv + 17assets: true + inputs: {} + module: investment_nodes +- id: '' + type: Output_Collector + conf: {} + inputs: + in1: merge_target.merged +- id: bootstrap + type: BootstrapNode + conf: + offset: 0 + samples: 4096 + partitions: 100 + inputs: + in: load_raw_csv.df_out + module: investment_nodes +- id: log_return + type: LogReturnNode + conf: {} + inputs: + in: bootstrap.out + module: investment_nodes +- id: distance_node + type: DistanceNode + conf: + window: 12 + inputs: + in: log_return.out + module: investment_nodes +- id: assets_order + type: HierarchicalClusteringNode + conf: {} + inputs: + in: distance_node.distance_df + module: investment_nodes +- id: hrp_weight + type: HRPWeightNode + conf: {} + inputs: + asset_order_df: assets_order.out + covariance_df: distance_node.cov_df + module: investment_nodes +- id: portfolio_construct_hrp + type: PortfolioNode + conf: {} + inputs: + return_df: log_return.out + weight_df: hrp_weight.out + transaction_df: hrp_transaction_cost.out + module: investment_nodes +- id: performance_hrp + type: PerformanceMetricNode + conf: {} + inputs: + in: leverage_hrp.lev_df + module: investment_nodes +- id: nrp_weight + type: NRPWeightNode + conf: {} + inputs: + in: distance_node.cov_df + module: investment_nodes +- id: portfolio_construct_nrp + type: PortfolioNode + conf: {} + inputs: + return_df: log_return.out + transaction_df: nrp_transaction_cost.out + weight_df: nrp_weight.out + module: investment_nodes +- id: performance_nrp + type: PerformanceMetricNode + conf: {} + inputs: + in: leverage_nrp.lev_df + module: investment_nodes +- id: max_drawdown + type: MaxDrawdownNode + conf: + window: 12 + inputs: + logreturn_df: log_return.out + module: investment_nodes +- id: max_drawdown_feature + type: FeatureNode + conf: + name: max_drawdown + inputs: + signal_df: max_drawdown.out + module: investment_nodes +- id: max_raise_feature + type: FeatureNode + conf: + name: max_raise + inputs: + signal_df: max_raise.out + feature_df: max_drawdown_feature.out + module: investment_nodes +- id: max_raise + type: MaxDrawdownNode + conf: + negative: true + window: 12 + inputs: + logreturn_df: log_return.out + module: investment_nodes +- id: all_data_distance + type: DistanceNode + conf: + window: 242 + inputs: + in: log_return.out + module: investment_nodes +- id: all_max_raise + type: MaxDrawdownNode + conf: + negative: true + window: 242 + inputs: + logreturn_df: log_return.out + module: investment_nodes +- id: all_max_drawdown + type: MaxDrawdownNode + conf: + negative: false + window: 242 + inputs: + logreturn_df: log_return.out + module: investment_nodes +- id: all_max_drawdown_feature + type: FeatureNode + conf: + name: all_max_drawdown + inputs: + signal_df: all_max_drawdown.out + module: investment_nodes +- id: all_max_raise_feature + type: FeatureNode + conf: + name: all_max_raise + inputs: + signal_df: all_max_raise.out + feature_df: all_max_drawdown_feature.out + module: investment_nodes +- id: mean_feature + type: FeatureNode + conf: + name: mean + inputs: + feature_df: max_raise_feature.out + signal_df: distance_node.mean_df + module: investment_nodes +- id: std_feature + type: FeatureNode + conf: + name: std + inputs: + signal_df: distance_node.std_df + feature_df: mean_feature.out + module: investment_nodes +- id: corr_feature + type: FeatureNode + conf: + name: corr + inputs: + signal_df: distance_node.corr_df + feature_df: std_feature.out + module: investment_nodes +- id: all_mean_feature + type: FeatureNode + conf: + name: all_mean + inputs: + feature_df: all_max_raise_feature.out + signal_df: all_data_distance.mean_df + module: investment_nodes +- id: all_std_feature + type: FeatureNode + conf: + name: all_std + inputs: + feature_df: all_mean_feature.out + signal_df: all_data_distance.std_df + module: investment_nodes +- id: all_corr_feature + type: FeatureNode + conf: + name: all_corr + inputs: + feature_df: all_std_feature.out + signal_df: all_data_distance.corr_df + module: investment_nodes +- id: aggregate_time_feature + type: AggregateTimeFeatureNode + conf: {} + inputs: + in: corr_feature.out + module: investment_nodes +- id: merge_features + type: MergeNode + conf: + column: sample_id + inputs: + right: all_corr_feature.out + left: aggregate_time_feature.out + module: investment_nodes +- id: hrp_nrp + type: DiffNode + conf: {} + inputs: + diff_b: performance_nrp.calmar_df + diff_a: performance_hrp.calmar_df + module: investment_nodes +- id: merge_target + type: MergeNode + conf: + column: sample_id + inputs: + right: hrp_nrp.out + left: merge_features.merged + module: investment_nodes +- id: leverage_hrp + type: LeverageNode + conf: + target_vol: 0.05 + long_window: 59 + short_window: 19 + inputs: + in: portfolio_construct_hrp.out + module: investment_nodes +- id: leverage_nrp + type: LeverageNode + conf: + target_vol: 0.05 + long_window: 59 + short_window: 19 + inputs: + in: portfolio_construct_nrp.out + module: investment_nodes +- id: hrp_transaction_cost + type: TransactionCostNode + conf: + cost: 0.0002 + inputs: + logreturn_df: hrp_weight.out + module: investment_nodes +- id: nrp_transaction_cost + type: TransactionCostNode + conf: + cost: 0.0002 + inputs: + logreturn_df: nrp_weight.out + module: investment_nodes diff --git a/gQuant/plugins/hrp_plugin/notebooks/17assets/full_workflow_simplified.gq.yaml b/gQuant/plugins/hrp_plugin/notebooks/17assets/full_workflow_simplified.gq.yaml new file mode 100644 index 00000000..f03ff120 --- /dev/null +++ b/gQuant/plugins/hrp_plugin/notebooks/17assets/full_workflow_simplified.gq.yaml @@ -0,0 +1,171 @@ +- id: '' + type: Output_Collector + conf: {} + inputs: + in1: merge_target.merged +- id: performance_diff + type: CompositeNode + conf: + input: + - nrp_weight.in + - hrp_weight.covariance_df + - assets_order.in + - portfolio_construct_nrp.return_df + - portfolio_construct_hrp.return_df + output: + - hrp_nrp_diff.out + subnodes_conf: {} + taskgraph: notebooks/17assets/workflow_bootstrap.gq.yaml + inputs: + portfolio_construct_nrp@return_df: log_return.out + portfolio_construct_hrp@return_df: log_return.out + nrp_weight@in: time_features.all_data_distance@cov_df + hrp_weight@covariance_df: time_features.all_data_distance@cov_df + assets_order@in: time_features.all_data_distance@distance_df +- id: all_feature_computation + type: CompositeNode + conf: + input: + - all_max_raise.logreturn_df + - all_max_drawdown.logreturn_df + - all_data_distance.in + output: + - all_corr_feature.out + - all_data_distance.cov_df + - all_data_distance.distance_df + subnode_ids: + - all_max_raise + - all_max_drawdown + - all_data_distance + - all_max_drawdown_feature + - all_max_raise_feature + - all_mean_feature + - all_std_feature + - all_corr_feature + subnodes_conf: + all_max_raise: + conf: + negative: true + window: 242 + all_max_drawdown: + conf: + negative: false + window: 242 + all_data_distance: + conf: + window: 242 + all_max_drawdown_feature: + conf: + name: all_max_drawdown + all_max_raise_feature: + conf: + name: all_max_raise + all_mean_feature: + conf: + name: all_mean + all_std_feature: + conf: + name: all_std + all_corr_feature: + conf: + name: all_corr + taskgraph: notebooks/17assets/feature_computation.gq.yaml + inputs: + all_max_raise@logreturn_df: log_return.out + all_max_drawdown@logreturn_df: log_return.out + all_data_distance@in: log_return.out +- id: load_raw_csv + type: LoadCsvNode + conf: + csvfile: data/pricess.csv + 17assets: true + inputs: {} + module: investment_nodes +- id: bootstrap + type: BootstrapNode + conf: + samples: 5120 + partitions: 200 + inputs: + in: load_raw_csv.df_out + module: investment_nodes +- id: log_return + type: LogReturnNode + conf: {} + inputs: + in: bootstrap.out + module: investment_nodes +- id: aggregate_time_feature + type: AggregateTimeFeatureNode + conf: {} + inputs: + in: time_features.all_corr_feature@out + module: investment_nodes +- id: merge_features + type: MergeNode + conf: + column: sample_id + inputs: + left: aggregate_time_feature.out + right: all_feature_computation.all_corr_feature@out + module: investment_nodes +- id: merge_target + type: MergeNode + conf: + column: sample_id + inputs: + left: merge_features.merged + right: performance_diff.hrp_nrp_diff@out + module: investment_nodes +- id: time_features + type: CompositeNode + conf: + input: + - all_max_raise.logreturn_df + - all_max_drawdown.logreturn_df + - all_data_distance.in + output: + - all_corr_feature.out + - all_data_distance.cov_df + - all_data_distance.distance_df + subnode_ids: + - all_max_raise + - all_max_drawdown + - all_data_distance + - all_max_drawdown_feature + - all_max_raise_feature + - all_mean_feature + - all_std_feature + - all_corr_feature + subnodes_conf: + all_max_raise: + conf: + negative: true + window: 12 + all_max_drawdown: + conf: + negative: false + window: 12 + all_data_distance: + conf: + window: 12 + all_max_drawdown_feature: + conf: + name: max_drawdown + all_max_raise_feature: + conf: + name: max_raise + all_mean_feature: + conf: + name: mean + all_std_feature: + conf: + name: std + all_corr_feature: + conf: + name: corr + taskgraph: notebooks/17assets/feature_computation.gq.yaml + inputs: + all_max_raise@logreturn_df: log_return.out + all_max_drawdown@logreturn_df: log_return.out + all_data_distance@in: log_return.out diff --git a/gQuant/plugins/hrp_plugin/notebooks/17assets/full_workflow_xgboost_performance.gq.yaml b/gQuant/plugins/hrp_plugin/notebooks/17assets/full_workflow_xgboost_performance.gq.yaml new file mode 100644 index 00000000..315ef735 --- /dev/null +++ b/gQuant/plugins/hrp_plugin/notebooks/17assets/full_workflow_xgboost_performance.gq.yaml @@ -0,0 +1,337 @@ +- id: load_raw_csv + type: LoadCsvNode + conf: + csvfile: data/pricess.csv + 17assets: true + inputs: {} + module: investment_nodes +- id: '' + type: Output_Collector + conf: {} + inputs: + in1: train_rsquared.out + in2: test_rsquared.out + in3: train_infer.out + in4: test_infer.out +- id: bootstrap + type: BootstrapNode + conf: + offset: 0 + samples: 4096 + partitions: 25 + inputs: + in: load_raw_csv.df_out + module: investment_nodes +- id: log_return + type: LogReturnNode + conf: {} + inputs: + in: bootstrap.out + module: investment_nodes +- id: distance_node + type: DistanceNode + conf: + window: 12 + inputs: + in: log_return.out + module: investment_nodes +- id: assets_order + type: HierarchicalClusteringNode + conf: {} + inputs: + in: distance_node.distance_df + module: investment_nodes +- id: hrp_weight + type: HRPWeightNode + conf: {} + inputs: + asset_order_df: assets_order.out + covariance_df: distance_node.cov_df + module: investment_nodes +- id: portfolio_construct_hrp + type: PortfolioNode + conf: {} + inputs: + return_df: log_return.out + weight_df: hrp_weight.out + transaction_df: hrp_transaction_cost.out + module: investment_nodes +- id: performance_hrp + type: PerformanceMetricNode + conf: {} + inputs: + in: leverage_hrp.lev_df + module: investment_nodes +- id: nrp_weight + type: NRPWeightNode + conf: {} + inputs: + in: distance_node.cov_df + module: investment_nodes +- id: portfolio_construct_nrp + type: PortfolioNode + conf: {} + inputs: + return_df: log_return.out + transaction_df: nrp_transaction_cost.out + weight_df: nrp_weight.out + module: investment_nodes +- id: performance_nrp + type: PerformanceMetricNode + conf: {} + inputs: + in: leverage_nrp.lev_df + module: investment_nodes +- id: max_drawdown + type: MaxDrawdownNode + conf: + window: 12 + inputs: + logreturn_df: log_return.out + module: investment_nodes +- id: max_drawdown_feature + type: FeatureNode + conf: + name: max_drawdown + inputs: + signal_df: max_drawdown.out + module: investment_nodes +- id: max_raise_feature + type: FeatureNode + conf: + name: max_raise + inputs: + signal_df: max_raise.out + feature_df: max_drawdown_feature.out + module: investment_nodes +- id: max_raise + type: MaxDrawdownNode + conf: + negative: true + window: 12 + inputs: + logreturn_df: log_return.out + module: investment_nodes +- id: all_data_distance + type: DistanceNode + conf: + window: 242 + inputs: + in: log_return.out + module: investment_nodes +- id: all_max_raise + type: MaxDrawdownNode + conf: + negative: true + window: 242 + inputs: + logreturn_df: log_return.out + module: investment_nodes +- id: all_max_drawdown + type: MaxDrawdownNode + conf: + negative: false + window: 242 + inputs: + logreturn_df: log_return.out + module: investment_nodes +- id: all_max_drawdown_feature + type: FeatureNode + conf: + name: all_max_drawdown + inputs: + signal_df: all_max_drawdown.out + module: investment_nodes +- id: all_max_raise_feature + type: FeatureNode + conf: + name: all_max_raise + inputs: + signal_df: all_max_raise.out + feature_df: all_max_drawdown_feature.out + module: investment_nodes +- id: mean_feature + type: FeatureNode + conf: + name: mean + inputs: + feature_df: max_raise_feature.out + signal_df: distance_node.mean_df + module: investment_nodes +- id: std_feature + type: FeatureNode + conf: + name: std + inputs: + signal_df: distance_node.std_df + feature_df: mean_feature.out + module: investment_nodes +- id: corr_feature + type: FeatureNode + conf: + name: corr + inputs: + signal_df: distance_node.corr_df + feature_df: std_feature.out + module: investment_nodes +- id: all_mean_feature + type: FeatureNode + conf: + name: all_mean + inputs: + feature_df: all_max_raise_feature.out + signal_df: all_data_distance.mean_df + module: investment_nodes +- id: all_std_feature + type: FeatureNode + conf: + name: all_std + inputs: + feature_df: all_mean_feature.out + signal_df: all_data_distance.std_df + module: investment_nodes +- id: all_corr_feature + type: FeatureNode + conf: + name: all_corr + inputs: + feature_df: all_std_feature.out + signal_df: all_data_distance.corr_df + module: investment_nodes +- id: aggregate_time_feature + type: AggregateTimeFeatureNode + conf: {} + inputs: + in: corr_feature.out + module: investment_nodes +- id: merge_features + type: MergeNode + conf: + column: sample_id + inputs: + right: all_corr_feature.out + left: aggregate_time_feature.out + module: investment_nodes +- id: hrp_nrp + type: DiffNode + conf: {} + inputs: + diff_b: performance_nrp.calmar_df + diff_a: performance_hrp.calmar_df + module: investment_nodes +- id: merge_target + type: MergeNode + conf: + column: sample_id + inputs: + right: hrp_nrp.out + left: merge_features.merged + module: investment_nodes +- id: leverage_hrp + type: LeverageNode + conf: + target_vol: 0.05 + long_window: 59 + short_window: 19 + inputs: + in: portfolio_construct_hrp.out + module: investment_nodes +- id: leverage_nrp + type: LeverageNode + conf: + target_vol: 0.05 + long_window: 59 + short_window: 19 + inputs: + in: portfolio_construct_nrp.out + module: investment_nodes +- id: hrp_transaction_cost + type: TransactionCostNode + conf: + cost: 0.0002 + inputs: + logreturn_df: hrp_weight.out + module: investment_nodes +- id: nrp_transaction_cost + type: TransactionCostNode + conf: + cost: 0.0002 + inputs: + logreturn_df: nrp_weight.out + module: investment_nodes +- id: split + type: DataSplittingNode + conf: + train_size: 0.9 + target: portfolio + inputs: + in: merge_target.merged + module: greenflow_gquant_plugin.ml +- id: xgboost_train + type: TrainXGBoostNode + conf: + num_of_rounds: 100 + columns: + - month + - sample_id + - year + - portfolio + include: false + xgboost_parameters: + eta: 0.3 + min_child_weight: 1 + subsample: 1 + sampling_method: uniform + colsample_bytree: 1 + colsample_bylevel: 1 + colsample_bynode: 1 + max_depth: 8 + max_leaves: 256 + grow_policy: depthwise + gamma: 0 + lambda: 1 + alpha: 0 + tree_method: gpu_hist + single_precision_histogram: false + deterministic_histogram: false + objective: 'reg:squarederror' + target: portfolio + inputs: + in: split.train + module: greenflow_gquant_plugin.ml +- id: train_infer + type: InferXGBoostNode + conf: + prediction: predict + pred_contribs: false + inputs: + data_in: split.train + model_in: xgboost_train.model_out + module: greenflow_gquant_plugin.ml +- id: test_infer + type: InferXGBoostNode + conf: + prediction: predict + pred_contribs: false + inputs: + data_in: split.test + model_in: xgboost_train.model_out + module: greenflow_gquant_plugin.ml +- id: train_rsquared + type: RSquaredNode + conf: + columns: + - portfolio + - predict + inputs: + in: train_infer.out + module: investment_nodes +- id: test_rsquared + type: RSquaredNode + conf: + columns: + - portfolio + - predict + inputs: + in: test_infer.out + module: investment_nodes diff --git a/gQuant/plugins/hrp_plugin/notebooks/17assets/hpo.gq.yaml b/gQuant/plugins/hrp_plugin/notebooks/17assets/hpo.gq.yaml new file mode 100644 index 00000000..0bf1e70d --- /dev/null +++ b/gQuant/plugins/hrp_plugin/notebooks/17assets/hpo.gq.yaml @@ -0,0 +1,75 @@ +- id: xgboost_train + type: ContextCompositeNode + conf: + output: + - test_rsquared.out + context: + num_rounds: + type: number + value: 100 + map: + - node_id: xgboost_train + xpath: xgboost_train.conf.num_of_rounds + eta: + type: number + map: + - node_id: xgboost_train + xpath: xgboost_train.conf.xgboost_parameters.eta + value: 0.3 + taskgraph: notebooks/17assets/parallel_xgboost_performance.gq.yaml + inputs: {} +- id: grid_search + type: GridRandomSearchNode + conf: + parameters: + - search: + function: grid_search + args: + - 100 + - 110 + - 120 + name: num_rounds + - search: + function: uniform + args: + - 0.1 + - 0.5 + name: eta + metrics: + - train_rsquared.out + - test_rsquared.out + best: + mode: max + metric: test_rsquared.out + tune: + local_dir: ./ray + name: exp + num_samples: 1 + resources_per_trial: + cpu: 16 + gpu: 4 + output: + - test_rsquared.out + context: + num_rounds: + type: number + value: 100 + map: + - node_id: xgboost_train + xpath: xgboost_train.conf.num_of_rounds + eta: + type: number + map: + - node_id: xgboost_train + xpath: xgboost_train.conf.xgboost_parameters.eta + value: 0.3 + taskgraph: notebooks/17assets/parallel_xgboost_performance.gq.yaml + inputs: + conf_in: xgboost_train.conf_out + module: greenflow_gquant_plugin.ml +- id: '' + type: Output_Collector + conf: {} + inputs: + in1: grid_search.conf_out + in2: grid_search.test_rsquared@out diff --git a/gQuant/plugins/hrp_plugin/notebooks/17assets/parallel_xgboost_performance.gq.yaml b/gQuant/plugins/hrp_plugin/notebooks/17assets/parallel_xgboost_performance.gq.yaml new file mode 100644 index 00000000..13e109df --- /dev/null +++ b/gQuant/plugins/hrp_plugin/notebooks/17assets/parallel_xgboost_performance.gq.yaml @@ -0,0 +1,113 @@ +- id: '' + type: Output_Collector + conf: {} + inputs: + in1: train_rsquared.out + in2: test_rsquared.out + in3: train_infer.out + in4: test_infer.out +- id: load_raw_csv + type: LoadCsvNode + conf: + csvfile: notebooks/data/pricess.csv + 17assets: true + inputs: {} + module: investment_nodes +- id: xgboost_train + type: TrainXGBoostNode + conf: + num_of_rounds: 100 + columns: + - month + - sample_id + - year + - portfolio + include: false + xgboost_parameters: + eta: 0.3 + min_child_weight: 1 + subsample: 1 + sampling_method: uniform + colsample_bytree: 1 + colsample_bylevel: 1 + colsample_bynode: 1 + max_depth: 8 + max_leaves: 256 + grow_policy: depthwise + gamma: 0 + lambda: 1 + alpha: 0 + tree_method: gpu_hist + single_precision_histogram: false + deterministic_histogram: false + objective: 'reg:squarederror' + target: portfolio + inputs: + in: persist.split_data@train + module: greenflow_gquant_plugin.ml +- id: train_infer + type: InferXGBoostNode + conf: + prediction: predict + pred_contribs: false + inputs: + model_in: xgboost_train.model_out + data_in: persist.split_data@train + module: greenflow_gquant_plugin.ml +- id: test_infer + type: InferXGBoostNode + conf: + prediction: predict + pred_contribs: false + inputs: + model_in: xgboost_train.model_out + data_in: persist.split_data@test + module: greenflow_gquant_plugin.ml +- id: parallel + type: SimpleParallelNode + conf: + input: + - bootstrap.in + output: + - merge_target.merged + map: + - node_id: bootstrap + xpath: bootstrap.conf.offset + taskgraph: notebooks/17assets/full_workflow_xgboost_performance.gq.yaml + iterations: 25 + inputs: + bootstrap@in: load_raw_csv.df_out + module: greenflow_dask_plugin +- id: persist + type: PersistNode + conf: {} + inputs: + split_data@test: split_data.test + split_data@train: split_data.train + module: greenflow_dask_plugin +- id: split_data + type: DataSplittingNode + conf: + train_size: 0.9 + target: portfolio + inputs: + in: parallel.merge_target@merged + module: greenflow_gquant_plugin.ml +- id: train_rsquared + type: RSquaredNode + conf: + columns: + - portfolio + - predict + inputs: + in: train_infer.out + module: investment_nodes +- id: test_rsquared + type: RSquaredNode + conf: + columns: + - portfolio + - predict + inputs: + in: test_infer.out + module: investment_nodes diff --git a/gQuant/plugins/hrp_plugin/notebooks/17assets/parallel_xgboost_shap.gq.yaml b/gQuant/plugins/hrp_plugin/notebooks/17assets/parallel_xgboost_shap.gq.yaml new file mode 100644 index 00000000..353c0ee2 --- /dev/null +++ b/gQuant/plugins/hrp_plugin/notebooks/17assets/parallel_xgboost_shap.gq.yaml @@ -0,0 +1,135 @@ +- id: '' + type: Output_Collector + conf: {} + inputs: + in1: train_shap_dot.summary_plot + in2: test_shap_dot.summary_plot + in3: train_shap_bar.summary_plot + in4: test_shap_bar.summary_plot +- id: load_raw_csv + type: LoadCsvNode + conf: + csvfile: notebooks/data/pricess.csv + 17assets: true + inputs: {} + module: investment_nodes +- id: xgboost_train + type: TrainXGBoostNode + conf: + num_of_rounds: 100 + columns: + - month + - sample_id + - year + - portfolio + include: false + xgboost_parameters: + eta: 0.3 + min_child_weight: 1 + subsample: 1 + sampling_method: uniform + colsample_bytree: 1 + colsample_bylevel: 1 + colsample_bynode: 1 + max_depth: 8 + max_leaves: 256 + grow_policy: depthwise + gamma: 0 + lambda: 1 + alpha: 0 + tree_method: gpu_hist + single_precision_histogram: false + deterministic_histogram: false + objective: 'reg:squarederror' + target: portfolio + inputs: + in: persist.split_data@train + module: greenflow_gquant_plugin.ml +- id: train_infer_shap + type: InferXGBoostNode + conf: + prediction: predict + pred_contribs: true + inputs: + model_in: xgboost_train.model_out + data_in: persist.split_data@train + module: greenflow_gquant_plugin.ml +- id: test_infer_shap + type: InferXGBoostNode + conf: + prediction: predict + pred_contribs: true + inputs: + model_in: xgboost_train.model_out + data_in: persist.split_data@test + module: greenflow_gquant_plugin.ml +- id: train_shap_dot + type: ShapSummaryPlotPlotNode + conf: + max_display: 20 + plot_type: dot + inputs: + model_in: xgboost_train.model_out + shap_in: train_infer_shap.out + data_in: persist.split_data@train + module: investment_nodes +- id: test_shap_dot + type: ShapSummaryPlotPlotNode + conf: + max_display: 20 + plot_type: dot + inputs: + model_in: xgboost_train.model_out + shap_in: test_infer_shap.out + data_in: persist.split_data@test + module: investment_nodes +- id: train_shap_bar + type: ShapSummaryPlotPlotNode + conf: + max_display: 20 + plot_type: bar + inputs: + model_in: xgboost_train.model_out + shap_in: train_infer_shap.out + data_in: persist.split_data@train + module: investment_nodes +- id: test_shap_bar + type: ShapSummaryPlotPlotNode + conf: + max_display: 20 + plot_type: bar + inputs: + model_in: xgboost_train.model_out + shap_in: test_infer_shap.out + data_in: persist.split_data@test + module: investment_nodes +- id: parallel + type: SimpleParallelNode + conf: + input: + - bootstrap.in + output: + - merge_target.merged + map: + - node_id: bootstrap + xpath: bootstrap.conf.offset + taskgraph: notebooks/17assets/full_workflow_xgboost_performance.gq.yaml + iterations: 25 + inputs: + bootstrap@in: load_raw_csv.df_out + module: greenflow_dask_plugin +- id: persist + type: PersistNode + conf: {} + inputs: + split_data@test: split_data.test + split_data@train: split_data.train + module: greenflow_dask_plugin +- id: split_data + type: DataSplittingNode + conf: + train_size: 0.9 + target: portfolio + inputs: + in: parallel.merge_target@merged + module: greenflow_gquant_plugin.ml diff --git a/gQuant/plugins/hrp_plugin/notebooks/17assets/workflow.gq.yaml b/gQuant/plugins/hrp_plugin/notebooks/17assets/workflow.gq.yaml new file mode 100644 index 00000000..0fbc9c50 --- /dev/null +++ b/gQuant/plugins/hrp_plugin/notebooks/17assets/workflow.gq.yaml @@ -0,0 +1,85 @@ +- id: load_raw_csv + type: LoadCsvNode + conf: + csvfile: data/pricess.csv + 17assets: true + inputs: {} + module: investment_nodes +- id: '' + type: Output_Collector + conf: {} + inputs: + in1: hrp_nrp_diff.out +- id: bootstrap + type: BootstrapNode + conf: + samples: 5120 + partitions: 100 + inputs: + in: load_raw_csv.df_out + module: investment_nodes +- id: log_return + type: LogReturnNode + conf: {} + inputs: + in: bootstrap.out + module: investment_nodes +- id: distance_node + type: DistanceNode + conf: + window: 12 + inputs: + in: log_return.out + module: investment_nodes +- id: assets_order + type: HierarchicalClusteringNode + conf: {} + inputs: + in: distance_node.distance_df + module: investment_nodes +- id: hrp_weight + type: HRPWeightNode + conf: {} + inputs: + asset_order_df: assets_order.out + covariance_df: distance_node.cov_df + module: investment_nodes +- id: portfolio_construct_hrp + type: PortfolioNode + conf: {} + inputs: + return_df: log_return.out + weight_df: hrp_weight.out + module: investment_nodes +- id: performance_hrp + type: PerformanceMetricNode + conf: {} + inputs: + in: portfolio_construct_hrp.out + module: investment_nodes +- id: nrp_weight + type: NRPWeightNode + conf: {} + inputs: + in: distance_node.cov_df + module: investment_nodes +- id: portfolio_construct_nrp + type: PortfolioNode + conf: {} + inputs: + weight_df: nrp_weight.out + return_df: log_return.out + module: investment_nodes +- id: performance_nrp + type: PerformanceMetricNode + conf: {} + inputs: + in: portfolio_construct_nrp.out + module: investment_nodes +- id: hrp_nrp_diff + type: DiffNode + conf: {} + inputs: + diff_a: performance_hrp.sharpe_df + diff_b: performance_nrp.sharpe_df + module: investment_nodes diff --git a/gQuant/plugins/hrp_plugin/notebooks/17assets/workflow_bootstrap.gq.yaml b/gQuant/plugins/hrp_plugin/notebooks/17assets/workflow_bootstrap.gq.yaml new file mode 100644 index 00000000..1962f67c --- /dev/null +++ b/gQuant/plugins/hrp_plugin/notebooks/17assets/workflow_bootstrap.gq.yaml @@ -0,0 +1,130 @@ +- id: load_raw_csv + type: LoadCsvNode + conf: + csvfile: notebooks/data/pricess.csv + 17assets: true + inputs: {} + module: investment_nodes +- id: '' + type: Output_Collector + conf: {} + inputs: + in1: hrp_nrp_diff.out + in2: performance_nrp.ret_df + in3: performance_nrp.sd_df + in4: performance_nrp.sharpe_df + in5: performance_hrp.ret_df + in6: performance_hrp.sd_df + in7: performance_hrp.sharpe_df + in8: performance_hrp.maxdd_df + in9: performance_nrp.calmar_df + in10: performance_hrp.calmar_df + in11: performance_nrp.maxdd_df +- id: log_return + type: LogReturnNode + conf: {} + inputs: + in: bootstrap.out + module: investment_nodes +- id: distance_node + type: DistanceNode + conf: + window: 12 + inputs: + in: log_return.out + module: investment_nodes +- id: assets_order + type: HierarchicalClusteringNode + conf: {} + inputs: + in: distance_node.distance_df + module: investment_nodes +- id: hrp_weight + type: HRPWeightNode + conf: {} + inputs: + asset_order_df: assets_order.out + covariance_df: distance_node.cov_df + module: investment_nodes +- id: portfolio_construct_hrp + type: PortfolioNode + conf: {} + inputs: + return_df: log_return.out + weight_df: hrp_weight.out + transaction_df: hrp_transaction_cost.out + module: investment_nodes +- id: performance_hrp + type: PerformanceMetricNode + conf: {} + inputs: + in: leverage_hrp.lev_df + module: investment_nodes +- id: nrp_weight + type: NRPWeightNode + conf: {} + inputs: + in: distance_node.cov_df + module: investment_nodes +- id: portfolio_construct_nrp + type: PortfolioNode + conf: {} + inputs: + weight_df: nrp_weight.out + return_df: log_return.out + transaction_df: nrp_transaction_cost.out + module: investment_nodes +- id: performance_nrp + type: PerformanceMetricNode + conf: {} + inputs: + in: leverage_nrp.lev_df + module: investment_nodes +- id: hrp_nrp_diff + type: DiffNode + conf: {} + inputs: + diff_a: performance_hrp.calmar_df + diff_b: performance_nrp.calmar_df + module: investment_nodes +- id: leverage_hrp + type: LeverageNode + conf: + target_vol: 0.05 + long_window: 59 + short_window: 19 + inputs: + in: portfolio_construct_hrp.out + module: investment_nodes +- id: leverage_nrp + type: LeverageNode + conf: + target_vol: 0.05 + long_window: 59 + short_window: 19 + inputs: + in: portfolio_construct_nrp.out + module: investment_nodes +- id: nrp_transaction_cost + type: TransactionCostNode + conf: + cost: 0.0002 + inputs: + logreturn_df: nrp_weight.out + module: investment_nodes +- id: hrp_transaction_cost + type: TransactionCostNode + conf: + cost: 0.0002 + inputs: + logreturn_df: hrp_weight.out + module: investment_nodes +- id: bootstrap + type: BootstrapNode + conf: + offset: 0 + samples: 4096 + partitions: 1 + inputs: + in: load_raw_csv.df_out + module: investment_nodes diff --git a/gQuant/plugins/hrp_plugin/notebooks/17assets/workflow_composite.gq.yaml b/gQuant/plugins/hrp_plugin/notebooks/17assets/workflow_composite.gq.yaml new file mode 100644 index 00000000..3123c203 --- /dev/null +++ b/gQuant/plugins/hrp_plugin/notebooks/17assets/workflow_composite.gq.yaml @@ -0,0 +1,105 @@ +- id: load_raw_csv + type: LoadCsvNode + conf: + csvfile: data/pricess.csv + 17assets: true + inputs: {} + module: investment_nodes +- id: '' + type: Output_Collector + conf: {} + inputs: + in1: hrp_nrp_diff.out + in2: performance_diff.hrp_nrp_diff@out +- id: bootstrap + type: BootstrapNode + conf: + samples: 5120 + partitions: 100 + inputs: + in: load_raw_csv.df_out + module: investment_nodes +- id: log_return + type: LogReturnNode + conf: {} + inputs: + in: bootstrap.out + module: investment_nodes +- id: distance_node + type: DistanceNode + conf: + window: 12 + inputs: + in: log_return.out + module: investment_nodes +- id: assets_order + type: HierarchicalClusteringNode + conf: {} + inputs: + in: distance_node.distance_df + module: investment_nodes +- id: hrp_weight + type: HRPWeightNode + conf: {} + inputs: + asset_order_df: assets_order.out + covariance_df: distance_node.cov_df + module: investment_nodes +- id: portfolio_construct_hrp + type: PortfolioNode + conf: {} + inputs: + return_df: log_return.out + weight_df: hrp_weight.out + module: investment_nodes +- id: performance_hrp + type: PerformanceMetricNode + conf: {} + inputs: + in: portfolio_construct_hrp.out + module: investment_nodes +- id: nrp_weight + type: NRPWeightNode + conf: {} + inputs: + in: distance_node.cov_df + module: investment_nodes +- id: portfolio_construct_nrp + type: PortfolioNode + conf: {} + inputs: + weight_df: nrp_weight.out + return_df: log_return.out + module: investment_nodes +- id: performance_nrp + type: PerformanceMetricNode + conf: {} + inputs: + in: portfolio_construct_nrp.out + module: investment_nodes +- id: hrp_nrp_diff + type: DiffNode + conf: {} + inputs: + diff_a: performance_hrp.sharpe_df + diff_b: performance_nrp.sharpe_df + module: investment_nodes +- id: performance_diff + type: CompositeNode + conf: + input: + - nrp_weight.in + - hrp_weight.covariance_df + - assets_order.in + - portfolio_construct_nrp.return_df + - portfolio_construct_hrp.return_df + output: + - hrp_nrp_diff.out + subnodes_conf: {} + taskgraph: notebooks/workflow.gq.yaml + inputs: + nrp_weight@in: distance_node.cov_df + hrp_weight@covariance_df: distance_node.cov_df + assets_order@in: distance_node.distance_df + portfolio_construct_nrp@return_df: log_return.out + portfolio_construct_hrp@return_df: log_return.out diff --git a/gQuant/plugins/hrp_plugin/notebooks/17assets/workflow_empirical.gq.yaml b/gQuant/plugins/hrp_plugin/notebooks/17assets/workflow_empirical.gq.yaml new file mode 100644 index 00000000..7f51ae7c --- /dev/null +++ b/gQuant/plugins/hrp_plugin/notebooks/17assets/workflow_empirical.gq.yaml @@ -0,0 +1,138 @@ +- id: load_raw_csv + type: LoadCsvNode + conf: + csvfile: notebooks/data/pricess.csv + 17assets: true + inputs: {} + module: investment_nodes +- id: '' + type: Output_Collector + conf: {} + inputs: + in1: hrp_nrp_diff.out + in2: raw.out + in3: log_return.out + in4: assets_order.out + in5: hrp_weight.out + in6: portfolio_construct_hrp.out + in7: portfolio_construct_nrp.out + in8: nrp_weight.out + in9: distance_node.cov_df + in10: distance_node.distance_df + in11: leverage_hrp.lev_df + in12: leverage_nrp.lev_df + in13: performance_nrp.calmar_df + in14: performance_hrp.calmar_df + in15: performance_nrp.sharpe_df + in16: performance_nrp.sd_df + in17: performance_nrp.ret_df + in18: performance_nrp.maxdd_df + in19: performance_hrp.ret_df + in20: performance_hrp.sd_df + in21: performance_hrp.sharpe_df + in22: performance_hrp.maxdd_df +- id: log_return + type: LogReturnNode + conf: {} + inputs: + in: raw.out + module: investment_nodes +- id: distance_node + type: DistanceNode + conf: + window: 12 + inputs: + in: log_return.out + module: investment_nodes +- id: assets_order + type: HierarchicalClusteringNode + conf: {} + inputs: + in: distance_node.distance_df + module: investment_nodes +- id: hrp_weight + type: HRPWeightNode + conf: {} + inputs: + asset_order_df: assets_order.out + covariance_df: distance_node.cov_df + module: investment_nodes +- id: portfolio_construct_hrp + type: PortfolioNode + conf: {} + inputs: + return_df: log_return.out + weight_df: hrp_weight.out + transaction_df: hrp_transaction_cost.out + module: investment_nodes +- id: performance_hrp + type: PerformanceMetricNode + conf: {} + inputs: + in: leverage_hrp.lev_df + module: investment_nodes +- id: nrp_weight + type: NRPWeightNode + conf: {} + inputs: + in: distance_node.cov_df + module: investment_nodes +- id: portfolio_construct_nrp + type: PortfolioNode + conf: {} + inputs: + weight_df: nrp_weight.out + return_df: log_return.out + transaction_df: nrp_transaction_cost.out + module: investment_nodes +- id: performance_nrp + type: PerformanceMetricNode + conf: {} + inputs: + in: leverage_nrp.lev_df + module: investment_nodes +- id: hrp_nrp_diff + type: DiffNode + conf: {} + inputs: + diff_a: performance_hrp.calmar_df + diff_b: performance_nrp.calmar_df + module: investment_nodes +- id: raw + type: RawDataNode + conf: {} + inputs: + in: load_raw_csv.df_out + module: investment_nodes +- id: leverage_hrp + type: LeverageNode + conf: + target_vol: 0.05 + long_window: 59 + short_window: 19 + inputs: + in: portfolio_construct_hrp.out + module: investment_nodes +- id: leverage_nrp + type: LeverageNode + conf: + target_vol: 0.05 + long_window: 59 + short_window: 19 + inputs: + in: portfolio_construct_nrp.out + module: investment_nodes +- id: nrp_transaction_cost + type: TransactionCostNode + conf: + cost: 0.0002 + inputs: + logreturn_df: nrp_weight.out + module: investment_nodes +- id: hrp_transaction_cost + type: TransactionCostNode + conf: + cost: 0.0002 + inputs: + logreturn_df: hrp_weight.out + module: investment_nodes diff --git a/gQuant/plugins/hrp_plugin/notebooks/17assets/workflow_raw.gq.yaml b/gQuant/plugins/hrp_plugin/notebooks/17assets/workflow_raw.gq.yaml new file mode 100644 index 00000000..faecba38 --- /dev/null +++ b/gQuant/plugins/hrp_plugin/notebooks/17assets/workflow_raw.gq.yaml @@ -0,0 +1,95 @@ +- id: load_raw_csv + type: LoadCsvNode + conf: + csvfile: data/pricess.csv + 17assets: true + inputs: {} + module: investment_nodes +- id: '' + type: Output_Collector + conf: {} + inputs: + in1: hrp_nrp_diff.out +- id: log_return + type: LogReturnNode + conf: {} + inputs: + in: raw.out + module: investment_nodes +- id: distance_node + type: DistanceNode + conf: + window: 12 + inputs: + in: log_return.out + module: investment_nodes +- id: assets_order + type: HierarchicalClusteringNode + conf: {} + inputs: + in: distance_node.distance_df + module: investment_nodes +- id: hrp_weight + type: HRPWeightNode + conf: {} + inputs: + asset_order_df: assets_order.out + covariance_df: distance_node.cov_df + module: investment_nodes +- id: portfolio_construct_hrp + type: PortfolioNode + conf: {} + inputs: + return_df: log_return.out + weight_df: hrp_weight.out + leverage_df: leverage.lev_df + module: investment_nodes +- id: performance_hrp + type: PerformanceMetricNode + conf: {} + inputs: + in: portfolio_construct_hrp.out + module: investment_nodes +- id: nrp_weight + type: NRPWeightNode + conf: {} + inputs: + in: distance_node.cov_df + module: investment_nodes +- id: portfolio_construct_nrp + type: PortfolioNode + conf: {} + inputs: + weight_df: nrp_weight.out + return_df: log_return.out + leverage_df: leverage.lev_df + module: investment_nodes +- id: performance_nrp + type: PerformanceMetricNode + conf: {} + inputs: + in: portfolio_construct_nrp.out + module: investment_nodes +- id: hrp_nrp_diff + type: DiffNode + conf: {} + inputs: + diff_a: performance_hrp.sharpe_df + diff_b: performance_nrp.sharpe_df + module: investment_nodes +- id: raw + type: RawDataNode + conf: {} + inputs: + in: load_raw_csv.df_out + module: investment_nodes +- id: leverage + type: LeverageNode + conf: + target_vol: 0.05 + long_window: 59 + short_window: 19 + window: 12 + inputs: + in: log_return.out + module: investment_nodes diff --git a/gQuant/plugins/hrp_plugin/notebooks/17assets/workflow_simplified.gq.yaml b/gQuant/plugins/hrp_plugin/notebooks/17assets/workflow_simplified.gq.yaml new file mode 100644 index 00000000..7b824d00 --- /dev/null +++ b/gQuant/plugins/hrp_plugin/notebooks/17assets/workflow_simplified.gq.yaml @@ -0,0 +1,52 @@ +- id: load_raw_csv + type: LoadCsvNode + conf: + csvfile: data/pricess.csv + 17assets: true + inputs: {} + module: investment_nodes +- id: '' + type: Output_Collector + conf: {} + inputs: + in1: performance_diff.hrp_nrp_diff@out +- id: bootstrap + type: BootstrapNode + conf: + samples: 5120 + partitions: 100 + inputs: + in: load_raw_csv.df_out + module: investment_nodes +- id: log_return + type: LogReturnNode + conf: {} + inputs: + in: bootstrap.out + module: investment_nodes +- id: distance_node + type: DistanceNode + conf: + window: 12 + inputs: + in: log_return.out + module: investment_nodes +- id: performance_diff + type: CompositeNode + conf: + input: + - nrp_weight.in + - hrp_weight.covariance_df + - assets_order.in + - portfolio_construct_nrp.return_df + - portfolio_construct_hrp.return_df + output: + - hrp_nrp_diff.out + subnodes_conf: {} + taskgraph: notebooks/workflow.gq.yaml + inputs: + nrp_weight@in: distance_node.cov_df + hrp_weight@covariance_df: distance_node.cov_df + assets_order@in: distance_node.distance_df + portfolio_construct_nrp@return_df: log_return.out + portfolio_construct_hrp@return_df: log_return.out diff --git a/gQuant/plugins/hrp_plugin/notebooks/17assets/xgboost_model.gq.yaml b/gQuant/plugins/hrp_plugin/notebooks/17assets/xgboost_model.gq.yaml new file mode 100644 index 00000000..430bcf84 --- /dev/null +++ b/gQuant/plugins/hrp_plugin/notebooks/17assets/xgboost_model.gq.yaml @@ -0,0 +1,262 @@ +- id: load_raw_csv + type: LoadCsvNode + conf: + csvfile: data/pricess.csv + 17assets: true + inputs: {} + module: investment_nodes +- id: '' + type: Output_Collector + conf: {} + inputs: + in1: export_model.filename +- id: bootstrap + type: BootstrapNode + conf: + samples: 2048 + partitions: 500 + inputs: + in: load_raw_csv.df_out + module: investment_nodes +- id: log_return + type: LogReturnNode + conf: {} + inputs: + in: bootstrap.dask_df + module: investment_nodes +- id: distance_node + type: DistanceNode + conf: + window: 12 + inputs: + in: log_return.out + module: investment_nodes +- id: assets_order + type: HierarchicalClusteringNode + conf: {} + inputs: + in: distance_node.distance_df + module: investment_nodes +- id: hrp_weight + type: HRPWeightNode + conf: {} + inputs: + asset_order_df: assets_order.out + covariance_df: distance_node.cov_df + module: investment_nodes +- id: portfolio_construct_hrp + type: PortfolioNode + conf: {} + inputs: + return_df: log_return.out + weight_df: hrp_weight.out + module: investment_nodes +- id: performance_hrp + type: PerformanceMetricNode + conf: {} + inputs: + in: portfolio_construct_hrp.out + module: investment_nodes +- id: nrp_weight + type: NRPWeightNode + conf: {} + inputs: + in: distance_node.cov_df + module: investment_nodes +- id: portfolio_construct_nrp + type: PortfolioNode + conf: {} + inputs: + weight_df: nrp_weight.out + return_df: log_return.out + module: investment_nodes +- id: performance_nrp + type: PerformanceMetricNode + conf: {} + inputs: + in: portfolio_construct_nrp.out + module: investment_nodes +- id: max_drawdown + type: MaxDrawdownNode + conf: + window: 12 + inputs: + logreturn_df: log_return.out + module: investment_nodes +- id: max_drawdown_feature + type: FeatureNode + conf: + name: max_drawdown + inputs: + signal_df: max_drawdown.out + module: investment_nodes +- id: max_raise_feature + type: FeatureNode + conf: + name: max_raise + inputs: + signal_df: max_raise.out + feature_df: max_drawdown_feature.out + module: investment_nodes +- id: max_raise + type: MaxDrawdownNode + conf: + negative: true + window: 12 + inputs: + logreturn_df: log_return.out + module: investment_nodes +- id: all_data_distance + type: DistanceNode + conf: + window: 242 + inputs: + in: log_return.out + module: investment_nodes +- id: all_max_raise + type: MaxDrawdownNode + conf: + negative: true + window: 242 + inputs: + logreturn_df: log_return.out + module: investment_nodes +- id: all_max_drawdown + type: MaxDrawdownNode + conf: + negative: false + window: 242 + inputs: + logreturn_df: log_return.out + module: investment_nodes +- id: all_max_drawdown_feature + type: FeatureNode + conf: + name: all_max_drawdown + inputs: + signal_df: all_max_drawdown.out + module: investment_nodes +- id: all_max_raise_feature + type: FeatureNode + conf: + name: all_max_raise + inputs: + signal_df: all_max_raise.out + feature_df: all_max_drawdown_feature.out + module: investment_nodes +- id: mean_feature + type: FeatureNode + conf: + name: mean + inputs: + feature_df: max_raise_feature.out + signal_df: distance_node.mean_df + module: investment_nodes +- id: std_feature + type: FeatureNode + conf: + name: std + inputs: + signal_df: distance_node.std_df + feature_df: mean_feature.out + module: investment_nodes +- id: corr_feature + type: FeatureNode + conf: + name: corr + inputs: + signal_df: distance_node.corr_df + feature_df: std_feature.out + module: investment_nodes +- id: all_mean_feature + type: FeatureNode + conf: + name: all_mean + inputs: + feature_df: all_max_raise_feature.out + signal_df: all_data_distance.mean_df + module: investment_nodes +- id: all_std_feature + type: FeatureNode + conf: + name: all_std + inputs: + feature_df: all_mean_feature.out + signal_df: all_data_distance.std_df + module: investment_nodes +- id: all_corr_feature + type: FeatureNode + conf: + name: all_corr + inputs: + feature_df: all_std_feature.out + signal_df: all_data_distance.corr_df + module: investment_nodes +- id: aggregate_time_feature + type: AggregateTimeFeatureNode + conf: {} + inputs: + in: corr_feature.out + module: investment_nodes +- id: merge_features + type: MergeNode + conf: + column: sample_id + inputs: + right: all_corr_feature.out + left: aggregate_time_feature.out + module: investment_nodes +- id: hpr_nrp + type: DiffNode + conf: {} + inputs: + diff_b: performance_nrp.sharpe_df + diff_a: performance_hrp.sharpe_df + module: investment_nodes +- id: merge_target + type: MergeNode + conf: + column: sample_id + inputs: + right: hpr_nrp.out + left: merge_features.merged + module: investment_nodes +- id: xgboost_model + type: TrainXGBoostNode + conf: + num_of_rounds: 100 + columns: + - sample_id + - year + - month + - portfolio + include: false + xgboost_parameters: + eta: 0.3 + min_child_weight: 1 + subsample: 1 + sampling_method: uniform + colsample_bytree: 1 + colsample_bylevel: 1 + colsample_bynode: 1 + max_depth: 8 + max_leaves: 256 + grow_policy: depthwise + gamma: 0 + lambda: 1 + alpha: 0 + tree_method: gpu_hist + single_precision_histogram: false + deterministic_histogram: false + objective: 'reg:squarederror' + target: portfolio + inputs: + in: merge_target.merged + module: greenflow_gquant_plugin.ml +- id: export_model + type: XGBoostExportNode + conf: + path: full_xgboost_model + inputs: + model_in: xgboost_model.model_out + module: greenflow_gquant_plugin.analysis diff --git a/gQuant/plugins/hrp_plugin/notebooks/17assets/xgboost_model_simplified.gq.yaml b/gQuant/plugins/hrp_plugin/notebooks/17assets/xgboost_model_simplified.gq.yaml new file mode 100644 index 00000000..21f9d7cc --- /dev/null +++ b/gQuant/plugins/hrp_plugin/notebooks/17assets/xgboost_model_simplified.gq.yaml @@ -0,0 +1,210 @@ +- id: '' + type: Output_Collector + conf: {} + inputs: + in1: export_model.filename +- id: xgboost_model + type: TrainXGBoostNode + conf: + num_of_rounds: 100 + columns: + - sample_id + - year + - month + - portfolio + include: false + xgboost_parameters: + eta: 0.3 + min_child_weight: 1 + subsample: 1 + sampling_method: uniform + colsample_bytree: 1 + colsample_bylevel: 1 + colsample_bynode: 1 + max_depth: 8 + max_leaves: 256 + grow_policy: depthwise + gamma: 0 + lambda: 1 + alpha: 0 + tree_method: gpu_hist + single_precision_histogram: false + deterministic_histogram: false + objective: 'reg:squarederror' + target: portfolio + inputs: + in: merge_target.merged + module: greenflow_gquant_plugin.ml +- id: export_model + type: XGBoostExportNode + conf: + path: full_xgboost_model + inputs: + model_in: xgboost_model.model_out + module: greenflow_gquant_plugin.analysis +- id: performance_diff + type: CompositeNode + conf: + input: + - nrp_weight.in + - hrp_weight.covariance_df + - assets_order.in + - portfolio_construct_nrp.return_df + - portfolio_construct_hrp.return_df + output: + - hrp_nrp_diff.out + subnodes_conf: {} + taskgraph: notebooks/workflow.gq.yaml + inputs: + portfolio_construct_nrp@return_df: log_return.out + portfolio_construct_hrp@return_df: log_return.out + nrp_weight@in: time_features.all_data_distance@cov_df + hrp_weight@covariance_df: time_features.all_data_distance@cov_df + assets_order@in: time_features.all_data_distance@distance_df +- id: all_feature_computation + type: CompositeNode + conf: + input: + - all_max_raise.logreturn_df + - all_max_drawdown.logreturn_df + - all_data_distance.in + output: + - all_corr_feature.out + - all_data_distance.cov_df + - all_data_distance.distance_df + subnode_ids: + - all_max_raise + - all_max_drawdown + - all_data_distance + - all_max_drawdown_feature + - all_max_raise_feature + - all_mean_feature + - all_std_feature + - all_corr_feature + subnodes_conf: + all_max_raise: + conf: + negative: true + window: 242 + all_max_drawdown: + conf: + negative: false + window: 242 + all_data_distance: + conf: + window: 242 + all_max_drawdown_feature: + conf: + name: all_max_drawdown + all_max_raise_feature: + conf: + name: all_max_raise + all_mean_feature: + conf: + name: all_mean + all_std_feature: + conf: + name: all_std + all_corr_feature: + conf: + name: all_corr + taskgraph: notebooks/17assets/feature_computation.gq.yaml + inputs: + all_max_raise@logreturn_df: log_return.out + all_max_drawdown@logreturn_df: log_return.out + all_data_distance@in: log_return.out +- id: load_raw_csv + type: LoadCsvNode + conf: + csvfile: data/pricess.csv + 17assets: true + inputs: {} + module: investment_nodes +- id: bootstrap + type: BootstrapNode + conf: + samples: 5120 + partitions: 200 + inputs: + in: load_raw_csv.df_out + module: investment_nodes +- id: log_return + type: LogReturnNode + conf: {} + inputs: + in: bootstrap.out + module: investment_nodes +- id: aggregate_time_feature + type: AggregateTimeFeatureNode + conf: {} + inputs: + in: time_features.all_corr_feature@out + module: investment_nodes +- id: merge_features + type: MergeNode + conf: + column: sample_id + inputs: + left: aggregate_time_feature.out + right: all_feature_computation.all_corr_feature@out + module: investment_nodes +- id: merge_target + type: MergeNode + conf: + column: sample_id + inputs: + left: merge_features.merged + right: performance_diff.hrp_nrp_diff@out + module: investment_nodes +- id: time_features + type: CompositeNode + conf: + input: + - all_max_raise.logreturn_df + - all_max_drawdown.logreturn_df + - all_data_distance.in + output: + - all_corr_feature.out + - all_data_distance.cov_df + - all_data_distance.distance_df + subnode_ids: + - all_max_raise + - all_max_drawdown + - all_data_distance + - all_max_drawdown_feature + - all_max_raise_feature + - all_mean_feature + - all_std_feature + - all_corr_feature + subnodes_conf: + all_max_raise: + conf: + negative: true + window: 12 + all_max_drawdown: + conf: + negative: false + window: 12 + all_data_distance: + conf: + window: 12 + all_max_drawdown_feature: + conf: + name: max_drawdown + all_max_raise_feature: + conf: + name: max_raise + all_mean_feature: + conf: + name: mean + all_std_feature: + conf: + name: std + all_corr_feature: + conf: + name: corr + taskgraph: notebooks/17assets/feature_computation.gq.yaml + inputs: + all_max_raise@logreturn_df: log_return.out + all_max_drawdown@logreturn_df: log_return.out + all_data_distance@in: log_return.out diff --git a/gQuant/plugins/hrp_plugin/notebooks/17assets/xgboost_performance.gq.yaml b/gQuant/plugins/hrp_plugin/notebooks/17assets/xgboost_performance.gq.yaml new file mode 100644 index 00000000..6da1eb55 --- /dev/null +++ b/gQuant/plugins/hrp_plugin/notebooks/17assets/xgboost_performance.gq.yaml @@ -0,0 +1,251 @@ +- id: '' + type: Output_Collector + conf: {} + inputs: + in1: train_rsquared.out + in2: test_rsquared.out + in3: train_infer.out + in4: test_infer.out +- id: performance_diff + type: CompositeNode + conf: + input: + - nrp_weight.in + - hrp_weight.covariance_df + - assets_order.in + - portfolio_construct_nrp.return_df + - portfolio_construct_hrp.return_df + output: + - hrp_nrp_diff.out + subnodes_conf: {} + taskgraph: notebooks/17assets/workflow_bootstrap.gq.yaml + inputs: + portfolio_construct_nrp@return_df: log_return.out + portfolio_construct_hrp@return_df: log_return.out + nrp_weight@in: time_features.all_data_distance@cov_df + hrp_weight@covariance_df: time_features.all_data_distance@cov_df + assets_order@in: time_features.all_data_distance@distance_df +- id: all_feature_computation + type: CompositeNode + conf: + input: + - all_max_raise.logreturn_df + - all_max_drawdown.logreturn_df + - all_data_distance.in + output: + - all_corr_feature.out + - all_data_distance.cov_df + - all_data_distance.distance_df + subnode_ids: + - all_max_raise + - all_max_drawdown + - all_data_distance + - all_max_drawdown_feature + - all_max_raise_feature + - all_mean_feature + - all_std_feature + - all_corr_feature + subnodes_conf: + all_max_raise: + conf: + negative: true + window: 242 + all_max_drawdown: + conf: + negative: false + window: 242 + all_data_distance: + conf: + window: 242 + all_max_drawdown_feature: + conf: + name: all_max_drawdown + all_max_raise_feature: + conf: + name: all_max_raise + all_mean_feature: + conf: + name: all_mean + all_std_feature: + conf: + name: all_std + all_corr_feature: + conf: + name: all_corr + taskgraph: notebooks/17assets/feature_computation.gq.yaml + inputs: + all_max_raise@logreturn_df: log_return.out + all_max_drawdown@logreturn_df: log_return.out + all_data_distance@in: log_return.out +- id: load_raw_csv + type: LoadCsvNode + conf: + csvfile: notebooks/data/pricess.csv + 17assets: true + inputs: {} + module: investment_nodes +- id: bootstrap + type: BootstrapNode + conf: + offset: 0 + samples: 4096 + partitions: 200 + inputs: + in: load_raw_csv.df_out + module: investment_nodes +- id: log_return + type: LogReturnNode + conf: {} + inputs: + in: bootstrap.out + module: investment_nodes +- id: aggregate_time_feature + type: AggregateTimeFeatureNode + conf: {} + inputs: + in: time_features.all_corr_feature@out + module: investment_nodes +- id: merge_features + type: MergeNode + conf: + column: sample_id + inputs: + left: aggregate_time_feature.out + right: all_feature_computation.all_corr_feature@out + module: investment_nodes +- id: merge_target + type: MergeNode + conf: + column: sample_id + inputs: + left: merge_features.merged + right: performance_diff.hrp_nrp_diff@out + module: investment_nodes +- id: time_features + type: CompositeNode + conf: + input: + - all_max_raise.logreturn_df + - all_max_drawdown.logreturn_df + - all_data_distance.in + output: + - all_corr_feature.out + - all_data_distance.cov_df + - all_data_distance.distance_df + subnode_ids: + - all_max_raise + - all_max_drawdown + - all_data_distance + - all_max_drawdown_feature + - all_max_raise_feature + - all_mean_feature + - all_std_feature + - all_corr_feature + subnodes_conf: + all_max_raise: + conf: + negative: true + window: 12 + all_max_drawdown: + conf: + negative: false + window: 12 + all_data_distance: + conf: + window: 12 + all_max_drawdown_feature: + conf: + name: max_drawdown + all_max_raise_feature: + conf: + name: max_raise + all_mean_feature: + conf: + name: mean + all_std_feature: + conf: + name: std + all_corr_feature: + conf: + name: corr + taskgraph: notebooks/17assets/feature_computation.gq.yaml + inputs: + all_max_raise@logreturn_df: log_return.out + all_max_drawdown@logreturn_df: log_return.out + all_data_distance@in: log_return.out +- id: split + type: DataSplittingNode + conf: + train_size: 0.9 + target: portfolio + inputs: + in: merge_target.merged + module: greenflow_gquant_plugin.ml +- id: xgboost_train + type: TrainXGBoostNode + conf: + num_of_rounds: 100 + columns: + - month + - sample_id + - year + - portfolio + include: false + xgboost_parameters: + eta: 0.3 + min_child_weight: 1 + subsample: 1 + sampling_method: uniform + colsample_bytree: 1 + colsample_bylevel: 1 + colsample_bynode: 1 + max_depth: 8 + max_leaves: 256 + grow_policy: depthwise + gamma: 0 + lambda: 1 + alpha: 0 + tree_method: gpu_hist + single_precision_histogram: false + deterministic_histogram: false + objective: 'reg:squarederror' + target: portfolio + inputs: + in: split.train + module: greenflow_gquant_plugin.ml +- id: train_infer + type: InferXGBoostNode + conf: + prediction: predict + pred_contribs: false + inputs: + data_in: split.train + model_in: xgboost_train.model_out + module: greenflow_gquant_plugin.ml +- id: test_infer + type: InferXGBoostNode + conf: + prediction: predict + pred_contribs: false + inputs: + data_in: split.test + model_in: xgboost_train.model_out + module: greenflow_gquant_plugin.ml +- id: train_rsquared + type: RSquaredNode + conf: + columns: + - portfolio + - predict + inputs: + in: train_infer.out + module: investment_nodes +- id: test_rsquared + type: RSquaredNode + conf: + columns: + - portfolio + - predict + inputs: + in: test_infer.out + module: investment_nodes diff --git a/gQuant/plugins/hrp_plugin/notebooks/17assets/xgboost_shap.gq.yaml b/gQuant/plugins/hrp_plugin/notebooks/17assets/xgboost_shap.gq.yaml new file mode 100644 index 00000000..6f42956e --- /dev/null +++ b/gQuant/plugins/hrp_plugin/notebooks/17assets/xgboost_shap.gq.yaml @@ -0,0 +1,273 @@ +- id: '' + type: Output_Collector + conf: {} + inputs: + in1: train_shap_dot.summary_plot + in2: test_shap_dot.summary_plot + in3: train_shap_bar.summary_plot + in4: test_shap_bar.summary_plot +- id: performance_diff + type: CompositeNode + conf: + input: + - nrp_weight.in + - hrp_weight.covariance_df + - assets_order.in + - portfolio_construct_nrp.return_df + - portfolio_construct_hrp.return_df + output: + - hrp_nrp_diff.out + subnodes_conf: {} + taskgraph: notebooks/17assets/workflow_bootstrap.gq.yaml + inputs: + portfolio_construct_nrp@return_df: log_return.out + portfolio_construct_hrp@return_df: log_return.out + nrp_weight@in: time_features.all_data_distance@cov_df + hrp_weight@covariance_df: time_features.all_data_distance@cov_df + assets_order@in: time_features.all_data_distance@distance_df +- id: all_feature_computation + type: CompositeNode + conf: + input: + - all_max_raise.logreturn_df + - all_max_drawdown.logreturn_df + - all_data_distance.in + output: + - all_corr_feature.out + - all_data_distance.cov_df + - all_data_distance.distance_df + subnode_ids: + - all_max_raise + - all_max_drawdown + - all_data_distance + - all_max_drawdown_feature + - all_max_raise_feature + - all_mean_feature + - all_std_feature + - all_corr_feature + subnodes_conf: + all_max_raise: + conf: + negative: true + window: 242 + all_max_drawdown: + conf: + negative: false + window: 242 + all_data_distance: + conf: + window: 242 + all_max_drawdown_feature: + conf: + name: all_max_drawdown + all_max_raise_feature: + conf: + name: all_max_raise + all_mean_feature: + conf: + name: all_mean + all_std_feature: + conf: + name: all_std + all_corr_feature: + conf: + name: all_corr + taskgraph: notebooks/17assets/feature_computation.gq.yaml + inputs: + all_max_raise@logreturn_df: log_return.out + all_max_drawdown@logreturn_df: log_return.out + all_data_distance@in: log_return.out +- id: load_raw_csv + type: LoadCsvNode + conf: + csvfile: notebooks/data/pricess.csv + 17assets: true + inputs: {} + module: investment_nodes +- id: bootstrap + type: BootstrapNode + conf: + offset: 0 + samples: 4096 + partitions: 200 + inputs: + in: load_raw_csv.df_out + module: investment_nodes +- id: log_return + type: LogReturnNode + conf: {} + inputs: + in: bootstrap.out + module: investment_nodes +- id: aggregate_time_feature + type: AggregateTimeFeatureNode + conf: {} + inputs: + in: time_features.all_corr_feature@out + module: investment_nodes +- id: merge_features + type: MergeNode + conf: + column: sample_id + inputs: + left: aggregate_time_feature.out + right: all_feature_computation.all_corr_feature@out + module: investment_nodes +- id: merge_target + type: MergeNode + conf: + column: sample_id + inputs: + left: merge_features.merged + right: performance_diff.hrp_nrp_diff@out + module: investment_nodes +- id: time_features + type: CompositeNode + conf: + input: + - all_max_raise.logreturn_df + - all_max_drawdown.logreturn_df + - all_data_distance.in + output: + - all_corr_feature.out + - all_data_distance.cov_df + - all_data_distance.distance_df + subnode_ids: + - all_max_raise + - all_max_drawdown + - all_data_distance + - all_max_drawdown_feature + - all_max_raise_feature + - all_mean_feature + - all_std_feature + - all_corr_feature + subnodes_conf: + all_max_raise: + conf: + negative: true + window: 12 + all_max_drawdown: + conf: + negative: false + window: 12 + all_data_distance: + conf: + window: 12 + all_max_drawdown_feature: + conf: + name: max_drawdown + all_max_raise_feature: + conf: + name: max_raise + all_mean_feature: + conf: + name: mean + all_std_feature: + conf: + name: std + all_corr_feature: + conf: + name: corr + taskgraph: notebooks/17assets/feature_computation.gq.yaml + inputs: + all_max_raise@logreturn_df: log_return.out + all_max_drawdown@logreturn_df: log_return.out + all_data_distance@in: log_return.out +- id: split + type: DataSplittingNode + conf: + train_size: 0.9 + target: portfolio + inputs: + in: merge_target.merged + module: greenflow_gquant_plugin.ml +- id: xgboost_train + type: TrainXGBoostNode + conf: + num_of_rounds: 100 + columns: + - month + - sample_id + - year + - portfolio + include: false + xgboost_parameters: + eta: 0.3 + min_child_weight: 1 + subsample: 1 + sampling_method: uniform + colsample_bytree: 1 + colsample_bylevel: 1 + colsample_bynode: 1 + max_depth: 8 + max_leaves: 256 + grow_policy: depthwise + gamma: 0 + lambda: 1 + alpha: 0 + tree_method: gpu_hist + single_precision_histogram: false + deterministic_histogram: false + objective: 'reg:squarederror' + target: portfolio + inputs: + in: split.train + module: greenflow_gquant_plugin.ml +- id: train_infer_shap + type: InferXGBoostNode + conf: + prediction: predict + pred_contribs: true + inputs: + data_in: split.train + model_in: xgboost_train.model_out + module: greenflow_gquant_plugin.ml +- id: test_infer_shap + type: InferXGBoostNode + conf: + prediction: predict + pred_contribs: true + inputs: + data_in: split.test + model_in: xgboost_train.model_out + module: greenflow_gquant_plugin.ml +- id: train_shap_dot + type: ShapSummaryPlotPlotNode + conf: + max_display: 20 + plot_type: dot + inputs: + model_in: xgboost_train.model_out + data_in: split.train + shap_in: train_infer_shap.out + module: investment_nodes +- id: test_shap_dot + type: ShapSummaryPlotPlotNode + conf: + max_display: 20 + plot_type: dot + inputs: + model_in: xgboost_train.model_out + data_in: split.test + shap_in: test_infer_shap.out + module: investment_nodes +- id: train_shap_bar + type: ShapSummaryPlotPlotNode + conf: + max_display: 20 + plot_type: bar + inputs: + model_in: xgboost_train.model_out + shap_in: train_infer_shap.out + data_in: split.train + module: investment_nodes +- id: test_shap_bar + type: ShapSummaryPlotPlotNode + conf: + max_display: 20 + plot_type: bar + inputs: + model_in: xgboost_train.model_out + shap_in: test_infer_shap.out + data_in: split.test + module: investment_nodes diff --git a/gQuant/plugins/hrp_plugin/notebooks/data/pricing.csv b/gQuant/plugins/hrp_plugin/notebooks/data/pricing.csv new file mode 100644 index 00000000..6457d85b --- /dev/null +++ b/gQuant/plugins/hrp_plugin/notebooks/data/pricing.csv @@ -0,0 +1,1259 @@ +,AAA,BBB,CCC,DDD,EEE,FFF,GGG,HHH,III,JJJ +2015-01-02,111.07624153236893,21.520832027326044,65.25908793471643,48.05976154619939,48.894889933630964,36.36601001633004,95.70193830601218,163.97976077546193,116.54285952138447,89.57435760810938 +2015-01-05,104.20249361849957,11.99660124771985,59.280183423484445,45.40685883612997,45.7763070330883,30.16561974245313,86.39808656157606,164.32582510514345,103.46810349175007,74.5183605870504 +2015-01-06,109.89444659947779,16.558498344339107,51.51055736089944,46.756220452123294,47.5261496583133,37.26799598299289,84.0535535554538,163.93892336105992,113.50033822391049,79.25558978003677 +2015-01-07,114.13476402789087,31.498445956653768,58.43738814137677,51.06051305149641,39.83292729910313,36.26645171309724,96.56554009469508,158.41324086439104,111.50403577228724,83.26496310285194 +2015-01-08,118.26415061321774,19.175207455698803,55.694490458691625,47.23872759278915,44.30094966785751,31.95843832936268,95.58435183710107,155.86180858271854,111.27802510063003,82.7151646533961 +2015-01-09,118.98629580040517,14.90793475936899,48.28100532743177,45.27099455477595,46.360015365479995,40.03252839444484,96.3325294017049,161.91441320206394,104.7262343141496,82.63333405326759 +2015-01-12,107.07629148323423,22.357750212618818,55.98378602241286,47.5491264971679,53.9397582484211,37.46453832459591,91.61472714153747,159.64769995875588,117.18146243756277,88.23610029940208 +2015-01-13,116.88359892503226,20.006239842376385,46.49605740990423,41.779948978831165,47.41002807783523,27.86566497256193,92.52391000810435,152.9154381055148,105.77947773733143,86.52049248817951 +2015-01-14,113.40843139775549,19.066553733900086,55.16697978707204,48.01937665973894,45.229305630655915,27.94296518537937,100.78363992420998,152.57964946307837,97.61916443132027,83.39852504960531 +2015-01-15,101.44899212803728,26.125493613520284,49.23455322853299,52.21935422571951,56.82929227710463,35.43273074224073,91.47711321545191,157.00398476165677,127.52586799554233,90.92667265465698 +2015-01-16,106.36941739722515,19.0596404475083,54.97587765822417,44.66317095340948,41.13496689188016,27.93237760318336,82.913687764986,162.38120409534127,130.96155624907138,84.68645355340247 +2015-01-20,115.77106705137803,17.938094281952935,57.320702874121565,59.41074731811206,43.67101128677563,33.44432674308912,89.4053579605533,157.9959135291642,118.65269810624847,90.73137940582315 +2015-01-21,116.46390914571943,16.645086607611503,60.65845599944595,52.368001159989156,47.11835570980707,32.137639570322825,96.27759170082416,166.33530041196514,137.43313335128624,84.14042796905748 +2015-01-22,114.84277464284823,25.300707034639586,54.31496312614439,38.39173229784303,53.211754029563636,24.849096619247497,90.34502780793386,160.7334760478993,133.96242886804856,94.4263921725024 +2015-01-23,114.90888854502931,28.140896071018137,62.515326146749786,43.7060450073263,58.424946898095,36.104099386579385,94.85635627284775,156.8299468252418,111.0312645706114,88.72671456051869 +2015-01-26,120.42156285884722,30.09124163703635,62.17792167656081,41.38003699073515,50.63295474905283,34.50932703235618,92.07580109059441,163.0185957745612,113.86812653215156,88.89219654194713 +2015-01-27,111.14293041964325,22.06067147000637,54.60868598658364,46.183533978211415,58.67214645324356,32.82138501109213,88.86997097894098,158.33305923205577,122.7116063149778,88.66501489545547 +2015-01-28,110.09715251114027,25.62650631180802,59.508064839182836,51.384088072690915,54.34302647093374,33.888209941186254,90.8411321637481,152.90660273214272,116.71326114314215,84.16285952635194 +2015-01-29,124.79346436528411,26.805632486781356,54.87404371427147,41.891808978052104,49.608687272552146,47.70130605424046,89.15094347878907,154.11214544748168,108.76066695998306,90.14488474741822 +2015-01-30,114.54707378859271,23.865787607707524,51.80501725452735,48.75640292651417,50.81642512970899,40.37943513309035,88.8844003547879,161.9108904004012,118.07470367710239,90.5161126623856 +2015-02-02,113.88560879060228,23.861633822646596,47.40216394114216,46.60669716849449,57.06403056107074,39.189228561276856,91.54537655812524,147.63274388045335,109.56065061774987,87.2456686757752 +2015-02-03,124.72407648299517,18.41541368092127,57.733335274913074,47.27884429040182,62.89118101423704,33.31272792014038,92.71313504009872,146.6112192377286,113.01857670816203,82.58856412120481 +2015-02-04,116.77844149946104,20.40988089232531,56.30971196949905,45.23971395371499,63.304356873250015,42.766860583292,93.27187862771633,152.51440529033533,117.41159218132469,95.72955716365888 +2015-02-05,130.19787973262055,28.69912790758167,58.09360198350416,47.06271087984857,50.0105436981618,43.69259222292966,99.99218898455308,159.04816384016232,113.96603211026414,82.29781185304101 +2015-02-06,118.28148589015366,23.873535860180105,51.39864912673564,53.17826373029925,40.54644281389858,35.86093310054601,98.46673289609782,159.8824111318552,115.77811137534013,86.20504879403722 +2015-02-09,123.69492204916203,24.10897683513388,58.03982506216279,48.55484829269779,41.41398212387741,31.5258001181106,93.85244344804062,151.2598590510561,108.4259047834823,90.78372681015045 +2015-02-10,120.3408004155836,14.77940886809259,56.902493430001,52.71921313986423,39.60403211046742,35.82622760525004,90.52762650154175,153.68774422689745,110.03508041521381,82.50251731958336 +2015-02-11,121.65077808845602,18.43237678946604,51.01971093313019,40.00083301766917,46.87399389327331,41.756156741055925,87.27443428869051,160.6574341458303,111.45852563886986,83.09270532264846 +2015-02-12,131.9279714283994,16.557011478256417,67.06644182727506,48.08027601503133,46.83126942505604,38.02215453564337,88.6655859462363,162.41720927857736,111.06815886611614,88.57704165793574 +2015-02-13,129.4899951180477,21.932347070147237,71.1857277144995,53.13265037902788,37.4625415323938,37.76988599238072,96.16465802521162,164.02634974777266,115.49633437328971,93.9204417818298 +2015-02-17,126.74766461406134,21.588882345123288,70.8438000349718,44.08190722283002,37.575997426716796,41.67413350645511,85.8716385377817,156.03723072275463,121.8556406011086,84.86853119795904 +2015-02-18,118.53620447872441,15.641390227942965,60.64038358047146,49.496060794905176,44.838162954287,29.350875041448102,86.88125277088895,162.9287924677309,118.04437926419132,86.95015793953053 +2015-02-19,127.4863875853714,23.612947188670134,61.981674858925416,50.00027452957585,45.22710274016917,34.96331869018301,94.32222272437781,169.64840806145577,112.94717409543135,79.1198549047262 +2015-02-20,124.40461341807855,20.63357233694667,63.037987872897915,58.52638566429503,52.20204345261762,43.43551951661986,88.4689589764636,163.30706959394834,122.43482357970395,78.69720198138907 +2015-02-23,132.77048887929269,22.035945471987095,59.59010161582438,41.609195887021954,49.284249795976066,34.71375331196065,96.66482476748475,165.51952695264697,119.30719962600472,81.74364025759537 +2015-02-24,134.19015859343608,30.550270066949672,66.28106543187789,49.784230137035514,47.88016706964782,38.30961288910386,95.82728141297676,156.10091297893493,110.18607910408555,79.76696691398314 +2015-02-25,120.92442467201171,17.676670500587935,64.93123363427615,55.23062133561342,45.47758613162413,26.060181287242543,75.39203389963856,162.38772178832028,113.16092566102486,94.2600620603341 +2015-02-26,123.85909209209142,16.321301806177395,58.4960808013082,50.1145597968836,40.512769393615166,36.59292621553683,98.72090829062986,159.21009932250976,112.18379740632858,93.07408894830778 +2015-02-27,126.45287985817367,26.593767556991583,59.30411290300116,49.20874141724811,48.891762654172524,35.330780390905375,98.46785696090421,167.5004923318229,114.87347327066733,86.37494928795908 +2015-03-02,125.12178589904121,24.062171298875853,72.63607642569688,51.03999857582127,52.114314198786786,43.157646444585495,91.78627069042153,156.37019929027898,115.3573588234232,87.31678069015825 +2015-03-03,132.5124956275331,24.700628233575188,52.633224471493406,51.017673023749865,43.09812708935155,36.034708830445474,93.75473576580893,161.61331231027117,114.69332784663577,90.50518624725808 +2015-03-04,134.69038838548673,20.518486703474863,70.48662293001209,42.8949502350941,45.20991633191116,30.97414052913244,89.66028061813182,159.84335502441712,109.58969643759431,95.15916510089922 +2015-03-05,121.52295559168358,31.871643085265333,71.08300797532036,47.86846637171793,42.87226093789724,40.0813674519046,98.04598881972453,156.47104050684638,108.93927821718964,92.2529292558909 +2015-03-06,124.27576386816881,21.255879880842507,69.45500970651385,44.2184426875697,43.61434663267529,34.2148346515859,92.18196265933928,154.6754762099297,106.6743229429918,76.12257216534076 +2015-03-09,131.21680313672098,31.306078818787256,66.04010628518162,58.519209242060704,46.325498533185325,38.34041840302408,97.35650342550335,159.53609050995837,108.28012845580254,82.34197471021332 +2015-03-10,121.50374405520331,23.91706374743351,64.50825079438378,38.689576060775295,47.53108071271251,41.902533601381855,88.91904846401899,164.30685379581078,113.16447618155446,90.99347529981767 +2015-03-11,122.91245895863166,24.895269843500273,68.08448874004453,48.91229013934828,45.74585956252183,43.730821337774344,90.58076835564088,148.33264213528903,93.88538666422866,80.93491857626411 +2015-03-12,119.5240814384186,34.76091396510613,65.74632859604858,53.741482432411395,41.28510327368092,37.51301539014162,88.79069417003387,157.45538896664758,112.18536304649352,84.96718817916043 +2015-03-13,127.75678077368512,18.669707942904548,76.99605174451972,51.836388385158585,45.03187151645187,30.359369240634955,93.9282810928679,153.98068528278412,103.2536804010127,87.03055437964933 +2015-03-16,124.83826491340129,20.669581832349273,66.9728133321145,41.8510243249408,44.64919136583518,38.62133171199757,91.52376733619485,162.0909339092152,100.08230420056147,86.71464940377554 +2015-03-17,126.78319130788158,20.769225475905202,72.12323684710958,49.66902157875457,42.21079337748519,38.274494776642356,90.0583792851228,158.62654705601858,112.17411631270309,80.25998575881093 +2015-03-18,128.88363885366894,18.868011576804484,80.84817505437721,47.7163265330961,44.708097362103615,27.711609022782227,88.73398849028754,149.92976058536564,113.87759013409254,81.01581917700213 +2015-03-19,129.25435494762655,19.878488853138194,74.25679760926833,45.29395642386007,43.787227414789946,32.97020613717958,84.1137755738211,157.0043702286966,113.97611790701103,83.6402962050586 +2015-03-20,130.99471609375695,31.309111706913548,76.82155544307182,41.86493576747794,36.61540221969018,36.469789563052615,83.62883734078501,159.30976697995263,106.6149300117827,76.91406712339473 +2015-03-23,125.97738249148156,16.652419923142027,80.00517632641342,49.0945267042341,35.38917846989303,36.16739692937216,89.88715323223055,164.1317403448582,102.7054787720025,94.8619575565773 +2015-03-24,127.05981069986558,20.970340457491314,61.430784997582975,51.31331195091933,42.707682018357,27.82838067326126,82.89157724529014,160.41741922020435,109.0143730358137,93.24573284156334 +2015-03-25,126.60809693342779,22.52553192474764,80.08136193169972,46.71476127193162,44.222894763168455,43.275121897581535,94.2291676792296,161.29711831500003,117.97661504582723,83.94315097846933 +2015-03-26,133.29949681252938,17.96647310358742,80.22665360532565,42.240527650259196,45.76917540831214,36.589947679858554,93.89274187997333,154.11857226725127,108.8812652802022,82.72927056522681 +2015-03-27,130.10599613535882,18.265599472617197,80.64426716444724,56.476632659953076,43.22492941557939,36.31968583289358,87.9375579346995,162.6915374449278,108.04199443780664,87.33456715408579 +2015-03-30,134.13575889117195,29.5748720980853,81.49613216167492,51.22983975841647,50.410809369314904,42.334910785740234,93.29173875478682,155.08573106151692,108.80627474395303,82.86878381585083 +2015-03-31,121.1616790453518,26.041173779822394,87.8043085285463,40.67571426592613,42.77232667214185,31.327327291275886,85.91088004798951,149.3903776155106,118.3078588593234,87.97530828168077 +2015-04-01,129.3873016794974,23.83949137022465,78.59792542720567,53.75981097348762,42.150933892725135,38.30724975421929,89.94291958774916,149.6123068261114,110.30320362881106,85.55466443789645 +2015-04-02,120.80593203930069,13.678944955832335,74.93934529638004,53.54060091476767,41.90519041345593,32.24343476106767,97.08892345332507,152.92880789418834,112.53481714201466,88.46525264325633 +2015-04-06,126.13336140847419,21.458095540684564,70.828963424036,46.286245763210545,52.874965074028616,42.83004042200141,88.35157886294627,158.11115145314872,118.77853539689606,90.1639398964263 +2015-04-07,123.93841024125062,20.20462364728732,84.85692918193149,45.787473729784836,50.12441956999773,34.433324404919276,86.9840644231901,153.82098717044775,111.57418925272248,95.02475596099062 +2015-04-08,126.65124987239359,29.30457978908281,84.79088308201439,46.245073732095136,48.9336599710702,39.61034884118573,92.14488781366013,149.96118244047685,110.25425842008127,84.92708142956819 +2015-04-09,124.58094176414681,25.306558674376507,69.35130132094383,54.98683326284703,48.525538200608956,42.653399353837216,92.86300548168009,157.14877693542417,98.6704217132511,84.75954368733632 +2015-04-10,133.05941561598175,23.882852115322446,79.74800181541114,54.25009745045783,52.932012832445885,30.74264836604876,87.63815367776462,159.240729140023,110.15538010011538,84.24076163583545 +2015-04-13,123.6609393187746,19.560500067343774,72.00235286727909,46.964165769919084,49.45788970289115,27.44451577552902,91.58509915020383,149.65345756899683,109.57124262698031,84.0829586269663 +2015-04-14,120.2902375165203,23.32434902237925,88.38619503951205,46.25663462821934,44.61687460892311,31.701527504943392,98.77354153392923,160.59989263401013,113.60078700387965,86.65210748579898 +2015-04-15,129.33600459289983,20.717718557090873,78.2819889101673,46.72589115324245,47.421968264574446,34.755345847658376,88.7929420291972,152.4194143147646,105.22665745423144,95.54995940117944 +2015-04-16,125.98805308004694,26.92626144360824,77.57201406329968,49.88049218693254,40.59545503131347,35.88747237628205,98.107335384266,148.05060830558747,113.48929600400535,78.99155697185539 +2015-04-17,124.00829126605032,24.455564313561894,76.30941481620181,52.94130332098188,39.215554425094936,27.1467263705858,90.33985133007045,157.18962464553783,104.01066407292166,88.91261922816066 +2015-04-20,124.97431089147871,15.484158058482533,84.65878638256275,46.654294148018785,46.492258218398725,36.04081889656418,93.58487105299734,148.7793825257951,121.79946098055576,81.10251205971758 +2015-04-21,126.73301594926258,28.721075403202768,85.2578605570631,44.759427686554446,51.24622204909459,32.96310415912128,96.2107430914298,154.6842159752057,108.10575010358582,83.67898174155792 +2015-04-22,128.32563275268853,21.828946264771197,78.40770480477872,47.201295352110606,48.452781377647455,30.70470543215345,85.07055162990453,158.35374526753768,101.73797662821615,83.83140548625336 +2015-04-23,130.39702678061386,21.537440967978377,66.39573987703903,38.694954027211914,47.29091023831138,47.1767123362985,102.89976019643544,162.29048455167305,109.26350403962324,85.47875605156399 +2015-04-24,132.85489252278916,26.60335989195282,73.50546224962346,46.734675942749675,49.80008340275127,33.57252915330895,96.00078701662041,157.27803575105727,114.50502916416563,84.11461824025328 +2015-04-27,127.73027522493857,28.69944828788838,81.94466338286378,52.39256709591089,48.5838965505081,34.4556804183826,90.82800465696872,164.7259351229292,110.17983247623823,84.23120987472687 +2015-04-28,127.19246698267973,32.20930748263839,75.70802301779501,52.22858995681465,46.28711674343627,26.007819865463723,86.66991686847204,160.0704530506382,107.6799925189973,81.33935673523803 +2015-04-29,132.09990466273965,23.991767929729228,75.65517292582466,58.515949206200965,43.66663891332593,37.17758336317395,93.55535614871175,152.24074405512928,119.07788073400415,86.10134603121776 +2015-04-30,128.1027965569519,28.523402369976914,75.17416786044035,64.1367827860129,43.46541987887339,40.82254088760621,85.52274125169961,155.65710513584142,118.83616257187072,95.49997635717953 +2015-05-01,125.17887988676458,26.75458134914641,66.95561741611036,47.37369202054413,43.29075691393013,34.897924184765614,92.46494078038603,154.40358427962855,117.61278850468928,84.78975072801776 +2015-05-04,130.79034262118344,11.351898117499474,73.06214793766918,49.405586617797525,43.3831883985872,41.58583317590486,99.39590808603157,150.90164390180715,118.14297990510252,78.84749515511899 +2015-05-05,131.33286188374998,28.900214567487474,72.86875787280697,47.380095479675475,44.12112358739299,43.140047360911694,92.28326116844588,160.81981612091505,111.38509306387083,75.50158380006619 +2015-05-06,130.50054841900257,16.82964032552234,73.03219792709109,54.846284697242545,45.545171005330815,36.92461570591168,100.48596746256334,162.49395531819198,123.04460364945095,68.84670309719422 +2015-05-07,121.55349633574518,19.464100230576463,76.57342290725317,44.34818676460535,40.18675400281596,41.134175910868045,90.61257709036927,156.05474009933204,120.1593239286951,78.57822088435776 +2015-05-08,123.65286482517513,21.181806208620237,92.44787696263313,55.142435333970404,50.49032560545986,35.34484895118391,98.00371408822886,155.66784371867044,107.64274250316193,90.69158923568801 +2015-05-11,128.39126020539214,24.41780751165848,88.45394957821765,55.8067840146103,43.29199654494542,40.899143112408964,90.80416300728588,166.78772980248294,116.8289089286114,80.62292550932014 +2015-05-12,127.52626034060565,25.025165159962377,82.07046584490683,51.22579705479587,40.08837436577983,46.41466628715479,83.70388561900451,154.8444002366778,112.24451385257234,80.53432218119191 +2015-05-13,128.85366686946216,31.74878909767962,79.69507079170131,50.91451928819861,47.074677607399344,39.39293442676919,100.75969708173169,165.55465334110227,118.25774449947166,93.01945996658156 +2015-05-14,138.7346353545433,26.930349256614093,83.66831001734501,58.76854279013162,41.14700469471231,38.910407527678075,100.25403468867104,168.28477918252247,124.49947682551885,85.63657472306505 +2015-05-15,130.20025408834474,22.777921018542774,83.62638869708725,49.28260902489848,42.48580511378997,45.60782207291396,93.98679012823777,167.57908808205977,120.41814592203727,81.90115683182333 +2015-05-18,131.73497912298362,24.829942119235916,80.05145389363621,53.86774666660605,49.02562791268822,32.73837104908345,83.97010992234144,166.45867569916075,116.49234994313008,81.91953102929327 +2015-05-19,129.6150024566919,22.483277526279867,80.85491175016303,46.91777018744747,37.60664102757795,38.491450171357485,88.15460527359585,158.53160265371625,112.10292047225963,90.6936714304602 +2015-05-20,126.52092270578287,18.59576313997939,85.00789073327685,54.70423575628554,47.52075456493767,34.22736329934936,88.54161605228414,159.22992144103608,120.6861111036225,86.5756716659672 +2015-05-21,128.89074386179826,25.857525050823615,86.46565541512852,61.07323418999408,46.40151960462134,41.26348977144824,86.94527342198305,167.7730558532357,118.33435338419658,89.24389843807519 +2015-05-22,137.89678854765296,12.660485709652818,78.6996266893011,55.71407326601396,48.0825894573847,33.79203628489705,94.454267326806,161.1641145736016,110.61788127799583,80.10638434040335 +2015-05-26,133.74373743285312,20.431996304961856,75.5227694941566,53.61903797303055,45.14187053261161,49.46825605572618,90.58547493855095,159.91960045239483,112.4876540903467,87.45691439454494 +2015-05-27,127.9359411078578,22.9886909183095,67.71949090067989,58.46532044755436,49.121905307970856,44.34742671015465,94.86807686218526,158.62940797127402,123.9105476541176,82.78807548840801 +2015-05-28,125.6881299757493,23.026877142713737,75.31132714928258,47.044632624582704,44.94873331831424,36.801998607043885,80.56106214372956,161.3904680661588,113.53404580688961,80.91563119780976 +2015-05-29,132.32783131359497,30.242150901798148,75.19033451659647,52.31313330578886,40.90812764561098,43.894714422654744,92.99639510770014,151.21095524497923,117.08233742649091,80.86616989212047 +2015-06-01,132.13818128212546,16.164963246446348,75.89380672918381,54.9953992491413,41.18403192245442,42.00667224261879,83.98033623158501,158.5794156799543,117.76553332902424,89.07537861792015 +2015-06-02,135.13115575809232,34.69463414850794,81.07177884190038,57.674111431103924,43.886239911403976,36.668850013014634,87.49498096020451,161.15219470832983,108.09918295369435,77.00139896649578 +2015-06-03,124.07071809462856,32.06169824501309,81.41122092861052,44.86009157850105,47.59795313608072,30.12368276375859,84.68243729202652,157.90658465847937,108.33510502611631,87.08403465172367 +2015-06-04,122.12503357862568,28.809868113571305,77.58624847022311,45.468172196122666,43.898316136465105,48.97411165514877,94.29767782573562,163.62466594967546,117.3271415733591,73.57389421829235 +2015-06-05,127.46840182254894,23.288329614650863,85.70480260614045,43.75421243151924,44.737882890140654,37.90512835928129,84.11925906475514,159.02055994472158,121.8343457140038,88.11093135402467 +2015-06-08,130.6759473182545,23.742968586791555,81.03221179889115,47.96731925007752,37.51952949308789,41.22137243445822,86.8646707035747,154.6891863227113,119.61417869002044,90.19516592132817 +2015-06-09,138.50254176350873,22.478725148508385,80.39871383362731,39.67666864407732,37.05469329947404,36.00038720128207,87.1016956062031,156.99201984932478,117.32648292987476,76.77897141348313 +2015-06-10,121.40959635277099,30.82743598379312,89.4268518710325,41.647729123818394,37.515257220290835,34.321727567314646,78.88910132340756,155.9511598090098,124.01504848756872,78.2798226947182 +2015-06-11,127.76303527420579,13.698688721604915,77.78703431315161,44.86920391284196,41.39946512832438,41.71138583898441,87.78701793908911,155.59967477547303,114.84453004096503,82.60531899717049 +2015-06-12,125.21379831842552,21.979601413184,76.20934802370988,52.6961946228101,33.34773578435953,33.60677577276589,85.83534230018839,166.85435634172916,109.63373854562963,81.83640760283964 +2015-06-15,129.75028583076707,34.0552591272049,83.44408870046028,51.465859601820156,43.37047229423613,42.133846739052686,89.54754201528968,169.9829179831388,119.40855759939079,81.50632827672698 +2015-06-16,122.56921848695744,28.120462106153013,81.48193984254672,49.80323566335669,40.49009904892502,43.7074820782748,85.41634327258386,164.6370054269438,121.3159779719339,76.39325517590791 +2015-06-17,128.4505927541516,28.425184522130987,73.04509537353414,53.684857932160064,45.50792913000312,42.83052593257894,91.12710438403998,160.63090115810004,116.68098238043335,84.2627057390752 +2015-06-18,127.62858967957817,24.701271809657342,86.60555429911768,48.80210760314176,42.56198917534336,37.131577186465314,92.05496435879222,173.41249109964306,109.53296114052603,77.9880975270435 +2015-06-19,127.99258649399998,19.751119415728105,85.1311006439885,42.94667753599664,46.91076340217365,38.89160876700769,84.51876788247473,162.15647946510458,112.01009243653186,71.84973022310632 +2015-06-22,127.10991174193106,28.923773039527887,78.67560143548674,46.41600488424272,46.3376296990552,40.38672424862763,89.07359413728301,164.87432594004588,111.24628238441186,84.07310176340783 +2015-06-23,123.03139449985957,26.118352621133063,81.57601573667672,46.46929887530587,45.766415049712045,38.49206537726917,82.96767672095066,162.91457925885453,107.95551513331031,79.09617329335302 +2015-06-24,135.37919967658684,22.361430001569204,89.73792806180847,42.077486621963295,51.368509615446555,35.223854634283136,85.83960674725712,166.03325136226496,119.7365252036447,86.6505092323527 +2015-06-25,133.83511558897135,16.379381552683206,84.2900906602593,48.73112908017393,42.63150813246686,32.0969605262454,84.32970073850659,167.79909858993494,113.80621870174258,74.9750150991215 +2015-06-26,139.01831253061476,29.530274703810917,83.56928578300375,56.28118773153213,37.349707780022044,40.7939561507154,91.03873979364319,160.92730584439897,112.56538049292963,85.6968879968204 +2015-06-29,124.2712486647649,34.5996270150929,84.81450207231063,45.52073441519234,40.216035432465794,35.38261114982569,84.4740599205407,166.18258285848307,116.09335477007394,73.09755156114383 +2015-06-30,129.2322441127551,25.52995104855681,77.69084507874409,49.62569942284472,46.54615715001837,39.14737869421157,91.95233048378755,167.03459425531614,113.5373358149541,83.02850622369384 +2015-07-01,128.78934088000594,22.68849477198891,80.3825023087686,48.43535520946397,41.61684997361536,34.85599983901063,92.29813964483726,161.4181428823024,117.66223221944188,85.78509152558382 +2015-07-02,114.70656832991544,17.57706825709494,89.33189202827634,55.379082653111226,53.80526757244566,37.43443601025494,83.28550753795153,169.93368515927924,111.50811288269439,80.95239743495604 +2015-07-06,127.93690738528906,24.197024213671128,79.8302143832806,41.081475267728614,40.64631387371706,28.494309985016073,91.34490945258509,157.68519214969817,98.0913043716361,84.2764864918903 +2015-07-07,124.82285479878249,33.822428428874694,84.39177391983472,43.220802517493844,44.93001987138397,47.802394615705,82.64691454097972,162.59414482549457,111.35373782881929,86.52144597577161 +2015-07-08,117.83307736782385,28.11600795496944,80.22276737972769,45.273680979685956,54.309449082070415,26.694879909534745,85.17629202918,159.92470705221155,113.82888609678432,79.16338682120966 +2015-07-09,121.2568930111911,21.590869422210815,85.22783439582707,47.848053331560834,39.36310830349514,32.274350925704745,92.9013341930777,157.75097184529773,109.70972042553863,73.523130922077 +2015-07-10,112.1533139736502,18.29224898950595,91.34362197440223,52.00462662992585,40.603730652469714,36.989310151727494,100.04748051905217,159.46198822321796,115.11822597787231,79.61905133737247 +2015-07-13,124.39170579846393,21.171061530502,90.12133658695264,41.05951857806413,45.543975234181715,46.84436181690967,86.46816147011268,159.83177072913563,112.83355582734575,80.31807209215052 +2015-07-14,122.59925538617344,29.379775611311896,76.66573557683586,54.86148925707083,39.776929408856084,33.897223679667334,83.02139466210566,165.35709049149833,111.65092586273448,71.21660883147864 +2015-07-15,129.8499594041064,18.311898935470893,89.92577997447168,55.55643315340723,41.217362747339614,40.45705377488137,90.8847183311693,161.98410033958248,117.74317570154624,79.41535121043029 +2015-07-16,134.94259599790894,22.765475255747752,86.42195686934497,55.26280850852373,47.26296982465323,32.8936340831917,80.6801788234081,162.2183633505394,113.21462273803654,74.38191155681372 +2015-07-17,132.85140482929089,28.66468775877344,83.54981071344957,41.40141931642322,42.30063561610176,48.16145152387268,90.03711529314758,168.20032929527449,110.35329575388447,78.16492253247405 +2015-07-20,131.84142924242178,24.24441729556321,98.39489094424077,45.651193357766545,48.999343606716515,39.01297946969208,89.8233603309705,165.99684411762328,108.26686879674294,70.20877024839778 +2015-07-21,130.90969587065814,18.827652461711864,85.78053073673853,54.235252911025384,48.178078959481965,30.51619304495906,83.51113720268765,160.37798955077557,113.19963696856436,71.37375901550357 +2015-07-22,126.10953385073208,29.77202569736116,94.20750337634749,51.46314945071579,42.216920321780634,36.18405445757533,89.26879263606762,160.6295287226251,104.30870851965304,90.5177160983938 +2015-07-23,126.7367992184704,26.294785808365525,93.41963772803112,55.19883914786217,40.59682504743749,35.7967948380481,90.54023329445144,153.2437375041806,118.72938767734294,81.90402995892264 +2015-07-24,123.11119559510959,24.9500275175473,87.67274040864584,50.432571673929004,38.685362414439986,37.73147236520776,90.66738646915046,158.29170602161986,104.35588557490458,80.54190961802907 +2015-07-27,125.63226293660288,34.8696436986532,80.82492303485316,52.33336259043776,44.07288499943339,35.123085073673764,95.53934002913789,163.4230925061421,109.13342527372048,78.98432429500184 +2015-07-28,119.33706291949225,28.2944701073652,86.13824054172417,55.565536146275605,46.23507832651833,33.747028042314135,95.28502592013628,162.09960839315187,114.57445669065605,80.56279927689675 +2015-07-29,122.67918799892877,27.711122294198653,79.3648281480159,52.80477900547495,53.72494361856977,31.016397061229696,78.8655546208492,158.64082072402624,106.91162829726014,82.59405104993104 +2015-07-30,127.76136272696898,19.775080221719953,71.84386326007191,45.901562375590274,49.85510407391582,35.60519969397387,84.97886976777309,168.97728070508325,103.37964969450951,78.82311149085598 +2015-07-31,121.7520698818701,18.809039726808635,88.20537579956239,50.33474214612585,46.33290139354052,25.493731046778695,95.35610154711159,162.66705839347563,109.07807343070648,77.23924176920559 +2015-08-03,123.43166008396415,21.558422025571154,76.89692753835406,52.18584901531539,48.083453498567735,46.87684881120444,97.55067680791447,161.2051331629416,113.63719891618624,78.75649872355903 +2015-08-04,113.18426394335667,39.55648825620385,89.52323629867321,51.87847889789555,54.848369378282165,41.01539762018532,76.88071064926079,166.05190254414438,114.18542320036192,82.44388529977645 +2015-08-05,116.66006907488259,21.564902013329963,74.70821616630931,49.25676174201769,49.77655763936589,31.474724345842905,96.50183647455442,156.7861786777515,101.36331790289492,81.53906887498559 +2015-08-06,103.42625540863298,29.228421837962202,81.40150677106035,55.98716147956227,47.69627680576592,37.57526322990185,89.07187195914516,154.03712192295936,115.6961386374295,88.38737088159701 +2015-08-07,112.72017177025984,30.397952308429726,94.60231071537763,44.147644318199944,39.370812821036225,33.920166580255035,92.32370982717903,156.87933439852108,111.586070970724,89.09417150177269 +2015-08-10,110.74793756865606,26.84415098961083,91.01644529614686,47.91839958813905,52.94667373585022,44.24718631930986,97.30354058050382,161.3786546876668,117.98617134215476,82.90624387628121 +2015-08-11,119.24754071385532,17.525106153269814,93.33986269974397,48.53130086860272,43.14465041753933,36.32365639961359,89.45272079922393,168.83864584874,104.51800989655297,80.38779796316194 +2015-08-12,122.96879771272786,12.3537608521091,96.66769732689022,57.81030614373572,46.49887588884235,28.079621966702156,83.58322326875572,164.2278793601047,114.62909220667049,83.51645212908068 +2015-08-13,112.0405087762275,27.615799181612733,89.51309823420485,50.48525563114642,45.955598561855226,48.921292758570644,89.49777986667101,171.88497059150916,115.82728676392249,83.57592979220036 +2015-08-14,113.89180659087306,21.532077707613556,90.01305649397324,44.14092015641408,51.334893472594814,41.399673787467336,84.75404808266791,173.8044507686466,102.96998938944262,82.91146697528488 +2015-08-17,119.25271642564508,14.840164697926665,94.785274274713,45.66853521419084,42.164806786218925,38.057065954020494,79.12504892391762,160.12108845089395,113.44996176840905,75.49787823242085 +2015-08-18,128.59655856367337,25.367233796166754,98.16564723050293,39.45297591022647,52.633792477932644,30.75364033913863,87.08911356845469,166.36207106844105,113.56974441090723,84.41238082093156 +2015-08-19,109.51720284187267,27.16836885903366,103.24960876163047,42.823796901848105,46.26957841396073,37.36424744162852,84.3897852818348,162.044112713914,119.11620668922106,81.64762711061675 +2015-08-20,106.18097859885646,21.32672804898464,99.11869439919447,42.902024415880256,48.41199570236894,32.512907333022675,84.60660967849255,166.29583303280987,111.3361030249506,76.701250087553 +2015-08-21,103.97166232353393,17.773135427997495,89.09276185477279,51.940050913734204,44.31920134947777,33.37854639604741,97.10422280666377,165.76771284139963,110.43825449125407,83.62598937150665 +2015-08-24,110.59892544639858,29.10556533640309,88.56536006975348,53.43294827294579,39.432524442144654,41.2516392741655,89.85477927591411,161.47550513311822,103.86651382101223,83.73530601538879 +2015-08-25,108.40523005628847,22.75298760968699,91.99271573791806,45.80295757995809,42.226149570254265,33.480257207105296,91.0573288490655,163.75442182697336,104.23872317623336,78.37496383414059 +2015-08-26,117.85156013143371,20.654732256090785,82.47596538403307,42.60768732948775,50.8538279132088,27.27359689456779,90.35810408724397,163.91910353748622,108.37737927835558,88.76961848405247 +2015-08-27,116.23986933470358,20.167906031935473,98.10374424381072,46.966815322953686,49.21519103559089,39.84462282313922,90.32603611430862,162.31867637230437,104.16027447112532,82.09233787387912 +2015-08-28,115.8679666259324,24.210808788041824,90.45994756136807,49.357105518393375,46.609658553915935,44.72101565567635,83.44820891125684,164.38938912470286,108.01193382324311,78.27049722591099 +2015-08-31,110.77271486023278,22.444464688460243,88.69859949521327,42.334809270571064,50.86699935739037,34.99410947258751,93.42973424685229,164.8673113823593,106.20370303167655,86.23843136116574 +2015-09-01,113.45765201794012,20.054518965708773,94.66814445683018,47.65791144616155,51.03753442132687,39.969307782593106,88.07477387958062,152.60622928582706,103.57970558062694,85.52643639750794 +2015-09-02,111.38135178072204,28.433731927663736,101.31434849134283,42.72738828730896,44.041179249808735,34.52906467519835,97.71790239277999,159.0303511139671,114.82424943705863,77.79764911364707 +2015-09-03,116.78098306640973,34.18576064815841,83.70226231998221,41.53454971453917,51.0737310678006,37.649395029498656,87.39890552892965,163.04632353020884,105.27564508154174,84.45408230709116 +2015-09-04,111.24850559232758,24.47873410595795,94.20721890923285,48.473236394098684,48.7874796774783,32.35041970360672,95.83587495241653,161.7878683519481,110.29464167761951,92.09947152602199 +2015-09-08,113.1382624638568,16.723049066203323,81.73375853421445,41.66725352923298,44.70238607583687,39.7011255384559,89.01419544053722,157.61021739420943,105.52060778742975,90.43750721970322 +2015-09-09,118.37755934026188,24.549908915414512,94.02340274944241,39.10367893046514,40.844375580081646,35.80569734897159,87.25975600197538,160.58878727037813,113.86904009939069,76.94167964083677 +2015-09-10,125.48945475625433,29.661844668831534,87.89203654634922,39.21911878615566,48.621285287658466,35.32457698252715,88.560796389048,160.74925974832178,109.36518256469284,83.18151491960307 +2015-09-11,120.84381955508235,25.66516432819302,96.46707720767056,39.087731739165555,46.48506539463902,30.031090815613076,101.39459399013339,164.54726634017462,107.54414332110902,78.9986207161613 +2015-09-14,118.37089631755708,23.504915297484434,86.08055437307948,49.25060671698667,33.999760712112234,39.680832597827475,93.62410169678913,165.35299753618386,104.15787707095319,84.35189142076355 +2015-09-15,123.23884202504271,18.18654919165656,84.26874590578609,44.47866876539268,42.64386537022287,35.313109622429856,86.39397822487871,156.43809603712967,112.09024030251777,76.4703268527052 +2015-09-16,128.79740557010948,19.025952194695687,96.57298465767386,51.6392547983596,48.05866253465193,39.517547931721325,88.88805137592429,162.64459077564112,105.3642283181851,87.72963109195503 +2015-09-17,116.44431036644328,22.57982103510721,92.38536247987045,53.378418019225926,45.16803020199249,28.167824884003362,88.20962019965235,168.03019080097215,111.78470674309324,82.35237137895713 +2015-09-18,109.40924414976723,19.212880366184013,85.4841478984438,47.01702370521224,53.09226058978763,31.62946477493747,96.73128957193926,166.1359096857482,116.16160928815056,77.1816678866095 +2015-09-21,120.36050311616283,27.560815468843476,82.7539934555546,44.44138165929475,44.624699416927456,38.60444228518146,85.82814548865092,159.75466268197917,113.27721856043578,87.28878739579868 +2015-09-22,112.57116141545738,20.519640852186598,98.67089612090791,53.64635307256171,42.62917791816198,35.987652359361306,85.4886263874878,165.5038339808658,103.7084091653843,75.02312317749208 +2015-09-23,123.59678754325768,26.29327081082512,85.91138100658016,50.61576399576569,49.4704495123988,41.947954782135305,93.18878508507012,156.54228844867066,115.49366610623234,85.4112603903627 +2015-09-24,118.39234563998939,27.942559399110085,92.37186501364556,47.023190059954295,50.671118423208114,32.44824815512303,85.7573342453498,162.62807376278133,108.22112494780299,76.99881198566428 +2015-09-25,122.08300943048906,21.514099284586777,84.22933033948615,48.48388409771115,60.159629621604864,24.2380392810805,87.33125752451504,149.52431301002298,115.48660705901116,78.72817812262527 +2015-09-28,121.22102652938212,27.143528642889425,85.90043474154854,42.82601176618121,44.714887683231524,34.412386577635985,88.83865722839217,156.04355766536068,115.35657582073436,79.7005080932879 +2015-09-29,110.06080030983023,22.09500064229014,87.9374724065546,45.62008634545017,48.66344259358242,31.0782940892038,96.76473248833292,169.4905741345814,118.50205745825821,81.21863077575728 +2015-09-30,121.44066524539991,21.774448763668037,80.42187150236856,39.0249713627577,46.90763419989956,30.979735327088054,87.76244466896553,155.6618942203288,109.8684523713856,89.32883897240909 +2015-10-01,112.06180501995944,26.755312205377372,81.23084016936156,43.56996336328055,36.64250094220664,42.80229400951796,82.59080634039145,157.20619564345543,108.39343604336824,81.95237279616828 +2015-10-02,116.21359108407364,38.45342874354064,89.00293015811407,37.52604267432292,46.73947394954888,35.80426861662971,85.92209662230341,163.08194523440167,111.89883770542696,85.69244352848487 +2015-10-05,98.8682046066589,28.03258183430589,78.53248353324895,45.41051708983756,44.17725778480933,35.63088429917489,90.00153169746388,157.01210888481134,112.03294890293962,75.42190355132583 +2015-10-06,105.58591858616796,30.226224074838317,82.78119250636509,49.04200127335088,37.53410658208644,39.07855287021286,80.56460001816444,164.42593984668608,114.0872453683476,75.89883778469333 +2015-10-07,120.01943460405079,21.73098615679752,82.80132385598151,42.52317689179065,53.179914512854666,36.25672224183225,89.88639715106457,162.9664256513822,109.01138108810875,82.91716085190545 +2015-10-08,101.34288815974654,26.021907782192983,84.2176048633248,47.476555758572424,44.69390362457509,31.500714150278196,86.47523023308118,157.8977906269183,101.84958909880241,72.95801724242745 +2015-10-09,111.00687907787669,27.814418922561885,86.73629025934616,48.20614263274245,48.603887435769224,31.379247041303397,85.98507392582745,164.981704999998,106.52867818096598,84.41105563411818 +2015-10-12,112.47324202873573,21.0548930675748,78.98972823965511,42.29348233659988,52.66929109996941,31.192629483136066,99.30657294364885,168.69546079360595,108.15486029298668,78.58990736745235 +2015-10-13,111.69883246311755,34.37814973744095,91.85527663899244,44.58495766678135,48.05939215245001,43.12857859081435,83.92922263731325,163.5077874556592,113.98675265353192,80.36394453174323 +2015-10-14,114.29938097105816,18.658660474695004,89.3163172938039,49.199455865911034,50.708359102735734,28.782117793491903,91.68627962343373,159.32738148267973,112.04595972327554,89.90853495349197 +2015-10-15,106.69723365796881,16.47018947129478,86.50678261224597,36.83663285187439,41.789352309389315,29.71723694891805,92.90561255319169,161.95053398638538,110.9567259750361,81.61750439425424 +2015-10-16,114.94269867782707,37.363575721199275,79.20811197881741,45.65875635667705,55.59832791806194,43.840447100590104,84.60843893466648,155.1708488100358,116.12802811331245,80.64108958320111 +2015-10-19,115.6336932104917,25.508342575776094,84.36939030713587,46.848305897835296,41.58279419915654,43.568148678932616,91.05765841670255,162.36937299530817,107.8788275215726,82.89795424127765 +2015-10-20,112.76578220301657,21.909803202600663,86.98746093121765,43.21118921782093,45.47836853669407,38.191726903169354,90.96990960768625,163.97048746495284,104.43580945387649,82.68086518659982 +2015-10-21,108.34575879571595,22.896799209841888,83.30295104233345,47.21983157688941,48.655714089758,38.34033815919729,86.39932013761977,167.73588478717411,111.6933194896048,91.74102166210733 +2015-10-22,107.35488534155965,19.810439981456625,86.63122763803185,50.52563692131796,45.65775758268024,33.21695562935743,97.1461228221505,163.7466809557347,100.84172506515023,88.21412146363072 +2015-10-23,114.19960896701818,22.159554436703008,92.43425837308381,48.427173418957786,45.59372091543528,35.56386482153349,99.14925892153667,152.6571677390803,110.37932376529419,74.11909412079065 +2015-10-26,107.15764815752286,25.04188691324015,81.52562806368394,43.6537458505015,44.49697299333947,33.459266339972864,95.3773963547734,169.89304933957067,114.74895082956805,85.24509556366445 +2015-10-27,104.0696512752613,21.762362584984558,87.7721872670697,50.718535476125,44.64733803476147,42.040714140783706,86.92980556014362,165.08282677522462,108.59180544607325,82.32710840850532 +2015-10-28,117.95744654714841,31.618883267880193,88.64015508256632,46.746652692847306,49.04536162829262,37.134214738142234,88.34552406864196,161.4897532285801,109.1590010580988,77.91341957922003 +2015-10-29,123.26014831311797,26.140666391613784,84.57133274498574,49.72069171224599,53.37859426608065,30.598692311210332,89.89664968677151,160.38204990834217,109.89696824525737,91.67553045428491 +2015-10-30,118.85930873416626,17.97379436304047,82.73889008379767,46.54123477675508,47.27356275475995,35.84071065689152,88.64725344914552,161.2832019795194,110.37631941834786,80.65502293377752 +2015-11-02,118.0387493736868,22.553092328198694,87.49870789029156,47.27432844602028,44.603694632294165,32.977749090315044,83.51105038025857,164.09054733078477,113.57392306685934,88.84538531590614 +2015-11-03,121.15245013142942,22.68709000681991,79.3962601535458,53.21321134103218,47.581678172623775,38.29319276444485,92.28092406430207,164.6768583464207,110.44449866308734,81.69535070946547 +2015-11-04,124.81312291048933,24.929385852878944,87.78218391437073,46.26095092082217,50.97777892651649,47.80265733210892,84.46015336485134,158.44486801553768,111.36147965127685,75.89928609199048 +2015-11-05,123.98571667939096,28.00765613850542,87.48527648167725,46.34797834299952,44.447969577590676,39.012026454987506,83.4620346523038,154.23265020634054,99.54737341632132,71.79606233079376 +2015-11-06,124.62174471370426,24.028483968209738,115.87685103055638,53.39251818533933,38.18091377783375,32.76972656815569,91.3305161154147,166.02298596933895,108.20844969953279,80.32109395267719 +2015-11-09,127.83220365616104,24.93608835631727,110.83731103630473,51.564492626447205,47.109001300566845,32.16437610412106,89.40973880585271,158.62170184711596,106.36113117745916,84.3912547352437 +2015-11-10,115.88749192752122,25.935202003796633,114.5509441561017,52.49790907681131,52.75721534583491,39.93485367191941,84.78979405802902,167.12442570834298,106.37256929085518,92.80936000244506 +2015-11-11,116.23612813331339,18.11670419746691,102.18792430144045,38.552471119713864,42.05153506491154,35.81613473588406,92.8891541705588,160.0249486577744,104.4056203903456,79.94265321751762 +2015-11-12,115.29681548701049,30.509774971533297,108.4523795612371,54.53550311884683,40.802844410005804,33.869049727808225,85.57584384906062,155.44529135772163,113.35007626500729,80.51107154067097 +2015-11-13,116.14478414264416,21.27966927575402,105.97368254076187,39.01353529778972,46.41156933958709,37.81481820373222,94.18267207955711,153.9895272965875,104.65240824148168,76.69329228733356 +2015-11-16,117.16484481239577,26.04439024346975,115.61254734173579,45.26084146647048,42.111082664115365,30.305168065303597,92.73694270555389,157.35174258965586,102.9308870192169,75.4325787877213 +2015-11-17,116.14989733614209,19.635495298018988,104.321802237636,37.850118363712795,39.68030075547456,31.61845770343929,90.46370239775516,163.9569018352865,104.55025620985214,79.76081304833198 +2015-11-18,127.6358470843668,34.96480713129806,103.5850875615154,44.74466211379753,50.90803863618301,33.15434187534254,80.3144707683515,164.6438101174576,101.4534584883258,75.75367591531398 +2015-11-19,114.18978904219367,24.067150040072327,98.5044359006571,46.568145673812886,54.49640618224145,35.896896565646585,89.88830352871308,160.31603823613284,106.25781448837456,84.17590583280324 +2015-11-20,126.98040664267786,27.383158786507373,106.58090416269813,39.81944370608466,38.224306470888365,32.59165021761738,93.52195892693426,162.8933282603927,108.49780307887691,78.36094221463439 +2015-11-23,124.00532880950229,21.59216887034959,104.63036136375268,51.615954727278776,54.83952604136125,40.408011273328,85.04133924421427,162.58289680235958,111.97201392953744,80.28674455620842 +2015-11-24,124.19489174952474,23.106119959976454,123.12974187977295,51.388539885003595,50.95181923831953,32.04163889252636,84.48321137564987,160.80192502758143,108.556428851027,86.35283221175429 +2015-11-25,122.86322384674969,23.86961781213251,110.08797244446995,46.84051108600151,48.12234775832942,31.967667605704115,92.40748680222202,156.40258274174045,99.58602889367019,94.09020087399362 +2015-11-27,113.85889211435607,28.667016837928024,108.14234681248445,43.99038916187761,45.248649600970616,42.942220710046435,92.49045851070647,153.7110194618246,100.42041141912358,78.65874100831795 +2015-11-30,123.0960592546425,32.909203881895664,107.71329362047807,47.907844675700815,47.52522075302539,46.309882811864,89.34593469913344,165.12165548132927,104.15505735678639,81.28287217343707 +2015-12-01,118.95891980207531,20.90348767809995,110.4467313964366,40.00665216985745,43.433859143793256,48.79173797327417,85.01618386573205,158.16051769288183,110.27560031776824,84.06932385128852 +2015-12-02,131.09204916829052,38.42847124413487,106.2094128600227,45.28276653496104,50.57598500912214,38.41605637399426,91.91140117677443,148.7824171710395,96.7401453654892,83.58266178917722 +2015-12-03,115.27022060002751,23.2894174205123,109.00794753542239,42.479137743528995,41.56277971570417,37.87605089846581,84.21749831148551,151.70194115492376,105.15089294266483,85.70801959694795 +2015-12-04,125.20211778919541,28.737293433851967,118.43967294510713,41.50995732490028,47.35320927530714,37.99687525021485,85.95870133590427,148.8888450152461,107.87993549439791,76.87750584483734 +2015-12-07,115.78659979870163,22.137886085235504,111.94276430505855,46.04167325923286,51.11553454041941,43.31492580157183,87.70957777929672,154.940832856454,101.5173762929647,79.91309158647361 +2015-12-08,121.314641778577,24.422534348343873,113.94147982909337,52.19753123077047,48.697289037232096,37.45440360690799,87.47468709570255,154.77537925791285,104.74513634906197,81.17538182058372 +2015-12-09,116.1506179968328,23.188690650660895,108.27290383249711,41.1004361052458,51.077466564681664,32.236041229584885,86.60946666856715,156.63322691881746,98.54996355343648,87.66551796183612 +2015-12-10,121.64591205251023,28.293259296119523,107.06479452155895,44.91252363879358,48.98518946880759,46.5793530394497,83.37755504658554,157.30392545805836,107.65465342073543,82.32643754615287 +2015-12-11,110.64847786428162,31.699811328763264,118.76784443954824,48.84002194649726,48.812490352733995,39.344769693354536,88.44865588564215,162.8408576479157,107.74548344098254,76.34114576051257 +2015-12-14,115.97628385079994,24.145053715322135,113.07173397705084,41.71485453109566,44.36453657000414,42.6386609038792,95.19917510439186,155.74748113745616,103.32793056442706,82.10120906855867 +2015-12-15,116.96111171015508,24.97058195351211,116.11903045778855,51.204750045932116,48.731410965795874,36.93060752063545,98.10575576378332,155.16875138191153,101.73062885189708,79.65006573075507 +2015-12-16,117.51578406143435,30.908004629071833,121.9692730808022,49.10466530954022,53.13495771280796,32.6358220335804,90.74093384415072,160.38244380229017,105.64840924717124,81.46410668657954 +2015-12-17,109.1891995350752,31.206060459218236,117.000801421568,53.76398265077983,54.137085818382445,30.519804379812108,93.63640031412524,161.0021631347559,104.69440783602896,81.14634932370566 +2015-12-18,114.78995050578163,23.333077934884,112.55613911437806,42.50956686785698,49.96983320791313,35.35167050968622,91.75348829602277,163.25571033812298,110.8788778762937,82.96727218828825 +2015-12-21,101.91277116212561,23.91144662540111,112.54735433234478,47.443251820347434,43.31548390800719,34.2915427723546,94.45269471356494,150.35766592937782,102.47505412212651,81.39789835617047 +2015-12-22,114.2655038960979,29.64588653131485,118.71251020190171,51.16710093373773,42.29974981542982,42.501635035616445,91.90111781706187,154.95500606470478,106.00421685115724,81.43758343651501 +2015-12-23,115.24371507361937,27.35224499870901,124.54108663893291,46.735403095422896,52.95012908512654,32.362488814043296,88.25186506514994,150.6283373284838,107.41482640106055,87.26331017719863 +2015-12-24,105.9014287542986,27.282748491116322,118.18568065234223,46.744530309789,51.965556578171515,34.32243547771814,94.61366690578713,162.5011513778206,109.81697993999953,82.64262863236114 +2015-12-28,115.69075706568226,25.48341736604345,121.85482002755523,41.95118145996497,56.61878382358263,39.86107010420885,87.39201328526747,154.55472074851892,108.60364696099109,84.90144578530597 +2015-12-29,105.37813008233368,15.853736472256347,130.04131774559852,45.755878373672275,58.16270642938527,37.194258645797504,98.63707826176056,154.13595809750478,105.96128823421188,85.54230924258104 +2015-12-30,101.41327366203231,20.858612494783436,116.80729493298908,43.53179595941977,46.95777983954158,35.9161739875815,88.8589063773404,141.88966899961721,107.95506878893599,72.12708134606595 +2015-12-31,103.8199767536441,30.09027009904335,126.57891346051704,38.88284641856342,48.221752843194324,37.45443569569859,84.16273446743378,143.81038383084618,108.98538028450096,76.35381221268258 +2016-01-04,107.04526950916308,26.5344142305766,114.08716209506679,53.41110271853532,32.98882814243163,39.94467312902502,91.92590080915986,150.34545072106857,101.56455128012303,81.21957934462174 +2016-01-05,107.72468211831803,36.233213771696214,119.06862847143168,41.10850492348105,56.56740282430618,36.49330154643648,91.50146279558179,149.96899968852696,105.43484810968536,79.81452124407838 +2016-01-06,109.79741525556167,26.19269234050728,115.21555172316566,49.00827871602826,41.06344834980514,32.48867984809939,87.55853695492891,154.6607289051047,105.20482455402093,79.63815164605198 +2016-01-07,99.13741413916141,23.980180584598735,110.32038983184725,49.458370066242104,48.456666591972095,35.697095632917346,91.837360573996,144.85521097231828,104.62612176496754,76.2396669059782 +2016-01-08,96.06237678397962,17.42730123913411,107.64834506369608,46.58573936455397,44.602391922473586,38.188118742445866,98.05253543563707,153.50958117882428,102.0970469472074,82.51677621801004 +2016-01-11,102.3004400236784,28.016011424886237,110.75365092926057,46.1026195040716,54.4527664423173,36.25176119474537,88.4340126366283,144.1970951037271,114.62125777491332,90.1439167039943 +2016-01-12,105.41911899679491,20.066125504459336,123.39316125380766,50.37563439913788,55.13375403714744,40.643235803423394,100.3045651848266,151.1134288500691,113.10461250195051,71.01196856397323 +2016-01-13,95.56744206772234,12.379318474411745,102.78427483537352,47.75657928197429,55.51031886953735,37.47708426808597,87.29180998342933,147.5249826488692,101.3022863815495,88.62129129718441 +2016-01-14,97.2596847449563,17.123557721244183,112.1812309269614,49.138529298620455,49.50950971135366,45.73474278369857,89.88501825392721,139.36915853754132,106.0100093494103,85.7464318376504 +2016-01-15,98.09825163459396,22.16071275558504,100.49248128720059,44.834692984251724,45.38470121114515,37.13870662724012,96.79889429354603,143.24870226724587,106.3797823078217,78.16801992462494 +2016-01-19,105.2281285356138,20.02800162667738,104.35052187420325,46.83352916960613,53.21114155662896,36.854243521770286,90.96598764174277,145.8564629196554,106.08620091394829,75.99247035940138 +2016-01-20,101.68212835300379,19.72154747321808,106.76451554958864,49.30675900572132,51.52858928837847,45.88637130411928,100.74705451662379,136.94870389439944,104.29221110883925,77.17573293580827 +2016-01-21,88.10420613096046,20.770817987710693,97.68876773808095,54.07571896110471,52.36506273745808,39.027787380645286,97.08312589896272,156.04965913503932,99.86452106029846,85.80078365586705 +2016-01-22,100.79024084400683,30.07652801783337,114.54652116278021,49.13856487857253,55.21373749609768,35.30326014086741,91.18503944517049,150.14523374850526,106.00892536382449,75.38759589746245 +2016-01-25,92.6648542572159,15.799035230170047,107.5999522555046,52.86172061499913,50.22723021339518,35.8829881353191,89.93315440855766,148.7650543213004,97.44942403210446,84.61467848362375 +2016-01-26,114.1632768059908,25.235478279917864,113.2189598947663,48.10425827976407,53.36444072409173,38.87591844699723,97.8647174754525,154.96665684839593,104.69823610276056,81.65364134480622 +2016-01-27,94.86274776346524,23.614304799521605,107.49338081832755,50.66123349524678,52.961884917214356,44.32131121486226,82.78707962883277,154.97068579513365,105.18400328688355,80.945139981375 +2016-01-28,104.3178480934248,25.74762883757548,101.54853382941741,46.88867355134646,49.3249874199859,41.01423751952278,85.80503047015317,147.98639875769024,108.71373938543859,80.9459264944812 +2016-01-29,95.10909512365498,19.810490516082538,112.232864065505,56.00687865404133,49.24392421774879,42.74823680754167,91.40522171309459,144.658760762538,104.3347697858491,87.26134748815106 +2016-02-01,99.47896751585465,24.485461887197886,106.01941480716714,59.55251900962436,54.308428796319646,35.404498858072806,86.27585310175658,153.33300962761945,105.86792489791708,69.35200348927168 +2016-02-02,98.70998505629942,18.612554447516324,97.7617484905072,55.30397237357294,41.9238071844343,32.61127003560317,95.77238342059628,154.81458899004346,102.046071304575,70.30476221398304 +2016-02-03,103.98414496819929,25.157251832245514,95.26241468820915,55.5537535139631,55.223372455973426,38.60006755980786,88.73305654198388,155.9945210915371,101.13406785727716,79.20450534900935 +2016-02-04,97.32308343744832,25.493119113854835,102.64562964848567,50.50354009797431,45.3238371324393,35.905743456486846,94.66806320730456,150.1105969781911,98.56239922853801,79.48126210364208 +2016-02-05,91.46675567392363,16.715669890396928,107.22657534915427,52.02665362455389,38.39302294720619,39.632992570940296,96.97403481944576,164.88792528253077,104.72989872179178,79.64352118356337 +2016-02-08,95.13576693974576,22.3362361882204,89.82795699308264,61.64471538953314,43.72189070629864,33.97990818377952,92.86434309498595,147.138926879057,102.89670097879034,77.44142388368161 +2016-02-09,95.87934526124967,19.23156635605949,100.26956706237951,46.4268946641918,49.08836965724394,32.49578953337473,93.1860121769653,154.95469427060607,103.42550092243718,71.15455141191524 +2016-02-10,105.90162907159798,20.515757046216855,98.30721944164208,47.134103266928776,48.46419075190349,44.77973501358236,100.1565067042751,151.31429355140307,110.2302484786434,85.13601910089265 +2016-02-11,103.41954360342702,20.17449690089334,95.7767776535281,50.99630106194206,46.538687663505804,42.702439405617646,98.57711413228535,156.50248390953521,108.58974913964839,76.03680714148574 +2016-02-12,99.28508932424839,31.23119578805522,97.14788252064513,45.102004066770014,48.7640126283991,46.21055847633146,89.28399674947534,149.72055994907012,111.12345497588066,79.4216356535445 +2016-02-16,105.6859671173255,35.82127523093644,100.99521755047928,52.497111772251,53.171979525944344,39.609731276016646,97.40540347580132,151.5600639766573,111.04949606477092,80.77594971343979 +2016-02-17,94.91826555883475,18.993806739277645,107.3302482307938,58.855916739283096,56.00157536138685,31.031142007788137,104.12284999881601,155.2822753606473,103.00647990112274,75.92078268274219 +2016-02-18,108.72042203148632,22.153753678439912,102.02351205690336,51.84898879682933,50.53875097760783,42.78306134119231,101.68978906352021,146.16551020538267,115.09561612341022,82.34753507524044 +2016-02-19,104.21818985594129,25.83226178204849,102.4528297147924,59.33447994698085,53.677522164097866,26.74985182914425,92.26262948290771,149.1153907006092,112.6084091817157,85.42831429472574 +2016-02-22,97.69668746577314,20.43202673401548,105.84353859810184,48.82845526204239,52.515378701735415,44.553494839785145,98.37741410931243,154.77637242344403,104.70734690792298,88.0858814264745 +2016-02-23,103.2407102309221,16.514113386604933,98.9241690169697,38.72383262989937,44.35011608087694,40.89128746105453,95.5506512172481,144.09862820044398,99.82282152643933,81.28047462432508 +2016-02-24,93.98186406439514,25.049002903539144,111.29773667370985,55.92175439530534,51.27633415753614,47.698429026413834,89.90281823376867,146.5935453634988,105.02490002412063,78.41295078691165 +2016-02-25,102.18074281360859,23.831531077684705,95.58167750380639,52.90035824340846,54.70740937546259,47.94737369264091,96.46932118170912,141.73326451955023,95.75221643360464,82.96315225271213 +2016-02-26,106.13306458091968,34.42485637189376,118.63042732236616,55.94410808450413,52.12216257447662,37.67377100199338,93.52658801542051,143.7130200251694,116.9403411730948,84.30010652113054 +2016-02-29,94.21707654945902,19.436559703275083,129.9492287274638,56.62674436032846,48.02169444562051,37.720576624476536,98.52432064140842,150.12603583927955,106.79709366859018,78.44362023060985 +2016-03-01,106.5040319743587,25.431485591414848,144.67608715477854,57.083992844644044,48.95626891734487,36.726133935395424,98.30166080942257,150.13507799012635,101.5710478698626,92.2701782479422 +2016-03-02,103.06062370495141,28.718924172967558,131.44184077105146,60.33347720862155,46.05588106048781,40.29572420227791,101.5285064247207,149.30689763533283,97.57727854492524,80.88210779495064 +2016-03-03,106.87490541952043,23.14791070880476,126.19468130845064,63.240947623987225,54.46598215931628,38.12713333645499,91.20650897238136,144.08486926572527,111.02155558028937,83.41173139127622 +2016-03-04,107.7573183818577,22.490814482083564,139.65851630137118,49.12178333160552,46.8223770907935,41.59327741507636,91.97370843965513,149.779186850117,106.7740567064769,77.46739801405884 +2016-03-07,98.26266069813423,15.567035688860257,135.10931343962605,48.154838269381656,54.547716460696506,43.64541263605972,94.83583523521449,147.14796935868415,99.48576684840914,80.16594375463887 +2016-03-08,103.50456003702642,16.467503370013418,127.50894473252244,58.00756967165559,52.567822451606034,48.45918791672173,90.1687523713277,155.54065920188867,104.2836726683568,79.10063203314314 +2016-03-09,104.57470894518224,21.43622178611414,123.48227868874208,49.58966326862462,47.30484340568934,39.28037282174682,99.72084406860694,150.33700644290775,109.04341803822312,87.03043216653208 +2016-03-10,109.90547482056257,20.796724062053258,131.39452893492395,55.96265380992598,55.03915727629479,41.899624016587,90.56414117272651,153.72309636993933,120.2751808230416,89.67617374309165 +2016-03-11,114.94202131611938,26.210703277262976,125.78569171279335,59.22507015364119,44.49108109613348,49.18344791526079,85.94139731174613,148.39476162992688,107.84406911622837,79.82035844938208 +2016-03-14,108.95897021776946,29.139074176274377,124.76971674148571,53.94728837772556,44.65661902267045,34.00638157506237,97.1567600965141,142.55502056442973,105.0801505911176,79.16354913838182 +2016-03-15,104.30756838766155,23.17284689870541,125.44094159538497,52.882465451138266,57.124026373097294,37.98519223532014,95.42587066777595,153.97671432292162,103.86953847801843,81.26715256157298 +2016-03-16,108.45921583625352,24.29783026755225,118.21580421070638,60.17980464262584,45.12899239742884,46.291088409214865,97.26729090657628,152.56319818520922,117.40128970448023,85.10530433985221 +2016-03-17,109.10119494468326,22.719753522044673,124.64267096847306,62.06606117929452,52.195992788748875,36.738082921233996,96.33898418818055,156.64281886847942,111.41010705228372,90.38564105608481 +2016-03-18,115.01729448405185,29.678321547557005,125.21603453582394,58.42728047946098,59.00250512627229,44.48441092563728,97.25844820112299,143.5071126848833,116.98273135972636,79.54861973228972 +2016-03-21,110.73104677923033,28.89021929071158,120.92784822507178,56.6923172154164,54.454458431788645,43.68776314529367,94.10418294956904,150.51296506330996,109.78281000687595,86.21374394955826 +2016-03-22,107.52307520408903,22.3180780251526,118.28600513437442,58.66177146770208,56.50321127242783,29.32471885764218,104.23473151801194,154.1065767304924,101.18684167561727,86.48005455570528 +2016-03-23,118.3592277641264,21.490358700896085,110.4019349928446,51.044668032205216,49.73246732453219,44.67854923058807,101.46762088222675,146.29693472789756,104.06612086906497,87.21556805219225 +2016-03-24,112.08800929018679,23.862744619206754,126.91793660879475,54.467626692870155,47.969144016443686,40.10290927475604,97.34472830434592,151.4097502191715,104.3802792500004,95.35912059682754 +2016-03-28,100.68055499070266,22.53011372557971,112.26029979144566,50.8322184187866,52.259332754953434,39.52251720970493,92.16341525684237,141.87403414809037,112.59361707169637,81.23914761080135 +2016-03-29,104.22034071301412,16.78238155422345,116.57260147186297,61.967986931308964,56.42498996986,44.87137457168099,97.7012569530379,151.57026376703467,111.4657313853642,95.83613939736749 +2016-03-30,109.18340469784512,31.15714354728675,111.43620137275583,55.91882163231513,52.96872928772066,44.121445872065806,96.7230037044978,151.74209564019165,112.11458143448111,89.98436364666395 +2016-03-31,118.63853785055136,33.4493363618669,112.27373139129286,54.51671557863619,53.99485486336626,48.96674813767894,91.3495212131275,147.7485408588309,104.55282236520884,89.2209567738051 +2016-04-01,112.38627015504613,29.698341364172336,107.7013280102516,57.37623451255841,50.797788887118095,46.307978592811835,98.64735848281549,151.16067491059408,112.53478950983748,95.31390032344548 +2016-04-04,113.56866971831764,24.809380771497448,107.87222820809035,63.65800906734211,49.61131149732608,37.14718243542832,91.03221497454246,147.13910168117596,112.95039091364868,90.86154200469272 +2016-04-05,119.35699031392375,23.359080123093136,112.4715065350542,53.74193519077201,51.50960782188426,29.975549014126837,101.15156775974037,152.3442603813993,118.39782068655443,93.95916149792058 +2016-04-06,113.72083666069283,23.663525673361598,101.55095431490261,49.352949741664204,53.312028024239346,48.03793783980996,98.79619771631376,151.8301093533,108.30259611593381,77.79231276626705 +2016-04-07,115.07705308120167,28.446141532484564,102.93612923533689,59.195975522508014,51.67388048022745,51.32087580580891,96.388090567664,139.48351626779,112.23763597090272,90.00278704388565 +2016-04-08,107.79622492487498,28.128106128987476,94.6806119687026,47.14345745316441,54.4026190138019,50.871209968862786,103.07511363144602,145.59256340169736,112.70971744042026,90.89537343849977 +2016-04-11,116.4751884200212,29.574848430219788,101.49965491532245,56.091286118206014,50.80896918296877,44.57655946759991,100.16502302775126,149.25799150562648,101.06765675318101,80.29867395905093 +2016-04-12,119.4103047543686,20.799781034535673,101.41642760449881,60.48514783746712,48.85802694524977,38.028705510387695,97.72475241155325,149.91174572950655,109.28138445285796,83.33396617209624 +2016-04-13,119.72307955070767,26.275098714169253,99.58173229708434,55.09862031021028,49.956307477511004,34.09796809176735,94.76788611878807,149.13795888708484,103.38787494835971,90.41832239386595 +2016-04-14,120.55919330347689,30.094529538861373,111.69516606959758,53.34466421650967,55.95098465565824,45.148968891260665,98.2837858886115,145.4250284820503,108.38412906444435,90.53486024652676 +2016-04-15,107.3442023197058,23.86832451033662,102.3762309571434,53.43282072258139,44.402191366127965,41.03607806243012,98.70458358814923,146.59777780002042,120.57357371867336,82.00069413598561 +2016-04-18,110.19113574978674,31.93066546937498,104.29019485173119,44.72654864568978,50.796660915055554,47.8688815817917,93.96899345424845,149.71807975561939,106.06751408567156,81.8247787133564 +2016-04-19,102.92512167019078,27.587978803541468,111.27640683869072,51.68501374412732,46.05545033256358,38.70477039159486,101.52700510375224,148.78512564065275,106.17117422703602,93.0415303924638 +2016-04-20,112.38419858237344,25.960972250112142,108.35290344815557,52.51037155672289,51.086090958336506,33.66976376759829,99.24675125948332,145.5033513991931,104.85769219099298,88.78067847612175 +2016-04-21,108.11919652344173,25.183779022210658,100.1692936751749,47.27829946043734,44.09154463930434,41.914648576159436,103.00447769345404,156.33279041584586,109.53544629056051,96.40253290165047 +2016-04-22,115.91364609649663,18.685677971067605,86.42181280953943,48.69815991101219,48.6682704903584,44.41724994320252,84.41236980725401,158.44896969347968,103.54237832736861,81.39130155330432 +2016-04-25,115.12154964989266,28.064065856821767,109.53699409303667,57.620912185321224,46.81606572428627,35.97326207052305,92.63994461965669,144.42258380345132,107.25663194934576,81.3397044636547 +2016-04-26,118.30776822728646,28.83622694870969,93.4564646399298,43.60102687432506,49.87430598860236,42.63477990524706,87.75750651878855,154.37480841755473,105.97648480879603,91.78342357552164 +2016-04-27,103.62500055073937,31.204002955997062,107.18201333015571,56.100539019162845,58.38753880526911,47.04609447101647,105.10318177948965,154.03225758109733,117.24832149460812,94.39319639555303 +2016-04-28,85.61441922882965,25.054052705001084,91.50735165259675,52.0112072211479,47.532696594499015,31.333834391078707,94.53211907797912,148.2310131222712,104.36782763125387,80.79331404993039 +2016-04-29,97.2374367631206,22.989347669738635,92.30416766011349,51.21292667473582,58.47327213074509,40.79033062100332,97.09592165188623,151.87560246607936,101.87572697798336,85.16543158104288 +2016-05-02,102.69113500870773,35.49471717376311,96.62522672848844,54.726404774657084,50.73567681838007,45.05774139803223,103.05412778897193,157.29081725568545,111.425211230579,85.39388095306961 +2016-05-03,105.30765590220176,21.20053881986656,101.42039113173294,58.40405910703431,54.20301685343902,46.48157439331628,103.55131181777915,156.6972938840415,107.58759879878582,83.5979764305569 +2016-05-04,96.1841922551507,24.886059580577324,90.79040187032894,50.308814178555075,53.447003286052976,40.68083739737283,102.20309354961715,147.98327764713537,109.6108599600286,86.52361706944605 +2016-05-05,91.36851037866137,29.30309580916935,96.98298294623702,45.44661774592272,54.877993580522656,46.96946012916503,96.74836492981734,152.86351673419432,115.78340943485554,82.35509804385225 +2016-05-06,104.97756338382095,26.858985039697217,92.80538995578202,62.72010527758662,55.82524765387413,32.29625098575216,99.58212372706902,146.29210248897238,106.17523253700783,93.07967972473955 +2016-05-09,100.99919935437444,25.21706305986354,101.9325617720652,56.28684675175373,64.47832726196283,39.91834160130314,104.98012369516931,142.11688134638462,100.92065041051028,87.1497247365164 +2016-05-10,92.10898659603951,25.119694606206373,79.29238912672467,56.3037879491302,53.260401230172974,44.38805999335542,108.8404355108903,151.59827703182935,106.89899170373403,95.87516802421742 +2016-05-11,103.33854620679688,30.705160563779387,98.20842680780802,55.18054142240999,49.94331577326309,40.023524509875564,102.43616234786666,149.92764045216904,104.42962840754512,90.966535027285 +2016-05-12,98.66992090423464,25.103706071133445,95.51294654461769,55.4147593741403,55.45449664226865,38.561863040717185,93.65619470366558,156.86365558939414,106.94441986315682,88.19336514234848 +2016-05-13,96.51398814388358,26.731858999463327,91.84042364938772,51.197135364317745,43.911869768230595,35.311162083638884,97.8103797199326,141.86367432776723,111.74918180863683,85.72284369991158 +2016-05-16,94.68536691755918,22.78495715914551,97.98443314397599,57.20793538994782,55.078019341684154,50.865244442914396,98.89443267146859,149.37548031386362,105.39375165335879,91.84770159022004 +2016-05-17,100.06157114196203,28.800209817278564,95.11420644095043,49.95157729684267,54.293547505370924,41.01355305553369,95.7656163195651,152.39666387770293,108.27076324850168,100.93568376454996 +2016-05-18,101.10462142898128,28.250777996439602,90.75036776223942,56.3735123545318,53.30417563339669,43.64867544239195,98.54613112236842,151.1570387283055,100.19089127896497,89.61411849937782 +2016-05-19,102.38776397470885,23.944981175062996,95.39965143280075,53.49648359310082,48.83265654634823,41.12728285693722,105.03110673301278,155.9398578100105,113.78571622226387,86.36723677524114 +2016-05-20,104.494793986701,25.874365279381273,87.59246435752544,59.29002089656246,51.04618579836688,45.29379789838177,106.28320891844481,157.71756150496824,104.85195386889563,82.54822791071246 +2016-05-23,100.14549830648384,26.84130996341629,97.21568011738313,46.86996464563557,51.033331037520576,44.538626400265834,98.13566588103821,144.72271684102537,109.7399401718778,92.99488459154439 +2016-05-24,103.48488584142177,27.0106019443869,96.97928336496302,56.30044631017724,50.393027235267795,45.76074794146524,103.05864393681912,155.7971012989183,91.9753736891293,83.89778152943856 +2016-05-25,103.85058976122694,28.300397034489805,99.52517589520032,53.86605037742485,51.47131431952255,39.22350357896266,98.9619352187167,151.1675270329152,116.95392928695978,80.28518236724636 +2016-05-26,106.75722140922635,22.424920486244375,95.91286962308827,55.14558780204921,56.592231324153815,34.391242219270005,106.15863059465252,142.6171260107945,102.92462210400163,94.1404194901899 +2016-05-27,101.09501197885022,32.77738009761435,104.04313690507884,52.78498001472754,55.39677647667163,31.31064591893185,95.58579267501568,155.9831260281575,109.95376610250598,96.95608609924733 +2016-05-31,102.25060484599388,31.568474229352155,107.31887734590151,55.09850762334978,49.78367775552111,42.04902974584259,106.75693362924696,155.03340106880142,104.80157963617759,89.51733502554283 +2016-06-01,104.52437999462278,28.384145885352204,95.89949165537747,52.641237497961114,47.88096150376753,43.658513180574715,97.06038789678546,154.22647442907436,109.62748961202898,91.58707636088415 +2016-06-02,102.02540692737342,27.243589878924023,102.49777196349511,47.24399873928084,47.883067924083214,54.92387149391945,104.93142074893328,160.04794217587093,103.10466570164675,96.22360557960081 +2016-06-03,106.22687477713413,22.264556173761108,99.78836664405429,47.83173942350923,52.394114002602656,51.08906380571279,103.35034037835933,141.13453925536402,103.68517134694324,88.93122510315904 +2016-06-06,104.25685352133428,29.02038320499658,102.08476400548543,52.8305593293273,47.36965701341302,40.93312201843985,96.96818223985679,154.17709024561498,108.93724884312738,83.69480720335028 +2016-06-07,118.33906620562055,23.424256177237094,103.2713508061235,50.84067312753978,49.322234148362924,35.91337033885869,98.24826888234159,154.36887989755513,109.53768043185384,86.9483657327458 +2016-06-08,94.72308189969219,20.086232774525232,105.55764780909348,56.01894743510722,50.43098239250766,35.04215052897722,100.68648815671918,139.7575993546414,109.27482629228355,90.72187614246867 +2016-06-09,108.27619310262003,23.73727008551653,105.14020760462563,51.12363870877225,55.010938102096,43.74075214416408,108.40017534100022,147.15060078242323,105.10777507944931,91.03969522242343 +2016-06-10,105.1311933134939,28.996683580449343,99.05471085550064,48.57984783634724,49.0894855688894,49.64317357954218,109.87037424574932,154.31352041210488,101.92734910217544,86.68606048874555 +2016-06-13,102.39488672719558,31.05360772863223,99.4438964956175,53.82672685883671,52.03719398533563,46.79772875226607,97.07264992904521,153.91939647445489,112.32399200796596,86.94196408502786 +2016-06-14,105.88550119165072,20.643942443542553,100.70076840370628,59.298152916131045,53.835365806993224,39.475936303720964,102.26653831272209,156.39032195986877,120.89780677441316,96.22804611775116 +2016-06-15,99.11460813650552,23.674150512729916,94.56167789525237,53.04179504618903,63.97463899654416,33.42481850309035,88.2272159001942,143.06296285866227,110.2899018805696,89.50302174606904 +2016-06-16,103.65936899811453,29.714487722576905,105.96458218982222,43.87345780325149,49.77741399962411,47.948534685111596,97.68217555073835,149.0320397915223,115.7989406604145,89.33623584506199 +2016-06-17,98.74714541118792,27.09064152044789,99.49378540277617,54.032301331396425,60.03060435831277,41.255016655200365,93.40858383393929,145.7096689114571,108.88592529440922,85.98868381354254 +2016-06-20,100.40165668373683,25.249401210645562,111.68186887684179,62.063944676223194,49.90021645718879,45.63884944325707,105.57247884063104,148.4778236812033,97.65735807554515,89.51091094076214 +2016-06-21,94.28063574680732,34.241992854244145,104.9401369762508,52.023013967389154,44.120590332982985,50.4350982500295,108.02245904713548,159.16301394658683,105.80211050911169,86.79575748328196 +2016-06-22,101.02718589765804,33.380451708821454,101.14298383677462,54.728353791928484,54.980696061372186,45.03660871564604,96.69323199165444,151.85975996026383,104.80189134741461,98.44602475954164 +2016-06-23,112.16962982946359,14.538334944621361,99.02330258100838,66.04229515083668,49.231170918402384,40.50157930811074,101.5376243800081,159.2570364860396,111.06694640627694,84.94093068820057 +2016-06-24,95.40780693095287,19.35875493671472,101.93425069550638,50.30114761929419,55.08871033476577,46.984823821861795,104.38317580699406,149.86573789438415,112.84978510519089,91.70573747675589 +2016-06-27,102.41075624344789,27.239120539323828,87.08113961773064,52.9076995688243,53.18512466646442,48.004727554418544,102.8358895744912,132.86244650349857,121.01015140407105,95.49262010575862 +2016-06-28,99.07582474468475,18.09120931614673,90.36382751205531,57.35782109382131,56.20905719183032,51.73193754027078,113.56755012725093,145.22299494800285,108.57331028810242,94.36450835839068 +2016-06-29,96.3696143016279,24.16156098478445,100.76812414625851,64.63489031166456,48.972069855452,40.60067756579268,111.15583356173865,144.91706374296245,107.20958673327883,88.81783835392059 +2016-06-30,105.3252437273601,20.00143128740489,95.88607098999574,61.46549628860032,53.06944983057319,58.111972589435055,101.98041958094218,137.3713583087448,116.07191876850175,84.20899585192377 +2016-07-01,93.26731633078272,21.642824854502713,102.32172576494432,59.20510567230605,58.722461409078605,42.04787398353433,106.75255314251304,140.2217891111337,113.40319590960816,86.66141709229065 +2016-07-05,97.76430987151919,32.263739403059546,94.01679973052883,58.26502934153332,57.58034278681326,41.797328716504325,107.35785346642115,132.40004449511238,115.16995663388364,87.42264300698514 +2016-07-06,101.40659869429099,25.843122662420924,99.09138236735963,59.728158919110385,57.702524853222044,46.45713148705668,98.54900405427682,127.01721023364911,104.49527679296155,88.52506687095347 +2016-07-07,112.82829026835927,30.147894603897072,93.74029207524487,66.41387346383539,54.61479674592695,48.34951755316146,104.53307464875927,139.52805326977892,108.86457431040557,92.33280798173686 +2016-07-08,98.59582597064905,27.016812399759267,90.81055126307233,56.463360372369635,54.00149422192989,44.57022376402124,107.65708114719499,142.33550122022854,100.5990469008101,95.75439163177862 +2016-07-11,104.7009876763448,21.156299756715345,95.88227565011245,56.85482146961582,62.89192472655912,38.984501102004856,101.25358201119725,138.7350663376219,107.336917636959,92.88540360957869 +2016-07-12,106.66812862399755,24.82025024279345,85.17484569205315,40.98150786343453,57.217904815196114,49.86253754783548,106.57482349376973,137.3363136013566,104.20504646567551,88.27885461898784 +2016-07-13,95.5235160907931,32.09225028074543,91.61006592653703,56.28176783404295,49.38810585946754,44.71859712108361,104.65270489928739,141.0933689073633,106.61092996442883,90.71126082597915 +2016-07-14,101.84660788559573,33.67545041159096,89.03289754217897,59.80078699671714,56.09161968933503,52.18278846319302,94.93853923743815,139.5826212486235,104.67575742611825,88.27841222207655 +2016-07-15,110.16454104917592,16.342984151290867,89.09503820354949,59.24825878838197,48.0394349990786,49.033702915396034,97.36844958673946,142.46410408376906,105.54489497699907,88.39708109690837 +2016-07-18,98.23278445934302,28.327749031377834,89.48867182236442,58.02869033807408,46.65684293891724,47.96817566945812,105.8997796078022,139.27887276601106,111.6801754281862,93.23166656793433 +2016-07-19,107.34417010353539,30.129345557253508,73.45927671989381,62.634051374362784,56.87280373524986,45.57403322940776,97.88739535223088,142.1002240341182,111.79077253007969,92.64918502495654 +2016-07-20,105.55526709005255,24.5694865974017,87.79294151898573,61.963817097476415,60.84801264875472,46.12009812022472,94.71594274114256,132.91616902476454,101.15401128041673,92.83873832035022 +2016-07-21,101.32342251824173,28.680378537729567,82.59208934128915,57.58161310271638,67.36343551637414,50.39218183531636,106.31060767679288,129.0792617877043,95.87864818105777,96.06125329158749 +2016-07-22,96.881192570815,29.327995073008047,82.32041977779001,55.64423463129137,59.41501731960461,48.15487955828898,104.59884122664857,135.2848740984015,101.84167773533379,94.48288776602166 +2016-07-25,94.44988589421462,34.83764224518958,89.12984927521408,53.58167868698086,55.997894254366436,41.532031242443196,110.8129544454874,139.83505651836813,105.7336892891165,93.50341265171149 +2016-07-26,102.47764355899415,28.12896439764877,86.06169174836373,56.6286829154623,58.2604743776086,53.28953077662261,98.37307473124862,138.08791788096642,116.92093355637599,91.00896858695972 +2016-07-27,101.56326793833055,32.272646636288286,86.7717234362983,50.54314649450349,68.83116285512752,49.47234863432328,103.58108096378315,138.95662471476095,102.64408749523115,92.56183743917805 +2016-07-28,103.79481803391823,36.27273079097733,91.59894651611145,45.71394321389324,38.783536401984605,51.58582750776152,108.22966555346122,138.93395318159565,98.9827032851836,88.6087278698113 +2016-07-29,110.80326958265165,26.165917166875854,82.98115100602493,57.446477538787995,49.94333709931913,59.53611731486906,105.26843357798617,142.44840512646815,111.81431613988906,91.97114839053506 +2016-08-01,109.2231293831124,27.90127182895875,87.19546270676993,52.05445997671524,58.93652683310915,60.13001451555225,101.56745255845914,144.24225098932817,107.53013901385846,88.14890844603903 +2016-08-02,113.47452227502959,31.791398383133817,93.38122956966617,49.58019029446357,63.7172433503843,48.334197452311365,106.02630315617961,143.63393259372938,106.61231717079343,85.50673735040593 +2016-08-03,109.63389941170362,27.526533261145005,91.45756462318053,55.75395958586022,49.94366555893173,43.829266080127695,107.0517410999759,137.8791731178055,106.7112809261449,91.51352617038401 +2016-08-04,119.33016431449155,32.187279271344565,93.22233844131442,54.15341298119113,51.69731298546863,43.459209483939084,101.80756701799307,137.89386199052677,106.78545868188105,93.24207632283175 +2016-08-05,113.64921326406696,29.618798080488528,87.32289917993057,59.740396058914946,47.51631770577012,45.33939179566857,103.55401553417977,138.4678862302207,106.22702340233558,89.66348370137014 +2016-08-08,106.00398204511019,32.91740238251812,92.315911449276,58.59139200036197,57.39159814199268,50.42787489787654,114.12051368017337,143.21754637973248,110.87296695285995,94.5595019271541 +2016-08-09,113.4953493867309,23.33944918288959,100.53598008172979,62.62933031151361,44.41228250998424,51.98352061788866,105.46633822428625,128.20897647070313,111.25191341298117,90.6151291188281 +2016-08-10,120.66872119210544,36.13734637980306,94.73291006795357,51.784341749250245,60.77991359573666,48.76722312449441,110.01981848566915,147.82913952240466,103.96338667897726,92.44304554551411 +2016-08-11,112.92285528524668,25.752057055118605,100.86067312171933,53.30966400712664,43.43239402739867,41.17425429890535,103.18311993394404,145.16283533145602,111.80837409935879,93.51390339403609 +2016-08-12,116.0672764372668,31.010513205706374,94.61080322641423,59.78461749873203,57.69115157924751,45.72289128364179,119.93829507051908,146.79357312366557,104.6356833167327,94.59235750127829 +2016-08-15,111.62543225911764,23.569698731944037,104.18471231842078,55.66377898296087,57.554353232484296,43.86214814278579,109.54309450694332,148.05573032193698,106.10925624769206,92.03850580938777 +2016-08-16,114.00634630678968,25.7805489063816,100.13338130493462,52.258643444513716,56.28702029552447,43.352915408510576,111.04377325323736,139.245130129801,114.82596318809742,97.05028472921514 +2016-08-17,114.27702582385908,23.281054461234863,96.38704341980136,61.26377922865019,54.56682913985246,45.42142397788706,99.11577227845257,137.89746359834177,110.77901603350735,91.88962402033782 +2016-08-18,119.64932694763996,27.529569491615902,94.88437102042809,55.3287489214066,53.26344311466981,48.39791764228373,104.79732947124391,137.53201855778116,107.59165444883634,88.15455383455797 +2016-08-19,120.66675778629687,28.517444532818416,97.71139675816369,54.39066185418578,55.761160236193405,41.01838444522009,112.10158239001706,139.5577300945664,108.66596063952004,102.5071239495326 +2016-08-22,96.94572925456654,28.679060988889923,91.64755781631865,57.09890872374011,39.40201440436102,54.2395901902525,90.00571833344382,137.25438452752266,102.9154516405594,87.5839284704671 +2016-08-23,111.10057139334603,25.92985976510813,102.35099805628415,55.20693884056306,54.96083555467506,45.73625742363692,105.18719590173002,135.62912673577483,112.3078174168856,89.43061103231452 +2016-08-24,121.51656386390242,30.2421867912976,96.16355629443478,53.45863016027791,56.79295540485037,39.62143595751291,97.56512992846223,129.29662338738683,110.41744592486035,96.61524207502198 +2016-08-25,121.05029977248526,28.21039473329602,99.03033453409711,66.35911158119673,49.53990733802586,40.6885193204945,113.15941518556616,135.773312279822,104.42918929556787,96.62308845013825 +2016-08-26,105.55188094583684,25.157831859041202,100.7517837823113,51.481207653823425,47.87934487048329,39.03491766715592,106.60558935828485,138.3404258368516,110.0105587711995,96.28953102931006 +2016-08-29,113.41557543156159,23.369843802579034,104.96921792148771,58.042960390851256,50.19985893250291,47.91108333745801,103.30262247129996,141.39304370378738,110.40013222220301,93.82694140695514 +2016-08-30,117.85338290549475,31.158621324597938,106.6386191288301,60.02554857919364,59.47812505035786,44.91387291180362,98.91228437572981,140.10962332791837,103.18197194384452,95.01145196281006 +2016-08-31,110.872493223558,36.92352599684508,105.2263300308743,49.926684281847955,54.69507171689001,41.94719537403928,101.28781600742606,133.26225581706518,107.79274200317917,99.65177069783114 +2016-09-01,100.84081914563946,30.662889642991736,102.68102376966753,54.407128833489054,63.05048950270222,42.08535454941767,106.1164205154569,146.74699453844005,105.23196824461905,87.27110578025459 +2016-09-02,112.36890367300464,26.945224766950496,113.49044636891514,62.20865289062737,46.01142905607949,50.80917648698618,106.25432814770204,148.51728718427813,104.37567233198915,89.7014637815883 +2016-09-06,106.10432163534591,29.948331570219338,101.30201395371368,46.17115515787533,53.94433038930141,42.042631930032094,100.0715837580197,141.36501439635654,101.81433540880866,93.70662098858176 +2016-09-07,116.86494633869336,29.427597863418928,103.62924365935784,47.24838581646322,52.49098589209581,39.733354488730754,97.18164071458642,137.14719149389708,101.88875366094263,96.8647606076874 +2016-09-08,112.7556486513656,23.398082958506865,105.79188042777936,48.57419658920703,47.70043767091032,44.29242886074104,103.47061205311508,141.72980032527988,103.30903480174781,97.5345530457127 +2016-09-09,107.73848825066526,31.950403906426626,97.32874514564081,53.2589741140389,52.84052881172266,40.78537007416152,105.05111566583972,135.27603810362686,99.95132762309308,84.26930431990579 +2016-09-12,112.78130692564275,32.99390586336133,101.31259415735245,56.11281923413478,55.26646027151864,40.606078893008174,103.55174610500335,137.6896101077014,112.22404724819798,90.33099507784544 +2016-09-13,111.96532894194227,29.890861766899604,95.33992700284375,53.13830679070139,59.64584826719789,50.90797711429275,106.25943328930856,130.25567778437434,117.10662104438644,90.033374641543 +2016-09-14,119.11495950866272,18.583513427068397,102.93942646040969,45.95623658599902,54.92624194619429,45.16403186208581,106.56127307562228,139.16372073436304,113.05934002009357,94.01654404343859 +2016-09-15,122.85481409970204,30.713623714309566,95.82201902646442,47.55400941191218,62.78839406631835,42.19886981894578,93.65093386348896,134.91200233905957,114.03174982297449,92.19716352944067 +2016-09-16,111.54481816656654,39.72520474346958,95.20595497927009,48.177013841243806,54.077805486095144,46.93490232955526,101.5533272763407,144.4208354299436,104.88193301393794,87.24933028853886 +2016-09-19,125.31336800108343,25.03852997929874,100.4624883299256,58.93963572770127,59.11654010591099,37.759541592173136,102.33759976714099,129.4013665850841,102.81909903162628,84.98878125684044 +2016-09-20,117.83011494802344,24.820836072844127,110.36169586754363,59.48926064292252,47.84533591514527,43.995030043157975,113.98290312780973,134.20345484273264,110.13723366034108,98.0356930946663 +2016-09-21,115.9133677007946,23.022449073426333,99.12212341539679,52.68852255502269,59.988787734049794,48.729826931571296,106.51064733931018,131.68502598484156,107.83050431592432,91.34753630336216 +2016-09-22,119.30823757639645,29.45551449938681,97.68337884918688,64.73031227852931,57.154173509788166,35.74167358544776,110.43436515272992,135.86364760453267,112.5781835751637,91.52720207818624 +2016-09-23,109.43538385789132,27.178563969042195,108.99668814924152,57.57069476422445,64.83578967080267,42.78688289564685,97.77716056719335,140.96361402974293,106.92925936213038,91.37171289678716 +2016-09-26,120.00567449438994,23.58924294890376,115.8847229185902,50.7088983151008,59.71829737037818,44.89420503576424,118.7474705943768,145.15515953990544,117.0550174980231,99.33292757800871 +2016-09-27,113.5055617513904,30.714109280150446,100.2307052541974,53.17228764139638,46.129540357721964,34.40747249185892,107.98096808015909,140.04283923291794,109.04836534495202,96.08560248044105 +2016-09-28,124.76492551829159,29.033986460966435,109.4411036514045,52.0760944253566,51.49289524291976,47.55633979798121,105.57038243817647,138.85767699200719,104.76973478305841,89.67408974835793 +2016-09-29,117.37085540568516,38.810190903305596,107.16387842568935,60.07302355202208,53.946462545594294,37.60518964783667,103.75854273555277,142.95896008486,96.97024542962365,97.70864474502417 +2016-09-30,116.72655645337525,31.193472189538543,101.64744293259177,50.23103646075051,55.90642932978489,40.45535728050714,107.09927712585193,131.2437105565222,107.10353783456026,87.56518886612164 +2016-10-03,125.45509232045544,33.29297767553441,105.37692201989043,56.51292993528498,50.82821022940256,39.74675017367232,121.90014696777786,132.62319593490005,105.72918112548837,96.51917454679531 +2016-10-04,117.92591681920732,24.97406327363613,109.80949138988588,56.57752258872044,51.30477141781702,40.18716970690042,108.55451309270522,138.93458589756125,115.59061405479632,89.74182716027619 +2016-10-05,127.35888806939579,23.943660747341887,102.41420494512478,54.40446831932976,54.68029757099051,46.68190716785273,100.9423577108252,128.67342757897154,112.37919345141235,93.35564756726758 +2016-10-06,121.16842577472663,31.79341417576544,98.08255209650213,38.26891024358875,54.802099718133924,39.53304048237301,107.07723003881489,139.30750578596124,106.78219285715011,90.58764308682883 +2016-10-07,121.0501828587315,35.74130598660601,103.88637672305632,57.62798405662457,52.807859762428286,42.64267981442314,107.14969230510262,132.7220718008936,118.05244604446555,95.29762161113126 +2016-10-10,122.22994451953612,31.411340095163645,119.70855470673371,40.28882579365159,52.60220025781438,47.6330451165654,99.64143503647578,128.68380268102587,104.04270834509418,88.36668444759705 +2016-10-11,123.13625339973274,17.504496058672686,118.18955963946193,55.22968870731076,49.71625381242915,43.96377435984445,105.0715369670266,137.05771491722464,108.31968320085194,96.44157634410018 +2016-10-12,119.75526455071497,28.49015752633455,101.43692127007199,50.47922766383316,51.84815774922328,41.9060351102464,97.73295961953065,139.56882676737825,116.21895767465017,82.95664249277141 +2016-10-13,134.23499205110735,28.08851824186501,97.3276677512772,49.902535597155534,52.48349875423766,48.767080391295195,101.90578108582443,134.43921480197238,108.63289335892759,90.94639195438334 +2016-10-14,119.92227616935318,23.750412582706712,106.61512150426647,59.630598701517975,55.09463752750748,41.54325180618905,102.25560627528115,128.2335127083273,109.15518018803823,85.05437802335044 +2016-10-17,122.80427106484969,27.686796283524426,105.8025840886475,46.33299437856387,47.570958448649705,36.99258969870256,92.69317450199391,123.60022581341661,101.83257782371126,92.19443806151271 +2016-10-18,121.33208321444447,31.950182202273893,87.45888709911613,44.02716159364726,58.096410244147314,38.1689268905633,103.57297600726285,124.99255279788801,103.510004779066,94.00799536984856 +2016-10-19,125.19299592193042,22.618481869957044,105.86798013029905,46.98339274464539,48.441873134312594,48.84221425606386,102.36728005345756,127.63181685124655,103.81035500261142,100.50951231274684 +2016-10-20,124.75876535790468,25.043907635022066,106.22279755835359,46.95906623266626,56.71017486303661,51.52717070222036,95.43756159177268,136.30674957545932,107.99997686776643,84.30522527517951 +2016-10-21,125.88892098123362,25.494873831748585,102.50219025085785,49.21672892249276,47.576676833450975,33.57242279902005,97.74115269726109,128.93383971893655,102.73364482703903,90.87869123952879 +2016-10-24,118.2771501128501,32.79472798272526,103.5026684705953,50.06725461100694,58.97058468121669,45.57953007130867,93.78857351364384,130.97888556162536,112.71083166283367,101.33768550386856 +2016-10-25,132.3266650898306,27.356496468151086,97.63916608661826,48.68295827676692,54.93965154279784,31.212975693392867,103.05479329134533,128.15502361544085,110.71297437632755,90.93039522599553 +2016-10-26,122.9353972178393,19.403363704756217,98.78041916505936,59.88355048132344,43.90888548373363,40.17106244817476,104.29547411789616,125.0597149452951,100.26030364226777,95.76209065135208 +2016-10-27,127.42825622635215,19.444083810418974,98.58964171514224,51.74169149196981,45.645580460601245,39.3448824570927,98.76044018057871,130.84122545192466,110.3757691190525,82.3258272749374 +2016-10-28,126.25043170774767,25.046432915852737,105.99384722131829,47.799295003325675,45.96696338739936,35.55212817953599,108.4172406696573,123.62532020254574,104.26451071385752,97.91065506574533 +2016-10-31,115.83859027828017,21.49599329206393,107.08075672340726,54.32217213400693,50.85440826312838,56.95236593750884,101.88272368106323,125.16987892728473,98.55710944830867,84.9057478995744 +2016-11-01,111.92446730258956,26.81772072467125,109.03534925247307,51.28870112806313,60.84520421246781,38.746772324300395,104.92803838139423,127.02197460704755,107.87604588597216,96.79755180958314 +2016-11-02,107.91963357946813,33.03986163342438,104.03120411740701,51.720920353109754,45.49715333965979,37.39047938352635,106.09315080630743,122.57799825774754,112.08362320711491,89.53203769345708 +2016-11-03,110.28775863580647,32.501580935490985,101.52614730423687,56.13161429491465,56.361949571645624,37.02657663189688,101.170513775205,135.71117269768047,107.0402063048622,95.98145879342715 +2016-11-04,122.94232758164543,23.982594633110025,109.91165091691096,52.44252407589293,53.565616468342206,46.0302543810693,100.38161710076291,141.25562644566526,110.49059547485786,85.62974838984188 +2016-11-07,125.96992240475093,30.502802286117863,110.79298118338777,45.76683496382386,60.90219359292071,42.36858724964418,95.7179150329926,136.07322043067225,115.83555434624816,92.42463520197794 +2016-11-08,125.58989831936766,32.542977353454205,119.14804241071712,51.76888926776604,54.50750968837251,43.23934429935524,109.74924560965447,129.66422111449114,108.14284783005296,83.4460631942944 +2016-11-09,111.54347224000122,28.316806448797752,115.40230027057672,60.28819692311137,47.24612859335148,32.976632873238664,89.76615974502963,135.51396890154183,114.16904276591842,84.7270484566779 +2016-11-10,106.10279950025783,35.153098027261464,102.061315147894,54.545014660589274,54.3580351682447,41.85548061257446,100.07990173706044,133.56194574373578,100.34028084943635,90.35070046541524 +2016-11-11,114.31064911680856,35.00087635387936,118.74725454916127,53.23875432304453,49.05155412802943,39.15608428913347,104.9595366684223,140.96913609800413,109.64082543048244,94.5798845527115 +2016-11-14,116.8294946015396,24.25753414501336,117.52666271209532,50.69042769834038,54.400815433480574,37.06436585130085,106.53466497622779,125.03001826564157,104.01670503772502,94.87362312072705 +2016-11-15,114.34704458070718,27.221313494452897,126.67505556935075,53.55953867384292,59.76062580059268,34.577297332829396,88.27649864567316,131.94252050374845,95.50497968266154,84.80781397229997 +2016-11-16,114.26844186968619,31.46489239382984,110.46741846588989,56.00323293794406,62.70507724373483,39.205094346822335,93.3439479965919,134.2046578267244,104.35089840606152,87.91216217690254 +2016-11-17,109.93724121682885,34.26163500150943,128.21674461507376,59.80704278878505,50.725890566728005,43.52674518715694,92.719999506623,137.27284675534196,105.62332696620769,85.38346454456672 +2016-11-18,126.51456905395479,33.20433001762073,122.47368472963217,43.377106862332724,59.18284484852471,44.368603404928066,104.29153241497777,128.2523738317309,106.4759268843517,89.95190165031605 +2016-11-21,121.252724317401,24.221891040986254,116.02999501837941,48.079083633491095,51.09269210208349,47.48440429663792,91.53444329238792,136.54441480646244,110.68909686880839,91.10141347386437 +2016-11-22,119.814351031518,32.71238407037607,130.8486519896782,62.53344296484256,40.96327827017228,44.73157133276606,96.74583440023326,118.50124509631596,106.28647423770913,86.4923083060656 +2016-11-23,105.23720274175645,35.833363619191495,119.09826563413169,59.816349302765644,61.21770748792596,44.4552486434011,91.71740908260192,125.31104653020935,102.68197370033862,77.80175119759402 +2016-11-25,116.20672158105211,36.40897296935661,126.08104277753858,64.34748465716301,54.227162912645746,46.04110005746855,80.37482780311187,133.51756987892998,99.33525083965056,83.0889600060768 +2016-11-28,111.64001200741768,29.622041925204577,124.43793248684264,58.48027326800505,57.13873487730406,47.81360025103392,100.2800527104305,126.03308039224098,103.7414491573991,86.04381046096748 +2016-11-29,118.66837837955657,29.01121224402656,118.73986549413023,46.578316928974964,53.52775429649589,39.127259918954955,99.00122434905437,134.48070323054208,110.99659337313982,92.58602799382795 +2016-11-30,121.40116280486245,19.17206852845463,107.20334386838162,46.39927269529362,50.562827002057915,38.92754587959284,101.20425929309381,127.41971742735105,107.20617067573865,82.66278349468075 +2016-12-01,121.86358267365829,21.811012499796387,114.58599163025508,52.71383027778227,52.682682965986125,44.89104589824635,93.52602655100063,122.52868848081513,104.47376456777516,85.34988250716616 +2016-12-02,110.5906445558067,29.275366854350473,118.87055473394514,49.05242986258618,50.13348156491944,41.66754955403859,92.28532405147715,136.68605130736555,102.95623884261238,90.15907399279564 +2016-12-05,112.29853451388493,26.113601294100047,108.4398297854826,51.012525301055206,45.621443939981454,37.64852501753579,97.55996606705332,133.56764741143073,97.1445709627826,85.5828315815096 +2016-12-06,107.90075881492956,32.46029562882301,134.63172354813318,61.321400534854305,52.35716159332116,45.30640618145466,91.53357803194194,130.705066518713,105.68074398119549,82.4914372732963 +2016-12-07,123.33046558191168,33.561681420204295,128.6439986015616,53.69565693374139,40.73297364605875,36.140184158927084,95.9758775132001,130.07039140441202,108.26680645293979,99.38926064100328 +2016-12-08,116.22894214339098,25.373408011349326,116.32941818430842,57.030154885832076,48.55453920428742,36.66455375260549,97.91067448584775,128.2924242774337,106.08288075884656,86.01970557401145 +2016-12-09,121.4500367583567,32.81453000400255,118.29826098947953,50.186813254843116,46.05398964799689,35.8329534220703,87.74995002429799,135.35829553182398,106.35469880641513,76.56881064134113 +2016-12-12,117.1720955867298,24.9617683445313,119.87210388929586,57.93983556120651,41.20233199749041,41.262743127045596,95.75199380914725,132.8566210301171,105.74880850323748,80.2505994472996 +2016-12-13,124.46206420550706,32.96019150458241,114.5876487194271,44.62211255217896,45.54361206399191,38.25164622337808,98.6457004816767,132.68868310807682,108.51756139643071,81.31609252333126 +2016-12-14,117.85480876144132,25.24311374053784,126.08627985438979,55.238328750124495,56.09515377321727,43.78713312492167,84.65760363919188,133.37974101876077,105.08107938464424,79.05318298757823 +2016-12-15,118.67857105806746,29.9606704707737,130.8821312342586,56.82190428236344,50.645574732360274,36.41518002972229,93.52427293339154,131.77306580606367,110.50664709314496,93.16738594752448 +2016-12-16,119.01971979506935,31.94738426049327,128.96224042704063,48.70501520797389,49.587301267475695,46.05683330506657,90.9975229554831,125.64165855791086,108.94020194238092,78.64504290286843 +2016-12-19,128.39436659754605,29.008633225698574,117.95818571381446,57.489364366034046,48.080231321838326,43.90705710557355,92.80402264210528,137.23645355465914,105.31642060975743,87.19392088253802 +2016-12-20,121.2127512093484,27.611526904197223,128.3189395494075,56.05798523600091,63.36793696877987,47.63057704198519,91.395722966969,136.07050534513613,98.51328120031842,79.01209967093595 +2016-12-21,119.9968651701388,32.02730878102632,127.3267737052588,52.35599658387255,70.33234821112272,47.14083181436234,97.26994448760584,128.93361546375627,104.64459124559,82.97094460787876 +2016-12-22,124.71197794406166,26.961491665768296,127.4770479263293,62.757344083008036,50.17549672292898,52.29095896679197,90.90716812441951,129.66793442065165,107.42187412834099,86.40117267624431 +2016-12-23,118.90314025001703,35.558629709561345,124.32067751500114,53.553034878061055,53.94274624142299,44.54042770309164,85.72685202163179,135.89757582890292,102.07256673598329,87.86180094004774 +2016-12-27,128.7652542533331,21.661683917506892,122.27651369686289,62.50786541367572,44.51368770244,48.876226411636196,88.6465357221564,119.32025252587103,112.22531484288521,83.84287061585044 +2016-12-28,124.92535210642566,29.155869898540743,131.6579695509846,53.0668996600493,53.05290116824211,49.14023139354755,93.12431498147849,122.23731505222737,113.2725885366344,91.22505952712007 +2016-12-29,125.37094130732989,36.1261516718221,118.43184196404808,55.76292321635636,54.59710449278956,44.42330545770316,92.08373707616516,116.9588896543413,103.86137750707987,78.00648326199735 +2016-12-30,120.86384542433237,40.91437518065888,112.191037394773,56.42294093174424,53.22752955641646,50.72620147643664,90.29982905733146,130.05457527357356,101.37241253146746,86.92286781083418 +2017-01-03,125.01235893091462,30.698928554651303,127.00485312395993,58.62126875766067,55.045898915673604,48.84110390689359,88.57442787623421,124.15492599055054,107.48392102555277,95.20575186692012 +2017-01-04,128.60337062416988,19.76836763881029,126.38574069202224,63.09666104270207,53.506049881929414,42.43019546912194,90.03689117924625,122.39620382418367,101.56646931398109,98.6469343629765 +2017-01-05,121.97209949304771,33.601995481012004,121.61658042259297,54.818528230503105,55.392432970407626,45.80040839637847,84.02200948396968,126.04492806321517,97.94994399066623,92.81629938507238 +2017-01-06,130.48788156900181,28.049415293325886,130.05387475250447,60.10169765182437,51.389793525592395,46.26667126819483,88.03887772401893,129.33680568837113,104.89140822889543,88.24763340132726 +2017-01-09,116.21780906646676,22.673689235085245,120.18209871721892,49.253850264713726,52.15437767454222,51.32531375070111,98.27308004119993,123.22238973994804,109.39616434843988,89.94135386617603 +2017-01-10,120.07266723357866,35.05752867515943,117.15918289691932,49.63253643871669,53.74230508156491,48.72610968538734,92.34925346322449,127.20827366862477,101.8139177395712,91.23080264831435 +2017-01-11,123.93142033466354,40.63640433156661,121.14429080139315,65.9819630763703,43.50728267136088,48.178894661220966,91.16764136451918,124.73491339993068,108.87109486890992,91.61232049514842 +2017-01-12,122.72139743973115,23.14139288994693,141.0336094300512,59.5918282254275,63.12046895898408,36.32306005440285,96.44475454954569,130.09956364759304,107.46675565448331,91.1444969746991 +2017-01-13,127.42090831013455,41.68622096992791,125.50988734808877,48.32898129225401,51.35819204520077,41.08675834008298,87.70506002986103,122.56575743355316,111.77974088140442,84.40676306007515 +2017-01-17,125.71779747852973,27.46667455990686,128.8880827612057,54.586866320143976,55.783413283712164,48.43870581037203,92.23150378813409,130.9706731400817,110.35128220101245,98.04280599807126 +2017-01-18,125.69347410092857,30.545130309916615,125.37094797981709,50.96088325493175,59.060339008646224,49.425022216227546,93.61739384260862,133.0136371352876,100.23158452471462,87.40116674281684 +2017-01-19,125.08180502423545,33.3299402103716,131.3597434765215,49.13884671057245,56.082111015941216,44.78075593875911,93.80748535748842,131.9843111593915,104.85904742899683,97.8079317186297 +2017-01-20,127.42980061905433,28.193491972719574,131.4763857816423,60.190343969790895,58.2691133676869,36.56811152327212,89.205468316976,126.60483529728583,99.02109850640113,76.90690861240611 +2017-01-23,121.21406675753873,26.115163016751524,134.52566730850268,60.98008220341208,55.114804919332215,41.97085287815817,95.91846568800722,129.94923493180505,109.31069353865615,89.56703362324188 +2017-01-24,123.29342374232519,27.01643582424885,128.21950619934898,51.73025268079178,51.163788201261795,37.67601735061769,95.0447711804368,129.28538925986737,96.24192085172257,92.05017182779673 +2017-01-25,125.90405549481491,33.42547784425753,132.0021616951706,65.20664928657146,43.87358226366317,44.058388675460535,95.89471424851038,128.2136656519905,106.33255677822683,89.19295887334424 +2017-01-26,132.36559085175386,30.49078284425911,129.17655821572947,48.48242159812045,58.043362134699315,42.50070746457009,87.36197033652392,133.95131132424225,108.22298202600172,88.9069310714212 +2017-01-27,133.3550915549058,31.407801043364472,130.45121725531155,53.09395966308829,50.89582813580056,46.458642348265,92.83906953688481,132.49891269121804,97.2822000849481,84.52792210414765 +2017-01-30,127.61430823309055,25.27100597897809,131.1054013434645,48.422001162256954,53.13771570663329,43.37310124665257,98.42468993402608,134.7228116110555,100.83885513348208,85.224222063844 +2017-01-31,130.1840240407999,23.519438940784244,134.69312602816126,50.22102775913654,53.012198966819895,47.32046547764446,96.05547770842628,129.5283307003714,102.9875016123185,93.14551758236257 +2017-02-01,133.09075037976046,24.594591604370017,130.08307578917206,42.495456762159115,43.7883720728739,49.3003435994688,103.32032844069793,139.07487065899946,97.71858969759558,84.63498902273597 +2017-02-02,137.43219850843005,32.55419083910505,131.2326893986658,52.32646945671589,58.36267245161077,47.474005602381645,96.8047159712597,131.803945301061,104.34925146538616,88.65722780608063 +2017-02-03,128.75544976418115,30.751632566821478,131.43763424337698,46.6155617670265,49.50586721118158,53.38782788191368,93.4541841136172,129.51685221261727,107.54521302165377,86.84055208999322 +2017-02-06,128.3283510291694,27.50697308817449,132.972045169079,47.224460191326614,56.09415591110519,41.62468624088229,96.5431244682836,129.9152007384338,107.93682638139782,94.54669118219283 +2017-02-07,133.86821995005005,35.54259091416167,129.81783372366772,43.292565998377945,56.663948230514926,45.06795297419252,100.71050896644078,127.47864300659727,99.10388350383705,87.87059253039817 +2017-02-08,134.89257993769866,34.85777660993635,127.14642321103926,48.2801713841443,52.69653760872157,38.51752911754809,102.99711072060236,124.374585684999,102.09313958151468,88.09732907884376 +2017-02-09,136.65145876642552,30.08096972694871,140.9820634630596,53.13607637068776,51.39373407581944,45.62554139161842,99.17888697392604,131.54304844822025,104.3249957108911,84.40491988020929 +2017-02-10,133.2114201475536,26.9226110630483,145.15948845729014,53.118919581217924,47.95683779972579,41.62136632327258,95.83208388449316,128.8038537791825,105.47790631918414,87.42524506022525 +2017-02-13,152.7214225377911,31.15608203495696,136.554033057311,48.89969166101337,55.61978714506664,40.41311466972079,97.82502937734972,141.64529526245883,113.33971852148,85.10014200951234 +2017-02-14,134.09434679514266,22.27311823019954,133.0292894403289,51.99213013229543,51.07356071593208,43.80523079186784,94.85029911998993,135.80924795764724,115.40758005559775,90.77071641411769 +2017-02-15,147.29548069582253,42.51373873619703,137.1255378760885,51.80727043656954,44.568448813064364,42.73902899962904,89.52549411585764,136.340209664259,114.98235667118436,87.90864621228717 +2017-02-16,144.89505973124338,23.678678058615457,140.34562684579197,59.17214957058148,50.96255440964878,47.11420534747987,103.58300085042899,136.51601625672632,108.31160285329119,86.03765613303706 +2017-02-17,142.5392698188839,26.08491300134243,140.26527229779342,55.51480970049002,49.26991211760259,36.728779439755826,96.85213991847776,132.05973345265156,107.13063188188598,85.54260092540369 +2017-02-21,142.1053814148181,36.075155238518,151.87420221150833,52.61635776036127,57.00549093718095,53.0794262202812,89.19747403902089,130.6465536402493,103.2916255265113,94.80968229049317 +2017-02-22,140.47555588145468,31.605607398148397,143.4984503976089,55.78354987738847,47.92576650806834,46.52777315609624,100.35265365733495,131.47677010689978,111.24888014534352,99.27130471541804 +2017-02-23,151.0442614293073,22.21009104996146,142.28593536679247,45.06719874122824,52.18264684782635,51.07553407298821,95.35424877848766,132.98654590055827,102.91391666569122,89.9796288786863 +2017-02-24,139.49479128205596,31.988441962605272,134.25489644348573,62.96583935766829,57.74557765739417,51.56742823340705,97.02371950550918,133.25299640974663,105.01765659562602,88.16486891011625 +2017-02-27,134.22516659982153,27.654499432947024,143.66077088099536,54.56762037682703,53.60090224920772,43.69534695832091,102.42868297922028,141.24232746296786,106.5651563733744,80.6308383187118 +2017-02-28,140.69199865284233,27.911362490136543,137.67780414035488,59.76470894073728,47.606653004542906,39.3424359713213,102.68531939663002,132.61496661818185,108.37231568512455,89.33914146764057 +2017-03-01,145.88665499664538,29.23454184892862,129.7969281021208,47.93530308864972,51.409435619420165,50.896998359842144,101.67928227621331,142.1052637749748,105.57647100878363,101.48913618982962 +2017-03-02,144.7990924096244,34.88177457656916,140.12907177141622,58.36715134274015,48.98757155783025,43.24641907962746,96.88224822314382,132.64268384765197,103.64942807455084,88.58715409428243 +2017-03-03,147.55693475370106,37.68441354619602,136.5633438325114,60.198726761542815,56.26925643493659,44.004151878297904,95.34581565546033,129.87095234039563,102.50326572796352,88.49701523893 +2017-03-06,141.61094348828493,35.00221537494028,136.60782305162633,52.63790889354935,58.12526013161111,44.64715232583348,96.29610751329618,124.80199891777953,105.45963831568923,92.09057687807939 +2017-03-07,146.07076518876053,25.037429619939907,136.2685398079616,58.622882702135165,51.175952801293704,44.34879991414481,99.56222442128788,136.16601542450104,111.08714275494424,87.3682331904331 +2017-03-08,147.67540655376922,19.45273753047651,141.6014009170519,51.71222066914335,58.40561595593809,39.450566487445926,95.68930165229352,129.06745246948515,107.91113351587221,83.89865083616125 +2017-03-09,145.0549541723298,24.523806067276205,135.023776822958,49.0928579904258,57.612337390162935,47.784033854055394,89.67669012264582,121.91530119040647,105.07156494417784,84.07758052431879 +2017-03-10,155.45669397617462,29.22986168853054,139.6649746501032,58.685434130996775,55.08605546172348,56.60572879381059,84.93134898071533,125.97537377542909,105.12124930380372,85.66863839318147 +2017-03-13,141.12032737075666,28.094160024309332,146.13257414624306,55.89758828588364,56.189286321145204,49.41611384273638,95.60856555341357,125.19275633909871,110.82340401904447,87.18885676079918 +2017-03-14,140.4837047990465,30.277309615270212,143.67991503207622,62.86297014615113,52.84812468074244,41.08447652184129,93.24866736317868,128.0890654903739,101.77018867648603,89.92441845202927 +2017-03-15,147.02568585656863,31.676618241628162,142.77286653269778,62.77765169645349,54.778677379189695,52.267725272054896,93.9013072997821,130.2074079224399,101.32887017784297,87.09049591639014 +2017-03-16,146.9435626323402,24.887034041199154,148.60173114663567,51.450312077951736,52.50693222592851,47.239176710737425,93.26042889083575,134.0905333226223,105.90963646226623,89.9861859130724 +2017-03-17,152.31161121762494,28.7652057034268,136.76116841236004,51.32227089702867,56.10928675095791,39.137603409455735,100.26343343332302,131.74881883939787,107.10329243921093,81.30963471821143 +2017-03-20,147.11261984926136,30.876005029945233,137.7973944234036,50.11412576706377,57.19243994274293,43.5261160690667,97.2650868289272,127.37360084021321,107.66840628937274,92.0988811058283 +2017-03-21,144.29669762582438,30.027134615906142,131.02401303914263,48.207454870525126,48.25691405723842,37.399913581378925,97.23260293182736,128.7634565029238,104.41439055864237,90.69273131198393 +2017-03-22,147.8442790890016,24.543948907195784,130.53875389651736,63.422381419123276,55.12474912767184,39.81170411320682,102.76433630119801,125.93098212636491,104.70160605237862,96.91557400814091 +2017-03-23,142.6031889310674,27.98568227730066,130.82250611792125,51.52386654125098,61.59623656577294,52.459378145727044,94.05898833998252,129.9879874685197,102.90693137042729,77.11496911134613 +2017-03-24,145.85807109203833,27.423860335607117,129.90638929175185,50.935667773652476,47.11152970346245,52.8524960839534,91.63457831076471,133.3944551968596,111.651308284454,94.207788028598 +2017-03-27,143.94446782866947,19.237516400073705,128.08050224022287,55.98953070052155,48.22223761450045,45.00006773851325,93.76127575174345,128.2602827110514,109.9035500817909,88.86319331303076 +2017-03-28,145.31218292637442,23.96766085280032,129.30145691637696,43.576695143606514,60.91321484971538,46.23772876905996,101.06954044875047,138.00249504723294,118.2099562353076,88.22664455141683 +2017-03-29,144.92898082360193,28.401129021162433,132.90680723627338,51.61168205553916,47.12446724337444,47.117038605989435,94.99880039255359,126.91701127535886,98.88137589539649,94.30088586805276 +2017-03-30,149.48124797655527,24.251508615831618,132.14611676507968,45.31309141856735,51.3241324087718,51.99180589209696,92.5225007242724,135.4526654989527,109.22959995221458,93.39545828808508 +2017-03-31,150.33732501192938,17.444638726482694,124.08268302187638,57.06351778300113,58.64684987108067,40.20490604718214,96.14042254534209,131.7747211483064,104.5497306322441,96.91298799573175 +2017-04-03,148.13729808372275,26.28945897559896,130.0958121630474,41.48376769974733,38.71904154797005,36.68936458815904,99.60047121402133,123.30526453364041,111.50497168224314,96.697608011218 +2017-04-04,151.78875683088975,23.746936405780488,119.73925596551234,53.263983622466554,58.684533403039644,48.02039103514332,98.16869598291005,137.20147768730627,99.79907313941162,91.40319428601542 +2017-04-05,149.78611811075703,31.178235682692886,124.38232017511092,50.702036404230405,44.99446371243362,50.075151772533175,90.66321107975868,115.10733542271514,104.10024136525652,86.20878045923195 +2017-04-06,147.14586790016835,33.75815361335333,114.87534489453732,55.168916852802184,52.24113427644731,46.48944493327919,92.80506704985933,137.71117189207845,103.31823450637172,96.22208611840385 +2017-04-07,147.4716272171128,33.617467114821295,120.234739918519,61.06931544447579,48.205969197829084,40.48134843599272,101.77673248467204,133.53412105930286,101.13357699386162,80.33591156105396 +2017-04-10,143.9191515548528,24.22756173387399,118.92871383570932,51.260316125274855,53.61763835556238,46.62057724881618,91.69241372026639,130.09009436986938,100.01936035466665,93.93865475296836 +2017-04-11,151.83320618395823,31.494241039756048,114.04113682615186,44.33618950105891,53.04441609290938,38.93304149540594,92.30301259211774,125.55016093425144,106.65604325954403,98.45897697695091 +2017-04-12,143.46693093684897,26.71528099429229,116.643753276804,55.72752057864946,50.55957627257678,49.23060366355226,97.54999661140553,131.25075521940244,107.5136039086676,92.15806914974421 +2017-04-13,149.93763984293716,35.359959696398306,117.11979642959167,47.269596796290614,55.054039727737305,42.13866671394224,103.4232660853487,130.7998686607518,107.13784144877076,88.41354164337497 +2017-04-17,143.60867088137474,37.02635191995125,107.1271905087733,44.24920025285643,56.847711100137744,44.762394248038234,95.63003786091699,120.92110057434927,101.70455539075971,88.44862112472978 +2017-04-18,141.0274642575009,25.187757050036673,114.41771400793489,58.24724555710851,52.65964379226873,41.070954559728406,104.52164634993373,128.2814719420861,101.45242215241792,95.01423361714318 +2017-04-19,143.11021458072196,30.05423807338993,122.59021145566881,61.112501282680896,57.778326305996444,45.9722987369511,99.221974776126,129.41074635273745,104.24456893570064,93.75107334214529 +2017-04-20,155.2143014691299,34.560169200891174,118.02492997689279,55.82856307192412,55.10712141786997,39.05260103107541,91.27873893179449,128.7680820765965,99.1988468178114,96.05536034867463 +2017-04-21,143.0436626989889,20.572013827876745,116.38697963234824,55.72591914457531,53.90492760155544,46.8703050109426,101.17484804445944,141.63715633461237,105.63551957902287,91.93886035918604 +2017-04-24,156.79096533693536,26.130867969239517,122.9735030808358,57.921193012462396,49.96326496480597,40.934251968650265,95.1519616791913,137.7416537578492,97.6556084194725,97.05846501940874 +2017-04-25,146.99177515263577,35.50924333303289,126.59409100758378,47.11554644542796,50.00464608835043,50.42168275846053,102.17106144558498,126.8238439864409,98.6913513420699,88.79818769089303 +2017-04-26,138.73756525826622,38.99711049724678,118.7429436311272,55.84533164339639,56.32098888719341,38.12072156663375,101.28838127294395,121.10963039403987,96.09794144702829,89.11066559781288 +2017-04-27,146.83543759535576,29.34877732962488,114.22999190132461,53.18946606899391,57.150365156745394,48.57571256336273,103.04045317476786,138.52935605411471,103.33172877957675,86.25341754273134 +2017-04-28,154.23610619448135,33.09186093524295,114.68043239723863,49.259518070032456,52.934991641164885,49.843726698542504,104.46637751129958,138.61422403388175,102.50074690043284,89.3787641171331 +2017-05-01,144.40450973835937,32.076158819984194,122.5624699152049,53.82567120512566,55.70307443878717,43.96023356833899,93.06690906249584,141.16029761564175,108.36283423397718,97.54432014244605 +2017-05-02,152.79533413432472,34.20900503873535,111.80018595908419,57.32425583420778,61.53701230656971,40.647458639904336,102.95753512350586,138.39513804051086,100.05780653547379,92.01217401432419 +2017-05-03,152.63390894844053,31.045599304663995,120.63171555955186,50.76555467895792,60.011367909433005,36.70435560306378,86.77182674506972,131.5214798534155,110.12785625680667,96.92749450558956 +2017-05-04,153.50702525996087,38.24811018675288,133.8059875906028,46.67677580970033,55.110072882975615,40.92734795527771,99.75397423029818,130.9336206651705,107.4865478346352,94.22624197321969 +2017-05-05,159.7395613645604,40.10580241155197,115.01619053955696,43.80863118508457,60.41081230383801,43.737398913400746,95.78600035507954,136.49087855043024,109.26014208800837,92.80327065049846 +2017-05-08,160.82365145941554,41.585033971399234,111.24011306181025,47.69576650093687,54.24277265751333,36.84182514260145,94.68537100924357,140.82916142256147,104.49278732266112,88.21495973557842 +2017-05-09,166.75013323845565,41.7696881330934,111.10734992923962,46.132438182254745,52.26841611872972,47.828195516716676,95.74669639448028,136.22479019599126,109.01802465071003,93.05860172022983 +2017-05-10,159.02466260300469,42.33599939877223,124.23871803193803,48.35184203959603,60.725636730155514,37.643086355093565,93.71509473937046,135.39078341013345,106.79868462892563,93.6710447386577 +2017-05-11,161.59537991754345,34.06949111116118,124.89058514396926,51.52137147053743,50.87281621569674,32.889941953200896,87.54608392944459,137.76051896848944,104.3699238164697,86.53844802398955 +2017-05-12,161.1334302631358,35.706980532092615,130.11169371537812,51.41369738398889,52.68397683635506,33.07220606265878,95.67673149148534,137.67936501573533,96.46975245719884,85.14079417081182 +2017-05-15,156.37603965281852,51.32877771216212,130.42118269557335,46.254187908565605,59.88877200802239,43.99580850861473,91.05061361574083,128.38422297656751,107.5263649820208,81.17709131451018 +2017-05-16,162.1869430200726,40.736008005349,125.07164814686716,47.18027209354916,64.39241817309103,43.33125392939182,101.94072121679643,146.73062895941274,99.48466327216664,92.31225172760645 +2017-05-17,152.00210650448608,42.743195622003284,125.9280790486216,46.8621940788754,51.08253884241735,41.650919832400554,103.70685872602488,136.90037861057598,117.75926103312524,85.60376251994117 +2017-05-18,158.39083092177145,41.74127891736619,127.03661352125441,47.44099348306406,55.00385616023631,44.89217044549112,88.09138153552907,131.13742700928177,96.2311001748565,88.98287207115385 +2017-05-19,161.69955411419662,42.546945522009935,133.74835874376421,51.44471900895943,54.738014634817155,42.791296000798724,95.51579924472409,136.4761588789451,99.66407252190689,93.25826371382104 +2017-05-22,154.312263262796,40.674795189365966,127.99451643495725,56.273564884076976,58.46886137555555,41.26914737917623,92.5855914231568,136.12381917028785,109.81718753164563,97.06344866293458 +2017-05-23,160.88758443922148,34.978074496665485,142.85703107923825,57.951356246733056,62.08607198449475,46.612724407925896,92.62858261028873,137.6277140652682,115.28458949932228,87.06727277625998 +2017-05-24,149.16738801762426,48.327539147028254,143.31570320897146,52.77061966330119,63.23203718496569,45.58384127055301,95.7659170266622,134.39702711149175,104.69810543960462,92.82810431533264 +2017-05-25,156.73849085263953,41.04364198679013,152.63263799484645,53.83526791709231,65.60933240744339,29.27523431070134,104.43236001525227,144.4915254969769,103.275002598292,96.44244656045132 +2017-05-26,157.90279234855936,42.931954478943865,146.51613870580647,47.41089425048706,50.84693847525584,42.69241702391125,96.10871976731471,132.853036107169,91.84908929182627,79.62255298511673 +2017-05-30,151.6491081613291,40.38111306711208,139.36334181127594,40.05023667319975,46.89309980642691,45.42555361502193,95.7105985834125,130.26548962702765,101.19815768893488,104.78335710946588 +2017-05-31,161.25044019033876,40.67205473238093,146.1741631360987,51.29627330234716,57.888326389278944,39.70288569035611,91.12901179845673,131.9488936537871,101.19385934537026,87.45495586529564 +2017-06-01,158.96811663787645,43.211553769919824,155.37107568143247,59.27795621150074,49.12036728403069,44.66092255318175,95.51047471779496,137.6453171447699,109.87606105073688,95.4274658851954 +2017-06-02,165.40785159135754,35.8723821779026,153.23775858928417,48.657401284700796,59.8824078519239,42.212469799372194,95.65483867969806,127.35429661270274,111.5555113942303,95.6083141165334 +2017-06-05,152.21146156185918,40.908403662873944,152.75745879439398,52.080425937388185,59.665860014277655,47.96084098910735,102.597280205067,137.50693461261048,103.0681345808624,97.83984295015088 +2017-06-06,147.30373258409543,39.30786710647897,159.02049805108575,55.94918089447954,54.25159220333118,36.44852362642291,99.06090618388464,133.9143527789773,108.41537678084552,90.47979968778353 +2017-06-07,160.3997519575609,52.101475700446095,147.36621075919055,49.650150390166516,49.0156456471121,40.02079811990256,99.87746616879548,133.69161549029457,103.72624663920584,99.8848988663292 +2017-06-08,158.2722037827903,42.42504665406368,153.75329732689784,53.16760059670447,54.03804433663445,44.683592775510306,92.63818878022425,137.47341867758433,109.8641848761692,101.49045243091274 +2017-06-09,160.94891156453275,43.023369510812024,157.78953911612192,55.707957362848774,51.968462003411034,42.8593984964828,93.51266985384409,139.46524112532603,115.60582587253236,86.37080393564645 +2017-06-12,147.46730011792766,42.76072526383949,148.3275389102582,56.18830912292696,53.64025762513695,44.67920124587197,89.94905541835524,134.55105594917734,114.81734671149768,91.91140918800296 +2017-06-13,151.05627675626897,49.56639364734105,147.9733911347193,46.3331936584384,53.42754796642507,41.43721939323355,91.64052789861385,131.45847046868653,101.14203580030363,85.79726849944925 +2017-06-14,149.58797221436205,52.401948807360576,155.44524610114098,58.00360947497727,55.21270429374093,42.47416221597131,92.58807508646117,134.1659625898845,103.00188898042329,86.5267638617427 +2017-06-15,151.2445907378792,44.85728039651512,163.02052298014524,55.7352793176574,55.339932049902814,45.29263109692218,96.31008035492908,132.42665287223497,107.47361344564875,89.54881322341292 +2017-06-16,145.24405785296108,47.05410989281393,156.2243805656249,50.61782777068573,54.7838524789208,39.658212927303744,100.85924280807924,129.6834080903592,100.42099102365208,95.31257789367584 +2017-06-19,148.5206946338138,42.56069880004774,163.73081331205594,52.922115866709,55.82528086398446,41.20443846123814,90.53275272879543,129.9871791876725,106.84444536285916,98.42337543687077 +2017-06-20,149.64944135236465,50.940866375843356,154.27603719971756,44.44882432496301,54.14685734751514,39.22252281006557,91.35389130127545,129.74440923657764,109.65152467012811,92.37775563128527 +2017-06-21,156.17018196157736,44.09344029059726,150.60651112703903,43.01156425924888,64.55089634190196,39.29325899942328,101.57846442200986,133.61943655490657,101.82943264702357,91.47219485658651 +2017-06-22,146.49453056532394,41.517135115582064,151.8232209837422,52.38083213619434,46.684291985110875,37.56175498289663,107.85469161377243,136.60808434994146,112.4860337486854,96.47562994052268 +2017-06-23,157.0876688871447,48.01036200345655,154.46419632866213,52.64392199915187,50.58335836331133,46.375142571480275,104.10070927734252,129.526637940819,99.10056628244386,90.51648497135886 +2017-06-26,151.17785773961253,47.36546063438725,163.07104863044452,57.603977786281426,51.81567489654682,43.08647263818716,96.58065658039428,133.08250822237426,107.96104958215312,98.21853756048579 +2017-06-27,138.18447891260973,50.439954958445924,160.75558605218657,47.7751580955461,45.97332850298133,42.71017437357225,85.7663020725189,137.72168407450113,105.8262543016304,100.06654432006243 +2017-06-28,156.55746244872546,48.654565486523765,166.0357381600856,42.95796227813598,56.02405473319328,47.4375698111552,98.79842256242992,132.827687776799,115.06207630710149,91.81604589079744 +2017-06-29,152.9295156653181,52.57348747341028,166.9603650914127,55.45329071426691,57.20062825026376,42.190283927924604,90.26009683549881,136.28388209048185,112.66800590473638,90.92429427842796 +2017-06-30,149.14616010358208,44.479761349265,160.88635699263915,39.61167878524032,55.56768604495505,45.39335411372703,96.03939514710619,143.15189772640753,110.11939185127208,90.66177041129198 +2017-07-03,156.14867914233298,40.37446755152586,152.85355381539182,43.480334760843405,55.41182567818801,43.5258111260233,95.68231350669694,133.34818383636744,107.82160890489085,87.11008552045146 +2017-07-05,146.34505431913408,43.959557352704785,150.4871204217799,54.84066920924247,56.60015924683328,39.23033369973608,93.79876286826486,136.53347373240712,103.15419099261784,95.3855209573062 +2017-07-06,150.7632234603303,48.42178335735558,138.0104506223215,42.60565604668717,49.081026433044265,42.98054018740878,93.98900003764989,137.5719078309229,114.99903844719744,90.51132571179512 +2017-07-07,141.31050087865677,48.593511658866035,153.72100105927362,50.89595358508469,55.00443672296245,39.5591322458628,90.62768174382985,143.0794630073832,104.78935896194591,81.82253123180976 +2017-07-10,162.1722581240281,50.68586561746528,161.03698068478204,48.438489498344964,54.7715185135711,49.38857075245893,89.64647796197085,136.80611254354255,102.6406000572878,90.55524344527198 +2017-07-11,146.50692410152794,51.98099898716462,154.09916528484004,50.80001247389236,51.84429361516085,48.55630927173588,89.95324319699242,138.8792059495676,107.59766295911753,94.74444929539408 +2017-07-12,155.0109901019155,51.9308175843232,155.68672974897402,51.168523107947706,56.82223942605195,48.32334828791129,86.54596692536929,141.6623980188863,105.86221967684412,90.25484902645408 +2017-07-13,157.04787471171468,40.017905392106506,155.291796713842,48.61454785583911,46.5596448847991,32.84814575284861,95.73263356068811,125.26196234103769,106.72530115049031,96.01979578848757 +2017-07-14,162.89850203772278,44.813876067362735,161.5293419330459,49.0258545416852,55.60139716063294,40.66750517073491,94.97252253523568,128.6120788853059,105.12883534907176,99.75719316179034 +2017-07-17,158.55271763486863,46.82423547050272,148.40613402407035,52.00594320519717,52.92328323013257,44.353295523183746,94.99571137981481,140.00307261222903,98.5167778057745,96.5112475525503 +2017-07-18,160.16644049852792,45.998725498466506,153.76321343559533,43.88925341962822,57.95195775604001,40.01435013593225,97.00374506279331,131.90282576680457,114.1910453255432,102.05384971346854 +2017-07-19,153.73185273147547,43.488911301225954,160.77254705683293,37.84058709430801,42.157109696279,39.11590509012032,91.04524651191996,147.70772856875888,103.4865363130648,89.11694756019078 +2017-07-20,158.37298687919065,42.35551345710693,161.30012993428264,51.16671943413441,53.41877504814476,40.83529494979817,94.46310535097967,142.01978675523335,115.50553183161907,91.51409105656414 +2017-07-21,156.2011625615454,42.80952435830321,161.02870778628647,54.00683349439066,55.94494269077025,42.752577295717614,91.63182815026225,129.05957726680083,111.60024253277808,98.2678969756136 +2017-07-24,156.36858822635315,51.035226572823134,166.88982131025173,52.62325806931619,51.48162671435537,36.60660927580858,101.079392613718,140.34770871238516,109.03458308805527,85.38823452714351 +2017-07-25,163.5918122047517,55.429256466822515,165.20308464907018,49.26816759433407,41.41306631811163,31.996329087091055,91.79893306110853,146.57152195025023,119.53147180712575,97.0690555824883 +2017-07-26,155.07017360120733,57.005180159343396,167.20452764120563,48.586648287494405,52.352167749924405,37.760462822744906,102.08962382670501,141.63350988995958,107.39417001459093,97.4730909827991 +2017-07-27,161.53805939069508,46.3960142206787,160.70151842840923,56.80279399873823,61.71951310243435,37.846336953126794,98.96494292184714,142.12166795163228,98.14854504791138,102.28681620629118 +2017-07-28,156.00824732220124,57.1551600502861,160.8208102586428,49.848984694814966,57.028146918834075,40.95779727674824,104.81860742818623,141.6638151458283,104.12871263757178,88.9160736737828 +2017-07-31,158.2401407160079,60.62139518282516,162.06103706944037,44.90421908892649,52.06653667778378,42.49160800871597,97.0258850203034,138.61306279028125,112.77328532673118,93.09569647904392 +2017-08-01,155.3121518345494,45.823258841637376,157.40994296941082,52.73894430833435,60.742529977898535,34.40725250236063,99.30174182971183,131.53220582295415,111.40077165302856,87.3998296275482 +2017-08-02,162.95020899792107,41.8703721734779,162.170949764612,46.59853862759037,51.51798421755617,45.57633780730171,98.32081089133999,129.95164988645288,106.81525211006237,92.75057205067294 +2017-08-03,171.3390063067681,57.34865451649306,219.53179273284505,45.68985669565498,48.796169098864674,42.3085966464329,102.34571981004451,133.61289185859047,98.21880880115611,96.86805161693584 +2017-08-04,164.3609392081835,50.75934021771297,223.46266138286276,48.37344559779589,61.29718997849816,43.68050701151095,92.07602924498865,134.080950424478,106.29958698800968,91.31973595595645 +2017-08-07,164.40690290528093,46.93972016819884,223.11727987402074,53.669797816967204,60.60795711891055,35.48016019807511,98.43457015169538,139.8717649070626,105.22873844032821,93.10614688448847 +2017-08-08,166.12266448918473,51.741936205422974,217.3225017578546,44.766723494148486,49.27575357659111,36.228516116769136,91.29003577934735,139.53416046685956,102.43192085949077,103.56747805299352 +2017-08-09,167.68081110814202,53.675235531541375,230.77788791947097,56.053345867196526,51.18401902495625,45.83948992618064,94.187600925697,144.25946502107738,111.57253378246466,101.11343416276758 +2017-08-10,156.72373543741037,54.50540747339826,222.71239896615324,49.46593265761335,51.911099863037215,34.94583567457494,99.31433904875624,134.30476406327054,108.34367230216648,94.25320953032242 +2017-08-11,157.8556837973496,58.376083676893494,227.98238547364164,44.804313915376596,53.67234398382559,41.6715762696285,94.8891013865686,138.5693275762888,104.15481066505876,92.08136388994645 +2017-08-14,156.13673944906648,48.50976067924043,222.3771111980923,49.87615369251627,53.55812948203475,46.9756778468559,98.96488373633284,139.2178954838995,109.460746077897,105.13818154124496 +2017-08-15,166.65325218851768,56.484893164841104,227.62490119831017,52.338971190061415,59.09714950681966,38.740970925295585,95.90453955242627,131.12588007133732,107.85816229689975,98.15708375311056 +2017-08-16,161.4231276475374,46.51759842575533,218.9927337148786,46.61278190637353,54.45708397128565,45.905384783659116,95.7989470288394,139.24993184659297,111.15870689720154,88.51264336057207 +2017-08-17,161.567542012805,51.72921121272048,226.41004895183596,53.6326530928569,61.69618107085765,44.181315654946786,93.65603269483839,127.92975513021591,114.51088503860319,92.56607580820918 +2017-08-18,171.529133734503,55.89726588201593,219.25624278527948,54.69081682036627,54.35490968253609,37.27587430072553,104.16307940197628,133.0883327932199,110.82636990758324,89.89035336232189 +2017-08-21,168.16169683170028,48.582657693955525,215.279241903798,50.158451447738784,58.654811604205605,42.21883795709549,86.42644213694483,139.37876429700208,113.1662526196839,102.44570774892618 +2017-08-22,162.4610868506812,43.7644199287122,219.61900762723957,63.36609081795288,48.67228785986403,36.07952015007106,109.58788570723152,139.4011790395115,107.79227006881878,89.24933154915927 +2017-08-23,163.7107366147133,38.49971468769629,219.1512730500509,55.64307957755827,54.31884228123249,39.57945347369307,94.2350163832191,135.38110108652708,111.6693198003267,91.49898581776225 +2017-08-24,156.11431425225976,47.62707567841461,198.7050760417658,65.21923220654621,50.0237984408166,50.788482850716115,99.6130752688997,138.12926969829337,100.11865836420611,90.42571471424851 +2017-08-25,165.37804845960994,46.61930621998303,204.69330654911303,51.40336565390001,56.20806238407697,40.74356645520638,98.65254180815262,137.6497342014917,113.82050853384582,94.18352905079476 +2017-08-28,161.12326450504628,43.801999005372956,207.7384581964111,49.058260387310625,52.07975639380894,49.16401844812903,97.75606516304816,143.33790917732028,105.34226942425246,93.36006413003811 +2017-08-29,167.56774245076966,37.536592450787516,205.0537290939692,50.56160591884145,51.51296452427076,37.252520292436714,98.35220337691109,144.73164845123932,114.61101195647375,102.03341904241506 +2017-08-30,176.7439443405161,43.322275666408956,204.4332315047349,47.32454105220053,58.544004784725686,35.06431130271065,97.78823845816643,136.35117044350702,109.13792303345728,100.07547521907524 +2017-08-31,178.24603448602448,47.92203109995812,200.7057666897645,59.6040781277499,51.98055409103726,51.24728663568864,97.83747385688189,138.7907045424804,108.43410506036793,99.44695888835561 +2017-09-01,175.18511011384453,41.52658628405237,199.786567842645,59.915860816538625,54.15762372624121,42.99565340651391,89.52941656603888,139.09572861960754,107.36293492089054,89.88659199150045 +2017-09-05,174.84878032491423,42.76199849569808,196.2993410011701,49.1884469950702,52.51272950349535,40.567075982987156,98.6836205197932,139.43766706900377,116.14269543827069,99.58058486529585 +2017-09-06,163.47894232529018,38.70970525262074,193.6596622074322,55.687075554557794,48.70197975768116,38.85855529287426,87.77841892441374,129.7844190134343,102.68227504360372,99.92161577935371 +2017-09-07,156.9402416080676,46.310825916451634,193.14951757173486,47.35122105627696,60.38233800892587,39.09464170399884,93.61160446525732,132.72175584467053,115.09244783077092,97.84727766833907 +2017-09-08,173.0844938160592,44.54432369208874,203.58765841799763,53.43045365046849,56.68136621229401,46.93800479989043,96.8259886586482,139.0449717838306,102.77148966648886,96.34544213080522 +2017-09-11,171.8618137017366,44.46921233498637,205.14954014400462,48.70103481068615,52.884751048431816,43.99922989086754,101.42747709296378,143.04345980071315,111.79631960294924,95.80449635946171 +2017-09-12,164.14389276520444,41.026528702512,211.38191897651524,49.97194057641612,53.2834225635512,36.3895198409864,95.77586133314823,137.80094829023722,102.85150144153644,88.93695860155422 +2017-09-13,169.39455604787702,39.561313995355974,211.04035133414524,51.5590590564591,58.49704722170493,40.92830400983216,93.5620896262491,132.10537871271185,109.42776136561052,102.55087418070487 +2017-09-14,164.99921123084624,48.70527886782732,202.6717666673357,53.436128523338965,53.926979284645824,35.059974662942565,96.13800931990043,142.2537451717715,101.74708843947326,96.94000132079101 +2017-09-15,167.66638092802015,45.97090827151243,206.90266318736732,47.72575846890204,53.73988965708125,44.41818072715418,98.80326363140452,139.36489717889367,113.71942694797514,99.42687621636694 +2017-09-18,159.88617934822986,42.48418842540627,221.1454706007093,53.32527080711665,54.111107928980175,35.976952599730595,104.14532834682032,148.31161392709885,106.64923455292902,90.81956301082229 +2017-09-19,153.0679157211523,33.97302689696274,224.05681818782443,62.792564426898885,49.61586562776959,44.06194064551643,109.3285319048226,142.85755897905415,106.68110852327104,90.28647888006402 +2017-09-20,155.2007924225619,41.8451868511661,221.8366374887336,59.11410366844636,49.36975374166674,44.39865090939503,97.80651007453662,137.11046112556704,105.52345949631282,92.76883312536312 +2017-09-21,157.21186686100197,49.04239412699766,215.8090735711611,55.34122397326981,47.842794363097724,40.41944506372322,99.37428726141987,143.36213379683298,103.540272351212,91.23987662762957 +2017-09-22,154.9160849234572,42.69649721620649,221.37581051075873,63.06098498465378,58.208608834891685,41.80045080323068,97.78041416453756,139.91069206453327,114.71832224754965,93.68080664146751 +2017-09-25,154.17089449384022,41.01589167791248,216.59130226766885,43.312221770407405,45.914344318346814,51.94969184392338,97.98987284194021,141.13198286459837,104.50022155592045,95.38019059098586 +2017-09-26,168.73283197813834,43.11452092325186,207.09729542047137,55.91858313541677,61.023958448365846,35.30870814826392,90.62990090363581,128.43767472731247,112.5792780104361,101.8969845395921 +2017-09-27,162.247478665168,46.93584436951765,213.22523868634238,60.38116180922867,52.411319765019755,48.95473711227365,93.98760007495275,147.61054487861864,108.84878323918252,100.97553097461282 +2017-09-28,157.64933182101782,46.15848596156559,207.70037611990128,55.891314695121906,50.97885274495503,50.996612259570256,100.86687299166624,133.8060419805424,112.19928102026644,96.70939977474924 +2017-09-29,154.90503731242632,39.98563059111965,204.18480610171434,46.797955140406444,51.377331942765665,50.449376223230274,93.45464479385824,132.64883666629856,115.79903143682786,92.65067842747303 +2017-10-02,159.93458526705913,44.89376539018981,221.54361906352258,51.22887415445741,67.86482758974938,46.581889130843464,96.73506638985378,139.9197404950515,111.61202856387864,93.10211379929417 +2017-10-03,155.37808479723532,43.22829495464289,219.22741930072272,45.85154926478532,47.29035915555134,40.57807708632181,83.63854699380235,136.8448707692501,111.67221225304733,101.5500804652924 +2017-10-04,158.14944166534943,42.193862671141204,232.36713959956435,65.32458865885111,53.02626637747407,40.065458030812906,87.9475277842817,139.42415199561307,97.61179727215185,102.91750546216771 +2017-10-05,163.23157532636495,42.47125876889149,226.15153481356694,47.85652514762219,59.34117885279299,41.592362434938416,100.84790777555965,134.54309286153605,105.2031103575326,89.70495797576551 +2017-10-06,157.21402130834076,42.37487162327907,226.29427757333843,56.0613637783492,67.02334281884032,42.80352731947931,88.84565363719223,139.8282712425091,112.00450523997023,89.82215962310684 +2017-10-09,155.48086551117646,39.77867934623975,226.87300273792158,53.32865422345285,59.30255326499517,46.50113687522264,96.63859014277978,127.44050681550428,112.27114973619841,101.8418368406532 +2017-10-10,162.39238025062295,48.839109482346444,213.5495519595428,57.97465359053877,52.611860198145195,48.98537726163115,89.60254086509045,139.44343561214654,100.8799145338607,98.64950532859561 +2017-10-11,170.81558060151022,41.406630295181166,225.86816373322952,55.26367583465313,52.02482179864383,44.520176363841394,103.64866649881452,138.9518158621921,106.05030034127607,103.63743489504391 +2017-10-12,156.9252564660187,49.141559224734785,231.31060403639256,52.05649069354277,59.915940497102696,41.93676583410913,99.74431607040425,141.6416093419123,106.5162253085754,100.51520560075969 +2017-10-13,160.4449208058746,38.3516391289746,226.76278845015918,57.620752741249575,55.24008314589782,34.85054762803935,87.47036753045478,137.90269030365357,116.43476363139655,95.77314202379746 +2017-10-16,165.7486789487144,48.64881937816328,226.26327640709115,54.95853920710631,61.53802441289961,40.92371965235108,91.38559155731338,133.75558386356525,107.81961108938793,91.58279412460251 +2017-10-17,172.29936799283288,37.38483601429163,236.76545904084455,54.274347781189206,56.56842566343314,45.547272692424244,94.67088275923108,135.4855419139953,107.61940147855678,100.61300815031497 +2017-10-18,166.56470162505497,45.517452618313385,237.10633223644513,57.635809896205814,58.04370660675646,50.33701070723764,97.20263265123249,140.3380612949895,95.95903474157711,99.50009608304117 +2017-10-19,164.5259119970203,40.587043090220504,227.34857293873677,57.198962890677464,59.62548650112547,48.3385390135901,97.02547889383305,142.40022831125194,103.53677514903777,99.33946969033823 +2017-10-20,161.95309000396043,45.23691230155356,241.8283235377862,50.21162913404966,60.99599765093924,43.12440421353912,86.42752680832209,136.55150153868837,118.28879074124478,92.99300184452223 +2017-10-23,155.11170711753758,55.61040390782313,234.45855092347222,51.0650249055753,47.34466806717083,45.65130608310893,93.23206343771822,138.80718912902984,112.8256836388687,96.68489592223436 +2017-10-24,161.8302129538815,38.098666107478934,239.0062223076901,58.9040189927763,58.64575169840275,38.93939755363143,90.68630106764401,129.405790136381,95.4010165197628,95.69726355471302 +2017-10-25,157.3621655514037,47.95646494727271,241.0781742969789,56.61340388710207,62.7585000589184,39.29230723510712,89.87529847643806,147.84237348259154,111.53601521084488,90.76549924663084 +2017-10-26,156.16139772971607,40.25275440860845,220.58533195801957,47.818297550178585,59.4497390109634,46.4358648564546,98.05670270011473,146.27679968293495,104.63762763359195,95.58876163094257 +2017-10-27,168.6305183204097,43.49456249396725,228.0045038529748,55.49862813347224,60.630637350623786,29.776551582098346,92.48161562031243,135.85165581198726,99.95306210391043,94.99379808275056 +2017-10-30,172.05994859059246,38.791553773399286,231.67851092097214,57.89740927479366,47.76991113175796,34.29990331094127,104.88671564624791,140.08452621126378,100.47875767255601,103.26993279971715 +2017-10-31,165.332412924768,36.094314328572985,233.5965572455199,61.83844851953103,61.88350398753519,36.151821380559454,92.2353558541306,141.09929625167626,107.47955739221253,103.5590383681211 +2017-11-01,175.63372098267087,38.22560985805298,241.81478530349645,52.62116675141628,55.5270816543971,38.244256826415196,95.2485494041697,139.74254885932058,110.54946092348075,90.5678951653143 +2017-11-02,177.25368259794186,42.63017314036205,236.80774593048673,46.98879874757388,63.23514925477276,37.68357094282126,91.51826535912703,136.1328043630157,103.62826944885171,84.8625847918437 +2017-11-03,187.34811089903562,44.25351429522312,174.77446794666517,48.74666811071388,59.62749070742494,47.337047713011195,95.06566924153563,135.7281266762104,105.07508468438203,80.81165676076338 +2017-11-06,184.82731447133705,50.989815284683154,193.7329462252767,54.132474511215165,60.765687572032284,47.69823727320936,90.53491504102286,139.64262575856472,104.193364946534,101.75188942944438 +2017-11-07,166.9205266756487,31.15490216214063,198.4716002503581,50.540445795033804,53.01360074462383,38.786581321491894,91.15503752444059,136.48746298172497,106.84546043729488,94.80656525184995 +2017-11-08,181.3394113334992,40.05827502267534,183.47233534434037,45.01532617308032,49.1739172463299,37.01982944289633,91.5986475763731,138.40151242562425,102.60640209580518,101.04123935062265 +2017-11-09,181.69047208620074,38.04962458442652,182.92659985073297,54.25502084427532,49.87491568845557,40.87870730285188,92.53723039574466,141.41410419005388,97.29300433516326,91.15953706996673 +2017-11-10,173.44554530334105,45.18526245853897,184.94239734632487,52.625921181014476,53.10298214095459,45.490353748495906,101.52805735540956,134.62296183971893,100.07871735838651,88.81527376186014 +2017-11-13,181.2947800663262,31.881182834358277,182.76826337549912,51.268113354747946,46.97574141018323,35.95347725706011,87.22568387674704,145.6561540321542,110.37218328680427,95.56508851860387 +2017-11-14,178.60986519351334,42.753692376692186,184.39820935288438,45.05834631374763,58.89800808961356,42.96575292265357,100.44036240786569,131.33346590795136,109.67634864674066,99.3691048645633 +2017-11-15,170.0830071578858,49.26676245636431,186.8953013039908,53.022856609874864,54.084908994318724,36.32352503608504,92.113452855269,135.67247736931293,103.42045130763314,97.25619548329831 +2017-11-16,175.46877004367303,50.45128896348219,184.36897260610485,49.99456092257428,57.23108560068201,38.38946653346088,104.43088435204376,142.96639835102314,110.66481559133133,100.1131206210828 +2017-11-17,174.8184898084055,54.81291097948714,175.0326655254278,49.9100526058334,57.77456077617531,40.216156585238316,94.61257663069077,146.48539541873834,110.06073068534829,95.61974939595842 +2017-11-20,183.033414920304,39.51864853949728,180.94850637855856,52.682688584634064,62.8459419934278,35.988178409571766,101.70467099818991,141.37678786044145,108.18435912253591,100.92143154590246 +2017-11-21,178.23426603200323,44.67818166543235,182.1811804738873,47.735728170719916,68.99018535892556,40.599509637952984,91.66187999594385,141.34440739535003,107.8305943259302,99.8446161103473 +2017-11-22,177.71983661066014,47.60178562584921,186.85046415325746,51.66532162144844,59.392449150643955,41.144164705689114,95.50302723947676,132.88362702649133,108.38810184960079,101.46599694183168 +2017-11-24,191.46439709020754,46.30940583840918,196.10528732954424,51.155010167775906,50.02090966936185,40.28519822449595,93.76167888938949,145.5321774906094,105.80621167425547,98.18878751026983 +2017-11-27,180.38435627472182,50.310649979743104,194.7702982941021,45.31127450805796,54.20412881911433,45.89869750812608,94.70679689511054,143.17692686883612,100.63306476055845,96.71296776849013 +2017-11-28,174.41971641739383,50.206782362022324,195.6054554537446,49.72796377423372,56.50129717513047,45.343572282679546,95.94301701547711,140.4652897075669,103.73356927250143,100.380445858987 +2017-11-29,180.18336056891098,43.17298818475196,193.1443352691626,56.24647542887018,56.97499387047281,40.94785295822777,87.5182969395854,135.74756018520614,98.4856942865692,98.07945656185471 +2017-11-30,185.9913323532046,44.84467386315543,173.85222176830294,50.813544534238424,56.17442639080072,33.543994149604856,98.45396372817207,142.99484964810028,100.01306369183713,93.28558290769652 +2017-12-01,169.25273223022026,37.34617273795368,174.53088313616013,62.022953466281685,50.83558415238042,43.94113768126943,101.96065931341298,138.87004222559412,111.95405964149116,94.44778553597449 +2017-12-04,172.94171348396617,56.04015596522661,177.91449487061544,61.58313648707403,53.37849743289604,44.86788887966672,102.9454485683526,145.35540269817957,101.02355640895526,99.75847395763455 +2017-12-05,171.5648076720888,45.88757214304848,186.32314550695767,60.96216966816178,51.246411775574984,45.31568358711793,97.90265509068485,140.14413292996173,107.23677918134683,101.15704585047365 +2017-12-06,168.25081209589763,45.57494338400633,177.10457488553334,52.62328466277987,54.78748073877985,48.90907019515153,93.83357842036774,134.01523464420632,101.44880771304075,100.06952504078298 +2017-12-07,174.26998953911297,55.0066794806769,187.55876306876698,54.38896975555936,59.16381927618421,38.250514761933914,97.53365557052771,137.22506469079175,107.91925373273895,99.99536049244826 +2017-12-08,166.63468343973628,48.52947126605519,183.09185127581068,62.62301285091,62.70371505377522,43.58098106572299,99.50378193010428,136.86630593880037,103.39291520529157,99.11818033327715 +2017-12-11,180.09755299520197,48.96622968186636,177.31882767874504,57.46944853760223,67.70890925284245,41.40121904305511,102.53217076171559,148.1681874696308,110.62765923326369,101.82182719159584 +2017-12-12,181.0680897531058,42.555865975987295,182.8553889929271,58.45472856877652,57.641911138510366,54.68874739842751,98.01316270294829,131.72825538516793,97.90927654254271,98.62333201816284 +2017-12-13,175.8061064426149,56.50579346207557,184.58499589476034,55.767785882275746,61.440038608960364,46.9432634066416,90.90757672080196,135.92168464583017,106.5219800685421,93.16771869724813 +2017-12-14,178.74507685385427,48.10286092896315,191.49928338679425,63.17585592625768,62.885025241996686,41.9247582819963,97.01846958819768,143.2629475644918,108.47666292676905,102.16999364802471 +2017-12-15,186.8809169445351,53.348655002724456,194.76357547987413,57.157806084815384,58.82045836063659,41.93550062094185,106.23166023696349,146.30157518577983,103.58511866298299,105.17380249308889 +2017-12-18,183.71148340924677,55.393471253121234,191.53481170946645,58.0908022324716,47.586385425469956,45.986166853109715,108.02202904892172,137.2583133317806,100.52650324109999,97.31385160298592 +2017-12-19,178.1602442851033,49.448380350126456,192.76764541574266,56.01116024152189,57.75237527946422,39.3310202522295,101.13814814637078,136.84397043108532,111.02988032977007,98.96123387902504 +2017-12-20,183.92968246020425,61.0257281349064,193.89005106466223,65.93299948423285,57.808354428785684,34.507846513304294,95.06352880880803,139.6060427196933,100.892083935126,89.20309894771847 +2017-12-21,173.0131918277304,47.084922923277624,190.55991059738056,61.70518950432892,57.2042593670116,51.254350985048156,104.90596472711802,147.86132504677647,105.00540475215726,91.09551118563886 +2017-12-22,178.9649216858076,43.01213432625306,190.94448070034358,53.00358672089011,48.08775607901453,50.8039169240569,93.70859717239145,143.22219321506597,102.3367380046681,102.41032768781949 +2017-12-26,180.32818848170842,54.6705502136493,194.47497232799824,63.467017387562535,56.42917147274415,54.190714758503816,99.84355065817114,151.29422581962282,97.89059080418735,85.04772307052492 +2017-12-27,176.10569006485247,50.714728979967326,193.69063161200413,52.863354731865044,51.449348464355595,51.09365588325013,92.56465268142442,144.04694396848512,106.73268579568635,102.25129185266353 +2017-12-28,177.51749240410462,48.04611144825622,208.9867374125257,53.41131645070895,56.20077052959518,50.24785754302092,91.85055416280383,134.99448797868283,103.21336919988416,97.83055234606778 +2017-12-29,164.44972654420124,51.8617859698647,196.57833500120216,55.00473228254512,47.48556977240872,37.67769364459612,104.7150787492552,136.6450596405146,111.37038753844963,94.88134424735219 +2018-01-02,179.2960162342141,45.27454518457306,198.07240943202012,64.57717937652322,46.68705751983918,36.250985736343424,98.21212232579194,145.49122284455242,105.50990989719642,93.65887757571285 +2018-01-03,171.73621559288452,51.58415030000418,196.20261479441265,50.67757984821415,57.0884813035565,35.23653079209701,95.90973498130286,147.07520123659637,110.00442553114449,94.85773955492692 +2018-01-04,176.88507462145932,47.892642704088686,194.18005207244605,55.70115356229116,49.566484223718305,38.62807506385826,91.7656953913685,140.59824323035554,104.44500912944378,89.28554467420112 +2018-01-05,176.19514132327575,55.46353042584691,207.2543905284718,65.01473348102415,63.77594605139252,41.710451342212,93.51954853576085,145.22684634804517,107.16547673356317,98.4921101165562 +2018-01-08,177.65241046338141,58.16493311214106,204.93473114212975,56.014508485658965,57.340336036285535,43.15706813671287,98.38736015984901,145.59121715822022,112.38639272679413,96.59736379004478 +2018-01-09,181.11209901850157,54.418646812702576,211.70804349087723,61.97194152709313,44.28733779254012,44.59328165343756,94.77862705300772,134.5922645502794,104.6077351910108,99.8484140999374 +2018-01-10,180.77711314047474,57.18996809072806,211.32388538433185,64.5989699090462,51.35705626108289,47.50273876308534,99.13430971057994,139.47892954663666,108.32028162162811,95.6705034318349 +2018-01-11,167.50510511694694,52.17082443277619,195.08505450037714,61.02415620714454,45.36519508788587,42.88464419083916,106.75605454580167,140.93366897004643,103.9481973923919,96.75278567882067 +2018-01-12,186.71455193099217,59.299071799935575,200.3159312319619,64.9419980888064,48.97179033578159,46.72094670005877,94.22240106595578,144.01689716441913,109.01010731818481,95.91597127481353 +2018-01-16,179.8608917444064,55.654669253573246,207.39437679153514,53.79656484257069,55.424601220792624,36.09168433398425,95.38986744366383,136.45933717495623,105.65063121272458,95.17110656340778 +2018-01-17,190.20156307127579,58.40791156162889,196.6950364106467,59.492077755949005,44.965586885239986,46.95717526823402,92.88873968098838,146.3267265641502,108.85076943941627,98.23230393892285 +2018-01-18,186.30330362546368,58.94206867813237,202.37782885040502,63.2223719642696,50.383639295825226,46.85781406694821,93.41747285423793,147.71884222970604,106.88427437619133,97.40799789361128 +2018-01-19,185.91579840014728,60.82942119520527,210.25324129768154,63.539960464220435,52.157807067248655,43.37209330768544,96.9972312447,145.9643114431694,111.3251006334851,99.28134222387702 +2018-01-22,185.28448224237766,54.30593812433245,206.85603620313725,66.16479478045663,47.1524420507261,46.94656207482257,100.1903087794455,137.8269745275193,114.17073953280726,91.21575116159983 +2018-01-23,178.17250278327143,59.16059837512305,211.7489335288129,59.12105235890579,56.343079659828206,41.31332372472517,98.19167250951207,146.09921810093505,106.12775152334426,94.66466539626948 +2018-01-24,184.73665463951977,50.124634328755754,215.24503066021123,58.684781554306895,49.31715921970304,38.33846957000446,95.84076894607338,157.5674698136006,108.27145891873737,101.3026369478589 +2018-01-25,167.4457327690422,63.57014082111157,215.64212767372558,63.5233925005885,50.00479746804699,53.777106041769,97.68915086314249,150.5178382932245,110.90153853574434,101.8000640070999 +2018-01-26,172.54592115641964,59.82157138724567,220.0460425031862,64.17042867158028,53.2459013845459,43.17475594816969,98.71537806773586,143.0871015379343,115.24211012564905,103.50454357494516 +2018-01-29,166.02092389001874,54.85884563925302,216.48257311176363,59.04196332031412,56.86245238786723,47.72248145168554,97.53667745618954,156.79966593390162,113.56432962804715,95.55146279106643 +2018-01-30,167.56495707290108,57.63763468207273,212.18370011586316,63.8024034012836,45.76220093061173,36.302030305210806,94.71839161658036,149.09029888385984,110.45386034752845,87.54122717011481 +2018-01-31,178.06695420112436,43.581743749675866,212.22328578738467,59.517229524530336,53.074937420288414,41.01846622466976,97.42296092323757,145.33518747782307,117.77118222907598,95.94132813899779 +2018-02-01,173.05279880143655,49.58633455180173,217.29406261040975,61.52944191995565,39.649942494952455,46.329478482500875,98.67430346061435,145.51200163819692,115.97897328949315,94.91187763323212 +2018-02-02,166.90475422711486,58.895033542118156,213.06702674203197,60.3945825605618,46.09027887326031,45.44024688071549,97.03884620944062,147.11766863815103,105.72953085198529,97.34740765810545 +2018-02-05,161.53511505787355,50.69810483251172,204.9666190223837,50.62811703909059,45.860764155706114,47.37374297644695,99.7172648163116,141.64912837071225,120.21049559684778,92.09425247317242 +2018-02-06,162.3253113390496,52.58129673931603,203.4928233122349,53.232901809727565,50.75444693763849,34.14340547126846,100.49789815064665,146.98072026591788,104.51534031355786,92.44484623963731 +2018-02-07,167.80245970146697,52.54201244478791,206.90541767702436,58.30370485406959,44.53927539368749,44.88536286235084,97.39570250316609,149.39767154467802,109.7450349278555,88.99857689738025 +2018-02-08,154.4655685149225,36.249041663889464,199.54538357356054,53.05083720547427,42.303216170027355,41.01225745286064,94.28642531157442,147.82253142759987,114.28577329109086,100.94598329979296 +2018-02-09,160.74783879705328,48.92314587447058,193.13332587166227,63.4499192151801,51.78938247527929,47.502833223899515,99.1291083236987,144.4505321469722,112.89103790678142,91.9745140629668 +2018-02-12,170.65822484190375,48.42246061590325,190.09720728186275,60.33426083604297,44.54430287033261,38.60764915251677,100.95233952794203,151.97640356832986,102.01936507250244,93.0937410451286 +2018-02-13,173.0985659725585,49.0603114124579,196.29288045434294,50.968106078023006,53.038003049308756,38.52320426043956,97.29527414349633,144.21319944315673,114.28290736860843,98.44255396645076 +2018-02-14,177.48417083580736,60.13130096846034,185.05916872628978,49.9150826435678,58.57153033214598,39.5564545184142,105.4834244142119,140.45794263631137,103.08774810290137,92.06249298169298 +2018-02-15,176.93885367262337,51.49548877763321,197.56313852257796,55.862241912772944,43.399158641030404,49.33782921401611,110.13941775194859,150.80944418366786,111.70607825026167,95.41615494919914 +2018-02-16,171.2059361712254,53.60132262482945,200.0184838878522,59.07584755538245,53.79977361964767,42.35001966866636,99.59623672549404,152.68761609034408,118.05470049034699,84.13463459639942 +2018-02-20,176.94309269416635,54.71612617605661,196.74578552743654,57.05743551607722,48.095214791960615,46.98646227875358,105.3335138470668,153.97972683477366,112.90639783216832,95.97707353406031 +2018-02-21,178.36544288761,58.44437130364794,192.93960085971108,48.47782368170207,53.31191878268182,38.54162138373933,96.35523362672237,141.91032729236497,105.8613536767293,97.37317662172052 +2018-02-22,189.07834456899053,54.360350005049426,222.5537372474788,48.62265634305254,42.923060967136394,41.67256578032499,103.43889763093189,150.52783407782456,110.41982304877699,98.69193113700867 +2018-02-23,176.56878537499492,59.99107499625564,207.90899566205326,56.27640756377966,47.71455556372952,50.10864420568781,104.14604857844327,141.98912660601022,117.58698692739097,92.5194428670892 +2018-02-26,177.939997589153,60.83648652682032,205.49572853870959,54.125624944750896,57.861345608084115,40.51924748963326,110.06773930430987,149.50665629351474,119.1634047570997,95.94372279606614 +2018-02-27,182.83790687433833,58.28657075258762,205.6445144475549,53.47445180613025,54.32300726343159,40.669935692180076,97.41939733005715,141.27488926342707,117.61578061360173,91.15360900478102 +2018-02-28,188.7357262438991,54.17402475527922,198.38230774409746,64.49558650162498,44.515105398130316,31.88554881687328,92.18508558467553,136.71033824715522,106.6761849777439,100.6468971200469 +2018-03-01,179.20390559583012,59.20605996880937,209.55244680042608,58.45165198054371,44.84523409637388,37.01858216701482,108.63823148046937,153.3370381164429,103.05002095172905,94.37446643146343 +2018-03-02,184.92491408409967,46.765789985554896,204.49720261457554,53.251402831929795,50.56972917734208,41.904692097730646,100.74385389843981,145.36656473329597,111.40972661922414,90.48886348252822 +2018-03-05,180.59983303271818,48.3877810040432,204.68639112743267,52.88174615009322,58.79811902660596,37.13002891697907,99.47004380323716,147.85274583694834,110.31117618110936,94.89483595900579 +2018-03-06,176.24534311683593,45.359781533028475,210.1836664186163,54.78567332580277,58.52636154822592,40.59455864863295,104.14082870754177,149.25034256617482,115.99174388524342,97.93628287350197 +2018-03-07,186.60420921768883,53.929032221853696,212.00214032734647,52.4397713033224,42.562933798427906,41.591490349520285,105.16764823364176,143.02122709151408,114.21744364794444,88.78422634097122 +2018-03-08,181.75315397254772,57.00748732398556,205.60410382214084,60.65074165207082,50.67226883171486,38.45237868967524,101.39191987872896,142.37758888716954,110.27068484192004,98.5107793153839 +2018-03-09,189.3517332268338,51.39558869480882,208.56175081735924,56.42150898313371,45.774485424780224,48.29268145165328,102.43760506911156,146.83301388847335,109.94775185084279,87.02280824088177 +2018-03-12,186.05945577128261,51.57572960851595,218.05224063607258,56.781049088755765,59.481366590382365,40.08141545692864,103.44293852358975,146.92328369438698,114.20918985010957,88.45041300810361 +2018-03-13,190.39416083331378,58.227468200862745,220.4558507580136,48.61039657069664,51.13719710917762,45.73104623093637,104.87479799699517,151.73084395117723,97.26321722280954,89.26351945430321 +2018-03-14,172.84758866691263,53.67876615172458,202.03624467115205,61.28178306210502,50.294429407792215,45.3754875996968,91.38953055731533,149.04262384142936,104.88904088571888,101.59949036651518 +2018-03-15,189.0542112155715,51.922621918903104,211.0044270109744,56.89462714073083,53.023528598304914,35.32597035212985,98.6200019306512,135.67650834492608,108.27615233856399,97.43999827682845 +2018-03-16,188.44525925279004,46.756317850606585,214.1342864220839,56.90192598382442,45.53900858519114,34.92077103930569,101.02729688806771,135.592211003395,95.01784755250827,99.24313507525004 +2018-03-19,178.24172347640516,45.95386106570852,196.75489586813387,57.192403194763706,49.938414131402126,51.76199586504756,108.01318029608312,148.33254032022313,111.9148600956132,86.55860206692296 +2018-03-20,173.3438598881225,63.41683210900055,209.05874106842072,48.25122513814871,55.488564777019654,43.55866494266975,94.44324500192644,151.07390636229988,109.79154548954672,98.46750002515898 +2018-03-21,176.02367124185784,55.739958961259276,212.9018702760212,55.07824318089474,48.61668084078758,35.93266745628281,113.59896199642424,144.02187001057325,113.51815689005593,89.68170042979627 +2018-03-22,175.41835697893382,53.32803494740304,204.49104792199213,50.77009540202875,45.6133823282808,43.82154115428631,101.20094398562384,142.37089416058356,106.62541214907058,99.72195787999854 +2018-03-23,171.16967756030434,43.31565242149655,200.00335887658383,44.91178551766907,46.5878536373424,42.69713936855433,103.96195716959707,145.39981082935566,114.73434066634668,86.54625915730325 +2018-03-26,177.61251308465359,45.84241399093407,201.9072442886949,50.85847006903259,46.52080885293445,45.421653128318724,98.38880585715646,137.8766521923037,112.37708742785102,93.06115362308671 +2018-03-27,179.45806529189485,46.46908130231398,209.0283530354893,59.9900448557043,36.434621059362264,38.05664412128271,103.24097879874196,148.07806299534536,111.50559228228944,100.29551716509268 +2018-03-28,185.32041505572187,49.933982007632494,210.9578479616551,52.98212096132895,51.17950933401353,40.738433658109365,97.86116244519168,153.74146590102472,106.11292283261696,90.19393344093939 +2018-03-29,174.26941518286054,53.12927342079924,211.90222208245473,48.905168610937416,46.330825247270944,45.33212483000736,102.4004728254562,150.775142460202,112.64474013451904,90.11415693572091 +2018-04-02,177.61976900865042,51.84299147438883,201.81430824001976,57.784258649238694,55.28090626732496,44.83579887257679,107.96035342219677,147.19103965168898,111.25480301569182,93.72944691305528 +2018-04-03,177.02854578310138,49.7204161545737,206.2708423142923,51.87544336590947,52.546992148763955,43.65572382195715,92.97064708984712,148.69133978661674,106.94641261160933,92.41321597366797 +2018-04-04,176.1350273475271,51.166465899901795,218.3435763490242,49.37162804218849,52.343613037631485,35.68299363262446,96.89263744658851,155.4839303450414,106.68364296346326,89.84317440635517 +2018-04-05,183.97236994215348,53.63462086774918,227.04346384608,55.61611760000976,56.9337602762035,45.49500387125451,95.38729781594493,151.21140230876202,118.84832170270863,99.24334646194535 +2018-04-06,178.001681025746,48.201150601829454,212.72404204776734,60.453448020483776,51.328668412318855,44.57058438777936,111.70565004961318,148.0212796736554,115.72836337304321,95.96313908721537 +2018-04-09,178.68999910042243,50.1488497607825,218.34568686897168,55.006588533242585,58.87592089152524,47.391483676732584,106.27412020097216,154.3068414614752,109.92136176004038,94.98262324694832 +2018-04-10,188.01417914895032,48.414699723849246,223.8582623170836,54.76217755486317,45.94142768437514,45.0895540836851,97.32750678588866,140.37413473774336,106.67217054879978,90.63007968173946 +2018-04-11,180.7962736689338,49.09663911294373,225.1081135178347,51.6491599395441,49.02598920260549,41.0622341765626,104.12960719557867,141.88140516809295,107.8910783817569,101.08959533308105 +2018-04-12,168.41307611005385,53.99715917232795,215.55451053836072,60.33523061238883,55.677205596986795,46.6545309992745,98.59601663630218,141.66648029232243,109.23434427213148,93.33081629208371 +2018-04-13,178.06546343307852,56.29689436239187,210.13902652034747,52.07805859819465,49.37404766313624,37.81085420712715,98.84524306165645,144.32152591175713,107.45922699589215,94.4138077396413 +2018-04-16,185.9642030843786,44.22513622279367,223.77745402847293,57.808949464496436,50.68167860601173,43.41785446851409,99.73733760018284,149.93246086621352,103.95039389537328,95.40433866137997 +2018-04-17,185.7481409772969,48.434354819696594,232.55360168428925,54.53703446706372,55.769992160684836,45.88469538227402,104.53698844601978,148.27121970399062,103.72372205374278,93.78090925304969 +2018-04-18,182.17307583321784,51.49555163850509,232.92918338480013,58.80812210748612,65.46486293005282,43.07424517556207,101.29228510867848,149.32884136252338,100.1561898823095,90.4670664140637 +2018-04-19,171.10742348944743,46.525786293415464,238.42659680968816,63.3917318660992,52.41339169315076,40.026866345768795,94.2490986513624,137.9817065343181,104.73114344643345,95.96313610952292 +2018-04-20,164.6529961951755,46.681541422863894,228.83735130983584,51.99126582180599,55.51516975493047,44.32553893057994,95.45821331183441,149.93634662952513,108.66609475688276,93.0085657935406 +2018-04-23,163.62532885217485,48.4146737908535,227.9849005014177,55.933019732934405,44.64154671700774,42.179186875568405,96.71644461935225,148.72944602464935,109.98878988736237,92.31391243815807 +2018-04-24,168.03492852162398,43.25429697927757,227.55268269433304,60.01408289755802,47.42972357664399,44.146263680567344,92.49044826909537,149.4400790914502,102.00266398987645,93.05968960093838 +2018-04-25,167.15580932720496,30.730329932132996,226.37738850714715,60.05633217064455,49.288581064078976,46.17235619616834,90.24680113328877,141.83443474981127,102.07438515560727,89.31694558929952 +2018-04-26,164.52791369626476,36.65771441405237,237.93702681572748,64.6325610722212,50.78226109458567,40.14697632654055,98.47116121490926,146.15837577790745,107.9467773757329,85.13678461584188 +2018-04-27,166.52829965938872,43.67414571338432,231.89223839781855,69.10968873946324,51.71058275189158,35.45020358664283,104.01683346521577,148.32933718058055,103.47279474580284,91.2339562529371 +2018-04-30,179.8432759112187,32.556331231957515,241.5600450452709,48.08163572003569,57.17625745704417,39.46603840661609,95.08570492523343,139.86543091828932,104.45799838908862,92.0612943872126 +2018-05-01,173.00805260754765,37.53331138159655,247.394781297049,56.17998266839179,53.22834901174102,33.95423584253942,94.35030795202998,129.76539341923225,107.77551334635424,89.52031430681517 +2018-05-02,186.0686304426916,40.526811106656154,241.26184634258556,62.95215807915287,54.20073599738796,31.22929561722019,95.44251049484734,136.90334639903566,105.19713718373796,93.15626844063023 +2018-05-03,185.74831544542323,45.93559920153211,242.21725248040255,56.64781649563125,50.51871498459167,42.5592060626402,101.82236157851317,144.94552481491266,112.82161225224269,87.64976321768063 +2018-05-04,183.4470346070892,38.81050047993065,238.57620768620788,51.89498047795219,50.43609745310705,37.322581429194415,95.26593297734385,145.3352382768348,109.18331892243008,98.0505956284737 +2018-05-07,197.26378497407654,42.52776479369423,254.60178095336062,58.63458110173164,50.82017147636032,37.61923536600236,96.65205163186218,147.19964490752855,103.44854850812553,80.26156530587829 +2018-05-08,192.87002985417953,45.62844310867391,249.76207305363545,53.24361796528841,47.30913524566038,41.846146408303504,90.14322960044628,136.19903128089797,103.52673688261012,99.52039120379304 +2018-05-09,193.59538078913516,34.91296051177258,259.02570345488925,54.20938433864303,47.85372248057084,41.82627293541343,103.98155420401503,145.6146171537158,106.31307928557015,95.06086573560341 +2018-05-10,196.10620921385248,44.745781856769334,255.0214719472723,58.85363732435144,52.85262444472633,40.16196070323835,100.22410877854371,140.4064863134447,106.54283366352757,83.87235866692924 +2018-05-11,180.53712567440408,52.27296933254017,255.9991245249978,60.30022793133321,50.207364516513366,47.579829005262766,96.26780410330412,140.68658566271301,106.32322595946145,94.74771405967628 +2018-05-14,191.50356869911016,43.71550356074421,264.34068146504006,61.9613247366726,46.18036834994709,36.29664947543737,98.66122371214875,139.06522551625056,96.049210997991,90.4529695659379 +2018-05-15,197.39230088432723,45.333182221802204,249.78319127124638,56.374853008975364,58.25097923180727,43.612186639746724,99.12143327378378,138.76824148426198,106.26079746370463,84.8533862667615 +2018-05-16,194.7600899374345,49.89587298798686,246.29961108439926,52.1333136413752,47.6955849712182,38.16557215355746,106.56081429822694,139.4695563844174,106.19758747143638,86.80921372210419 +2018-05-17,183.5963217553638,46.97508214074679,265.90853133912594,52.15716212030831,49.94073138715786,33.2949003275116,99.57195012626545,137.8279341057515,104.34300538008733,85.84996311386703 +2018-05-18,192.96717447517187,41.20584313531508,246.4406607242108,49.842994110001264,48.31611513694389,36.69957887426072,105.85415506721549,135.43595138821783,108.24476343844651,85.5149765339354 +2018-05-21,198.7144390206808,46.28097786540428,258.83137979790337,47.167726358999516,39.92956553766803,46.199614776629446,96.56185353709787,150.28200383781402,108.2068979834813,92.07472868832953 +2018-05-22,198.37195061563364,37.15220693396937,254.16154633969705,59.7971470454435,48.66608990592574,39.97885305196613,99.5267876483056,139.16659805686788,102.03933396230474,88.42642142743976 +2018-05-23,201.30508414190604,42.042581678638285,260.1515757221026,56.638412466158734,54.32329634586142,37.82094303077788,100.11056453385214,146.6720475905377,104.05914160742897,88.72870630643837 +2018-05-24,191.00623287456932,46.67817419296518,251.2786401624146,57.463761251291885,52.153288677078756,40.055476619758004,101.49651845455995,144.0642818266503,100.91237260620561,94.17429688242257 +2018-05-25,198.40793742513108,44.35890697048429,260.8435796515251,48.547150622010406,56.60945714108864,35.22752548287619,98.41517122812124,149.6761869241736,102.0715910285146,96.3297282199456 +2018-05-29,198.87866705165334,46.89481927650695,256.00949804391485,55.315198947175176,53.42738765007117,41.559118564925924,101.1442296352772,142.6747424494607,102.14547539635093,87.81518494806294 +2018-05-30,201.02618056778553,50.98458640855942,260.2756344907213,58.85032931037835,58.92382890601861,40.81937211574589,93.54503077777544,134.07118291433804,105.48878299825884,92.23383221061098 +2018-05-31,182.6589237023023,40.617013125762,260.7909761459432,54.619154134029046,45.08027612503044,46.810345157151204,93.28303559455985,140.61920665156185,101.07165562933554,97.8351992825457 +2018-06-01,199.66313443453097,47.97950272028909,275.1511681580638,57.45122974877374,56.745202133825885,37.79597435802065,99.66290995646294,130.16228916370284,111.73545648807556,89.55034483585447 +2018-06-04,200.94958108613554,35.492618848584904,270.01783194838254,59.228355133767074,60.11262261624607,39.565374566310076,92.0880227448006,131.60489866389514,109.78308076393344,94.64075421936532 +2018-06-05,203.88954342073094,31.48551472887349,262.31704941845726,57.65006080941493,53.344352883251844,44.332574641611586,98.85204171694579,140.41596987741005,104.07307158940807,87.44817204100363 +2018-06-06,188.13934712171908,51.98300529207488,273.9064767160161,54.8852427758594,58.422220421587525,38.43270033274513,101.98621477481545,140.33453726074774,103.68802367725273,91.07393593339975 +2018-06-07,210.94802846008716,43.99176115523871,278.2292330400996,56.13480238016289,43.242433717906216,45.160421091791925,105.40204112803696,140.58179266505672,97.77495681689375,95.71663551878399 +2018-06-08,199.64060750755382,46.032600529598035,279.69949566903017,64.54816638763367,46.38473704631066,43.555105576913704,85.81638027601734,140.39932050965402,106.32278108168427,96.50566665930192 +2018-06-11,197.2836438772242,46.0074822245251,270.1651305423242,53.80631444450633,57.55890807078649,36.023476993023344,93.6320111433124,137.97819197100117,100.91536971437651,97.35111119235478 +2018-06-12,187.24291369541837,53.25471482189992,282.3752967921854,57.03740465906039,48.9242969711205,43.987951681931094,97.12612998224736,138.50926639192016,99.07980313315701,91.6995470854599 +2018-06-13,199.0081341578263,53.36701451229327,293.6383432523264,58.78769144252611,44.699639927762874,43.77916348252042,95.08619988779097,137.62513376618142,106.1163358879509,90.04187028988682 +2018-06-14,198.8048829641853,42.57016493946119,285.11402366979183,50.75994741449493,56.01851957412627,45.533404207119204,98.77319206661186,137.20937241292916,103.0374166190202,84.1723518212641 +2018-06-15,199.64331249511005,52.52603905908366,286.77219755643307,58.88560001683999,61.85312956215314,39.58319851024266,90.35152268391846,133.58656685733322,103.69110175934087,93.99149402151285 +2018-06-18,190.58416480076124,45.15548226890962,293.0581628534896,54.458149577927934,59.17781123942313,48.7004542132249,102.336869877235,136.6526885979601,95.10703392967957,103.01508366485949 +2018-06-19,195.31652408084534,55.5054718166543,289.4371090024326,58.3465308850907,54.71567178575046,42.68582472892855,98.13927713784119,137.1924219223771,99.38838447540267,90.08677107173762 +2018-06-20,194.8732553945658,48.630845232467735,295.59061830320434,58.97218574496494,45.15404686666083,46.01170494532333,106.34089626284384,132.25186389652754,99.08096967464667,92.96120122193848 +2018-06-21,180.18305017035956,46.47150670423824,257.01274479289384,47.65063671247636,48.05022935588263,39.98857363994161,98.64694246185007,144.28327492214092,109.78899903562905,96.58965578421241 +2018-06-22,189.8882162557003,50.408250490561024,262.03738998061453,57.16465554079546,63.155064052647546,37.67491684983511,91.43419873472803,137.04117407162778,107.02385246057543,90.41014103362487 +2018-06-25,185.36897670238312,60.23333884812814,253.78098566840495,48.663912661452265,52.964850511002844,53.290413280671046,99.7367064689968,137.7341012772425,102.99264604700655,97.4056940224185 +2018-06-26,190.18300892415408,56.25660108786501,258.7158164063813,49.30184773832355,52.319503641862205,44.712897353089545,98.6158489591045,129.74016301508695,103.22491802728479,97.62874374757476 +2018-06-27,182.54870162059112,52.94297211893319,262.508693732453,59.07747649347536,61.323649200590545,41.155534670732465,88.67130816271819,127.29029731070567,95.3125072157961,83.10189206824496 +2018-06-28,196.9743798656321,49.462704839303285,260.13933232584367,53.903496414939895,53.41312375545829,44.13822490771955,96.92736308868764,131.77823408234252,106.89334834568133,85.82850308298805 +2018-06-29,189.16891523684689,49.851573989327406,248.15342399504055,64.05475324577567,52.22569210313603,42.57917913749682,95.51225085456667,143.45511058304598,104.89545460189437,87.16541668658685 +2018-07-02,186.0416849024585,47.91124588023252,273.5002984557642,57.82213605699803,53.008472937750426,34.38912425633346,98.81564175712367,138.16495166024552,98.6169084707193,87.1107576474411 +2018-07-03,188.6055453668659,54.871671703649675,262.85664323156885,56.25694380687336,55.119326002347705,46.38199853915949,95.0707915973733,140.83077058083373,106.0835157859743,95.15310416325761 +2018-07-05,194.07368571355013,49.018664614105646,275.6860050347135,56.560184173596,55.87218768803962,47.02491829324673,93.37227970454975,142.4615334016887,107.6073499913666,98.9914071136171 +2018-07-06,191.70807418910357,50.50267833728058,280.77772004894746,55.85295652670063,53.74991874107343,38.762322905673685,88.71915210842137,134.07276170729176,105.17044216299551,96.96251997296257 +2018-07-09,197.40260308321936,36.14636317909928,285.69717331329485,59.13376064897507,51.76030810613788,36.77753896357332,82.56556649651671,139.12475677339762,94.95301680839223,89.09449228381662 +2018-07-10,192.40857514253793,42.29192973054526,289.1445970104024,55.04284762144467,53.548516859142445,43.00004265943771,101.00612398439596,134.31128516885383,108.48615343588669,90.20701499664605 +2018-07-11,198.53896619049755,39.02478138633774,290.52273818104834,44.55170172082355,53.122047865161534,43.67336936267636,98.19566043838466,140.3348678050032,106.43602621949478,88.29858623820108 +2018-07-12,187.79643520448568,41.071185866450634,285.7537129441588,63.68367535801076,47.33359514626011,42.213005836590696,99.49041154419469,140.21139086419183,109.48526118822109,94.57218046295766 +2018-07-13,200.54384699490006,45.88033068243042,284.56191298567575,59.73166048596036,55.808591277688706,31.469794727179384,92.44674017423291,138.79009152404046,105.71165854179705,94.09942092731391 +2018-07-16,194.97933004096933,53.93131183579698,280.44002655046245,62.5604719415107,50.212853086552286,39.05116264397,103.08849609312651,145.08462809457328,104.73770729185247,91.5971029806034 +2018-07-17,208.24847349274222,48.020784014213,291.4589440842298,66.72190473465352,53.73831071505929,38.09669657934674,99.42395689475217,125.270847149362,109.82263455464411,88.80288577534249 +2018-07-18,195.6109764779131,49.88527352918335,290.6402399065721,55.48537372988474,59.336179347038836,42.238317076196324,89.7506472641137,138.31943326839692,102.45423339239863,89.90614580781933 +2018-07-19,200.32012566275728,47.03331265003134,283.8903845163683,65.99089932193144,47.552656592188995,36.1328457137298,105.7464402132796,141.46803849153525,103.83828294473369,83.78831971347616 +2018-07-20,194.6265779005823,45.04616996813021,277.76351319365483,43.656436695687475,48.94924571241701,27.211424844793992,93.77246167247176,134.60612237203625,107.30517767302273,92.49501147577097 +2018-07-23,197.99238799703593,36.921240647831155,288.7272944717863,60.16574721295928,62.16890456594808,41.998512606937794,95.53460869699812,143.78837805239746,106.14346748707723,92.0532398677196 +2018-07-24,197.43699053512535,51.60092590262245,284.2992549955554,60.80251267489663,48.49536447706421,36.613099046807044,99.20893524073955,133.02648743305642,108.16288673249122,94.87019731626742 +2018-07-25,206.0823031208181,45.637681532164336,290.32856653119126,59.83879681319038,46.34397164531847,43.40716956110822,93.16391682779638,132.29431508558025,103.14934084341076,85.7794815812887 +2018-07-26,198.67614279614108,48.694999529177636,283.3521931619951,66.16008637270569,57.216503385656566,30.654821128089125,97.03072848755019,138.48523156002173,107.15512015695343,91.05563105866686 +2018-07-27,207.57160063168044,44.03409887831621,283.29704032142104,56.055107438845894,51.18890243977166,36.43056532043302,88.63348130197757,143.8276016729166,104.5475947605968,92.95616293819124 +2018-07-30,202.7708476893478,41.16535849372039,280.1258449413927,60.816949931203844,50.834679905130045,48.55990838907856,100.93320881281588,133.6155199378968,108.00514520593444,90.09516554300805 +2018-07-31,200.81628815672056,47.44992837696846,275.6297226662451,69.35366591256633,55.48068514840625,41.3480938869627,96.6341789748338,138.45068832135726,103.22834151925903,101.28322867298249 +2018-08-01,212.47691709439684,46.417076256816905,259.0089126101972,52.26928568787203,61.99559213830794,36.74193847799949,102.97017741570711,138.5651691312905,106.61256149336134,93.83152400512138 +2018-08-02,209.32424699619258,42.81024290584004,296.181859614837,55.487528384087064,52.44638277172927,43.54546299785356,87.30936900111904,139.91102395902547,100.74261207824635,95.66444117028564 +2018-08-03,211.44312805019587,41.392247043678054,273.6787955736554,58.94121892786187,52.48085487008901,43.311961174280945,95.68956144051515,131.81054928498654,97.356151791061,93.92074319909231 +2018-08-06,210.24772568390415,46.952277853093264,277.413043382116,53.21083107294211,46.36715525293043,41.534483455656954,97.58385891883822,140.65944994629797,105.01408629104755,86.49771755445123 +2018-08-07,205.94988610111434,38.59106332841936,276.4080690795964,59.407908696652,53.462374075117125,44.34741045986306,94.86592710800306,136.20222496507589,102.98020177333859,98.86017056982767 +2018-08-08,206.29185919196902,47.72151597365803,262.97068561530125,62.499234364059994,53.10657844561557,35.4522597906674,95.68203595280208,135.14680225505376,103.58894505024863,92.37945654505876 +2018-08-09,222.01985968051315,47.80418587647965,268.8050389489757,61.85649855732136,53.93216343169776,37.81357591248868,101.48489131481956,132.62262089863808,113.31743890644552,92.38534212081518 +2018-08-10,207.09375459311286,48.53250136403275,273.2750182487791,55.44974431569735,53.09030171898894,40.60389600879696,99.6150748265953,127.75187914593066,106.09523740249637,91.09959515504028 +2018-08-13,214.34361486986376,44.24699129221918,249.58304518287858,64.98296442124841,55.9881629373953,42.44494663506756,102.3475067258325,137.3072139875911,96.53286714541066,98.57352851778941 +2018-08-14,210.44082325967065,48.128396178793395,244.76263088180477,65.14671914439063,63.22767075004596,34.88829285837616,103.21355196176876,139.28468914849967,107.00970171268412,85.46417634002611 +2018-08-15,226.12179946625298,54.155458797014425,238.28767872154413,67.8850793665798,45.41089094698259,45.30769980935509,96.09189144371986,119.78372528246317,98.36762252457892,96.5589181674147 +2018-08-16,216.02583822956467,40.00005820364549,247.83791920054335,54.111452356883085,56.42068933309212,51.10763806062734,104.90225853603624,133.67844353853968,112.84767635401852,99.39692301938103 +2018-08-17,221.4145959083626,40.438126565071,250.56192514151718,57.618899334000076,56.62430295919934,41.25062862418828,90.64671733849254,131.31584089179964,108.1154512026317,89.00807693172379 +2018-08-20,206.56685880052174,46.51309109003519,246.80449723589763,58.37061989489327,63.788308823155106,41.302058301104374,100.1368737345274,126.12522651539444,99.69359710164525,104.84505755953678 +2018-08-21,215.11223758431802,51.35765208835603,242.48321914453004,65.44509666532703,51.919184953846965,36.26420973541868,92.79803409198855,134.9243637872785,107.91158392467989,93.0743181845733 +2018-08-22,209.41943542951805,36.44531286507646,239.97360190189636,61.44623281203307,58.32649058325882,35.83090705383968,86.32135665729216,135.4548030540566,97.6967366284365,80.87796630700652 +2018-08-23,217.96450571848317,43.84453568146969,243.01378782015956,69.11410311450058,46.99916689275855,31.926292788075237,89.14197282918289,137.72466395503344,102.63086329625396,90.42315265173498 +2018-08-24,220.29259811189974,47.76773998280088,245.32978410064553,61.666457473879554,50.832713383826224,48.7491427025909,99.54407785922635,134.04407324853662,96.86311462961969,108.34276149122134 +2018-08-27,227.68654063680316,51.47052314396781,245.37092451043,68.3063867028839,54.56849866293231,28.74611672363846,87.69691792728325,130.47584702753988,108.88904354105125,98.32658428390916 +2018-08-28,226.77117950013744,50.789619029408655,249.66522366820186,60.75189714058125,54.18638676738147,43.63365012947527,96.06763961601668,131.2687469646407,112.49208651872533,89.62460107005957 +2018-08-29,218.83198990416753,48.04120903110299,244.6187187162528,59.92750344013682,40.48343946893367,41.22304537529153,101.05293981873297,143.2568822710779,108.90725023545873,94.4556654061862 +2018-08-30,225.60574828527925,37.60864048079649,248.80706437909825,64.89298746500931,47.12082423888441,36.35335421844882,99.36053660331116,142.13180388837728,109.89579847125863,103.012184660467 +2018-08-31,237.31347793946378,42.82992793868303,257.7459457698478,54.47388644543703,47.65083631531796,35.732380233423804,94.59121064738963,132.26482576747102,102.33607834136231,98.61707886360009 +2018-09-04,229.56862382728045,49.36847998940992,262.42801644016765,61.42527788619242,58.83395354310407,42.22276546110865,95.29780070012754,137.60998706779665,105.2541079185525,87.44160667360605 +2018-09-05,227.34216566560247,36.38435183079786,267.47267829293156,51.11914766388387,52.579781071981294,42.12479245342464,99.50918947945476,131.8766511248816,109.0050178451403,92.88944781960313 +2018-09-06,226.48137058112283,40.49988042999178,248.97243006013315,58.347335597982635,49.19398097057223,44.27976603765778,98.05601704003021,127.19817559976046,107.12910081688844,97.37292663175118 +2018-09-07,232.8660244001267,47.63642664341653,252.3750683386482,65.86667502069409,51.77552086722683,33.55590446121855,105.92862633009338,133.6507010063467,103.21019448493192,91.98199375535287 +2018-09-10,229.17840965563963,42.831691421822356,249.82619445069648,63.88206515998123,47.20640129169759,39.727678490210174,97.17306720864093,129.3957454133824,106.50907288043075,86.14072484263347 +2018-09-11,226.92968178712806,33.18553132459208,250.18607064800955,62.15725621232911,61.67257716085614,41.981577745790915,99.28208855153291,142.91185346969078,104.55026609412187,103.13610591564597 +2018-09-12,229.41978134513744,48.64079592266648,245.96733841482734,58.86130386705839,52.685692059390966,41.37743613900595,96.78962173998256,131.91815095355855,110.611014801483,95.78697192920652 +2018-09-13,230.98778068663907,39.13288378444362,243.65771712192233,62.4992398821629,55.35418922136291,51.592042093910955,98.7046074118967,126.2083123613811,103.51420092743396,89.45033480506541 +2018-09-14,232.16525305165206,54.310091302890356,236.75459488163426,63.82865832282698,54.827008019471535,41.166957109836396,97.16559866253586,137.93626796658148,111.97179668544268,81.54640786134804 +2018-09-17,225.87752255320194,40.697616282262004,222.83475265791782,64.79194065532101,49.312213142184255,41.12893260418953,96.43396578057347,139.00591926299956,108.6672387094841,89.39993854114212 +2018-09-18,215.8396247170472,46.47819748315938,230.64786663789243,57.776041953805326,57.82101053277498,42.853983385194155,88.44910428991524,138.74037901706788,110.88427368495789,97.9542223077616 +2018-09-19,222.0556862139626,39.64171654666315,243.4356766683969,54.11560471360138,51.414205388347604,34.890404384519165,88.29175995896604,129.26128729207443,111.87116096809717,86.26089106141471 +2018-09-20,230.116888010543,49.66706711856089,241.39136113263868,63.92199893139879,56.79223876425451,40.3998659622809,89.25713057383267,140.32064837099531,93.77341107554507,98.94167318745953 +2018-09-21,227.84818656730198,43.90123664478815,238.57291581036668,54.20308418294548,54.04341554717149,40.31577779310898,92.96106374936633,134.1294209112443,115.06235248176083,89.56917506431165 +2018-09-24,230.49360404457633,40.52437799550835,239.8941566444648,58.388638379511555,55.81324154251794,46.38883599021729,96.92896480746816,138.8590986735399,112.53836724251522,98.36283750766191 +2018-09-25,221.98947148630208,39.02803043067683,234.4429115992206,66.67004990430847,45.45164726550013,44.1882520983619,87.76402688242797,126.00330930976952,115.19464941540065,89.26927296501746 +2018-09-26,238.16684057680718,43.74698189278189,229.62624344841223,61.09907511141406,48.417687770136865,41.54197142798496,97.2674444557459,145.10554863995972,113.52866223793404,92.89666547312345 +2018-09-27,237.4307444549541,47.51235989283148,232.12473164252236,63.195392397197445,47.17869359810029,34.43583318625368,99.26727999246627,133.40636483514064,100.8035997995249,87.42141354075264 +2018-09-28,244.33841644390998,38.945719777955695,230.94180719549863,64.26718305551768,51.69233188967568,38.39106731623001,83.74934030229367,133.8025814028043,106.59537555219892,91.45428643446205 +2018-10-01,230.0138951652033,37.438302796634666,222.3874354248856,59.72533498168262,59.44123655500706,40.92634696964594,83.68055647935438,130.43558257262185,101.56354424872174,89.16621704010569 +2018-10-02,244.20580497048965,38.685134684084105,223.20186764962884,65.05184390536516,49.40249489194368,36.98723498908673,93.61234080354002,130.6101983181507,110.72126002584332,96.06698912382373 +2018-10-03,234.49631635657306,30.757791207508518,226.18823846904002,57.1554836669479,45.74035299207174,40.51139641117483,98.13142897152801,139.0104398139327,105.03994997489511,99.23304256334865 +2018-10-04,224.42682202222005,39.99550735811732,234.28024747159296,57.823143760307374,50.735306295579846,42.66811508636994,90.12215126546101,141.19624435571458,102.60862881698883,90.77163778024905 +2018-10-05,232.60768706669657,36.29762323233861,224.40035345380758,65.91084650507636,48.75343820121884,41.32142052741934,95.9577391828999,140.5629844504199,101.34249492994613,90.64548346742126 +2018-10-08,232.98100723561834,34.26357402115467,226.33509687067868,56.37796474294512,45.7801758406164,51.40032270122724,88.77200380789282,140.33123227984987,110.31822289436785,88.9537461034656 +2018-10-09,237.409645238959,41.65771683900831,225.52512415858718,66.06134026986241,56.27282125047232,33.5589125173075,78.53757269745577,136.99629851494097,112.38989161325784,89.40009491064387 +2018-10-10,220.04215380847268,35.77743091739386,208.20409389875834,61.706957344003335,39.79089392738711,43.890695622140456,92.43350268773403,138.2971724139716,106.99036799530276,92.84860021471599 +2018-10-11,224.97261830762943,32.6413321478356,218.62607363584422,67.16049279599066,49.565398691640716,39.82450436783356,94.25371200375474,131.93410620144496,101.27762315692549,94.4187607534761 +2018-10-12,228.4912862100968,35.11220510114494,226.7903158134962,70.79226588002211,44.80071749409404,38.38414732710223,88.13409831918655,137.66143069453665,98.13800282769888,92.26597128019328 +2018-10-15,220.69238429225913,33.00492869880601,215.77344810218756,65.30830650679613,44.03651602912989,31.219104470014216,94.5718548476985,139.81321998447825,105.4824797691794,85.78408832891498 +2018-10-16,226.82197669301084,39.24069002504686,237.8416856617145,67.84301460270615,47.893507159210756,39.38514640723109,103.28004921894745,140.68422899199516,103.42793189234962,97.22242464400178 +2018-10-17,229.05927866398895,36.29254944402273,219.6728928572113,67.9155932617316,42.96424801660616,37.041150681075074,93.04986664503915,128.50469834910703,101.82350926776556,93.7304244374532 +2018-10-18,223.43321269926298,41.19681248384777,203.7227206252335,58.53679099705677,50.503546255375646,30.52757300424642,85.55306687424873,142.91651289079468,103.80829313497496,83.683195086645 +2018-10-19,229.78525238640657,33.07816851049618,210.05228043913564,62.00140824733875,43.86102670897027,34.14864863811112,90.66021719179287,133.19656924751425,98.54132207926385,88.9669635688057 +2018-10-22,218.69624144418992,29.767788893204894,212.3975971932445,62.95698797379731,55.21930299809489,37.68018722855864,95.34035848306769,140.1842290717322,101.34796335372694,90.42878213222572 +2018-10-23,230.12179071281136,35.895290498702195,208.34384878499114,62.40947744260512,53.88628903396691,45.07551735660802,92.74448249953228,133.6746401977825,107.52852522271243,92.22848270964353 +2018-10-24,211.6718407401553,36.923654795621125,189.45796296341797,60.88623985340717,44.48757080775883,33.73975878256459,92.50480733174489,139.19879830666113,100.14055264614649,88.87759605056698 +2018-10-25,231.6934846747393,43.03345360383311,197.74855757624437,64.62444517123569,58.60885597025793,29.17204899847814,91.29918556140849,130.56962130628403,103.61148048565187,98.12789516024097 +2018-10-26,216.90629076088024,34.236275349395314,190.7380447017305,59.31306384804197,64.63179778017332,35.003381409216445,93.65184534761853,130.8274865960975,105.07477596915592,85.32429286744224 +2018-10-29,219.04629257342313,39.68716580278586,196.16990780438704,69.34156533766964,54.28032886196273,46.015194857214695,98.36526494767307,131.3305645059036,101.34734647828617,86.58963633692132 +2018-10-30,225.8645578848459,30.247961977783444,214.1574684025278,63.12387041607833,59.78028976081222,42.62290843286719,93.06455052072323,142.5129979249782,105.29264404287764,90.30613869678452 +2018-10-31,220.6775422217932,43.65052113767036,212.829406637429,55.109387644529704,46.84285393645882,36.43982566400013,95.80779065628938,127.72264525570223,98.74156562795,79.97284474261436 +2018-11-01,224.2976133049392,34.24694643494224,186.8899842408369,62.24663114353869,51.563643880861534,39.27340411494547,101.59033580135966,130.28266727362575,101.212820389357,90.41262542562296 +2018-11-02,218.95388237928694,41.669001410687,194.70193387666956,57.95746145292625,60.33253353772278,43.96937534804401,89.02259932434704,133.53341196896022,102.38804384504176,95.05737884341232 +2018-11-05,211.3743947237906,40.43647048590128,191.26667476090194,65.85381655545325,52.47002351529109,35.86094847290704,96.37672194935463,141.2952682433434,105.77957469220404,85.32662155041203 +2018-11-06,204.40390538122415,44.02313271773167,184.00930023977529,66.68481361710094,49.25139767634097,35.91282688637109,87.41967721267463,135.2798204665835,108.79920157086333,92.9737641804678 +2018-11-07,218.25136444639702,44.46212270171789,174.94292575796302,62.95890498589792,52.87468016302071,39.333845577923604,92.65737295584115,137.0830391338684,110.22506609213785,89.2118660404911 +2018-11-08,209.108792586988,33.601425723966564,172.70045288998926,52.5325802738431,47.6074177305041,40.51936847080861,97.09732214442819,141.12921930781144,102.06335472566708,88.26023466094964 +2018-11-09,208.8366657673637,41.45193989328462,177.26402921918407,56.917216304729735,59.41405090946015,40.947236482229485,88.8475032690076,139.8120659473435,99.35333934544863,94.84015788456193 +2018-11-12,197.8590062431388,40.11625316311826,171.9263488301461,58.46284436291298,53.99656705621025,30.43443071909291,98.12824133676999,120.1180627953192,88.9659797240064,97.69698942692854 +2018-11-13,204.1567823143701,38.207740294752625,170.33764177862295,68.292630880845,61.97733283366041,29.387619380890584,99.78343081063156,138.0357211947104,101.45265474994083,91.90178778650954 +2018-11-14,193.1218404428923,32.69884521064114,178.5093113085719,67.98478592029323,54.954645851798176,42.59017286693375,95.90225206463052,139.78293215084588,103.9390539466826,95.87934809305202 +2018-11-15,203.4487737414695,39.15012556824105,173.93594178678177,68.47866141933791,62.13091020976951,46.19275739671433,96.17609153850138,144.4094718748512,110.91182052317542,87.59838947768048 +2018-11-16,203.79182796807603,34.62345514399907,164.70836183057813,65.70671663720236,52.8242044776402,34.33043546596894,90.01892893991013,134.99676638898399,104.82476283554792,93.26912047182287 +2018-11-19,193.5026449337498,26.6080844112995,166.4820463321068,62.59324624120101,56.2621933570648,42.425582007340054,93.87163095086954,139.3693272213421,116.65565538518032,86.47252895110975 +2018-11-20,183.98473606115326,29.38170561561567,162.9364141125474,64.73148454020179,49.02443078902836,38.91521898351499,100.051789637441,134.84197295731576,114.31836641862614,90.27294855590016 +2018-11-21,191.77298585088175,37.72210887858559,160.458235137489,54.879317358034584,46.376111957630755,40.34096806496713,92.71343963622192,133.5427177988585,106.5935913253212,98.46591277922982 +2018-11-23,177.9475660385255,38.03702483103435,170.4394123260965,76.29583316853378,51.797300041272266,28.362336751238306,87.43728659874374,134.65236667675336,100.63607004132419,92.44119610628344 +2018-11-26,183.23875567958393,33.710520860774714,168.9590036970857,65.00598515406972,51.731786125044195,31.027793880988074,93.10270881638318,135.09851084831158,99.33865602859333,82.6709209214483 +2018-11-27,182.3328274865635,37.95505821205902,166.81701074135188,64.34909586643792,53.257413687951775,42.206514031419374,98.9151070726376,131.70988567410268,98.66135314985306,90.07420874390696 +2018-11-28,194.44465708742536,40.73520876467434,173.87464972794447,64.1585888009069,50.5598573537604,40.794878871592054,96.91522638060994,125.91663981296205,112.2271469463632,86.62228264180439 +2018-11-29,182.0892387449958,25.721223442194866,179.2392636647721,69.6888265680522,62.591551109338766,37.56937165853953,98.90316569142557,131.24418999934616,100.32565571419953,94.3073862447064 +2018-11-30,187.70811323085857,23.118054741482158,185.08823851901127,69.53524083721194,60.0103983223232,39.684767884818505,93.68945873130194,136.58017844984246,99.8931271763672,88.66299804374744 +2018-12-03,194.64883997065684,39.62293617415045,170.0754205966757,60.570241793748906,59.232040043652624,37.98171984503665,94.32594578848278,129.70572635555976,105.9633889943997,96.29163718313201 +2018-12-04,185.6257775405227,29.55408122789273,174.03291978471552,74.32277061451582,50.200617608490326,39.038485924882885,100.30173519598024,133.96895223941286,111.10376388285442,86.77346692267173 +2018-12-06,190.52828715510327,45.16644548904074,178.1541648556834,71.04511552213273,53.475609856955145,40.09709717282469,95.54090466937944,130.76889374753543,93.64190499013586,97.20483096769087 +2018-12-07,173.46618681435908,29.299118413698274,180.65771134448073,64.4961748689562,50.50519679079359,30.13269705844169,97.06933104852843,134.681807218354,105.21532894038656,87.52679576583412 +2018-12-10,181.85177729358819,26.67995607853151,183.40427682069134,67.4933548109524,59.832814124161715,36.30551777169764,97.59786753369906,124.84376812334187,109.2251281014467,93.47838178246191 +2018-12-11,181.16890702441708,30.341106398573636,179.00179460354244,61.01138402088503,47.451828784430745,32.72928588447112,96.06850753625113,136.96603654134236,107.45005715548916,88.34390873593006 +2018-12-12,174.10792118360587,33.52450691352106,173.51561843595195,70.4275413874366,48.7762921947471,31.478036507715093,86.74078574229043,127.84658663474654,98.14555667055566,86.26975526718648 +2018-12-13,175.10111566964355,28.297322552522374,172.65867389814036,65.43012821243259,52.448507165288945,27.678848418377243,94.02788310563261,132.52178654058065,105.0590392537469,87.25534753507613 +2018-12-14,178.05244163181862,34.98781473985343,171.69650847062553,62.49680987818738,56.63622582275978,35.69811769782447,104.3389538082444,135.40440855537946,104.78254865064119,88.21157920298769 +2018-12-17,177.3762450402848,32.33693636238747,159.72966793606474,63.628690859838244,57.73437474984986,39.69223944610516,94.54283399800747,134.69245834698995,104.77601290423544,85.89441924692574 +2018-12-18,179.40864033338843,38.95760358539686,162.17121806747406,55.975066804257935,56.940439911235046,33.14162604594417,98.33565651990833,138.9309180079546,105.2226193466515,98.48996381121383 +2018-12-19,169.1305614010413,28.1207161953226,152.83589686135966,64.27031453807427,47.84108147586397,44.63919182631763,99.06105642506682,136.61521645652857,96.7145555636846,89.25061674737834 +2018-12-20,160.89264432749584,38.768805755324976,163.6708304940075,53.78006832032765,53.62590800855457,37.12463448920604,96.97062648064005,136.07870524120517,102.08348600961689,97.31897517605893 +2018-12-21,156.98549770528723,34.27999669119167,157.29632808656544,62.53867354896557,52.143585540095614,40.408020498361694,96.84873977858796,130.21775330773968,107.36057655041658,88.17059448923435 +2018-12-24,153.5557350796742,25.33362438506018,151.9288035060277,56.703283653283734,56.330693262928236,40.5380884633416,93.44479680310204,136.7065197928084,102.32555147907368,84.44944100993186 +2018-12-26,162.45479694320966,36.474295030914135,165.2000610427869,63.15808683753494,52.00515741123375,43.96390398723435,105.42560429123625,133.7998096356689,96.50788266802851,93.64293103773642 +2018-12-27,166.63586655186057,37.110046321357636,156.89083587290008,65.47202684967871,53.07617184142664,36.258118394738496,89.29060022587497,134.60023163698818,109.06224665655071,87.5770708475821 +2018-12-28,167.28575444498915,30.244352882580976,166.45593104507535,59.8007663257687,52.581870690218636,38.454516374678214,96.23213618257523,125.39543069514544,93.61983399255637,90.97114251815657 +2018-12-31,171.89818741327298,33.491072902237306,159.66484370741958,64.64994613962688,49.36306588489438,25.21734150103698,99.05879918415557,134.65798772393455,93.21899030372292,92.22000359711153 +2019-01-02,169.6442210161969,40.15629770480813,162.60669800432112,71.64044743830688,49.11391595159344,39.717689582878755,99.5426872317382,136.83105068158284,103.55154753493139,91.5536491773872 +2019-01-03,154.6169447798255,37.34066026605274,153.51808936197733,63.093868958052646,64.96190245076576,37.7921891195717,102.79806522788115,134.37795059146893,103.839684668259,92.25695063690188 +2019-01-04,153.35596238121175,30.83219166549139,167.37251046988388,75.57925569608943,50.616546192914925,35.21165488020635,95.15647848672198,133.65948934002748,101.95133421032811,98.41338654956402 +2019-01-07,159.57740824345746,24.967152364753243,167.08987945408091,69.52349402822229,53.14071240618854,40.19841676263866,93.9404630158687,129.53748396266457,104.9857834076194,99.92464081565441 +2019-01-08,162.82459088581214,28.453534354910044,163.88449066170676,76.42743355469335,56.31016552995609,36.48672390989776,110.71978627104829,138.20737413192083,105.32238933358099,87.89549846356672 +2019-01-09,166.9031356197901,29.74499332288854,179.49709510882522,69.10026837698571,61.3800863311138,39.16665916186005,93.93727903763856,141.74489664594876,110.64972086505999,100.07887032525032 +2019-01-10,161.34664308577712,33.748613272633456,175.09915197114913,62.13922254325592,48.805923339146005,33.43075120150655,93.55380851700599,136.2895721065185,106.88355145631603,97.82120092190206 +2019-01-11,159.4107322026068,33.91567134763047,178.16209907427893,62.85516467548658,58.202295650194756,31.9241362330307,98.37257177213696,135.37735246426016,112.49616528832924,86.22216455835338 +2019-01-14,160.46501808875828,26.489700483104443,181.1252285681488,56.18422670606854,48.40936933707364,49.21000959654414,104.51155717735332,143.36071084586985,103.82325190930274,91.59320352978338 +2019-01-15,163.20933598713887,30.190906566332547,177.22491066159301,69.34564274018082,60.284846867255524,39.14809001062727,95.98904722605904,135.54779381014234,98.84896956036033,85.77774270594911 +2019-01-16,163.35501620076406,34.63541048796994,174.1038875362203,78.04486954204445,54.81231375514912,49.98572068700217,90.4377454816281,138.1911142825742,100.42346140092035,94.92502222456281 +2019-01-17,157.10222790390532,34.72936613690031,180.3818598543741,53.51227434150817,53.89508883385012,33.51111816300745,103.47437964180554,136.10010109669207,98.63071652339913,80.13580438070213 +2019-01-18,163.09274806326695,35.07988258979517,182.84659380884563,59.826335745737,51.15863219653765,49.186302939124374,97.78932819533372,133.7520966304897,97.66301194052792,84.28178068191788 +2019-01-22,166.78733656582807,34.557577035038044,182.2545590091839,66.62110449451703,50.91793471182436,43.221719567496606,99.55371656387803,136.33583297390825,101.30366593510242,87.48690963088133 +2019-01-23,161.42491261515548,19.892742400399847,185.99548516208353,74.12267802379236,52.872617294712555,43.41302804104256,103.2235137176843,138.32208267081646,97.11537224902689,89.80686708226428 +2019-01-24,146.87571582935487,33.276761993832366,187.98610312374234,69.24952970992592,58.04631506752085,32.27508837093212,101.4467578678237,139.68126850849433,104.23460986711777,94.13499568155574 +2019-01-25,160.48706526040112,26.476952496567876,190.9178670793848,57.761310926699835,56.43151240899262,39.60476675483314,89.65365831774255,141.14922275366015,102.9991580327076,100.40484328027972 +2019-01-28,162.66006158874802,27.479815639287544,194.77712446911613,67.21572697468056,41.32126254816115,36.2405653953542,89.93165733861538,143.4465668178058,107.36472886378677,97.00569062122466 +2019-01-29,162.10151782312414,22.405219941609815,191.11540301640852,54.133540300684544,48.46839102929105,46.333443429518134,103.598989456868,135.8089061853901,105.4214395415612,98.95025100203628 +2019-01-30,177.6652103072956,35.16807927035731,197.84926011090013,62.08584236644357,53.6080265572637,40.4048191424518,91.51187730060799,133.32239013143538,103.03057698576072,96.73296717741358 +2019-01-31,170.3038169742576,21.735276879107715,210.6509193058895,61.62694377906966,57.48642926526186,39.68069499130255,102.2926687561413,147.37619016401584,110.92023756875025,89.51046452823587 +2019-02-01,174.4010000655524,26.486518953975626,195.95204233732105,49.39421779876968,62.95822623162129,26.358278293697264,103.11420005657914,142.05289495046668,100.07581475796692,98.17921917775325 +2019-02-04,182.18500112910948,31.357787885334922,195.43992829787226,67.77844434192859,48.93483370486912,46.2859461692576,100.47964280652198,129.46661858297026,106.34650603067912,94.3989827648738 +2019-02-05,179.22183747819798,36.343557125954156,201.64644025685894,69.43241743864505,51.03570952440399,38.865437542737396,85.29764744165078,136.48978263375855,102.86861766434383,92.99618301494525 +2019-02-06,189.94501734279936,37.75099151533455,200.49487208061566,60.27870063753411,60.52243818509939,40.974382614783444,99.36726175664619,126.33441661642178,95.37202320616687,93.0362687462422 +2019-02-07,177.87486443064074,26.419711030355767,204.8154804539015,60.237018902064555,53.311038460496135,34.601645710228226,88.24174787402262,143.3826749081249,100.07219452119486,102.45543378881631 +2019-02-08,175.2762242277205,19.333014877470042,194.66290880911163,57.96390488904154,61.06001443944233,31.76861074553456,96.01353142128171,138.60059086443275,105.55983830811793,95.34210634464925 +2019-02-11,181.95934225162594,28.54820100835382,193.88011439922636,56.52786160583126,51.72220070352433,42.86704794821772,101.7655383971241,144.9056504507323,105.0312311248586,98.26518580589682 +2019-02-12,176.51672902811578,35.0512676508847,202.91624844641828,55.338123601030034,49.70217544161924,39.435310453886885,97.1128993351502,135.14577007420888,110.99250304120761,93.78687849084989 +2019-02-13,180.12243002760863,25.28846566540712,207.91510630495054,67.10616545071787,60.18747479355405,46.58436110639286,103.12941786570174,132.41875709825268,107.81045979722272,108.23208708710413 +2019-02-14,175.21737345787918,34.46066730950746,208.0567510058518,52.22407362175606,54.37922241948921,32.545812369540776,101.56653627099114,132.15824755751805,98.52510771867715,86.59738479335957 +2019-02-15,173.27271990737154,23.52563894375227,205.54206724742178,61.49548195211899,59.35443196085998,42.51015594116359,91.80038814483204,135.74455261894386,104.47753003477446,94.31444632827102 +2019-02-19,173.10453694047527,34.58344036285824,213.6183125570831,53.40482143520177,63.33017896158939,40.08588610025402,97.52066095930381,132.50229701536395,103.3530061474033,95.21673114899482 +2019-02-20,180.6554568125698,28.148062944967037,212.22687495596267,64.24575965325465,64.13170636889873,33.156054914205434,96.24155542348987,140.41885100782466,108.65941336319565,96.99438396955436 +2019-02-21,195.9539470615378,41.60555354434992,211.04610139026582,63.78385592671774,61.426526878699846,36.12683048771736,103.21925496766784,142.63299631850737,106.58984871913418,101.74098275586068 +2019-02-22,170.26530559261616,27.564767921521472,97.15819484737159,65.89813564692396,63.15817439691415,48.153738238594016,101.62353621413493,133.88047371035276,108.01326863998179,96.84558589894706 +2019-02-25,176.95033763609743,24.770915349861596,105.01723697561651,74.12632090298054,52.14657612303328,40.96100803348847,92.53227223602515,138.82280721550953,98.11401750511523,89.01730602269632 +2019-02-26,174.52659605180878,40.1856401606707,107.95237192903689,55.91370413946237,60.5124661789852,39.47014012445539,85.47116217233165,129.8322773767668,100.77237411215107,91.00872846663684 +2019-02-27,186.01270461970662,35.711568400324836,116.1622833982679,66.55188506694219,40.021090694842066,47.887695992003955,97.4077648651808,142.50957146912606,93.67246073258718,100.16110957260129 +2019-02-28,179.89085218377244,25.890132035440473,110.13833648989588,65.3864619406455,53.191692288983695,35.04295930053081,87.60813258573128,146.9118459133769,89.05977974712867,94.90191023306139 +2019-03-01,185.30033426965045,32.337251868459745,97.06087720891821,61.81843163552979,57.361530607223585,42.339819867708655,91.83663500982043,130.57068258740424,105.97764521189809,85.13181750061496 +2019-03-04,184.61705788905113,39.95367949472902,102.72420705531428,65.56029573145736,63.68588501562963,37.17255562947894,91.4428350031362,143.4495200738494,104.92441423155509,95.12249771231252 +2019-03-05,172.35567387021496,30.210661454372612,115.11551454284472,62.416175362337256,58.208531027565385,33.33010801935035,92.05787399728018,143.70880963929923,98.24774229516122,98.27607977398506 +2019-03-06,185.25333823055374,33.18416273492913,103.45010118460327,65.30016752962607,63.42007612292101,38.617627079864775,92.56473374936985,128.67118006571957,114.30685653189069,100.06799312751549 +2019-03-07,175.95605435058667,26.31311062400614,102.76974316988414,61.56082903049294,52.41807416047206,31.01334183229357,99.97266065862132,134.50421051479353,99.04442874668973,93.16422287535683 +2019-03-08,181.34254980089258,37.505284357355386,96.93308196698268,63.518321982279545,66.57343999160486,33.731751597465426,99.12926044852004,130.78378294511742,107.06309582701849,95.82649405097231 +2019-03-11,188.6938720109337,32.52391539516421,96.18594496539406,67.69833842248278,58.28149885306431,34.36655286230151,99.80096496601966,140.72152820227703,94.08264360119853,97.39370198058342 +2019-03-12,187.09985054987072,24.97063388235752,107.26210365961155,66.92365295389487,61.454856388972765,37.32676699253514,96.20475698431096,131.77605143327332,106.48247580815847,106.45096953159704 +2019-03-13,193.14773072770868,35.53984839494287,101.97449045615237,60.46026299275861,55.620369910408805,38.90693413922287,95.25615711423731,148.6897361908018,94.36110250368506,92.80978399728788 +2019-03-14,190.61222985272585,28.12339458736892,101.06940638337768,58.439468911442525,60.84433038396518,33.59419380707408,105.98477236666128,134.92643363428922,103.53260571590738,92.63383714987567 +2019-03-15,191.26749700702726,25.44205702509556,95.85530287070526,71.19154624115785,55.57134934572182,44.16480638473903,98.87715006992022,145.27994353283864,104.33303580110133,102.74594232309255 +2019-03-18,188.00731735289276,27.205124983981595,93.83384237627116,56.01581765918274,59.2903589446848,42.14573886523907,89.96413931983403,138.19203021966487,111.5860140451854,98.66894883676498 +2019-03-19,190.75649228153424,28.68007835568512,101.82444609405955,50.1391376070713,57.473189337455494,32.938460888715646,88.91572879418474,146.17349431346787,98.76168991263725,90.23825255492079 +2019-03-20,196.18042210432333,30.79484007949079,97.48907315132881,71.59199979715702,63.904065987917406,40.59012164263648,97.00313030843094,132.79912459712014,104.83856553185669,92.45024757570704 +2019-03-21,201.16010415490237,33.45854355522795,92.60087045884787,63.63887506753291,63.9065881271293,25.653632372930367,88.77582856732361,138.27372697164856,107.44172005478178,103.44476009012048 +2019-03-22,199.1739449134246,34.18473463048345,90.93850535098987,68.13127530030458,60.57198683185376,48.45453414285137,101.93960827430048,139.7080002946451,103.19368045394911,92.99296168345671 +2019-03-25,201.1885569890658,44.08902707942226,97.55248920776111,66.15919264622684,58.09756846950668,37.6330423918589,101.21567983342689,142.15931822813963,100.39116587646079,101.38510499623156 +2019-03-26,193.88776008726964,32.500007549386204,88.53114578119369,72.07762049539625,59.61155982068457,35.155611569369285,94.57155889137935,133.58406285555063,103.717964423459,101.66300990361458 +2019-03-27,200.93473983673655,35.75144648273008,94.30355735097288,76.13031121912275,59.55887225071139,34.32752506744403,96.09316086690927,133.4782008789806,100.65401361188214,96.42189109312666 +2019-03-28,204.72254083962875,27.50692598697419,96.0237128971535,62.27566381005897,54.7004358522544,37.85207082515071,90.45406786760701,134.29725770769724,96.55398652672035,100.14808309686761 +2019-03-29,199.05483942458963,33.72722668687231,84.68330996900113,80.65437119573588,63.47580707359653,41.32230757603961,96.33712848589732,137.26813526871334,112.62565380881117,88.02498619127277 +2019-04-01,203.21991149912603,34.45523031552657,92.96717069768856,66.65092761638486,62.02121934783132,35.58343597661811,91.51089723107621,147.1397154049797,98.16540252069554,95.27818175477265 +2019-04-02,189.40883795957063,26.263415887843507,98.96160673150263,60.98300007411185,47.32404189577077,44.61818561360136,104.64628845834253,142.3437396408986,106.95210110635855,100.95297565038183 +2019-04-03,194.97452070001106,33.758246181649625,89.1590233850203,60.17706436147794,63.359219521793406,37.45930682855175,91.32715011745734,134.7480467903286,104.91838886040387,95.80558173033054 +2019-04-04,198.90368152023106,36.141794829025756,89.96322765865501,66.84662476119382,54.20961875544136,48.590456512467966,101.41809889670996,132.8168912669588,100.14037843644088,97.4088308928596 +2019-04-05,203.27237883352143,40.163235269618895,85.88020594848255,71.17503115954929,55.1808007671428,32.68466618475277,96.8228168013922,136.38471376184805,105.66612437985579,100.86815439258591 +2019-04-08,205.4584183214741,28.048763256709208,89.12506723044496,65.31280809443712,59.92078902681486,40.75128015582419,88.60662459860463,133.8008303075034,115.19467409733014,103.24404850232838 +2019-04-09,220.34752758359778,28.634312622191956,86.18005796780614,58.45679799780968,57.63818431415997,32.906962210864314,91.25335153027082,136.33851600935247,110.72116174283232,107.1708669950227 +2019-04-10,210.38044430401393,34.30567393254769,97.35781084847065,66.25329630931,65.50176357076208,41.074327930383376,102.12005998003355,141.65169082336186,106.16364411835153,91.15573322537196 +2019-04-11,213.14056142281638,32.218710168427215,89.21522066410174,68.19240169394628,59.09897608914211,47.59948851125163,96.81153627779814,138.1813442334749,111.37987958466923,91.81511878229223 +2019-04-12,207.10869820000636,41.68215139196194,87.93370228303425,66.66012366923428,66.65088202154813,42.33106672995333,102.65672185274255,142.28445348525818,102.28178411335082,98.31029131577927 +2019-04-15,204.70429607937925,27.36070227705349,91.3020649049736,62.65221332387687,61.64589967769942,46.142612298691745,94.35705605195308,136.62658988121115,107.1751783536059,102.37626778621008 +2019-04-16,207.57744466323427,32.49531942330398,85.70353343652063,67.11632725119438,58.37811435393455,45.5617306958794,96.93764258043144,128.23418994775943,98.39330287710187,91.38069620416394 +2019-04-17,202.5719129094258,32.138982223248036,95.77167644970862,65.55175076669046,71.10581678492625,45.866617100316425,85.68182147610887,140.80197627900154,98.2070690211811,105.08842971346758 +2019-04-18,212.79578188206884,27.690593338058022,95.53121187016974,66.96976622798073,58.92550062175614,47.55888322479237,98.43598018386216,127.1181685321398,102.7358274543399,106.09018918534032 +2019-04-22,208.09718153409412,33.72708838971689,97.41996673757447,59.34425665501594,66.8398268269245,41.58947389794423,91.14063877676398,135.24716669602145,94.84290164949243,93.28060227208589 +2019-04-23,221.21787371939558,24.61972539881619,86.34759420841371,67.74682089043914,68.78594341595412,43.7201989571298,101.88423931552913,135.87596872850008,106.60338960456656,96.22576018421036 +2019-04-24,214.0928279027291,36.929264153726756,86.82940797395197,73.80527619476536,62.26940909642017,40.82859098115409,98.2112593185042,138.16653366860976,101.0532152566514,100.28329782072706 +2019-04-25,211.69184375501843,33.63380338415216,93.80257413688744,67.04368752866449,51.75170122807781,32.39863757166679,95.39410592222984,132.64088196079604,98.72255568887346,97.5248051004003 +2019-04-26,211.92140468730386,33.99196167008444,96.67558332604813,62.151734672654825,63.07465240734279,40.001799138272425,94.86997090551836,138.0764879291054,101.22462724266823,96.84732575397949 +2019-04-29,210.49153739482205,23.616701133872464,100.75513749696931,61.84110187531074,62.01459425484222,36.29689594512189,96.02160960922363,140.73950974599683,98.31379803676509,94.05168220415077 +2019-04-30,217.4139665512003,25.33086239207684,101.6401419435758,59.784061199468375,68.54414938541727,39.50071642714407,97.2408307764939,137.75662098154075,100.0857011112092,92.85798615453469 +2019-05-01,217.2447717521616,37.621243356072256,97.03532897223162,61.88853714986757,63.25111423785335,32.998587972524795,95.25478115645505,140.06579750225148,108.84553250082644,97.03233898404913 +2019-05-02,218.6242605313145,37.91721137537715,92.88513504311672,65.68811716550327,63.332511723625004,35.53504858750527,95.16068477594793,133.48468429032212,98.21896973894862,93.94957369195946 +2019-05-03,229.52672266102573,26.811630851568868,100.29004277332793,63.824474086883654,60.724962912095236,36.77626481800759,98.67230781424811,136.6538964727457,101.1057608617445,90.61213666800296 +2019-05-06,223.31608456393474,35.27981469284595,88.87880739628231,64.67022807570595,64.3949133652659,45.29236585990477,99.62786769208132,133.4594926843777,104.66921124504029,105.24784840026915 +2019-05-07,212.3427085317456,26.355096696672398,87.4941122867807,67.87890385281459,50.44682260127655,45.26782413543854,93.03715002181535,141.7032182179385,107.4905386939576,95.76676803251122 +2019-05-08,213.3430189859895,24.973656186310986,98.44076843847702,59.77345802912969,56.91977054603668,37.56134295140549,95.25995484307794,136.52538168335306,93.37517548639244,100.14419343544746 +2019-05-09,210.03014580332032,33.27189940529166,42.392088221434314,54.30350861990555,61.180354405215056,45.62953869454089,96.88220371743107,140.46362673022855,113.43628035901118,100.96915862861186 +2019-05-10,199.86481149848404,33.535687543002126,50.76671065810862,63.5425463501528,53.69192849884164,40.84418606539889,100.3065720696606,147.91352633755065,101.49091563693288,89.01268650868506 +2019-05-13,194.77995866257925,28.69356016607565,43.72699102397849,58.61828174996843,61.91632340906429,38.923613440501825,94.69970498322388,128.46894614639197,106.22570872782015,102.96147823285729 +2019-05-14,196.38706352567417,21.15090064940034,56.96794282162211,70.75024995900071,66.89585769512948,39.133030836978335,99.48711639180502,131.20015744399745,106.35096455706989,97.38366850420397 +2019-05-15,196.9835446572278,35.43728039657272,56.04676739143696,67.53930894090612,57.890466436648516,41.34759893158356,97.56440940789392,140.03968309742478,96.0973130071707,100.41275281221498 +2019-05-16,202.52803355493717,24.856625792863476,55.76867330139321,67.7572476187743,57.76796229520888,41.098493125374226,105.6815316041342,137.86586312182092,93.8573413684305,96.91647464177694 +2019-05-17,195.995223300138,28.06003539858561,51.72814270086989,77.59745257241991,63.63702028092312,48.17235622316609,100.60598680125273,139.96940895702264,103.10516328985737,98.24401624076708 +2019-05-20,198.84422606010907,27.030379264040036,52.06724517459491,69.64519057951287,57.69276359989969,49.05628955049526,90.93474793053504,131.73937025718698,113.85556311358977,103.98615086572238 +2019-05-21,192.21716494157113,24.5936674292568,52.15434216116127,71.25687549353545,68.28882758319412,39.98522533745777,100.3562453133187,134.15260046351358,107.67042543104594,99.63751608497422 +2019-05-22,196.6664473059308,29.681370419191282,50.6363783409121,61.794627679847906,59.14928169111366,43.28525097127301,103.20644513943719,136.90629976244196,97.91193345687827,100.54998829479533 +2019-05-23,193.9068199528847,30.5467557835616,35.70196326374577,71.55007633417571,58.71772268217329,43.446583539921654,96.03615033015697,130.1309948228891,97.86150846203219,98.21044098331035 +2019-05-24,188.32667300582008,29.24456135150516,40.0561950889795,70.02393089910488,58.736820791169094,48.82081253181653,90.64284229293239,129.74655241561172,98.48091499123414,102.28438647001444 +2019-05-28,185.60476115451812,27.700001827328165,44.60314732778269,61.897897295469264,53.541110172498186,43.837123266056764,93.8390903987364,140.52841512671264,108.64061795822516,94.7316279495078 +2019-05-29,179.17144818557813,33.21286669579859,40.060790163854875,70.26759454293264,58.64884422726781,28.764909023112907,100.24972188162894,129.1136747374531,108.78025592967123,96.89775934868631 +2019-05-30,184.78518149854435,19.135489480347776,46.4594064642594,71.59857821816044,58.45744070055407,43.449039612657245,97.0834851071637,125.21801967455752,102.5498559938433,102.86388153702444 +2019-05-31,188.40089097895498,24.415717008870963,37.73485725169366,64.03404471608536,56.52951886846601,39.318239762493164,104.42435755339505,138.95880140473332,102.71341642348642,94.8687151761741 +2019-06-03,180.61041343000508,33.01404410734163,41.94912679390757,57.90952160615352,58.649127007713936,42.51059946391611,107.59199516161883,136.29359855696893,102.71225398218175,106.18847729506051 +2019-06-04,191.87212459198216,31.82757390455872,44.654942124543396,65.46564708244892,62.82105347211912,29.913113066304305,95.41337171189329,130.30629527591933,102.99907226046024,99.63313550511978 +2019-06-05,189.78926402889002,36.437603290441245,45.83577695512094,65.47760949892394,65.64651250451743,35.953027876979746,93.62449570696153,132.6097287217338,98.18837643704506,96.18981782201956 +2019-06-06,191.60322883459776,24.27096946661316,50.23221526626005,65.49536416377306,71.16576102699275,38.57525764430591,104.03140090400747,136.93049637776522,103.99037616774196,93.56532385505751 +2019-06-07,195.80988312541723,20.829454400858562,48.362875129558525,68.84379976406618,63.85172491167894,39.756890544547446,84.61565342231273,135.77589747012559,104.55916727167356,97.8177270783767 +2019-06-10,196.35750632563273,26.354098895147867,52.42828524677776,64.97869057310912,65.25092818852865,54.142188026262716,92.56948094889961,133.06296348605107,101.48154432467052,100.34344319070172 +2019-06-11,203.9916017835958,34.73691455993635,33.34202215492857,67.79350550929948,74.14377649419198,37.56278309964727,98.229428541762,136.39830796093278,104.98035386734098,93.36733088827896 +2019-06-12,206.24427235921178,20.013816279037222,42.545351607598256,61.14898295633928,60.40355580454691,36.03895215152156,100.38031799930927,141.09029565545038,104.94498660282665,95.1087625720295 +2019-06-13,200.78902228096675,31.13636885187263,49.46712336936733,66.2977841966716,56.98548060462184,38.152109165660654,94.46383023321448,137.61611888523103,108.56835548797972,102.46334624315585 +2019-06-14,199.6123452283267,25.14286779696696,46.302055117335996,75.69327920419792,63.56810132546986,37.03374331629535,93.26964034289054,131.77296051974395,102.99619499381944,103.10893423359474 +2019-06-17,201.7862045788663,29.93217493716245,51.7975913385306,60.81152847033175,66.80919603611198,43.779278043444464,104.46601229302229,132.09092217619767,113.18844648234165,99.49006721145845 +2019-06-18,196.18267980403095,24.59706136856085,48.46874371671022,55.66171959507651,66.39331913654749,37.817078134876674,93.84066067451288,125.57900450407425,94.84246675944175,102.85094371524146 +2019-06-19,218.47631495639422,30.928222369028322,47.02464659570875,74.51100655250971,60.675987055832046,47.12083065357929,93.71493675648671,128.99501108194977,95.44127445339001,104.39926628052584 +2019-06-20,199.0541580597266,24.918294887615,44.811768688976656,67.15293949851329,67.90961893487697,45.3271700099788,99.74917767467734,130.39985433347343,107.88092204758894,109.67752271459051 +2019-06-21,206.03367604552858,23.781068570679977,55.10530561772211,55.33682304731064,70.73581317513671,38.61868253421366,102.44417997697398,132.15294256380926,116.01156997148216,100.77909807558045 +2019-06-24,207.4959179167147,33.56542069544623,57.98569864313809,56.41121758596202,68.41789718534372,41.10788196722675,94.87027183344661,131.69883895071527,118.24802396133741,108.80214018952691 +2019-06-25,206.01371192459249,20.714984904579737,49.71609051112287,74.21278672697845,55.94647600680926,37.575646322746735,102.34792051135861,133.80134359505612,112.34828092089336,107.40013127982255 +2019-06-26,205.21209664620918,22.947886469718846,51.318516730427056,67.67688059288149,61.46180679294645,46.50392370876868,95.48177280636595,135.02921296593914,99.59274545867319,105.93747499623242 +2019-06-27,213.2598566183733,16.714396403046095,55.05761210597231,64.17039036871012,64.15970031480475,36.33738602043162,97.64336449795614,135.09027016105676,95.03813710653009,102.76794160838725 +2019-06-28,200.52628687183372,23.008811433876534,67.37387042042954,68.78203341668124,60.26754624532673,46.154180306993055,88.0113303155639,140.11253052650102,107.64814975113447,101.7540279937896 +2019-07-01,207.9009434827341,20.101512343673946,57.657181632188625,71.05894167548064,67.61381634061496,43.05043099091725,100.06763549510005,134.62978144265668,107.57738219150342,105.08835395152215 +2019-07-02,212.25877014507756,18.082833208764477,57.72432191441439,69.00430826970836,64.38180188477207,40.7290893679599,105.09934004394246,133.83128572217157,98.74249033398544,107.99102594375974 +2019-07-03,214.3387654806658,25.972454546417318,54.278619736505554,59.25920799212409,67.15883042104943,39.482772481750466,105.82052843974104,128.7490083283263,102.72265390790757,114.85762569395615 +2019-07-05,216.42621283510988,21.906183140811894,56.946779706088094,69.14292307501837,66.67655387243235,44.57823213755154,101.3186064994411,137.038912868151,105.79733096325268,102.71205619711253 +2019-07-08,204.0283518645142,26.29886292222347,65.23184746956981,63.455707887971286,68.5705457354643,49.702856939641265,88.92722246318542,129.96127282686874,100.70389230040627,107.85119174030608 +2019-07-09,213.23050343941347,28.264109087945005,61.42825322578433,69.74593567235343,68.26662611693378,45.43003895817476,96.64281798765602,134.84576307182553,110.34370387884297,101.21475437870403 +2019-07-10,214.46327933042755,22.712279339077106,55.42052390956216,64.25732068634599,62.718211067841516,38.68355569418188,90.78365058535665,129.48633061593432,102.553866229477,98.8122176110623 +2019-07-11,209.43294005114512,33.01921666926941,53.73356645517624,66.05595933459131,63.040191049858066,38.056860831856966,97.62610744897798,132.0747482050849,98.64147480482298,104.87067157617466 +2019-07-12,215.08158856468324,22.856146343465362,51.75277172959966,71.44917239599738,57.255625860286514,43.3549995233988,101.38196448131578,135.9318929434386,106.2283620250217,108.60505346653937 +2019-07-15,209.10840263658656,20.118706805593185,55.87985087813937,74.74688510482683,52.085088598346346,47.336410130756306,96.88754740713809,129.69251666243898,104.43087916610295,98.29091526243342 +2019-07-16,215.54664001272033,34.678671439601494,59.01558874324965,68.22696247659701,67.48727414858665,50.43036747761763,102.10278042637883,126.36795107918529,108.23787213803215,104.51017300702753 +2019-07-17,219.25489561272582,17.024979230787302,53.31971642587979,66.58015366324187,66.90540178999522,41.574395637828786,102.69422963839716,137.64120841855876,108.53862737574795,101.08699236586232 +2019-07-18,223.37710030365292,25.791052390327728,56.752875654361524,62.72692089914998,70.30221717190749,48.217960265222644,111.9331461053527,138.97368974701885,108.2171988464888,108.00275950519097 +2019-07-19,207.7424851746406,26.465540486036474,64.55222622154697,59.07145270204271,66.5949607350517,37.70438792028002,97.35256665952383,130.49839814948956,95.98567878895142,101.61683540807391 +2019-07-22,224.2245889696937,28.793317987719398,48.782518938413936,66.88628428815281,59.63929713516759,40.74038789019339,100.08066075050884,127.97477758970344,116.18287403254882,107.90746414894991 +2019-07-23,223.98508595846783,22.20689131232725,60.48439825947203,69.26601183827844,74.43113731114428,37.57989120420641,105.99744189413215,132.21376055594774,97.56263313199574,99.81270262510701 +2019-07-24,205.73135475476965,21.736874922458824,62.5211682560962,58.68323262010489,54.85305979570624,35.93087606315573,96.22184697350961,131.5148454280639,98.87315364098316,107.59338113684008 +2019-07-25,215.72148253754102,15.27598960421842,55.26568429831601,65.53842004376162,61.807292784090876,40.708942822012105,99.05484336013228,127.26946470178027,95.01729186035062,113.55450237534546 +2019-07-26,216.5888430702963,26.059864990555496,55.160983774252614,65.44275518707683,66.25927262867364,49.847565286249655,110.39764776659143,131.42173536850757,98.39223473832246,109.36942431802137 +2019-07-29,211.01807792640855,31.8174775866573,55.46911414957569,64.87268854323077,74.38157744166381,44.039382355265545,97.90171591164997,129.5810987240568,101.60198843396367,112.40195643437056 +2019-07-30,215.8444865139831,23.239836232571907,63.954667679899885,70.48041404348824,68.71244275507529,33.72824311927286,103.46314596466948,129.0376827892151,94.10811311943324,101.37171854903175 +2019-07-31,215.88829429491784,29.619316584059895,48.040417265734504,61.812299048353495,63.25269326761172,37.167071581542466,92.96093324399918,130.98675394397236,104.01931376927821,110.29373675825231 +2019-08-01,225.61401836231772,29.056186339365414,50.368793901367425,63.539552574397476,64.98694613356878,43.038492619204256,94.41406381234553,135.67858482902795,111.72509062372532,107.22064111815371 +2019-08-02,210.2992212037638,22.309490878238716,52.09839912039351,75.84064217908693,69.30218579012451,35.663406305247406,98.47609030678625,130.72033214141175,113.18777447036564,100.93114385078174 +2019-08-05,203.9753988441185,30.972160547171562,54.06503728623863,58.23555870932855,63.64094854865145,44.06894200482723,106.01864496191789,127.47597488676335,106.3325711393504,106.44732003966908 +2019-08-06,207.29733013007,34.94573362793752,61.810563567561566,60.054324284929315,66.61287144176737,46.22116142129043,98.1753350748809,135.47382620500906,103.984137750891,111.63552154625143 +2019-08-07,209.40649696869693,27.231250466458597,55.86842244425079,58.49995348335675,68.71902354679202,38.79004212750669,100.91653290892654,128.86076635285048,104.7512554403586,106.84045179549553 +2019-08-08,209.59812506995547,24.37044612344884,63.186674122861454,66.2785978842748,65.42027684227341,41.27320144730399,97.15078344554632,135.63541114753423,105.82250723254427,110.68220969961251 +2019-08-09,206.71282748128985,29.019391860549025,71.82813234054203,59.44491682788167,68.6126152873403,36.624292408829554,94.54564011138025,125.43187260091673,106.06289894449178,104.05762408188714 +2019-08-12,215.06674973634327,30.427057307753152,68.68822570430656,62.76819082224238,68.44733889871696,46.63336242020485,100.70426259921312,129.23475783492088,106.96864768894983,101.1973656303971 +2019-08-13,220.82281772444352,34.17195615822167,65.06987338193704,64.62146649593409,74.0035788826924,48.228053239746004,97.44010876973667,121.0881526039449,96.42216169515183,111.39947071228562 +2019-08-14,207.03203326588763,29.43856659997814,62.05668349085869,59.04159809130284,57.700300169509354,48.054827880415175,94.23866841107787,123.82831390854682,102.63286645194401,112.00998341954025 +2019-08-15,209.25335710763667,25.99664205079998,66.52222564461572,72.19828032423794,71.75335670296181,41.22884886531072,101.70715815229478,134.84318526099034,107.0111186928918,111.06512848949863 +2019-08-16,219.52015235965328,23.803127071701624,64.01631768661032,64.50905697726058,60.92070097614946,38.35857958855911,96.63899860150325,133.15325422173296,102.52578361380402,110.03043013033168 +2019-08-19,224.4141407294334,20.264326523135345,61.86433588496077,74.27701170981356,63.49232293926469,43.05660397057025,104.19096765462503,131.36421085363793,107.22081254131406,112.34577983704176 +2019-08-20,221.55103747283664,29.915700162252,75.51972114145305,53.956827664751614,69.08318735944327,43.96491146144088,107.57446588905366,125.7568207500984,114.27973206832739,115.91922193029703 +2019-08-21,217.20970083110277,24.607218034393824,71.64316602750124,63.59566865879994,77.64357851013216,42.89150870968378,98.09155727379556,130.40691845362446,105.62757951138012,110.47796017303992 +2019-08-22,229.66570405019309,23.664640998511103,82.0947335057011,59.770845989295665,64.60549713937239,41.58491491869728,100.54284232223486,120.0314186732794,108.85053262043735,110.6129924569814 +2019-08-23,211.04919148636503,24.282560093430924,73.67993395796404,59.16269498955327,68.22349043239142,52.708386430322506,96.66522871572744,126.31967375179391,106.63084242848095,107.4755439707724 +2019-08-26,213.24364822723456,28.73501574551984,77.93406322326784,62.74013009473168,71.04059186111466,48.15208394169632,99.66935681461642,133.6723611370259,100.75459185879139,110.9292453898668 +2019-08-27,209.32471993534773,21.486350174858043,75.28239178296066,53.41934968775681,68.06071555784176,46.30528824777823,106.29776678396708,127.1545295091253,110.59272884197131,105.77334813096813 +2019-08-28,211.94123293842563,25.991316458936893,72.3869693004949,67.19642555832361,68.67823481169485,47.06640304697704,100.10536820464492,125.93909162868302,98.01431824070858,115.84620177471338 +2019-08-29,215.2800332857011,24.806589404885948,77.94277846612219,63.64173525204364,72.41287139693824,44.73058708328543,94.58969324222605,129.90417468108387,106.61529075725763,107.89213833918866 +2019-08-30,217.53755623811145,18.01344065180315,75.88168261861748,67.68261260821282,67.66158908985248,44.47252516623921,102.11015310627313,133.42612933280836,106.88771386527259,119.36339886189144 +2019-09-03,216.55569146352403,26.653423354337868,83.38050284688958,69.87828543255205,62.272526820208896,48.24735132769162,106.50147834288319,134.89847919884465,108.95494832329098,102.3723777682493 +2019-09-04,214.237911239292,26.883525029610936,82.42109038214113,65.24753057640002,60.40206122028185,49.13986513422951,96.9278311298681,133.47685226041799,104.1512383015513,110.46537288431942 +2019-09-05,224.73048589634433,25.467129674641708,76.98731833462817,58.89560949052115,67.28803959924304,50.44831030610046,93.96648784582274,136.99387643019122,102.69387333781867,100.18168243234074 +2019-09-06,221.1938742338896,29.75206094969213,78.39158913657565,66.50912791743235,69.33232210210883,38.02919365356799,99.53649033833463,139.399760301271,102.90624739373229,109.45884906509394 +2019-09-09,229.62321954629502,21.815261989016463,77.62876591060036,74.10138409445227,66.17920431601242,43.69167504062598,98.27723087615836,136.18967981598283,102.35457767005853,106.62999052124034 +2019-09-10,220.9073174198566,31.731512834254623,82.68838810955859,80.3260204431714,66.56035671166745,48.07644923573733,101.56607763285191,125.38834625196861,107.68338174962491,101.14790413303515 +2019-09-11,238.90617964808263,30.622453372549135,83.73657018297398,73.19571944454445,73.00569321112593,46.56792749297682,98.50862524956965,123.90461528249958,110.92193676041087,116.11635395304339 +2019-09-12,231.57278703713902,39.968732598226225,86.25599826329669,65.19817030120684,74.42481382186001,50.01277936389567,99.17025170973977,129.64157945142207,99.44951323018171,112.17859242187986 +2019-09-13,223.1261290346548,26.75276641854593,85.14976639081591,75.91426901551232,64.13867292765654,46.802670818423806,91.93705344425454,137.38091758692968,94.45605404979173,107.72073693798927 +2019-09-16,223.25533478579146,34.716376504575294,83.5343204693233,64.3221247544422,72.17919665583473,38.49527702460437,101.04831215441432,130.3393805263021,110.91283132067865,108.02676362572845 +2019-09-17,229.1425691825125,28.905567500604093,87.94178494628738,72.65254323386469,62.77064966023631,47.54713573799105,103.69075590343331,128.2369094171562,92.9249403572581,109.79501652957136 +2019-09-18,241.61898476052352,30.854213452470574,81.61275513776106,73.1863528105179,62.27416365435268,49.64234011813801,95.80329201434566,137.2562444000436,109.01447572537987,106.22692111061261 +2019-09-19,231.58548731001878,20.60358303361612,82.17001718085928,67.70846931225074,75.46242675966171,47.1067164164797,92.00599853450821,131.50111820198993,103.00511832470796,105.85310790203931 +2019-09-20,231.21840399963574,21.402580729375302,87.703065102908,70.08606687877925,67.88743242449748,45.027757451156425,100.76852872193622,129.31187955911807,103.35997122844215,111.38593476528288 +2019-09-23,234.12517106974042,29.518203098864955,83.23156210627704,68.41234708022127,79.23724193920484,44.5378213468296,104.13650836200989,138.4071639817792,108.27042025824025,114.61361896445048 +2019-09-24,224.32426833682698,22.31486642307426,75.68825679241044,61.21133434312488,74.32270692842557,39.6529464553564,103.52623406091521,130.08500430880792,100.71579752054626,102.48433275835738 +2019-09-25,229.39268049349343,28.994058096639257,85.98715734554159,69.28419915235634,76.56642303828446,46.210161210103834,99.71421887427485,133.10722190064027,99.75512046993529,108.12151582786211 +2019-09-26,229.81679751970862,24.653573372831872,76.56013761342922,64.49006483029243,70.06957763939668,45.714997447109596,99.87809115044601,130.05219114102775,107.76107246209772,115.20396050081555 +2019-09-27,232.98520650474165,21.92702749235481,85.18997923682579,70.45578163547171,69.81872124613542,44.3060125738877,90.59643413876832,117.8739695845313,102.39192045692717,112.05058253724765 +2019-09-30,235.22943799779497,25.551767087481462,89.01495121602913,68.71189968181405,72.0027323367339,47.03146054969654,94.13127762495954,129.79631654772658,104.48862565168064,108.88171681724528 +2019-10-01,234.3135935809797,31.26535143183405,83.45937113828006,63.56814283082023,73.68271939210369,49.38256630451535,102.24093273192672,138.62124735870665,107.11963883361415,104.07981496206948 +2019-10-02,238.2250502821418,30.06928497706624,76.25776559148589,75.09133298748053,75.49753617957738,41.75183453595785,90.62781919143218,133.19602931620958,102.81869192446285,105.53059058408094 +2019-10-03,233.24578408176473,36.062179646788046,82.57710486382842,71.06755856376716,74.19193943407045,47.698367878113764,99.73332259613139,129.8259826919852,104.27795538704041,118.7130497808001 +2019-10-04,238.68299261729243,24.50404144662494,89.90629711908785,64.1846090324501,74.7046939081344,42.22883213524462,96.37723991892797,124.29926305022384,101.20918896230222,118.43829397861242 +2019-10-07,234.28220763651814,30.896900561130956,81.29667472488288,74.71964444924801,75.21551227236219,48.39132586751848,97.99101258858559,128.46115797698113,105.99366934825042,114.10296682531731 +2019-10-08,228.55490778173132,22.756085329737438,82.73134747558875,70.10260956769756,66.51723464201402,46.264970174990125,103.12401032617743,127.86364964209696,108.16885050063759,105.06877110658921 +2019-10-09,243.69313205813995,32.87241478997155,85.5537891415505,67.35626987979795,72.47122605507018,44.93648292799322,101.63146066036201,127.45986169196162,93.4535121892098,109.1968224054853 +2019-10-10,237.37166667188364,31.6548936478227,82.65505495107323,69.52346443180737,74.6967132082158,41.552431335975164,96.07474138097362,125.56620127756133,99.53128477587286,104.56591360263661 +2019-10-11,246.74122336721626,34.39672030868398,93.35256667202063,66.96882639379417,71.7682414868426,50.109572533979225,88.27264111588524,133.0348099071908,104.59713369587752,112.63208611543286 +2019-10-14,244.08672115503543,27.476538745923047,84.32702843034171,66.89196856537536,65.97972902113025,51.98177684921119,91.74573856179705,134.37315999478585,109.16508686792218,102.63649428967307 +2019-10-15,240.74121100628003,27.820397686971006,95.2563724097851,70.70566001390783,68.3648494579063,48.66898251948636,103.63372289961107,136.69425572618297,106.3935231959576,106.52783360477092 +2019-10-16,248.8943376209241,36.81140712602739,86.97752950536314,66.58268810773751,68.73189640077291,49.766596166937326,98.71581853872046,133.4044959692768,104.16878024570335,108.67653370236205 +2019-10-17,252.4979987204387,18.614299300082596,87.94454625853895,65.58842447925484,67.98199967773756,48.29611701484961,94.82688218050886,130.73416357944936,110.13327263509521,113.68524873167459 +2019-10-18,244.53499349121788,30.669119678572248,79.43653586983616,71.67222028587759,67.09814138736354,48.50955474269679,104.59374316267055,139.134154485775,108.64736473561923,110.62714604154587 +2019-10-21,256.5590693511978,41.59414903422517,89.16566616534307,79.48586600240725,74.4780319145615,51.294647540107405,96.56473797293665,138.02990800821766,103.25234318697376,113.30951585019582 +2019-10-22,256.80520356869545,30.31115426983762,97.09770225363712,70.25715849076964,71.12379543827055,51.996450815940435,102.88549863159403,130.3910383365257,101.24162041874402,114.94981952885567 +2019-10-23,254.64601437585026,34.40710020805658,101.75924984531828,72.09322669946002,68.49287232389895,49.47879710537459,91.46694068076214,130.6879085306665,106.05471136593532,117.19854976263593 +2019-10-24,244.37910518099986,35.267837969743375,104.57182775207642,61.41415548316677,77.05749839909126,46.07069942629345,95.77872133509783,134.49648762812345,112.20330993618681,107.54700896390881 +2019-10-25,249.78801135413974,35.2138156178244,105.01423814497933,65.00693292227943,67.66615860582088,41.33104162822816,95.47545538561108,136.44771029347584,102.53580800567612,109.96621185820115 +2019-10-28,268.9169277181278,36.22966717170656,107.47468312860961,63.20170383564578,78.6037277091946,49.578172170415456,95.11508376752715,133.37844466493416,102.37875392346554,107.92902037376979 +2019-10-29,259.28062859691926,41.07453290075113,103.38376553587952,72.37828767561882,64.37452100998033,39.65201185809703,94.50364401919286,129.92712643945723,99.04211775811093,109.88083536384629 +2019-10-30,257.61734083497396,29.033265175106628,94.88009060268108,72.54324899829022,71.45499874485758,45.71310217163888,101.50114724609173,129.43352378677253,98.08667451354307,105.8691441361714 +2019-10-31,256.6268139144784,30.564967482164874,86.91017579489022,68.34512285940302,68.22669661024754,46.58790082188795,96.38043144139606,136.01993703365008,105.41247880058243,107.44234011277098 +2019-11-01,262.77150801059247,31.260985251836406,89.3795425001334,68.53380358217738,65.31784765862575,53.115250612344596,96.57710976973735,135.7758632561192,100.88539339710007,109.62980334528814 +2019-11-04,272.31574294594066,19.977856447731533,96.9877721585032,68.0961021307836,72.7236687987092,52.9198837801199,91.19433938867967,131.90645850003264,103.03475232030317,108.72534671632896 +2019-11-05,263.6522034427696,26.31654420561367,91.54658007933685,73.09443766776859,60.60378864381508,42.102290597042845,100.58863238459841,140.62758128414166,109.22060153250071,108.55473186427909 +2019-11-06,265.92806086968255,36.39577527252469,92.63258071050144,68.90996306807709,71.86650344337794,43.5091380815827,97.59852337826483,132.2221447998272,99.52910292691048,103.10503613463528 +2019-11-07,268.3258658497451,31.084033846983314,87.28431167151497,61.534789622919774,68.56712515147187,47.44402856043286,87.03224953142357,128.81887270102644,103.9476235228037,99.35218742134076 +2019-11-08,266.19907249798405,35.74583976144328,99.84043737686257,73.20672400318975,63.242929648216986,49.77469178051282,100.26670422923924,136.9352178909125,103.90541908545993,106.25392278303322 +2019-11-11,282.983719579264,36.30916830370974,104.026764976334,63.670260856479445,70.72100731763791,46.520142074369865,97.87557048203661,131.2094355174088,95.80517472713099,101.33116503961826 +2019-11-12,273.33640296436863,41.152927898913404,100.78388674746495,67.4900738473827,66.1697670635366,61.0241657331725,86.17372868118439,134.4285150771358,108.23273135571277,108.3339995331872 +2019-11-13,276.5513070633409,25.819803525399116,94.35547497989776,71.37676281803392,73.63612311775114,45.89613968721351,107.87546874112394,140.4788839306723,97.78852275772627,118.81374425270504 +2019-11-14,271.2668171949527,36.06492045198632,90.29267852554348,63.17792697077519,73.82711138590258,45.02062962938793,90.04675416717056,130.16706662563942,99.1507544444473,115.74739913787434 +2019-11-15,278.62396099965355,32.608829340877456,106.07957303697256,67.51727846291665,65.68682690637098,44.394876550319374,95.71393109798115,134.58697825914558,103.17677523558812,115.89388141965516 +2019-11-18,279.406317237863,33.185887078410644,96.2451456560459,71.91841821614719,74.38173446429721,47.75978473752637,94.98520704007197,139.17107201205872,107.2701745994447,114.21660446009342 +2019-11-19,273.2466844802886,32.12397547545204,93.86640260468224,78.52154591658191,76.3760893668867,48.43052430705255,95.81567783645599,135.296526684382,92.64290343534284,112.33994033011224 +2019-11-20,273.13839868322157,34.86450134745509,107.53902069312315,65.97161703138018,70.66007559532858,46.41102545623943,96.40677838488466,127.1544658585043,102.27620362689811,111.18391034134389 +2019-11-21,263.7169286709213,31.148583966592163,99.89857134797275,70.36492079016897,75.03025515383486,50.64769070853572,96.63524103369971,139.15078702549317,99.75049576856195,103.18531800350392 +2019-11-22,271.1700550024832,42.31976030068296,101.26604784417344,72.19610898437416,70.75688531072211,43.737620892248245,101.88427476250634,137.47929192911332,103.03320186468983,110.31228589008239 +2019-11-25,285.4754627344678,33.41252483876979,95.16495064461212,68.03200817768266,66.61319262432933,52.57089162053997,89.11436196765423,133.3437147280247,104.59686323661374,115.77312186959479 +2019-11-26,267.7786269232061,34.36035333389458,90.21071523277594,75.54226093862235,73.35058603219801,48.30309214278155,97.06252051393194,134.60125210591565,102.0671476194193,104.08604826883453 +2019-11-27,275.9253304044948,30.35173019812574,103.35841199730517,71.62088289487842,58.27594667385235,44.14420857976997,99.26479417470225,129.6995063012488,100.5694476595858,100.96033321427413 +2019-11-29,273.74193714287014,32.98538245282543,93.12587489478324,63.11165976501972,76.89717022330692,50.32994994882353,94.79667728949774,142.37912118735002,107.60745636731173,105.0201722269076 +2019-12-02,274.85357943056965,24.99965369014281,96.27042256313999,65.87890918016485,82.55945635955453,52.846886124729224,97.95913136467263,135.83483837858387,102.695122052823,111.07794485085886 +2019-12-03,257.48822526170056,34.79484477965042,84.38984355215707,73.25164010866996,69.64760638934209,52.90624766633961,95.09092942580787,129.76910006142654,101.15080423432279,111.72052505299115 +2019-12-04,265.1955865862269,35.718979001489615,85.5572085346987,75.15499824833128,72.08883215118726,49.69759485278547,98.26788724418404,143.11672747466812,107.31618565429469,117.73538470351049 +2019-12-05,279.289490647791,32.85372598820975,97.67100060946876,63.45584897150039,78.00912462997528,42.6641123000804,95.04092064934095,138.84537540217815,104.42687772894718,111.20514756307529 +2019-12-06,274.4054382971357,27.525271320693772,89.1161498227477,62.58643665702283,66.42028315139648,47.489815109849225,96.60276244007562,135.90586358895445,106.70942006821475,111.7120105109465 +2019-12-09,281.10792910415273,36.70961010419871,95.50000888457878,69.20232435213715,69.76710163281682,52.08326715902058,100.54936085061256,138.41126068059765,116.29528630169736,113.81446896075558 +2019-12-10,281.2269007722871,29.828275460003695,96.55774408312845,75.14523232379801,62.11228412704391,45.60561397678747,96.5805111875936,138.531396205944,102.45763607303532,101.88676628809178 +2019-12-11,278.51982682580774,33.848443006768754,89.54499958710161,71.83447527356049,80.61408504496154,43.018392539710696,90.9215479001903,146.87723457456156,102.76487642812977,109.00077240177716 +2019-12-12,281.0925711651109,39.15103140137774,95.05291999856075,78.45825720748164,66.47914334704105,44.531681432080106,88.75423777301496,139.38825413081238,103.62540852147151,108.78369702887211 +2019-12-13,285.51919664478135,33.40871322034952,84.70725995422518,77.2510252979688,65.82170338809098,45.35054669444524,101.11112818626255,136.46829371302425,105.22588851845357,119.98767493025007 +2019-12-16,291.28578010064155,37.896702158874504,96.72601295419969,70.79504864044196,72.67414359306457,43.02667709561093,102.86039759234743,127.12573974631951,110.98456511199086,115.9323488490374 +2019-12-17,294.63450463813285,32.633721746312155,92.63638286096858,66.6629450711525,68.59049335808643,57.39854475130564,94.1241060715059,132.5347612954111,104.590476247993,108.08780397221418 +2019-12-18,284.16605862595895,37.19880712179088,93.2754614708754,76.61680896502335,70.93817552880985,46.93380389904282,97.88359159709859,132.29409588472978,109.20686653570957,106.4193399833346 +2019-12-19,293.6749972181246,36.270850356366424,90.67276484505715,63.449058847466226,68.63093695036768,52.824934890617676,92.58536914861801,128.69674927047356,100.51512655929041,98.04845404896976 +2019-12-20,295.1979307712716,28.127206820865915,92.64715636502751,73.15138775143765,75.43680143563193,49.654497498908924,96.683730907386,138.8009548089142,105.70537448600388,117.67303110709751 +2019-12-23,293.78716770260394,32.837929589134504,93.5906623799985,79.26155869535691,72.73546337681366,45.26587221840012,95.31272191622777,134.51416271289278,108.01501622924306,107.17489900537176 +2019-12-24,294.8307740927948,25.0499595866208,88.48503367003153,67.7461498302673,82.43608548821021,47.72584440398731,91.7102688869326,140.04875351348932,102.68850456455338,119.27974760006319 +2019-12-26,293.21039619603863,23.50413071006355,97.90844493163114,69.58499637318262,72.93654045371062,53.63786012216126,96.89065669119692,142.16213710532745,102.07838988468322,111.56127185142648 +2019-12-27,292.05825472330065,36.297660013974415,93.98756210441375,71.30359752746318,64.66875692257159,50.2498058458058,98.17051068594257,139.60033471883233,110.32580497700508,104.8351461803715 +2019-12-30,308.27167530357247,35.358857804092615,91.15458457743429,67.51690205603202,77.45551458501133,49.31236278310409,100.48270613505615,134.63886049872937,107.94403825804204,108.3856118293109 +2019-12-31,306.9370925458821,33.77125146124297,105.74231132979307,69.84617534337268,69.00071081204784,52.53992091092047,93.92010576828191,142.7751476336534,106.93398175138363,113.29051700662593 diff --git a/gQuant/plugins/hrp_plugin/setup.py b/gQuant/plugins/hrp_plugin/setup.py new file mode 100644 index 00000000..f87b7561 --- /dev/null +++ b/gQuant/plugins/hrp_plugin/setup.py @@ -0,0 +1,30 @@ +""" + //////////////////////////////////////////////////////////////////////////// + // + // Copyright (C) NVIDIA Corporation. All rights reserved. + // + // NVIDIA Sample Code + // + // Please refer to the NVIDIA end user license agreement (EULA) associated + // with this source code for terms and conditions that govern your use of + // this software. Any use, reproduction, disclosure, or distribution of + // this software and related documentation outside the terms of the EULA + // is strictly prohibited. + // + //////////////////////////////////////////////////////////////////////////// +""" + +from setuptools import setup, find_packages + +setup( + name='greenflow_hrp_plugin', + install_requires=[ + "matplotlib", "shap" + ], + packages=find_packages(include=['greenflow_hrp_plugin']), + entry_points={ + 'greenflow.plugin': [ + 'investment_nodes = greenflow_hrp_plugin', + ], + } +) diff --git a/gQuant/plugins/hrp_plugin/tests/unit/__init__.py b/gQuant/plugins/hrp_plugin/tests/unit/__init__.py new file mode 100644 index 00000000..99001463 --- /dev/null +++ b/gQuant/plugins/hrp_plugin/tests/unit/__init__.py @@ -0,0 +1,16 @@ +""" + //////////////////////////////////////////////////////////////////////////// + // + // Copyright (C) NVIDIA Corporation. All rights reserved. + // + // NVIDIA Sample Code + // + // Please refer to the NVIDIA end user license agreement (EULA) associated + // with this source code for terms and conditions that govern your use of + // this software. Any use, reproduction, disclosure, or distribution of + // this software and related documentation outside the terms of the EULA + // is strictly prohibited. + // + //////////////////////////////////////////////////////////////////////////// +""" + diff --git a/gQuant/plugins/hrp_plugin/tests/unit/test_bootstrap.py b/gQuant/plugins/hrp_plugin/tests/unit/test_bootstrap.py new file mode 100644 index 00000000..b932ab19 --- /dev/null +++ b/gQuant/plugins/hrp_plugin/tests/unit/test_bootstrap.py @@ -0,0 +1,62 @@ +""" + //////////////////////////////////////////////////////////////////////////// + // + // Copyright (C) NVIDIA Corporation. All rights reserved. + // + // NVIDIA Sample Code + // + // Please refer to the NVIDIA end user license agreement (EULA) associated + // with this source code for terms and conditions that govern your use of + // this software. Any use, reproduction, disclosure, or distribution of + // this software and related documentation outside the terms of the EULA + // is strictly prohibited. + // + //////////////////////////////////////////////////////////////////////////// +""" + +#!/usr/bin/env python +# -*- coding: utf-8 -*- + +''' +python -m unittest tests/unit/test_bootstrap.py -v +''' +import unittest +import cupy +from greenflow_hrp_plugin.kernels import boot_strap + + +class TestBootstrap(unittest.TestCase): + + def setUp(self): + pass + + def test_bootstrap(self): + number_samples = 2 + block_size = 2 + number_of_threads = 256 + length, assets = (6, 2) + ref = cupy.array([[1.0, 2.0], [2.0, 3.0], [3.0, 4.0], [4.0, 5.0], + [5.0, 6.0]]) + output = cupy.zeros((number_samples, assets, length)) # output results + num_positions = ( + length - 2 + ) // block_size + 1 + # number of positions to sample to cover the whole seq length + # sample starting position, exclusive + sample_range = length - block_size + print('price_len', length, 'sample range', sample_range) + sample_positions = cupy.array([0, 1, 2, 3, 2, 1]) + number_of_blocks = len(sample_positions) + boot_strap[(number_of_blocks,), (number_of_threads,)]( + output, + ref.T, + block_size, + num_positions, + sample_positions) + truth0 = cupy.array([[0., 1., 2., 2., 3., 3.], + [0., 2., 3., 3., 4., 4.]]) + truth1 = cupy.array([[0., 4., 5., 3., 4., 2.], + [0., 5., 6., 4., 5., 3.]]) + self.assertTrue(cupy.allclose(truth0, output[0])) + self.assertTrue(cupy.allclose(truth1, output[1])) + print(output) diff --git a/gQuant/plugins/hrp_plugin/tests/unit/test_distance.py b/gQuant/plugins/hrp_plugin/tests/unit/test_distance.py new file mode 100644 index 00000000..6edda559 --- /dev/null +++ b/gQuant/plugins/hrp_plugin/tests/unit/test_distance.py @@ -0,0 +1,124 @@ +""" + //////////////////////////////////////////////////////////////////////////// + // + // Copyright (C) NVIDIA Corporation. All rights reserved. + // + // NVIDIA Sample Code + // + // Please refer to the NVIDIA end user license agreement (EULA) associated + // with this source code for terms and conditions that govern your use of + // this software. Any use, reproduction, disclosure, or distribution of + // this software and related documentation outside the terms of the EULA + // is strictly prohibited. + // + //////////////////////////////////////////////////////////////////////////// +""" + +#!/usr/bin/env python +# -*- coding: utf-8 -*- + +''' +python -m unittest tests/unit/test_distance.py -v +''' +import unittest +import pandas as pd +import cupy +import cudf +from greenflow_hrp_plugin.kernels import _get_log_return_matrix +from greenflow_hrp_plugin.kernels import _get_month_start_pos +from greenflow_hrp_plugin.kernels import compute_cov, MAX_YEARS +from scipy.spatial.distance import squareform +import math + + +class TestDistance(unittest.TestCase): + + def create_df(self): + date_df = cudf.DataFrame() + date_df['date'] = pd.date_range('1/1/1990', '12/31/1991', freq='B') + full_df = cudf.concat([date_df, date_df]) + sample_id = cupy.repeat(cupy.arange(2), len(date_df)) + full_df['sample_id'] = sample_id + full_df['year'] = full_df['date'].dt.year + full_df['month'] = full_df['date'].dt.month-1 + cupy.random.seed(3) + full_df[0] = cupy.random.rand(len(full_df)) + full_df[1] = cupy.random.rand(len(full_df)) + full_df[2] = cupy.random.rand(len(full_df)) + return full_df + + def setUp(self): + self.df = self.create_df() + + def test_months_start(self): + log_return = self.df + first_sample = log_return['sample_id'].min().item() + all_dates = log_return[first_sample == log_return['sample_id']]['date'] + months_start = _get_month_start_pos(all_dates) + print(type(months_start)) + + self.assertTrue(months_start[0].item() == 0) + for i in range(1, len(months_start)): + start_day_month = log_return.iloc[months_start[i].item( + )]['date'].dt.month + last_day_month = log_return.iloc[( + months_start[i].item()-1)]['date'].dt.month + diff = start_day_month.values[0] - last_day_month.values[0] + self.assertTrue(abs(diff) != 0) + + def test_distance(self): + total_samples = 2 + window = 6 + log_return = self.df + first_sample = log_return['sample_id'].min().item() + all_dates = log_return[first_sample == log_return['sample_id']]['date'] + months_start = _get_month_start_pos(all_dates) + log_return_ma = _get_log_return_matrix(total_samples, log_return) + _, assets, timelen = log_return_ma.shape + number_of_threads = 256 + num_months = len(months_start) - window + number_of_blocks = num_months * total_samples + means = cupy.zeros((total_samples, num_months, assets)) + cov = cupy.zeros((total_samples, num_months, assets, assets)) + distance = cupy.zeros( + (total_samples, num_months, (assets - 1) * assets // 2)) + + compute_cov[(number_of_blocks, ), (number_of_threads, ), 0, + 256 * MAX_YEARS * 8](means, cov, distance, log_return_ma, + months_start, num_months, assets, + timelen, window) + print('return shape', log_return_ma.shape) + num = 0 + for sample in range(2): + for num in range(num_months): + truth = ( + log_return_ma[sample, :, months_start[num]:months_start[ + num + window]].mean(axis=1)) + compute = means[sample][num] + self.assertTrue(cupy.allclose(compute, truth)) + + for sample in range(2): + for num in range(num_months): + s = log_return_ma[sample, :, months_start[num]:months_start[ + num + window]] + truth = (cupy.cov(s, bias=True)) + compute = cov[sample][num] + self.assertTrue(cupy.allclose(compute, truth)) + + for sample in range(2): + for num in range(num_months): + cov_m = cov[sample][num] + corr_m = cov_m.copy() + for i in range(3): + for j in range(3): + corr_m[i, j] = corr_m[i, j] / \ + math.sqrt(cov_m[i, i] * cov_m[j, j]) + dis = cupy.sqrt((1.0 - corr_m)/2.0) + res = cupy.zeros_like(dis) + for i in range(3): + for j in range(3): + res[i, j] = cupy.sqrt( + ((dis[i, :] - dis[j, :])**2).sum()) + truth = (squareform(res.get())) + compute = distance[sample][num] + self.assertTrue(cupy.allclose(compute, truth)) diff --git a/gQuant/plugins/hrp_plugin/tests/unit/test_hrp_weight.py b/gQuant/plugins/hrp_plugin/tests/unit/test_hrp_weight.py new file mode 100644 index 00000000..12bebe74 --- /dev/null +++ b/gQuant/plugins/hrp_plugin/tests/unit/test_hrp_weight.py @@ -0,0 +1,106 @@ +""" + //////////////////////////////////////////////////////////////////////////// + // + // Copyright (C) NVIDIA Corporation. All rights reserved. + // + // NVIDIA Sample Code + // + // Please refer to the NVIDIA end user license agreement (EULA) associated + // with this source code for terms and conditions that govern your use of + // this software. Any use, reproduction, disclosure, or distribution of + // this software and related documentation outside the terms of the EULA + // is strictly prohibited. + // + //////////////////////////////////////////////////////////////////////////// +""" + +#!/usr/bin/env python +# -*- coding: utf-8 -*- + +''' +python -m unittest tests/unit/test_hrp_weight.py -v +''' +import unittest +import cupy +from greenflow_hrp_plugin.kernels import HRP_weights +import numpy as np +import pandas as pd + + +def compute_HRP_weights(covariances, res_order): + weights = pd.Series(1, index=res_order) + clustered_alphas = [res_order] + + while len(clustered_alphas) > 0: + clustered_alphas = [cluster[start:end] for cluster in clustered_alphas + for start, end in ((0, len(cluster) // 2), + (len(cluster) // 2, len(cluster))) + if len(cluster) > 1] + for subcluster in range(0, len(clustered_alphas), 2): + left_cluster = clustered_alphas[subcluster] + right_cluster = clustered_alphas[subcluster + 1] + + left_subcovar = covariances[left_cluster, :][:, left_cluster] + inv_diag = 1 / cupy.diag(left_subcovar) + parity_w = inv_diag * (1 / cupy.sum(inv_diag)) + left_cluster_var = cupy.dot( + parity_w, cupy.dot(left_subcovar, parity_w)) + + right_subcovar = covariances[right_cluster, :][:, right_cluster] + inv_diag = 1 / cupy.diag(right_subcovar) + parity_w = inv_diag * (1 / cupy.sum(inv_diag)) + right_cluster_var = cupy.dot( + parity_w, cupy.dot(right_subcovar, parity_w)) + + alloc_factor = 1 - left_cluster_var / \ + (left_cluster_var + right_cluster_var) + + weights[left_cluster] *= alloc_factor.item() + weights[right_cluster] *= 1 - alloc_factor.item() + + return weights + + +class TestHRPWeight(unittest.TestCase): + + def setUp(self): + self.assets = 10 + self.samples = 5 + self.numbers = 30 + seq = 100 + cupy.random.seed(10) + self.cov_matrix = cupy.zeros( + (self.samples, self.numbers, self.assets, self.assets)) + self.order_matrix = cupy.random.randint( + 0, self.assets, (self.samples, self.numbers, self.assets)) + for i in range(self.samples): + for j in range(self.numbers): + cov = cupy.cov(cupy.random.rand(self.assets, seq)) + self.cov_matrix[i, j] = cov + order = cupy.arange(self.assets) + cupy.random.shuffle(order) + self.order_matrix[i, j] = order + + def test_order(self): + num_months = self.numbers + total_samples = self.samples + assets = self.assets + + number_of_threads = 1 + + number_of_blocks = num_months * total_samples + + weights = cupy.ones((total_samples, num_months, assets)) + + HRP_weights[(number_of_blocks,), (number_of_threads,)]( + weights, + self.cov_matrix, + self.order_matrix, + assets, + num_months) + for i in range(self.samples): + for j in range(self.numbers): + cpu_weights = compute_HRP_weights( + self.cov_matrix[i][j], self.order_matrix[i][j].get()) + cpu_weights = cpu_weights[range(self.assets)].values + self.assertTrue(np.allclose(cpu_weights, weights[i][j].get())) diff --git a/gQuant/plugins/hrp_plugin/tests/unit/test_leverage.py b/gQuant/plugins/hrp_plugin/tests/unit/test_leverage.py new file mode 100644 index 00000000..c9bb922f --- /dev/null +++ b/gQuant/plugins/hrp_plugin/tests/unit/test_leverage.py @@ -0,0 +1,138 @@ +""" + //////////////////////////////////////////////////////////////////////////// + // + // Copyright (C) NVIDIA Corporation. All rights reserved. + // + // NVIDIA Sample Code + // + // Please refer to the NVIDIA end user license agreement (EULA) associated + // with this source code for terms and conditions that govern your use of + // this software. Any use, reproduction, disclosure, or distribution of + // this software and related documentation outside the terms of the EULA + // is strictly prohibited. + // + //////////////////////////////////////////////////////////////////////////// +""" + +#!/usr/bin/env python +# -*- coding: utf-8 -*- + +''' +python -m unittest tests/unit/test_leverage.py -v +''' +import unittest +import pandas as pd +import cupy +import cudf +from greenflow_hrp_plugin.kernels import _get_log_return_matrix +from greenflow_hrp_plugin.kernels import _get_month_start_pos +from greenflow_hrp_plugin.kernels import leverage_for_target_vol, MAX_YEARS +import math + + +class TestDistance(unittest.TestCase): + + def create_df(self): + date_df = cudf.DataFrame() + date_df['date'] = pd.date_range('1/1/1990', '12/31/1991', freq='B') + full_df = cudf.concat([date_df, date_df]) + sample_id = cupy.repeat(cupy.arange(2), len(date_df)) + full_df['sample_id'] = sample_id + full_df['year'] = full_df['date'].dt.year + full_df['month'] = full_df['date'].dt.month-1 + cupy.random.seed(3) + full_df['portfolio'] = cupy.random.rand(len(full_df)) + return full_df + + def setUp(self): + self.df = self.create_df() + + def test_months_start(self): + log_return = self.df + first_sample = log_return['sample_id'].min().item() + all_dates = log_return[first_sample == log_return['sample_id']]['date'] + months_start = _get_month_start_pos(all_dates) + self.assertTrue(months_start[0].item() == 0) + for i in range(1, len(months_start)): + start_day_month = log_return.iloc[months_start[i].item( + )]['date'].dt.month + last_day_month = log_return.iloc[( + months_start[i].item()-1)]['date'].dt.month + diff = start_day_month.values[0] - last_day_month.values[0] + self.assertTrue(abs(diff) != 0) + + def test_distance(self): + total_samples = 2 + # window = 3 + long_window = 59 + short_window = 19 + target_vol = 0.05 + log_return = self.df + first_sample = log_return['sample_id'].min().item() + all_dates = log_return[first_sample == log_return['sample_id']]['date'] + all_dates = all_dates.reset_index(drop=True) + months_start = _get_month_start_pos(all_dates) + for window in range(len(months_start)): + if (months_start[window] - long_window) > 0: + break + print(window) + print('offset', months_start[window] - long_window) + port_return_ma = log_return['portfolio'].values.reshape( + total_samples, -1) + number_of_threads = 256 + num_months = len(months_start) - window + if num_months == 0: # this case, use all the data to compute + num_months = 1 + number_of_blocks = num_months * total_samples + leverage = cupy.zeros((total_samples, num_months)) + leverage_for_target_vol[(number_of_blocks, ), (number_of_threads, ), 0, + 256 * MAX_YEARS * 8](leverage, port_return_ma, + months_start, num_months, + window, + long_window, short_window, + target_vol) + + for sample in range(2): + for num in range(num_months): + + end_id = months_start[num + window] + mean = port_return_ma[sample, + end_id - long_window:end_id].mean() + sd_long = cupy.sqrt( + ((port_return_ma[sample, end_id - long_window:end_id] - + mean)**2).mean()) + # print('long', sd_long) + mean = (port_return_ma[sample, + end_id - short_window:end_id].mean()) + sd_short = cupy.sqrt( + ((port_return_ma[sample, end_id - short_window:end_id] - + mean)**2).mean()) + + # print('sort', sd_short) + max_sd = max(sd_long, sd_short) + lev = target_vol / (max_sd * math.sqrt(252)) + # print(lev) + # print(leverage[sample, num], lev-leverage[sample, num]) + # compute = means[sample][num] + self.assertTrue(cupy.allclose(leverage[sample, num], lev)) + + # for sample in range(2): + # for num in range(num_months): + # s = log_return_ma[sample, :, months_start[num]:months_start[ + # num + window]] + # truth = (cupy.cov(s, bias=True)) + # compute = cov[sample][num] + # self.assertTrue(cupy.allclose(compute, truth)) + + # for sample in range(1): + # for num in range(1): + # cov_m = cov[sample][num] + # corr_m = cov_m.copy() + # for i in range(3): + # for j in range(3): + # corr_m[i, j] = corr_m[i, j] / \ + # math.sqrt(cov_m[i, i] * cov_m[j, j]) + # dis = (1.0 - corr_m)/2.0 + # truth = (squareform(dis.get())) + # compute = distance[sample][num] + # self.assertTrue(cupy.allclose(compute, truth)) diff --git a/gQuant/plugins/hrp_plugin/tests/unit/test_max_drawdown.py b/gQuant/plugins/hrp_plugin/tests/unit/test_max_drawdown.py new file mode 100644 index 00000000..d5075c10 --- /dev/null +++ b/gQuant/plugins/hrp_plugin/tests/unit/test_max_drawdown.py @@ -0,0 +1,86 @@ +""" + //////////////////////////////////////////////////////////////////////////// + // + // Copyright (C) NVIDIA Corporation. All rights reserved. + // + // NVIDIA Sample Code + // + // Please refer to the NVIDIA end user license agreement (EULA) associated + // with this source code for terms and conditions that govern your use of + // this software. Any use, reproduction, disclosure, or distribution of + // this software and related documentation outside the terms of the EULA + // is strictly prohibited. + // + //////////////////////////////////////////////////////////////////////////// +""" + +#!/usr/bin/env python +# -*- coding: utf-8 -*- + +''' +python -m unittest tests/unit/test_max_drawdown.py -v +''' +import unittest +import pandas as pd +import cupy +import numpy as np +import cudf +from greenflow_hrp_plugin.kernels import _get_log_return_matrix +from greenflow_hrp_plugin.kernels import _get_month_start_pos +from greenflow_hrp_plugin.kernels import drawdown_kernel + + +class TestMaxDrawdown(unittest.TestCase): + + def create_df(self): + date_df = cudf.DataFrame() + date_df['date'] = pd.date_range('1/1/1990', '12/31/1992', freq='B') + full_df = cudf.concat([date_df, date_df]) + sample_id = cupy.repeat(cupy.arange(2), len(date_df)) + full_df['sample_id'] = sample_id + full_df['year'] = full_df['date'].dt.year + full_df['month'] = full_df['date'].dt.month-1 + cupy.random.seed(3) + full_df[0] = cupy.random.normal(0, 0.02, len(full_df)) + full_df[1] = cupy.random.normal(0, 0.02, len(full_df)) + full_df[2] = cupy.random.normal(0, 0.02, len(full_df)) + return full_df + + def setUp(self): + self.df = self.create_df() + + def compute_drawdown(self, times): + cumsum = np.cumsum(times) + cumsum = np.exp(cumsum) + maxreturn = np.maximum.accumulate(np.concatenate([np.array([1.0]), + cumsum]))[1:] + drawdown = cumsum/maxreturn - 1.0 + return -drawdown.min() + + def test_max_drawdown(self): + total_samples = 2 + window = 12 + log_return = self.df + + first_sample = log_return['sample_id'].min().item() + all_dates = log_return[first_sample == log_return['sample_id']]['date'] + all_dates = all_dates.reset_index(drop=True) + months_start = _get_month_start_pos(all_dates) + log_return_ma = _get_log_return_matrix(total_samples, log_return) + _, assets, timelen = log_return_ma.shape + number_of_threads = 128 + num_months = len(months_start) - window + number_of_blocks = num_months * total_samples + drawdown = cupy.zeros((total_samples, num_months, assets)) + drawdown_kernel[(number_of_blocks, ), + (number_of_threads, )](drawdown, log_return_ma, + months_start, window) + for s in range(total_samples): + for a in range(assets): + for i in range(num_months): + gpu_drawdown = drawdown[s][i][a] + cpu_drawdown = self.compute_drawdown( + log_return_ma[s][a][ + months_start[i]:months_start[i+window]].get()) + self.assertTrue(cupy.allclose(gpu_drawdown, + cpu_drawdown)) diff --git a/gQuant/plugins/hrp_plugin/tests/unit/test_order.py b/gQuant/plugins/hrp_plugin/tests/unit/test_order.py new file mode 100644 index 00000000..a6ae697a --- /dev/null +++ b/gQuant/plugins/hrp_plugin/tests/unit/test_order.py @@ -0,0 +1,90 @@ +""" + //////////////////////////////////////////////////////////////////////////// + // + // Copyright (C) NVIDIA Corporation. All rights reserved. + // + // NVIDIA Sample Code + // + // Please refer to the NVIDIA end user license agreement (EULA) associated + // with this source code for terms and conditions that govern your use of + // this software. Any use, reproduction, disclosure, or distribution of + // this software and related documentation outside the terms of the EULA + // is strictly prohibited. + // + //////////////////////////////////////////////////////////////////////////// +""" + +#!/usr/bin/env python +# -*- coding: utf-8 -*- + +''' +python -m unittest tests/unit/test_order.py -v +''' +import unittest +import cupy +from greenflow_hrp_plugin.kernels import single_linkage +from scipy.spatial.distance import squareform +from scipy.cluster.hierarchy import linkage +import numpy as np + + +def seriation(Z, N, cur_index): + """Returns the order implied by a hierarchical tree (dendrogram). + + :param Z: A hierarchical tree (dendrogram). + :param N: The number of points given to the clustering process. + :param cur_index: The position in the tree for the recursive traversal. + + :return: The order implied by the hierarchical tree Z. + """ + if cur_index < N: + return [cur_index] + else: + left = int(Z[cur_index - N, 0]) + right = int(Z[cur_index - N, 1]) + return (seriation(Z, N, left) + seriation(Z, N, right)) + + +class TestOrder(unittest.TestCase): + + def setUp(self): + self.assets = 10 + self.samples = 5 + self.numbers = 30 + seq = 100 + self.distance = cupy.zeros( + (self.samples, self.numbers, self.assets * (self.assets-1) // 2)) + cupy.random.seed(10) + for i in range(self.samples): + for j in range(self.numbers): + cov = cupy.cov(cupy.random.rand(self.assets, seq)) + dia = cupy.diag(cov) + corr = cov / cupy.sqrt(cupy.outer(dia, dia)) + dist = (1.0 - corr) / 2.0 + self.distance[i, j] = cupy.array(squareform(dist.get())) + + def test_order(self): + num_months = self.numbers + total_samples = self.samples + assets = self.assets + + number_of_threads = 1 + number_of_blocks = num_months * total_samples + output = cupy.zeros((total_samples, num_months, assets-1, 3)) + orders = cupy.zeros( + (total_samples, num_months, assets), dtype=cupy.int64) + single_linkage[(number_of_blocks,), (number_of_threads,)]( + output, + orders, + self.distance, + num_months, assets) + + for i in range(self.samples): + for j in range(self.numbers): + gpu_order = orders[0][0] + gpu_linkage = output[0][0] + cpu_linkage = linkage(self.distance[0][0].get()) + cpu_order = seriation(cpu_linkage, assets, assets*2 - 2) + self.assertTrue(np.allclose(gpu_order.get(), cpu_order)) + self.assertTrue(np.allclose( + gpu_linkage.get(), cpu_linkage[:, :-1])) diff --git a/greenflow/greenflow/dataframe_flow/_node_flow.py b/greenflow/greenflow/dataframe_flow/_node_flow.py index 6fda95f4..1b8027c3 100644 --- a/greenflow/greenflow/dataframe_flow/_node_flow.py +++ b/greenflow/greenflow/dataframe_flow/_node_flow.py @@ -12,14 +12,11 @@ from .metaSpec import MetaData from ._node import _Node from ._node_taskgraph_extension_mixin import NodeTaskGraphExtensionMixin +from .output_collector_node import OUTPUT_TYPE -# OUTPUT_ID = 'f291b900-bd19-11e9-aca3-a81e84f29b0f_uni_output' -OUTPUT_ID = 'collector_id_fd9567b6' -OUTPUT_TYPE = 'Output_Collector' - -__all__ = ['NodeTaskGraphMixin', 'OUTPUT_ID', 'OUTPUT_TYPE', - 'register_validator', 'register_copy_function'] +__all__ = ['NodeTaskGraphMixin', 'register_validator', + 'register_copy_function', 'register_cleanup'] # class NodeIncomingEdge(object): # from_node = 'from_node' @@ -84,6 +81,7 @@ class NodeTaskGraphMixin(NodeTaskGraphExtensionMixin): ---------- _task_obj uid + node_type_str conf load save @@ -348,11 +346,10 @@ def get_input_meta(self, port_name=None): return meta_data.outports[from_port_name] if from_port_name not in meta_data.outports: - nodetype_list = _get_nodetype(self) - nodetype_names = [inodet.__name__ for inodet in nodetype_list] - if 'OutputCollector' in nodetype_names: + if self.node_type_str == OUTPUT_TYPE: continue + nodetype_list = _get_nodetype(self) warnings.warn( 'node "{}" node-type "{}" to port "{}", from node "{}" ' 'node-type "{}" oport "{}" missing oport in metadata for ' @@ -417,9 +414,13 @@ def flow(self, progress_fun=None): iport = out['to_port'] oport = out['from_port'] + # Prevent memory leaks. + if not onode.visited: + continue + if oport is not None: if oport not in output_df: - if onode.uid in (OUTPUT_ID,): + if onode.node_type_str == OUTPUT_TYPE: onode_msg = 'is listed in task-graph outputs' else: onode_msg = 'is required as input to node "{}"'.format( @@ -684,6 +685,7 @@ def timer(*argv): end = time.time() print('id:%s process time:%.3fs' % (self.uid, end-start)) return result + if self.profile: return timer else: @@ -708,7 +710,7 @@ def __call__(self, inputs_data): else: output_df = self.decorate_process()(inputs) - if self.uid != OUTPUT_ID and output_df is None: + if self.node_type_str != OUTPUT_TYPE and output_df is None: raise Exception("None output") else: self.__validate_output(output_df) @@ -722,12 +724,11 @@ def _validate_connected_ports(self): """ Validate the connected port types match """ - self_nodetype = _get_nodetype(self) - nodetype_names = [inodet.__name__ for inodet in self_nodetype] - if 'OutputCollector' in nodetype_names: - # Don't validate for OutputCollector + if self.node_type_str == OUTPUT_TYPE: + # Don't validate for Output_Collector return + self_nodetype = _get_nodetype(self) msgfmt = '"{task}":"{nodetype}" {inout} port "{ioport}" {inout} port '\ 'type(s) "{ioport_types}"' @@ -858,6 +859,10 @@ def validate_required(iport, kcol, kval, ientnode, icols): dy = PortsSpecSchema.dynamic if inports[iport].get(dy, False): continue + + if inports[iport].get(PortsSpecSchema.optional, False): + continue + # Is it possible that iport not connected? If so iport should # not be in required. Should raise an exception here. warn_msg = \ diff --git a/greenflow/greenflow/dataframe_flow/_node_taskgraph_extension_mixin.py b/greenflow/greenflow/dataframe_flow/_node_taskgraph_extension_mixin.py index 0363df0f..b19a275f 100644 --- a/greenflow/greenflow/dataframe_flow/_node_taskgraph_extension_mixin.py +++ b/greenflow/greenflow/dataframe_flow/_node_taskgraph_extension_mixin.py @@ -1,5 +1,6 @@ from .portsSpecSchema import (PortsSpecSchema, NodePorts) from .metaSpec import (MetaDataSchema, MetaData) +from copy import deepcopy __all__ = ['NodeTaskGraphExtensionMixin'] @@ -56,12 +57,10 @@ def ports_setup_ext(self, ports): dynamic = None inports = {} for input_port in port_inports: + inports[input_port] = deepcopy(port_inports[input_port]) if input_port in input_connections: determined_type = input_connections[input_port] - inports[input_port] = {port_type: determined_type} - else: - types = port_inports[input_port][port_type] - inports[input_port] = {port_type: types} + inports[input_port].update({port_type: determined_type}) if dy in port_inports[input_port]: inports[input_port][dy] = True diff --git a/greenflow/greenflow/dataframe_flow/config_nodes_modules.py b/greenflow/greenflow/dataframe_flow/config_nodes_modules.py index 03506f9f..fa8f0aad 100644 --- a/greenflow/greenflow/dataframe_flow/config_nodes_modules.py +++ b/greenflow/greenflow/dataframe_flow/config_nodes_modules.py @@ -13,6 +13,7 @@ from .task import Task from ._node import _Node from ._node_flow import NodeTaskGraphMixin +from .output_collector_node import (Output_Collector, OUTPUT_TYPE) DEFAULT_MODULE = os.getenv('GREENFLOW_PLUGIN_MODULE', "greenflow.plugin_nodes") @@ -90,8 +91,13 @@ def import_submodules(package, recursive=True, _main_package=None): continue if not issubclass(nodecls, _Node): continue + if nodecls.__name__ == 'Node': + continue - setattr(_main_package, nodecls.__name__, nodecls) + try: + getattr(_main_package, nodecls.__name__) + except AttributeError: + setattr(_main_package, nodecls.__name__, nodecls) def load_modules(pathfile, name=None): @@ -213,10 +219,14 @@ def get_node_obj(task, replace=None, profile=False, tgraph_mixin=False, modules[module_name], name=module_name) module_dir = loaded.path mod = loaded.mod + try: NodeClass = getattr(mod, node_type) except AttributeError: pass + elif node_type == OUTPUT_TYPE: + # Output collector does not reside in default plugins + NodeClass = Output_Collector else: try: global DEFAULT_MODULE diff --git a/greenflow/greenflow/dataframe_flow/node.py b/greenflow/greenflow/dataframe_flow/node.py index 296b91e5..e0715542 100644 --- a/greenflow/greenflow/dataframe_flow/node.py +++ b/greenflow/greenflow/dataframe_flow/node.py @@ -92,6 +92,9 @@ def __init__(self, task): assert isinstance(task, Task) self._task_obj = task # save the task obj self.uid = task[TaskSpecSchema.task_id] + node_type = task[TaskSpecSchema.node_type] + self.node_type_str = node_type if isinstance(node_type, str) else \ + node_type.__name__ self.conf = task[TaskSpecSchema.conf] self.load = task.get(TaskSpecSchema.load, False) self.save = task.get(TaskSpecSchema.save, False) diff --git a/greenflow/greenflow/dataframe_flow/output_collector_node.py b/greenflow/greenflow/dataframe_flow/output_collector_node.py new file mode 100644 index 00000000..ff627b8d --- /dev/null +++ b/greenflow/greenflow/dataframe_flow/output_collector_node.py @@ -0,0 +1,25 @@ +from .node import Node +from .portsSpecSchema import NodePorts, ConfSchema + + +__all__ = ['Output_Collector', 'OUTPUT_ID', 'OUTPUT_TYPE'] + + +class Output_Collector(Node): + def meta_setup(self): + return super().meta_setup() + + def ports_setup(self): + return NodePorts(inports={}, outports={}) + + def conf_schema(self): + return ConfSchema() + + def process(self, inputs): + return super().process(inputs) + + +# TODO: DO NOT RELY ON special OUTPUT_ID. +# OUTPUT_ID = 'f291b900-bd19-11e9-aca3-a81e84f29b0f_uni_output' +OUTPUT_ID = 'collector_id_fd9567b6' +OUTPUT_TYPE = Output_Collector.__name__ diff --git a/greenflow/greenflow/dataframe_flow/task.py b/greenflow/greenflow/dataframe_flow/task.py index 7addcf39..cfb8b0aa 100644 --- a/greenflow/greenflow/dataframe_flow/task.py +++ b/greenflow/greenflow/dataframe_flow/task.py @@ -1,7 +1,5 @@ import copy from .taskSpecSchema import TaskSpecSchema -from ._node_flow import OUTPUT_ID - module_cache = {} @@ -27,14 +25,6 @@ def __init__(self, task_spec): def __getitem__(self, key): return self._task_spec[key] - def set_output(self): - """ - set the uniq output id to task - """ - from .taskGraph import OutputCollector - self._task_spec[TaskSpecSchema.task_id] = OUTPUT_ID - self._task_spec[TaskSpecSchema.node_type] = OutputCollector - def get(self, key, default=None): return self._task_spec.get(key, default) diff --git a/greenflow/greenflow/dataframe_flow/taskGraph.py b/greenflow/greenflow/dataframe_flow/taskGraph.py index 70149b18..34796b95 100644 --- a/greenflow/greenflow/dataframe_flow/taskGraph.py +++ b/greenflow/greenflow/dataframe_flow/taskGraph.py @@ -7,15 +7,15 @@ from collections import OrderedDict import ruamel.yaml -from .node import Node -from ._node_flow import OUTPUT_ID, OUTPUT_TYPE, _CLEANUP +from ._node_flow import _CLEANUP from .task import Task from .taskSpecSchema import TaskSpecSchema -from .portsSpecSchema import NodePorts, ConfSchema, PortsSpecSchema +from .portsSpecSchema import PortsSpecSchema from .util import get_encoded_class from .config_nodes_modules import get_node_obj +from .output_collector_node import (Output_Collector, OUTPUT_TYPE, OUTPUT_ID) -__all__ = ['TaskGraph', 'OutputCollector'] +__all__ = ['TaskGraph', 'Output_Collector'] server_task_graph = None @@ -33,20 +33,6 @@ def add_module_from_base64(module_name, class_str): return class_obj -class OutputCollector(Node): - def meta_setup(self): - return super().meta_setup() - - def ports_setup(self): - return NodePorts(inports={}, outports={}) - - def conf_schema(self): - return ConfSchema() - - def process(self, inputs): - return super().process(inputs) - - class Results(object): def __init__(self, values): @@ -181,6 +167,24 @@ def __next__(self): self.__index = idx + 1 return task + def __getitem__(self, key): + # FIXME: This is inconsistent. Above for __contains__, __iter__, and + # __next__, the returned object is a Task instance. Here however + # the returned object is a Node instance. + if not self.__node_dict: + warnings.warn( + 'Task graph internal state empty. Did you build the task ' + 'graph? Run ".build()"', + RuntimeWarning) + + elif key not in self.__node_dict: + warnings.warn( + 'Task graph missing task id "{}". Check the spelling of the ' + 'task id.'.format(key), + RuntimeWarning) + + return self.__node_dict[key] + def __find_roots(self, node, inputs, consider_load=True): """ find the root nodes that the `node` depends on @@ -198,9 +202,9 @@ def __find_roots(self, node, inputs, consider_load=True): None """ - if (node.visited): return + node.visited = True if len(node.inputs) == 0: @@ -310,7 +314,7 @@ def save_taskgraph(self, filename): with open(filename, 'w') as fh: ruamel.yaml.dump(tlist_od, fh, default_flow_style=False) - def viz_graph(self, show_ports=False): + def viz_graph(self, show_ports=False, pydot_options=None): """ Generate the visulization of the graph in the JupyterLab @@ -320,6 +324,8 @@ def viz_graph(self, show_ports=False): """ import networkx as nx G = nx.DiGraph() + if pydot_options: + G.graph['graph'] = pydot_options # instantiate objects for itask in self: task_inputs = itask[TaskSpecSchema.inputs] @@ -353,7 +359,7 @@ def viz_graph(self, show_ports=False): if (to_type == OUTPUT_TYPE): continue - task_node = get_node_obj(itask) + task_node = get_node_obj(itask, tgraph_mixin=True) # task_outputs = itask.get(TaskSpecSchema.outputs, []) for pout in task_node._get_output_ports(): out_tip = '{}.{}'.format( @@ -390,13 +396,10 @@ def _build(self, replace=None, profile=False): for task in self: task_id = task[TaskSpecSchema.task_id] nodetype = task[TaskSpecSchema.node_type] - if (task_id == OUTPUT_ID or nodetype == OUTPUT_TYPE): - output_task = Task({ - TaskSpecSchema.task_id: OUTPUT_ID, - TaskSpecSchema.conf: {}, - TaskSpecSchema.node_type: OutputCollector, - TaskSpecSchema.inputs: task[TaskSpecSchema.inputs] - }) + nodetype = nodetype if isinstance(nodetype, str) else \ + nodetype.__name__ + if nodetype == OUTPUT_TYPE: + output_task = task node = get_node_obj(output_task, tgraph_mixin=True) else: node = get_node_obj(task, replace.get(task_id), profile, @@ -436,7 +439,7 @@ def _build(self, replace=None, profile=False): 'from_port': src_port }) - def build(self, replace=None, profile=False): + def build(self, replace=None, profile=None): """ compute the graph structure of the nodes. It will set the input and output nodes for each of the node @@ -446,6 +449,7 @@ def build(self, replace=None, profile=False): replace: dict conf parameters replacement """ + profile = False if profile is None else profile # make connection only self._build(replace=replace, profile=profile) @@ -487,9 +491,6 @@ def breadth_first_update(self, extra_roots=[], extra_updated=set()): queue.append(child) # print('----done----') - def __getitem__(self, key): - return self.__node_dict[key] - def __str__(self): out_str = "" for k in self.__node_dict.keys(): @@ -515,59 +516,96 @@ def register_node(self, module_name, classObj): add_module_from_base64(module_name, encoded_class) self.__widget.cache = cacheCopy - def _run(self, outputs=None, replace=None, profile=False, formated=False): + def _run(self, outputs=None, replace=None, profile=None, formated=False, + build=True): replace = dict() if replace is None else replace - self.build(replace, profile) + if build: + self.build(replace, profile) + else: + if replace: + warnings.warn( + 'Replace is specified, but build is set to False. No ' + 'replacement will be done. Either set build=True or ' + 'first build with replace then call run.', + RuntimeWarning) - graph_outputs = [] - # add the output graph only if the Output Node is not in the graph - found_output_node = False - for task in self: - if (task[TaskSpecSchema.task_id] == OUTPUT_ID or - task[TaskSpecSchema.node_type] == OUTPUT_TYPE): - found_output_node = True - outputs_collector_node = self[task[TaskSpecSchema.task_id]] - for input_item in outputs_collector_node.inputs: - from_node_id = input_item['from_node'].uid - fromStr = from_node_id+'.'+input_item['from_port'] - graph_outputs.append(fromStr) - break + if profile is not None: + warnings.warn( + 'Profile is specified, but build is set to False. ' + 'Profile will be done according to last build. ' + 'Alternatively either set build=True or first build with ' + 'desired profile option then call run.', + RuntimeWarning) + # Reset visited status to run the taskgraph. This is done during + # build, but since not building need to reset here. + for inode in self.__node_dict.values(): + inode.visited = False + + using_output_node = False if outputs is None: - outputs = graph_outputs + graph_outputs = [] + outputs = graph_outputs # reference copy + # Find the output collector in the task graph. + for task in self: + # FIXME: Note the inconsistency of getting a task + # "for task in self" yet also retrieving a node + # via "self[task_id]". + node = self[task[TaskSpecSchema.task_id]] + if node.node_type_str == OUTPUT_TYPE: + using_output_node = True + outputs_collector_node = node + for input_item in outputs_collector_node.inputs: + from_node_id = input_item['from_node'].uid + fromStr = from_node_id + '.' + input_item['from_port'] + graph_outputs.append(fromStr) + break + + if not using_output_node: + warnings.warn( + 'Outputs not specified and output collector not found ' + 'in the task graph. Nothing will be run.', + RuntimeWarning) - if not found_output_node: + result = Results([]) + if formated: + return formated_result(result) + else: + return result + + if using_output_node: + # This is rewiring the graph which should not be needed. + # clean all the connections to this output node + # for inode in self.__node_dict.values(): + # inode.outputs = list(filter( + # lambda x: x['to_node'] != outputs_collector_node, + # inode.outputs)) + outputs_collector_node.input_df.clear() + else: + # This does make it possible to temporarily have 2 output + # collectors in a task graph. This 2nd collector is cleaned up. output_task = Task({ - TaskSpecSchema.task_id: OUTPUT_ID, + # Use a slightly different uid to differentiate from an + # output node that might be part of the task graph. + TaskSpecSchema.task_id: '{}-outspec'.format(OUTPUT_ID), TaskSpecSchema.conf: {}, - TaskSpecSchema.node_type: OutputCollector, - TaskSpecSchema.inputs: [] + TaskSpecSchema.node_type: Output_Collector, + TaskSpecSchema.inputs: outputs }) outputs_collector_node = get_node_obj(output_task, tgraph_mixin=True) - - outputs_collector_node.clear_input = False - if not found_output_node or outputs is not None: - if found_output_node: - # clean all the connections to this output node - for uid in self.__node_dict.keys(): - node = self.__node_dict[uid] - node.outputs = list(filter( - lambda x: x['to_node'] != outputs_collector_node, - node.outputs)) - - # remove the output - # set the connection only if output_node is manullay created - # or the output is overwritten - outputs_collector_node.inputs.clear() - outputs_collector_node.outputs.clear() for task_id in outputs: nodeid_oport = task_id.split('.') nodeid = nodeid_oport[0] - oport = nodeid_oport[1] if len(nodeid_oport) > 1 else None - onode = self.__node_dict[nodeid] + oport = nodeid_oport[1] + try: + onode = self.__node_dict[nodeid] + except KeyError as err: + raise RuntimeError('Missing nodeid: {}. Did you build the ' + 'task graph?'.format(nodeid)) from err + dummy_port = task_id outputs_collector_node.inputs.append({ 'from_node': onode, @@ -580,7 +618,7 @@ def _run(self, outputs=None, replace=None, profile=False, formated=False): 'from_port': oport }) - results_task_ids = outputs + outputs_collector_node.clear_input = False inputs = [] self.__find_roots(outputs_collector_node, inputs, consider_load=True) @@ -609,10 +647,11 @@ def progress_fun(uid): current_node = nodes[0] current_node['busy'] = True self.__widget.cache = cacheCopy + for i in inputs: i.flow(progress_fun) - # clean up the progress + # clean up the progress def cleanup(): import time cacheCopy = copy.deepcopy(self.__widget.cache) @@ -620,6 +659,7 @@ def cleanup(): node['busy'] = False time.sleep(1) self.__widget.cache = cacheCopy + import threading t = threading.Thread(target=cleanup) t.start() @@ -631,16 +671,31 @@ def cleanup(): port_map = {} for input_item in outputs_collector_node.inputs: from_node_id = input_item['from_node'].uid - fromStr = from_node_id+'.'+input_item['from_port'] + fromStr = from_node_id + '.' + input_item['from_port'] port_map[fromStr] = input_item['to_port'] + + results_task_ids = outputs results = [] for task_id in results_task_ids: results.append((task_id, results_dfs_dict[port_map[task_id]])) + # clean the results afterwards - outputs_collector_node.input_df = {} + outputs_collector_node.input_df.clear() + if not using_output_node: + # Remove the output collector that's not part of the task graph. + for inode in self.__node_dict.values(): + inode.outputs = list(filter( + lambda x: x['to_node'] != outputs_collector_node, + inode.outputs)) + del outputs_collector_node + + # Prevent memory leaks. Clean up the task graph. + for inode in self.__node_dict.values(): + # if not inode.visited: + inode.input_df.clear() + result = Results(results) - #### - # this is for nemo work around, to clean up the nemo graph + # Cleanup logic for any plugin that used "register_cleanup". self.run_cleanup() if formated: @@ -652,7 +707,8 @@ def run_cleanup(self, ui_clean=False): for v in _CLEANUP.values(): v(ui_clean) - def run(self, outputs=None, replace=None, profile=False, formated=False): + def run(self, outputs=None, replace=None, profile=None, formated=False, + build=True): """ Flow the dataframes in the graph to do the data science computations. @@ -678,25 +734,29 @@ def run(self, outputs=None, replace=None, profile=False, formated=False): err = "" result = None result = self._run(outputs=outputs, replace=replace, - profile=profile, formated=formated) + profile=profile, formated=formated, + build=build) except Exception: err = traceback.format_exc() finally: import ipywidgets out = ipywidgets.Output(layout={'border': '1px solid black'}) out.append_stderr(err) + if result is None: result = ipywidgets.Tab() + result.set_title(len(result.children), 'std output') result.children = result.children + (out,) return result else: return self._run(outputs=outputs, replace=replace, profile=profile, - formated=formated) + formated=formated, build=build) - def to_pydot(self, show_ports=False): + def to_pydot(self, show_ports=False, pydot_options=None): import networkx as nx - nx_graph = self.viz_graph(show_ports=show_ports) + nx_graph = self.viz_graph(show_ports=show_ports, + pydot_options=pydot_options) to_pydot = nx.drawing.nx_pydot.to_pydot pdot = to_pydot(nx_graph) return pdot @@ -710,9 +770,24 @@ def get_widget(self): self.__widget = widget return self.__widget - def draw(self, show='lab', fmt='png', show_ports=False): + def del_widget(self): + del self.__widget + self.__widget = None + + def draw(self, show='lab', fmt='png', show_ports=False, + pydot_options=None): + ''' + :param show: str; One of 'ipynb', 'lab' + :param fmt: str; 'png' or 'svg'. Only used if show='ipynb' + :param show_ports: boolean; Labels intermediate ports between nodes in + the taskgraph. Only used if show='ipynb' + :param pydot_options: dict; Passed to the graph attribute of a graphviz + generated dot graph. Only used when show='ipynb'. Refer to: + https://graphviz.org/doc/info/attrs.html + Example: pydot_options={'rankdir': 'LR'} to draw left-to-right + ''' if show in ('ipynb',): - pdot = self.to_pydot(show_ports) + pdot = self.to_pydot(show_ports, pydot_options) pdot_out = pdot.create(format=fmt) if fmt in ('svg',): from IPython.display import SVG as Image # @UnusedImport diff --git a/greenflow/setup.py b/greenflow/setup.py index 8fa50400..6341e5bb 100644 --- a/greenflow/setup.py +++ b/greenflow/setup.py @@ -14,7 +14,7 @@ setup( name='greenflow', - version='1.0.4', + version='1.0.5', description='greenflow - RAPIDS Financial Services Algorithms', long_description=long_description, long_description_content_type='text/markdown', diff --git a/greenflowlab/greenflowlab/server_utils.py b/greenflowlab/greenflowlab/server_utils.py index fb13ec8c..b8b76e2a 100644 --- a/greenflowlab/greenflowlab/server_utils.py +++ b/greenflowlab/greenflowlab/server_utils.py @@ -3,7 +3,8 @@ from greenflow.dataframe_flow import TaskGraph from greenflow.dataframe_flow import Node from greenflow.dataframe_flow.task import Task -from greenflow.dataframe_flow._node_flow import OUTPUT_TYPE, OUTPUT_ID +from greenflow.dataframe_flow.output_collector_node import ( + OUTPUT_TYPE, OUTPUT_ID) from greenflow.dataframe_flow import (TaskSpecSchema, PortsSpecSchema) from greenflow.dataframe_flow.config_nodes_modules import ( load_modules, get_greenflow_config_modules, get_node_tgraphmixin_instance) @@ -99,7 +100,9 @@ def get_nodes(task_graph): """ for task in task_graph: if (task.get(TaskSpecSchema.node_type) == OUTPUT_TYPE): - task.set_output() + # Setting output collector ID should not be needed. + task._task_spec[TaskSpecSchema.task_id] = OUTPUT_ID + # task._task_spec[TaskSpecSchema.node_type] = Output_Collector task_graph.build() nodes = [] edges = [] diff --git a/gtc21-s32407-backtestingequityinvestmentstrats/docker/requirements.txt b/gtc21-s32407-backtestingequityinvestmentstrats/docker/requirements.txt index 2cf57d6b..30c84453 100644 --- a/gtc21-s32407-backtestingequityinvestmentstrats/docker/requirements.txt +++ b/gtc21-s32407-backtestingequityinvestmentstrats/docker/requirements.txt @@ -7,6 +7,6 @@ cupy-cuda110 pandas dask-cuda jupyter -jupyterlab==1.2.1 +jupyterlab==1.2.21 jupyterlab-nvdashboard dask_labextension diff --git a/nlp_demo_riva/LICENSE b/nlp_demo_riva/LICENSE new file mode 100755 index 00000000..18bcb431 --- /dev/null +++ b/nlp_demo_riva/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "{}" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright 2018 NVIDIA Corporation + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/nlp_demo_riva/README.md b/nlp_demo_riva/README.md new file mode 100644 index 00000000..6f06fec9 --- /dev/null +++ b/nlp_demo_riva/README.md @@ -0,0 +1,64 @@ +## Simple Conversational AI Demo + + +### What it is? + +It is a simple conversational AI demo that you can ask the question to AI about the provided context text and get the answer back in speech. It deploys RIVA ASR, Tacotron2/Waveglow (we could also have FastPitch/HiFiGAN if available), [BERT](https://github.com/NVIDIA/DeepLearningExamples/tree/master/TensorFlow/LanguageModeling/BERT) models as AI services. + +In the larger text area, user can provide any long articles in text to provide question context. The model can find the answer to the question asked. It pre-loaded an article from the WIKI. User can copy-paste their own text to the text area. + +User can either record the question in English audio or type it in text. After clicking the 'Ask' button, the answer will be responded in both text and speech formats. The play button generates speech from the question texts. + +There are some "example questions" for users to try. Feel free to come up your own questions for the AI demo. + +Not satisfied with the model performance? Try to improve it with your own data. Easy fine-tuning with [Transfer Learning Toolkit](https://developer.nvidia.com/transfer-learning-toolkit). + +### How to use? + +You need to deploy the [RIVA](https://docs.nvidia.com/deeplearning/riva/index.html) to host all the models in the Triton Server. To use RIVA, go to [NGC](https://ngc.nvidia.com/setup) to sign up or log in to your NGC account. Follow the instruction at [this page](https://ngc.nvidia.com/setup) to setup the API keys for your system. + +The easiest way to set it up is to run script: + +```bash +bash build.sh +``` + +Use [docker-compose](https://docs.docker.com/compose/) to orgnize the containers. The latest `docker-compose` is downloaded in the `bulid.sh` script + +```bash +cd riva +./docker-compose up +``` + +Open up the webpage at: +``` +https://ip:8888 +``` + +Note, it is required to use `https://` connection to get the browser microphone to work remotely. Note, you might need to accept the risk warning from the browser to proceed. Have fun playing with it! + +To shut down the demo +```bash +./docker-compose down +``` + +### Change default text + +The default context text file(`doc.txt`) and default questions(`questions.txt`) are loaded in the `/workspace/server/text` directory inside the client docker image. +To use your own default text and questions for the demo, you can preprare the `doc.txt` and `questions.txt` files in a different host directory and mount it to the client docker image in the `riva/docker-compose.yml` file using [volumes](https://docs.docker.com/storage/volumes/). E.g. + +```yaml +client: + image: client + ports: + - "8888:8888" + depends_on: + - "riva" + volumes: + - HOST_PATH:/workspace/server/text + command: ["/usr/bin/python3", "webserver.py"] +``` + +### Screen shot +![Screen shot](image.png) + diff --git a/nlp_demo_riva/asr_infer.py b/nlp_demo_riva/asr_infer.py new file mode 100644 index 00000000..897b7467 --- /dev/null +++ b/nlp_demo_riva/asr_infer.py @@ -0,0 +1,50 @@ +""" + //////////////////////////////////////////////////////////////////////////// + // + // Copyright (C) NVIDIA Corporation. All rights reserved. + // + // NVIDIA Sample Code + // + // Please refer to the NVIDIA end user license agreement (EULA) associated + // with this source code for terms and conditions that govern your use of + // this software. Any use, reproduction, disclosure, or distribution of + // this software and related documentation outside the terms of the EULA + // is strictly prohibited. + // + //////////////////////////////////////////////////////////////////////////// +""" +import grpc +import riva_api.riva_audio_pb2 as ra +import riva_api.riva_asr_pb2 as rasr +import riva_api.riva_asr_pb2_grpc as rasr_srv +import io +import wave + + +channel = grpc.insecure_channel("riva:50051") +client = rasr_srv.RivaSpeechRecognitionStub(channel) + + +def asr_text(data): + audio_data = data.read() + wf = wave.open(io.BytesIO(audio_data), 'rb') + rate = wf.getframerate() + config = rasr.RecognitionConfig( + encoding=ra.AudioEncoding.LINEAR_PCM, + sample_rate_hertz=rate, + language_code="en-US", + max_alternatives=1, + enable_automatic_punctuation=True, + audio_channel_count=1, + ) + + request = rasr.RecognizeRequest(config=config, audio=audio_data) + + response = client.Recognize(request) + print(response) + + if len(response.results[0].alternatives) > 0: + asr_best_transcript = response.results[0].alternatives[0].transcript + else: + asr_best_transcript = '' + return asr_best_transcript diff --git a/nlp_demo_riva/build.sh b/nlp_demo_riva/build.sh new file mode 100755 index 00000000..254c3eb9 --- /dev/null +++ b/nlp_demo_riva/build.sh @@ -0,0 +1,14 @@ +#!/bin/bash +source riva/config.sh + +# download docker-compose +VERSION=$(curl --silent https://api.github.com/repos/docker/compose/releases/latest | grep -Po '"tag_name": "\K.*\d') +curl -L https://github.com/docker/compose/releases/download/${VERSION}/docker-compose-$(uname -s)-$(uname -m) -o riva/docker-compose +chmod 777 riva/docker-compose + +pushd riva +bash riva_init.sh +popd + +### start to build the container for server +docker build --network=host -f docker/Dockerfile.riva -t client . diff --git a/nlp_demo_riva/cert.pem b/nlp_demo_riva/cert.pem new file mode 100755 index 00000000..15d999c1 --- /dev/null +++ b/nlp_demo_riva/cert.pem @@ -0,0 +1,21 @@ +-----BEGIN CERTIFICATE----- +MIIDYDCCAkigAwIBAgIJAJT9hjcwV18JMA0GCSqGSIb3DQEBCwUAMEUxCzAJBgNV +BAYTAkFVMRMwEQYDVQQIDApTb21lLVN0YXRlMSEwHwYDVQQKDBhJbnRlcm5ldCBX +aWRnaXRzIFB0eSBMdGQwHhcNMjAwMzA4MTgyMzI4WhcNMjEwMzA4MTgyMzI4WjBF +MQswCQYDVQQGEwJBVTETMBEGA1UECAwKU29tZS1TdGF0ZTEhMB8GA1UECgwYSW50 +ZXJuZXQgV2lkZ2l0cyBQdHkgTHRkMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIB +CgKCAQEAxUlwbpoVYqH24XV+pniyHZUyWiCBpp+IhATA0dt5VobmKPgMgwGXDZx0 +iZd+fKf6SO8uo+N5iSuCbmnyNePQyxgtH8XAAJhQWLSXFdIDh1i+O/GCOcf433j4 +6QJl823lQzmChzuuNMuWLZ4rTk4gtIB7n2DSycyxtphbMFJD2pWX35d/0nRSJE0+ +fcl9EAvWn4+m4fzB4tb/sSKlx79u7CPFeUSOp73Wklh63cWc+yQaBgk3gYCdvWrR +OQ+//Kmg6ka0RtNqdPgASZSJa3uvbt7Yvn+hmgpdBxBb2XodFoBiw5P+HsFy0G6N +at8tg0oVhDcP6Wqextv8i0OuCc2siwIDAQABo1MwUTAdBgNVHQ4EFgQUT580Esaw +SPd+E6w8DsslOfyePSYwHwYDVR0jBBgwFoAUT580EsawSPd+E6w8DsslOfyePSYw +DwYDVR0TAQH/BAUwAwEB/zANBgkqhkiG9w0BAQsFAAOCAQEACEUpoU+o6unEIXUC +rGZnL7+ewbdRFPItCrpArhFe0L0wxkxbKkgldPKyqFcXzR6NmVydsIezqF/7gkrJ +li0LNdEkTzLJso2EQVJsxgaDdep4vOpjHFVZdeX9XaSb2dXGGf1Bx3w15ahqm5Hn +nnIHMBAbBvW5KOS2m8FoZByhL7V0mBa/RvEWM4ypBJQym7zS6dpcs5ZJvV1HaqaI +yLbz2Evv+XXBrYk/udvEyAdW2Sc6BYhcpcqFkjQ5fQONkI/7IxRYBs1ZnEW1o8ZF +OhWV/DRV3QFuXjUeK30eedyv1QPM84pyoz8FiMsd3us/c/qTlmqkYSihSs8AmqXn +ja16Cw== +-----END CERTIFICATE----- diff --git a/nlp_demo_riva/client/css/all.css b/nlp_demo_riva/client/css/all.css new file mode 100644 index 00000000..8ebd25ff --- /dev/null +++ b/nlp_demo_riva/client/css/all.css @@ -0,0 +1,4556 @@ +/*! + * Font Awesome Free 5.13.0 by @fontawesome - https://fontawesome.com + * License - https://fontawesome.com/license/free (Icons: CC BY 4.0, Fonts: SIL OFL 1.1, Code: MIT License) + */ +.fa, +.fas, +.far, +.fal, +.fad, +.fab { + -moz-osx-font-smoothing: grayscale; + -webkit-font-smoothing: antialiased; + display: inline-block; + font-style: normal; + font-variant: normal; + text-rendering: auto; + line-height: 1; } + +.fa-lg { + font-size: 1.33333em; + line-height: 0.75em; + vertical-align: -.0667em; } + +.fa-xs { + font-size: .75em; } + +.fa-sm { + font-size: .875em; } + +.fa-1x { + font-size: 1em; } + +.fa-2x { + font-size: 2em; } + +.fa-3x { + font-size: 3em; } + +.fa-4x { + font-size: 4em; } + +.fa-5x { + font-size: 5em; } + +.fa-6x { + font-size: 6em; } + +.fa-7x { + font-size: 7em; } + +.fa-8x { + font-size: 8em; } + +.fa-9x { + font-size: 9em; } + +.fa-10x { + font-size: 10em; } + +.fa-fw { + text-align: center; + width: 1.25em; } + +.fa-ul { + list-style-type: none; + margin-left: 2.5em; + padding-left: 0; } + .fa-ul > li { + position: relative; } + +.fa-li { + left: -2em; + position: absolute; + text-align: center; + width: 2em; + line-height: inherit; } + +.fa-border { + border: solid 0.08em #eee; + border-radius: .1em; + padding: .2em .25em .15em; } + +.fa-pull-left { + float: left; } + +.fa-pull-right { + float: right; } + +.fa.fa-pull-left, +.fas.fa-pull-left, +.far.fa-pull-left, +.fal.fa-pull-left, +.fab.fa-pull-left { + margin-right: .3em; } + +.fa.fa-pull-right, +.fas.fa-pull-right, +.far.fa-pull-right, +.fal.fa-pull-right, +.fab.fa-pull-right { + margin-left: .3em; } + +.fa-spin { + -webkit-animation: fa-spin 2s infinite linear; + animation: fa-spin 2s infinite linear; } + +.fa-pulse { + -webkit-animation: fa-spin 1s infinite steps(8); + animation: fa-spin 1s infinite steps(8); } + +@-webkit-keyframes fa-spin { + 0% { + -webkit-transform: rotate(0deg); + transform: rotate(0deg); } + 100% { + -webkit-transform: rotate(360deg); + transform: rotate(360deg); } } + +@keyframes fa-spin { + 0% { + -webkit-transform: rotate(0deg); + transform: rotate(0deg); } + 100% { + -webkit-transform: rotate(360deg); + transform: rotate(360deg); } } + +.fa-rotate-90 { + -ms-filter: "progid:DXImageTransform.Microsoft.BasicImage(rotation=1)"; + -webkit-transform: rotate(90deg); + transform: rotate(90deg); } + +.fa-rotate-180 { + -ms-filter: "progid:DXImageTransform.Microsoft.BasicImage(rotation=2)"; + -webkit-transform: rotate(180deg); + transform: rotate(180deg); } + +.fa-rotate-270 { + -ms-filter: "progid:DXImageTransform.Microsoft.BasicImage(rotation=3)"; + -webkit-transform: rotate(270deg); + transform: rotate(270deg); } + +.fa-flip-horizontal { + -ms-filter: "progid:DXImageTransform.Microsoft.BasicImage(rotation=0, mirror=1)"; + -webkit-transform: scale(-1, 1); + transform: scale(-1, 1); } + +.fa-flip-vertical { + -ms-filter: "progid:DXImageTransform.Microsoft.BasicImage(rotation=2, mirror=1)"; + -webkit-transform: scale(1, -1); + transform: scale(1, -1); } + +.fa-flip-both, .fa-flip-horizontal.fa-flip-vertical { + -ms-filter: "progid:DXImageTransform.Microsoft.BasicImage(rotation=2, mirror=1)"; + -webkit-transform: scale(-1, -1); + transform: scale(-1, -1); } + +:root .fa-rotate-90, +:root .fa-rotate-180, +:root .fa-rotate-270, +:root .fa-flip-horizontal, +:root .fa-flip-vertical, +:root .fa-flip-both { + -webkit-filter: none; + filter: none; } + +.fa-stack { + display: inline-block; + height: 2em; + line-height: 2em; + position: relative; + vertical-align: middle; + width: 2.5em; } + +.fa-stack-1x, +.fa-stack-2x { + left: 0; + position: absolute; + text-align: center; + width: 100%; } + +.fa-stack-1x { + line-height: inherit; } + +.fa-stack-2x { + font-size: 2em; } + +.fa-inverse { + color: #fff; } + +/* Font Awesome uses the Unicode Private Use Area (PUA) to ensure screen +readers do not read off random characters that represent icons */ +.fa-500px:before { + content: "\f26e"; } + +.fa-accessible-icon:before { + content: "\f368"; } + +.fa-accusoft:before { + content: "\f369"; } + +.fa-acquisitions-incorporated:before { + content: "\f6af"; } + +.fa-ad:before { + content: "\f641"; } + +.fa-address-book:before { + content: "\f2b9"; } + +.fa-address-card:before { + content: "\f2bb"; } + +.fa-adjust:before { + content: "\f042"; } + +.fa-adn:before { + content: "\f170"; } + +.fa-adobe:before { + content: "\f778"; } + +.fa-adversal:before { + content: "\f36a"; } + +.fa-affiliatetheme:before { + content: "\f36b"; } + +.fa-air-freshener:before { + content: "\f5d0"; } + +.fa-airbnb:before { + content: "\f834"; } + +.fa-algolia:before { + content: "\f36c"; } + +.fa-align-center:before { + content: "\f037"; } + +.fa-align-justify:before { + content: "\f039"; } + +.fa-align-left:before { + content: "\f036"; } + +.fa-align-right:before { + content: "\f038"; } + +.fa-alipay:before { + content: "\f642"; } + +.fa-allergies:before { + content: "\f461"; } + +.fa-amazon:before { + content: "\f270"; } + +.fa-amazon-pay:before { + content: "\f42c"; } + +.fa-ambulance:before { + content: "\f0f9"; } + +.fa-american-sign-language-interpreting:before { + content: "\f2a3"; } + +.fa-amilia:before { + content: "\f36d"; } + +.fa-anchor:before { + content: "\f13d"; } + +.fa-android:before { + content: "\f17b"; } + +.fa-angellist:before { + content: "\f209"; } + +.fa-angle-double-down:before { + content: "\f103"; } + +.fa-angle-double-left:before { + content: "\f100"; } + +.fa-angle-double-right:before { + content: "\f101"; } + +.fa-angle-double-up:before { + content: "\f102"; } + +.fa-angle-down:before { + content: "\f107"; } + +.fa-angle-left:before { + content: "\f104"; } + +.fa-angle-right:before { + content: "\f105"; } + +.fa-angle-up:before { + content: "\f106"; } + +.fa-angry:before { + content: "\f556"; } + +.fa-angrycreative:before { + content: "\f36e"; } + +.fa-angular:before { + content: "\f420"; } + +.fa-ankh:before { + content: "\f644"; } + +.fa-app-store:before { + content: "\f36f"; } + +.fa-app-store-ios:before { + content: "\f370"; } + +.fa-apper:before { + content: "\f371"; } + +.fa-apple:before { + content: "\f179"; } + +.fa-apple-alt:before { + content: "\f5d1"; } + +.fa-apple-pay:before { + content: "\f415"; } + +.fa-archive:before { + content: "\f187"; } + +.fa-archway:before { + content: "\f557"; } + +.fa-arrow-alt-circle-down:before { + content: "\f358"; } + +.fa-arrow-alt-circle-left:before { + content: "\f359"; } + +.fa-arrow-alt-circle-right:before { + content: "\f35a"; } + +.fa-arrow-alt-circle-up:before { + content: "\f35b"; } + +.fa-arrow-circle-down:before { + content: "\f0ab"; } + +.fa-arrow-circle-left:before { + content: "\f0a8"; } + +.fa-arrow-circle-right:before { + content: "\f0a9"; } + +.fa-arrow-circle-up:before { + content: "\f0aa"; } + +.fa-arrow-down:before { + content: "\f063"; } + +.fa-arrow-left:before { + content: "\f060"; } + +.fa-arrow-right:before { + content: "\f061"; } + +.fa-arrow-up:before { + content: "\f062"; } + +.fa-arrows-alt:before { + content: "\f0b2"; } + +.fa-arrows-alt-h:before { + content: "\f337"; } + +.fa-arrows-alt-v:before { + content: "\f338"; } + +.fa-artstation:before { + content: "\f77a"; } + +.fa-assistive-listening-systems:before { + content: "\f2a2"; } + +.fa-asterisk:before { + content: "\f069"; } + +.fa-asymmetrik:before { + content: "\f372"; } + +.fa-at:before { + content: "\f1fa"; } + +.fa-atlas:before { + content: "\f558"; } + +.fa-atlassian:before { + content: "\f77b"; } + +.fa-atom:before { + content: "\f5d2"; } + +.fa-audible:before { + content: "\f373"; } + +.fa-audio-description:before { + content: "\f29e"; } + +.fa-autoprefixer:before { + content: "\f41c"; } + +.fa-avianex:before { + content: "\f374"; } + +.fa-aviato:before { + content: "\f421"; } + +.fa-award:before { + content: "\f559"; } + +.fa-aws:before { + content: "\f375"; } + +.fa-baby:before { + content: "\f77c"; } + +.fa-baby-carriage:before { + content: "\f77d"; } + +.fa-backspace:before { + content: "\f55a"; } + +.fa-backward:before { + content: "\f04a"; } + +.fa-bacon:before { + content: "\f7e5"; } + +.fa-bahai:before { + content: "\f666"; } + +.fa-balance-scale:before { + content: "\f24e"; } + +.fa-balance-scale-left:before { + content: "\f515"; } + +.fa-balance-scale-right:before { + content: "\f516"; } + +.fa-ban:before { + content: "\f05e"; } + +.fa-band-aid:before { + content: "\f462"; } + +.fa-bandcamp:before { + content: "\f2d5"; } + +.fa-barcode:before { + content: "\f02a"; } + +.fa-bars:before { + content: "\f0c9"; } + +.fa-baseball-ball:before { + content: "\f433"; } + +.fa-basketball-ball:before { + content: "\f434"; } + +.fa-bath:before { + content: "\f2cd"; } + +.fa-battery-empty:before { + content: "\f244"; } + +.fa-battery-full:before { + content: "\f240"; } + +.fa-battery-half:before { + content: "\f242"; } + +.fa-battery-quarter:before { + content: "\f243"; } + +.fa-battery-three-quarters:before { + content: "\f241"; } + +.fa-battle-net:before { + content: "\f835"; } + +.fa-bed:before { + content: "\f236"; } + +.fa-beer:before { + content: "\f0fc"; } + +.fa-behance:before { + content: "\f1b4"; } + +.fa-behance-square:before { + content: "\f1b5"; } + +.fa-bell:before { + content: "\f0f3"; } + +.fa-bell-slash:before { + content: "\f1f6"; } + +.fa-bezier-curve:before { + content: "\f55b"; } + +.fa-bible:before { + content: "\f647"; } + +.fa-bicycle:before { + content: "\f206"; } + +.fa-biking:before { + content: "\f84a"; } + +.fa-bimobject:before { + content: "\f378"; } + +.fa-binoculars:before { + content: "\f1e5"; } + +.fa-biohazard:before { + content: "\f780"; } + +.fa-birthday-cake:before { + content: "\f1fd"; } + +.fa-bitbucket:before { + content: "\f171"; } + +.fa-bitcoin:before { + content: "\f379"; } + +.fa-bity:before { + content: "\f37a"; } + +.fa-black-tie:before { + content: "\f27e"; } + +.fa-blackberry:before { + content: "\f37b"; } + +.fa-blender:before { + content: "\f517"; } + +.fa-blender-phone:before { + content: "\f6b6"; } + +.fa-blind:before { + content: "\f29d"; } + +.fa-blog:before { + content: "\f781"; } + +.fa-blogger:before { + content: "\f37c"; } + +.fa-blogger-b:before { + content: "\f37d"; } + +.fa-bluetooth:before { + content: "\f293"; } + +.fa-bluetooth-b:before { + content: "\f294"; } + +.fa-bold:before { + content: "\f032"; } + +.fa-bolt:before { + content: "\f0e7"; } + +.fa-bomb:before { + content: "\f1e2"; } + +.fa-bone:before { + content: "\f5d7"; } + +.fa-bong:before { + content: "\f55c"; } + +.fa-book:before { + content: "\f02d"; } + +.fa-book-dead:before { + content: "\f6b7"; } + +.fa-book-medical:before { + content: "\f7e6"; } + +.fa-book-open:before { + content: "\f518"; } + +.fa-book-reader:before { + content: "\f5da"; } + +.fa-bookmark:before { + content: "\f02e"; } + +.fa-bootstrap:before { + content: "\f836"; } + +.fa-border-all:before { + content: "\f84c"; } + +.fa-border-none:before { + content: "\f850"; } + +.fa-border-style:before { + content: "\f853"; } + +.fa-bowling-ball:before { + content: "\f436"; } + +.fa-box:before { + content: "\f466"; } + +.fa-box-open:before { + content: "\f49e"; } + +.fa-box-tissue:before { + content: "\f95b"; } + +.fa-boxes:before { + content: "\f468"; } + +.fa-braille:before { + content: "\f2a1"; } + +.fa-brain:before { + content: "\f5dc"; } + +.fa-bread-slice:before { + content: "\f7ec"; } + +.fa-briefcase:before { + content: "\f0b1"; } + +.fa-briefcase-medical:before { + content: "\f469"; } + +.fa-broadcast-tower:before { + content: "\f519"; } + +.fa-broom:before { + content: "\f51a"; } + +.fa-brush:before { + content: "\f55d"; } + +.fa-btc:before { + content: "\f15a"; } + +.fa-buffer:before { + content: "\f837"; } + +.fa-bug:before { + content: "\f188"; } + +.fa-building:before { + content: "\f1ad"; } + +.fa-bullhorn:before { + content: "\f0a1"; } + +.fa-bullseye:before { + content: "\f140"; } + +.fa-burn:before { + content: "\f46a"; } + +.fa-buromobelexperte:before { + content: "\f37f"; } + +.fa-bus:before { + content: "\f207"; } + +.fa-bus-alt:before { + content: "\f55e"; } + +.fa-business-time:before { + content: "\f64a"; } + +.fa-buy-n-large:before { + content: "\f8a6"; } + +.fa-buysellads:before { + content: "\f20d"; } + +.fa-calculator:before { + content: "\f1ec"; } + +.fa-calendar:before { + content: "\f133"; } + +.fa-calendar-alt:before { + content: "\f073"; } + +.fa-calendar-check:before { + content: "\f274"; } + +.fa-calendar-day:before { + content: "\f783"; } + +.fa-calendar-minus:before { + content: "\f272"; } + +.fa-calendar-plus:before { + content: "\f271"; } + +.fa-calendar-times:before { + content: "\f273"; } + +.fa-calendar-week:before { + content: "\f784"; } + +.fa-camera:before { + content: "\f030"; } + +.fa-camera-retro:before { + content: "\f083"; } + +.fa-campground:before { + content: "\f6bb"; } + +.fa-canadian-maple-leaf:before { + content: "\f785"; } + +.fa-candy-cane:before { + content: "\f786"; } + +.fa-cannabis:before { + content: "\f55f"; } + +.fa-capsules:before { + content: "\f46b"; } + +.fa-car:before { + content: "\f1b9"; } + +.fa-car-alt:before { + content: "\f5de"; } + +.fa-car-battery:before { + content: "\f5df"; } + +.fa-car-crash:before { + content: "\f5e1"; } + +.fa-car-side:before { + content: "\f5e4"; } + +.fa-caravan:before { + content: "\f8ff"; } + +.fa-caret-down:before { + content: "\f0d7"; } + +.fa-caret-left:before { + content: "\f0d9"; } + +.fa-caret-right:before { + content: "\f0da"; } + +.fa-caret-square-down:before { + content: "\f150"; } + +.fa-caret-square-left:before { + content: "\f191"; } + +.fa-caret-square-right:before { + content: "\f152"; } + +.fa-caret-square-up:before { + content: "\f151"; } + +.fa-caret-up:before { + content: "\f0d8"; } + +.fa-carrot:before { + content: "\f787"; } + +.fa-cart-arrow-down:before { + content: "\f218"; } + +.fa-cart-plus:before { + content: "\f217"; } + +.fa-cash-register:before { + content: "\f788"; } + +.fa-cat:before { + content: "\f6be"; } + +.fa-cc-amazon-pay:before { + content: "\f42d"; } + +.fa-cc-amex:before { + content: "\f1f3"; } + +.fa-cc-apple-pay:before { + content: "\f416"; } + +.fa-cc-diners-club:before { + content: "\f24c"; } + +.fa-cc-discover:before { + content: "\f1f2"; } + +.fa-cc-jcb:before { + content: "\f24b"; } + +.fa-cc-mastercard:before { + content: "\f1f1"; } + +.fa-cc-paypal:before { + content: "\f1f4"; } + +.fa-cc-stripe:before { + content: "\f1f5"; } + +.fa-cc-visa:before { + content: "\f1f0"; } + +.fa-centercode:before { + content: "\f380"; } + +.fa-centos:before { + content: "\f789"; } + +.fa-certificate:before { + content: "\f0a3"; } + +.fa-chair:before { + content: "\f6c0"; } + +.fa-chalkboard:before { + content: "\f51b"; } + +.fa-chalkboard-teacher:before { + content: "\f51c"; } + +.fa-charging-station:before { + content: "\f5e7"; } + +.fa-chart-area:before { + content: "\f1fe"; } + +.fa-chart-bar:before { + content: "\f080"; } + +.fa-chart-line:before { + content: "\f201"; } + +.fa-chart-pie:before { + content: "\f200"; } + +.fa-check:before { + content: "\f00c"; } + +.fa-check-circle:before { + content: "\f058"; } + +.fa-check-double:before { + content: "\f560"; } + +.fa-check-square:before { + content: "\f14a"; } + +.fa-cheese:before { + content: "\f7ef"; } + +.fa-chess:before { + content: "\f439"; } + +.fa-chess-bishop:before { + content: "\f43a"; } + +.fa-chess-board:before { + content: "\f43c"; } + +.fa-chess-king:before { + content: "\f43f"; } + +.fa-chess-knight:before { + content: "\f441"; } + +.fa-chess-pawn:before { + content: "\f443"; } + +.fa-chess-queen:before { + content: "\f445"; } + +.fa-chess-rook:before { + content: "\f447"; } + +.fa-chevron-circle-down:before { + content: "\f13a"; } + +.fa-chevron-circle-left:before { + content: "\f137"; } + +.fa-chevron-circle-right:before { + content: "\f138"; } + +.fa-chevron-circle-up:before { + content: "\f139"; } + +.fa-chevron-down:before { + content: "\f078"; } + +.fa-chevron-left:before { + content: "\f053"; } + +.fa-chevron-right:before { + content: "\f054"; } + +.fa-chevron-up:before { + content: "\f077"; } + +.fa-child:before { + content: "\f1ae"; } + +.fa-chrome:before { + content: "\f268"; } + +.fa-chromecast:before { + content: "\f838"; } + +.fa-church:before { + content: "\f51d"; } + +.fa-circle:before { + content: "\f111"; } + +.fa-circle-notch:before { + content: "\f1ce"; } + +.fa-city:before { + content: "\f64f"; } + +.fa-clinic-medical:before { + content: "\f7f2"; } + +.fa-clipboard:before { + content: "\f328"; } + +.fa-clipboard-check:before { + content: "\f46c"; } + +.fa-clipboard-list:before { + content: "\f46d"; } + +.fa-clock:before { + content: "\f017"; } + +.fa-clone:before { + content: "\f24d"; } + +.fa-closed-captioning:before { + content: "\f20a"; } + +.fa-cloud:before { + content: "\f0c2"; } + +.fa-cloud-download-alt:before { + content: "\f381"; } + +.fa-cloud-meatball:before { + content: "\f73b"; } + +.fa-cloud-moon:before { + content: "\f6c3"; } + +.fa-cloud-moon-rain:before { + content: "\f73c"; } + +.fa-cloud-rain:before { + content: "\f73d"; } + +.fa-cloud-showers-heavy:before { + content: "\f740"; } + +.fa-cloud-sun:before { + content: "\f6c4"; } + +.fa-cloud-sun-rain:before { + content: "\f743"; } + +.fa-cloud-upload-alt:before { + content: "\f382"; } + +.fa-cloudscale:before { + content: "\f383"; } + +.fa-cloudsmith:before { + content: "\f384"; } + +.fa-cloudversify:before { + content: "\f385"; } + +.fa-cocktail:before { + content: "\f561"; } + +.fa-code:before { + content: "\f121"; } + +.fa-code-branch:before { + content: "\f126"; } + +.fa-codepen:before { + content: "\f1cb"; } + +.fa-codiepie:before { + content: "\f284"; } + +.fa-coffee:before { + content: "\f0f4"; } + +.fa-cog:before { + content: "\f013"; } + +.fa-cogs:before { + content: "\f085"; } + +.fa-coins:before { + content: "\f51e"; } + +.fa-columns:before { + content: "\f0db"; } + +.fa-comment:before { + content: "\f075"; } + +.fa-comment-alt:before { + content: "\f27a"; } + +.fa-comment-dollar:before { + content: "\f651"; } + +.fa-comment-dots:before { + content: "\f4ad"; } + +.fa-comment-medical:before { + content: "\f7f5"; } + +.fa-comment-slash:before { + content: "\f4b3"; } + +.fa-comments:before { + content: "\f086"; } + +.fa-comments-dollar:before { + content: "\f653"; } + +.fa-compact-disc:before { + content: "\f51f"; } + +.fa-compass:before { + content: "\f14e"; } + +.fa-compress:before { + content: "\f066"; } + +.fa-compress-alt:before { + content: "\f422"; } + +.fa-compress-arrows-alt:before { + content: "\f78c"; } + +.fa-concierge-bell:before { + content: "\f562"; } + +.fa-confluence:before { + content: "\f78d"; } + +.fa-connectdevelop:before { + content: "\f20e"; } + +.fa-contao:before { + content: "\f26d"; } + +.fa-cookie:before { + content: "\f563"; } + +.fa-cookie-bite:before { + content: "\f564"; } + +.fa-copy:before { + content: "\f0c5"; } + +.fa-copyright:before { + content: "\f1f9"; } + +.fa-cotton-bureau:before { + content: "\f89e"; } + +.fa-couch:before { + content: "\f4b8"; } + +.fa-cpanel:before { + content: "\f388"; } + +.fa-creative-commons:before { + content: "\f25e"; } + +.fa-creative-commons-by:before { + content: "\f4e7"; } + +.fa-creative-commons-nc:before { + content: "\f4e8"; } + +.fa-creative-commons-nc-eu:before { + content: "\f4e9"; } + +.fa-creative-commons-nc-jp:before { + content: "\f4ea"; } + +.fa-creative-commons-nd:before { + content: "\f4eb"; } + +.fa-creative-commons-pd:before { + content: "\f4ec"; } + +.fa-creative-commons-pd-alt:before { + content: "\f4ed"; } + +.fa-creative-commons-remix:before { + content: "\f4ee"; } + +.fa-creative-commons-sa:before { + content: "\f4ef"; } + +.fa-creative-commons-sampling:before { + content: "\f4f0"; } + +.fa-creative-commons-sampling-plus:before { + content: "\f4f1"; } + +.fa-creative-commons-share:before { + content: "\f4f2"; } + +.fa-creative-commons-zero:before { + content: "\f4f3"; } + +.fa-credit-card:before { + content: "\f09d"; } + +.fa-critical-role:before { + content: "\f6c9"; } + +.fa-crop:before { + content: "\f125"; } + +.fa-crop-alt:before { + content: "\f565"; } + +.fa-cross:before { + content: "\f654"; } + +.fa-crosshairs:before { + content: "\f05b"; } + +.fa-crow:before { + content: "\f520"; } + +.fa-crown:before { + content: "\f521"; } + +.fa-crutch:before { + content: "\f7f7"; } + +.fa-css3:before { + content: "\f13c"; } + +.fa-css3-alt:before { + content: "\f38b"; } + +.fa-cube:before { + content: "\f1b2"; } + +.fa-cubes:before { + content: "\f1b3"; } + +.fa-cut:before { + content: "\f0c4"; } + +.fa-cuttlefish:before { + content: "\f38c"; } + +.fa-d-and-d:before { + content: "\f38d"; } + +.fa-d-and-d-beyond:before { + content: "\f6ca"; } + +.fa-dailymotion:before { + content: "\f952"; } + +.fa-dashcube:before { + content: "\f210"; } + +.fa-database:before { + content: "\f1c0"; } + +.fa-deaf:before { + content: "\f2a4"; } + +.fa-delicious:before { + content: "\f1a5"; } + +.fa-democrat:before { + content: "\f747"; } + +.fa-deploydog:before { + content: "\f38e"; } + +.fa-deskpro:before { + content: "\f38f"; } + +.fa-desktop:before { + content: "\f108"; } + +.fa-dev:before { + content: "\f6cc"; } + +.fa-deviantart:before { + content: "\f1bd"; } + +.fa-dharmachakra:before { + content: "\f655"; } + +.fa-dhl:before { + content: "\f790"; } + +.fa-diagnoses:before { + content: "\f470"; } + +.fa-diaspora:before { + content: "\f791"; } + +.fa-dice:before { + content: "\f522"; } + +.fa-dice-d20:before { + content: "\f6cf"; } + +.fa-dice-d6:before { + content: "\f6d1"; } + +.fa-dice-five:before { + content: "\f523"; } + +.fa-dice-four:before { + content: "\f524"; } + +.fa-dice-one:before { + content: "\f525"; } + +.fa-dice-six:before { + content: "\f526"; } + +.fa-dice-three:before { + content: "\f527"; } + +.fa-dice-two:before { + content: "\f528"; } + +.fa-digg:before { + content: "\f1a6"; } + +.fa-digital-ocean:before { + content: "\f391"; } + +.fa-digital-tachograph:before { + content: "\f566"; } + +.fa-directions:before { + content: "\f5eb"; } + +.fa-discord:before { + content: "\f392"; } + +.fa-discourse:before { + content: "\f393"; } + +.fa-disease:before { + content: "\f7fa"; } + +.fa-divide:before { + content: "\f529"; } + +.fa-dizzy:before { + content: "\f567"; } + +.fa-dna:before { + content: "\f471"; } + +.fa-dochub:before { + content: "\f394"; } + +.fa-docker:before { + content: "\f395"; } + +.fa-dog:before { + content: "\f6d3"; } + +.fa-dollar-sign:before { + content: "\f155"; } + +.fa-dolly:before { + content: "\f472"; } + +.fa-dolly-flatbed:before { + content: "\f474"; } + +.fa-donate:before { + content: "\f4b9"; } + +.fa-door-closed:before { + content: "\f52a"; } + +.fa-door-open:before { + content: "\f52b"; } + +.fa-dot-circle:before { + content: "\f192"; } + +.fa-dove:before { + content: "\f4ba"; } + +.fa-download:before { + content: "\f019"; } + +.fa-draft2digital:before { + content: "\f396"; } + +.fa-drafting-compass:before { + content: "\f568"; } + +.fa-dragon:before { + content: "\f6d5"; } + +.fa-draw-polygon:before { + content: "\f5ee"; } + +.fa-dribbble:before { + content: "\f17d"; } + +.fa-dribbble-square:before { + content: "\f397"; } + +.fa-dropbox:before { + content: "\f16b"; } + +.fa-drum:before { + content: "\f569"; } + +.fa-drum-steelpan:before { + content: "\f56a"; } + +.fa-drumstick-bite:before { + content: "\f6d7"; } + +.fa-drupal:before { + content: "\f1a9"; } + +.fa-dumbbell:before { + content: "\f44b"; } + +.fa-dumpster:before { + content: "\f793"; } + +.fa-dumpster-fire:before { + content: "\f794"; } + +.fa-dungeon:before { + content: "\f6d9"; } + +.fa-dyalog:before { + content: "\f399"; } + +.fa-earlybirds:before { + content: "\f39a"; } + +.fa-ebay:before { + content: "\f4f4"; } + +.fa-edge:before { + content: "\f282"; } + +.fa-edit:before { + content: "\f044"; } + +.fa-egg:before { + content: "\f7fb"; } + +.fa-eject:before { + content: "\f052"; } + +.fa-elementor:before { + content: "\f430"; } + +.fa-ellipsis-h:before { + content: "\f141"; } + +.fa-ellipsis-v:before { + content: "\f142"; } + +.fa-ello:before { + content: "\f5f1"; } + +.fa-ember:before { + content: "\f423"; } + +.fa-empire:before { + content: "\f1d1"; } + +.fa-envelope:before { + content: "\f0e0"; } + +.fa-envelope-open:before { + content: "\f2b6"; } + +.fa-envelope-open-text:before { + content: "\f658"; } + +.fa-envelope-square:before { + content: "\f199"; } + +.fa-envira:before { + content: "\f299"; } + +.fa-equals:before { + content: "\f52c"; } + +.fa-eraser:before { + content: "\f12d"; } + +.fa-erlang:before { + content: "\f39d"; } + +.fa-ethereum:before { + content: "\f42e"; } + +.fa-ethernet:before { + content: "\f796"; } + +.fa-etsy:before { + content: "\f2d7"; } + +.fa-euro-sign:before { + content: "\f153"; } + +.fa-evernote:before { + content: "\f839"; } + +.fa-exchange-alt:before { + content: "\f362"; } + +.fa-exclamation:before { + content: "\f12a"; } + +.fa-exclamation-circle:before { + content: "\f06a"; } + +.fa-exclamation-triangle:before { + content: "\f071"; } + +.fa-expand:before { + content: "\f065"; } + +.fa-expand-alt:before { + content: "\f424"; } + +.fa-expand-arrows-alt:before { + content: "\f31e"; } + +.fa-expeditedssl:before { + content: "\f23e"; } + +.fa-external-link-alt:before { + content: "\f35d"; } + +.fa-external-link-square-alt:before { + content: "\f360"; } + +.fa-eye:before { + content: "\f06e"; } + +.fa-eye-dropper:before { + content: "\f1fb"; } + +.fa-eye-slash:before { + content: "\f070"; } + +.fa-facebook:before { + content: "\f09a"; } + +.fa-facebook-f:before { + content: "\f39e"; } + +.fa-facebook-messenger:before { + content: "\f39f"; } + +.fa-facebook-square:before { + content: "\f082"; } + +.fa-fan:before { + content: "\f863"; } + +.fa-fantasy-flight-games:before { + content: "\f6dc"; } + +.fa-fast-backward:before { + content: "\f049"; } + +.fa-fast-forward:before { + content: "\f050"; } + +.fa-faucet:before { + content: "\f905"; } + +.fa-fax:before { + content: "\f1ac"; } + +.fa-feather:before { + content: "\f52d"; } + +.fa-feather-alt:before { + content: "\f56b"; } + +.fa-fedex:before { + content: "\f797"; } + +.fa-fedora:before { + content: "\f798"; } + +.fa-female:before { + content: "\f182"; } + +.fa-fighter-jet:before { + content: "\f0fb"; } + +.fa-figma:before { + content: "\f799"; } + +.fa-file:before { + content: "\f15b"; } + +.fa-file-alt:before { + content: "\f15c"; } + +.fa-file-archive:before { + content: "\f1c6"; } + +.fa-file-audio:before { + content: "\f1c7"; } + +.fa-file-code:before { + content: "\f1c9"; } + +.fa-file-contract:before { + content: "\f56c"; } + +.fa-file-csv:before { + content: "\f6dd"; } + +.fa-file-download:before { + content: "\f56d"; } + +.fa-file-excel:before { + content: "\f1c3"; } + +.fa-file-export:before { + content: "\f56e"; } + +.fa-file-image:before { + content: "\f1c5"; } + +.fa-file-import:before { + content: "\f56f"; } + +.fa-file-invoice:before { + content: "\f570"; } + +.fa-file-invoice-dollar:before { + content: "\f571"; } + +.fa-file-medical:before { + content: "\f477"; } + +.fa-file-medical-alt:before { + content: "\f478"; } + +.fa-file-pdf:before { + content: "\f1c1"; } + +.fa-file-powerpoint:before { + content: "\f1c4"; } + +.fa-file-prescription:before { + content: "\f572"; } + +.fa-file-signature:before { + content: "\f573"; } + +.fa-file-upload:before { + content: "\f574"; } + +.fa-file-video:before { + content: "\f1c8"; } + +.fa-file-word:before { + content: "\f1c2"; } + +.fa-fill:before { + content: "\f575"; } + +.fa-fill-drip:before { + content: "\f576"; } + +.fa-film:before { + content: "\f008"; } + +.fa-filter:before { + content: "\f0b0"; } + +.fa-fingerprint:before { + content: "\f577"; } + +.fa-fire:before { + content: "\f06d"; } + +.fa-fire-alt:before { + content: "\f7e4"; } + +.fa-fire-extinguisher:before { + content: "\f134"; } + +.fa-firefox:before { + content: "\f269"; } + +.fa-firefox-browser:before { + content: "\f907"; } + +.fa-first-aid:before { + content: "\f479"; } + +.fa-first-order:before { + content: "\f2b0"; } + +.fa-first-order-alt:before { + content: "\f50a"; } + +.fa-firstdraft:before { + content: "\f3a1"; } + +.fa-fish:before { + content: "\f578"; } + +.fa-fist-raised:before { + content: "\f6de"; } + +.fa-flag:before { + content: "\f024"; } + +.fa-flag-checkered:before { + content: "\f11e"; } + +.fa-flag-usa:before { + content: "\f74d"; } + +.fa-flask:before { + content: "\f0c3"; } + +.fa-flickr:before { + content: "\f16e"; } + +.fa-flipboard:before { + content: "\f44d"; } + +.fa-flushed:before { + content: "\f579"; } + +.fa-fly:before { + content: "\f417"; } + +.fa-folder:before { + content: "\f07b"; } + +.fa-folder-minus:before { + content: "\f65d"; } + +.fa-folder-open:before { + content: "\f07c"; } + +.fa-folder-plus:before { + content: "\f65e"; } + +.fa-font:before { + content: "\f031"; } + +.fa-font-awesome:before { + content: "\f2b4"; } + +.fa-font-awesome-alt:before { + content: "\f35c"; } + +.fa-font-awesome-flag:before { + content: "\f425"; } + +.fa-font-awesome-logo-full:before { + content: "\f4e6"; } + +.fa-fonticons:before { + content: "\f280"; } + +.fa-fonticons-fi:before { + content: "\f3a2"; } + +.fa-football-ball:before { + content: "\f44e"; } + +.fa-fort-awesome:before { + content: "\f286"; } + +.fa-fort-awesome-alt:before { + content: "\f3a3"; } + +.fa-forumbee:before { + content: "\f211"; } + +.fa-forward:before { + content: "\f04e"; } + +.fa-foursquare:before { + content: "\f180"; } + +.fa-free-code-camp:before { + content: "\f2c5"; } + +.fa-freebsd:before { + content: "\f3a4"; } + +.fa-frog:before { + content: "\f52e"; } + +.fa-frown:before { + content: "\f119"; } + +.fa-frown-open:before { + content: "\f57a"; } + +.fa-fulcrum:before { + content: "\f50b"; } + +.fa-funnel-dollar:before { + content: "\f662"; } + +.fa-futbol:before { + content: "\f1e3"; } + +.fa-galactic-republic:before { + content: "\f50c"; } + +.fa-galactic-senate:before { + content: "\f50d"; } + +.fa-gamepad:before { + content: "\f11b"; } + +.fa-gas-pump:before { + content: "\f52f"; } + +.fa-gavel:before { + content: "\f0e3"; } + +.fa-gem:before { + content: "\f3a5"; } + +.fa-genderless:before { + content: "\f22d"; } + +.fa-get-pocket:before { + content: "\f265"; } + +.fa-gg:before { + content: "\f260"; } + +.fa-gg-circle:before { + content: "\f261"; } + +.fa-ghost:before { + content: "\f6e2"; } + +.fa-gift:before { + content: "\f06b"; } + +.fa-gifts:before { + content: "\f79c"; } + +.fa-git:before { + content: "\f1d3"; } + +.fa-git-alt:before { + content: "\f841"; } + +.fa-git-square:before { + content: "\f1d2"; } + +.fa-github:before { + content: "\f09b"; } + +.fa-github-alt:before { + content: "\f113"; } + +.fa-github-square:before { + content: "\f092"; } + +.fa-gitkraken:before { + content: "\f3a6"; } + +.fa-gitlab:before { + content: "\f296"; } + +.fa-gitter:before { + content: "\f426"; } + +.fa-glass-cheers:before { + content: "\f79f"; } + +.fa-glass-martini:before { + content: "\f000"; } + +.fa-glass-martini-alt:before { + content: "\f57b"; } + +.fa-glass-whiskey:before { + content: "\f7a0"; } + +.fa-glasses:before { + content: "\f530"; } + +.fa-glide:before { + content: "\f2a5"; } + +.fa-glide-g:before { + content: "\f2a6"; } + +.fa-globe:before { + content: "\f0ac"; } + +.fa-globe-africa:before { + content: "\f57c"; } + +.fa-globe-americas:before { + content: "\f57d"; } + +.fa-globe-asia:before { + content: "\f57e"; } + +.fa-globe-europe:before { + content: "\f7a2"; } + +.fa-gofore:before { + content: "\f3a7"; } + +.fa-golf-ball:before { + content: "\f450"; } + +.fa-goodreads:before { + content: "\f3a8"; } + +.fa-goodreads-g:before { + content: "\f3a9"; } + +.fa-google:before { + content: "\f1a0"; } + +.fa-google-drive:before { + content: "\f3aa"; } + +.fa-google-play:before { + content: "\f3ab"; } + +.fa-google-plus:before { + content: "\f2b3"; } + +.fa-google-plus-g:before { + content: "\f0d5"; } + +.fa-google-plus-square:before { + content: "\f0d4"; } + +.fa-google-wallet:before { + content: "\f1ee"; } + +.fa-gopuram:before { + content: "\f664"; } + +.fa-graduation-cap:before { + content: "\f19d"; } + +.fa-gratipay:before { + content: "\f184"; } + +.fa-grav:before { + content: "\f2d6"; } + +.fa-greater-than:before { + content: "\f531"; } + +.fa-greater-than-equal:before { + content: "\f532"; } + +.fa-grimace:before { + content: "\f57f"; } + +.fa-grin:before { + content: "\f580"; } + +.fa-grin-alt:before { + content: "\f581"; } + +.fa-grin-beam:before { + content: "\f582"; } + +.fa-grin-beam-sweat:before { + content: "\f583"; } + +.fa-grin-hearts:before { + content: "\f584"; } + +.fa-grin-squint:before { + content: "\f585"; } + +.fa-grin-squint-tears:before { + content: "\f586"; } + +.fa-grin-stars:before { + content: "\f587"; } + +.fa-grin-tears:before { + content: "\f588"; } + +.fa-grin-tongue:before { + content: "\f589"; } + +.fa-grin-tongue-squint:before { + content: "\f58a"; } + +.fa-grin-tongue-wink:before { + content: "\f58b"; } + +.fa-grin-wink:before { + content: "\f58c"; } + +.fa-grip-horizontal:before { + content: "\f58d"; } + +.fa-grip-lines:before { + content: "\f7a4"; } + +.fa-grip-lines-vertical:before { + content: "\f7a5"; } + +.fa-grip-vertical:before { + content: "\f58e"; } + +.fa-gripfire:before { + content: "\f3ac"; } + +.fa-grunt:before { + content: "\f3ad"; } + +.fa-guitar:before { + content: "\f7a6"; } + +.fa-gulp:before { + content: "\f3ae"; } + +.fa-h-square:before { + content: "\f0fd"; } + +.fa-hacker-news:before { + content: "\f1d4"; } + +.fa-hacker-news-square:before { + content: "\f3af"; } + +.fa-hackerrank:before { + content: "\f5f7"; } + +.fa-hamburger:before { + content: "\f805"; } + +.fa-hammer:before { + content: "\f6e3"; } + +.fa-hamsa:before { + content: "\f665"; } + +.fa-hand-holding:before { + content: "\f4bd"; } + +.fa-hand-holding-heart:before { + content: "\f4be"; } + +.fa-hand-holding-medical:before { + content: "\f95c"; } + +.fa-hand-holding-usd:before { + content: "\f4c0"; } + +.fa-hand-holding-water:before { + content: "\f4c1"; } + +.fa-hand-lizard:before { + content: "\f258"; } + +.fa-hand-middle-finger:before { + content: "\f806"; } + +.fa-hand-paper:before { + content: "\f256"; } + +.fa-hand-peace:before { + content: "\f25b"; } + +.fa-hand-point-down:before { + content: "\f0a7"; } + +.fa-hand-point-left:before { + content: "\f0a5"; } + +.fa-hand-point-right:before { + content: "\f0a4"; } + +.fa-hand-point-up:before { + content: "\f0a6"; } + +.fa-hand-pointer:before { + content: "\f25a"; } + +.fa-hand-rock:before { + content: "\f255"; } + +.fa-hand-scissors:before { + content: "\f257"; } + +.fa-hand-sparkles:before { + content: "\f95d"; } + +.fa-hand-spock:before { + content: "\f259"; } + +.fa-hands:before { + content: "\f4c2"; } + +.fa-hands-helping:before { + content: "\f4c4"; } + +.fa-hands-wash:before { + content: "\f95e"; } + +.fa-handshake:before { + content: "\f2b5"; } + +.fa-handshake-alt-slash:before { + content: "\f95f"; } + +.fa-handshake-slash:before { + content: "\f960"; } + +.fa-hanukiah:before { + content: "\f6e6"; } + +.fa-hard-hat:before { + content: "\f807"; } + +.fa-hashtag:before { + content: "\f292"; } + +.fa-hat-cowboy:before { + content: "\f8c0"; } + +.fa-hat-cowboy-side:before { + content: "\f8c1"; } + +.fa-hat-wizard:before { + content: "\f6e8"; } + +.fa-hdd:before { + content: "\f0a0"; } + +.fa-head-side-cough:before { + content: "\f961"; } + +.fa-head-side-cough-slash:before { + content: "\f962"; } + +.fa-head-side-mask:before { + content: "\f963"; } + +.fa-head-side-virus:before { + content: "\f964"; } + +.fa-heading:before { + content: "\f1dc"; } + +.fa-headphones:before { + content: "\f025"; } + +.fa-headphones-alt:before { + content: "\f58f"; } + +.fa-headset:before { + content: "\f590"; } + +.fa-heart:before { + content: "\f004"; } + +.fa-heart-broken:before { + content: "\f7a9"; } + +.fa-heartbeat:before { + content: "\f21e"; } + +.fa-helicopter:before { + content: "\f533"; } + +.fa-highlighter:before { + content: "\f591"; } + +.fa-hiking:before { + content: "\f6ec"; } + +.fa-hippo:before { + content: "\f6ed"; } + +.fa-hips:before { + content: "\f452"; } + +.fa-hire-a-helper:before { + content: "\f3b0"; } + +.fa-history:before { + content: "\f1da"; } + +.fa-hockey-puck:before { + content: "\f453"; } + +.fa-holly-berry:before { + content: "\f7aa"; } + +.fa-home:before { + content: "\f015"; } + +.fa-hooli:before { + content: "\f427"; } + +.fa-hornbill:before { + content: "\f592"; } + +.fa-horse:before { + content: "\f6f0"; } + +.fa-horse-head:before { + content: "\f7ab"; } + +.fa-hospital:before { + content: "\f0f8"; } + +.fa-hospital-alt:before { + content: "\f47d"; } + +.fa-hospital-symbol:before { + content: "\f47e"; } + +.fa-hospital-user:before { + content: "\f80d"; } + +.fa-hot-tub:before { + content: "\f593"; } + +.fa-hotdog:before { + content: "\f80f"; } + +.fa-hotel:before { + content: "\f594"; } + +.fa-hotjar:before { + content: "\f3b1"; } + +.fa-hourglass:before { + content: "\f254"; } + +.fa-hourglass-end:before { + content: "\f253"; } + +.fa-hourglass-half:before { + content: "\f252"; } + +.fa-hourglass-start:before { + content: "\f251"; } + +.fa-house-damage:before { + content: "\f6f1"; } + +.fa-house-user:before { + content: "\f965"; } + +.fa-houzz:before { + content: "\f27c"; } + +.fa-hryvnia:before { + content: "\f6f2"; } + +.fa-html5:before { + content: "\f13b"; } + +.fa-hubspot:before { + content: "\f3b2"; } + +.fa-i-cursor:before { + content: "\f246"; } + +.fa-ice-cream:before { + content: "\f810"; } + +.fa-icicles:before { + content: "\f7ad"; } + +.fa-icons:before { + content: "\f86d"; } + +.fa-id-badge:before { + content: "\f2c1"; } + +.fa-id-card:before { + content: "\f2c2"; } + +.fa-id-card-alt:before { + content: "\f47f"; } + +.fa-ideal:before { + content: "\f913"; } + +.fa-igloo:before { + content: "\f7ae"; } + +.fa-image:before { + content: "\f03e"; } + +.fa-images:before { + content: "\f302"; } + +.fa-imdb:before { + content: "\f2d8"; } + +.fa-inbox:before { + content: "\f01c"; } + +.fa-indent:before { + content: "\f03c"; } + +.fa-industry:before { + content: "\f275"; } + +.fa-infinity:before { + content: "\f534"; } + +.fa-info:before { + content: "\f129"; } + +.fa-info-circle:before { + content: "\f05a"; } + +.fa-instagram:before { + content: "\f16d"; } + +.fa-instagram-square:before { + content: "\f955"; } + +.fa-intercom:before { + content: "\f7af"; } + +.fa-internet-explorer:before { + content: "\f26b"; } + +.fa-invision:before { + content: "\f7b0"; } + +.fa-ioxhost:before { + content: "\f208"; } + +.fa-italic:before { + content: "\f033"; } + +.fa-itch-io:before { + content: "\f83a"; } + +.fa-itunes:before { + content: "\f3b4"; } + +.fa-itunes-note:before { + content: "\f3b5"; } + +.fa-java:before { + content: "\f4e4"; } + +.fa-jedi:before { + content: "\f669"; } + +.fa-jedi-order:before { + content: "\f50e"; } + +.fa-jenkins:before { + content: "\f3b6"; } + +.fa-jira:before { + content: "\f7b1"; } + +.fa-joget:before { + content: "\f3b7"; } + +.fa-joint:before { + content: "\f595"; } + +.fa-joomla:before { + content: "\f1aa"; } + +.fa-journal-whills:before { + content: "\f66a"; } + +.fa-js:before { + content: "\f3b8"; } + +.fa-js-square:before { + content: "\f3b9"; } + +.fa-jsfiddle:before { + content: "\f1cc"; } + +.fa-kaaba:before { + content: "\f66b"; } + +.fa-kaggle:before { + content: "\f5fa"; } + +.fa-key:before { + content: "\f084"; } + +.fa-keybase:before { + content: "\f4f5"; } + +.fa-keyboard:before { + content: "\f11c"; } + +.fa-keycdn:before { + content: "\f3ba"; } + +.fa-khanda:before { + content: "\f66d"; } + +.fa-kickstarter:before { + content: "\f3bb"; } + +.fa-kickstarter-k:before { + content: "\f3bc"; } + +.fa-kiss:before { + content: "\f596"; } + +.fa-kiss-beam:before { + content: "\f597"; } + +.fa-kiss-wink-heart:before { + content: "\f598"; } + +.fa-kiwi-bird:before { + content: "\f535"; } + +.fa-korvue:before { + content: "\f42f"; } + +.fa-landmark:before { + content: "\f66f"; } + +.fa-language:before { + content: "\f1ab"; } + +.fa-laptop:before { + content: "\f109"; } + +.fa-laptop-code:before { + content: "\f5fc"; } + +.fa-laptop-house:before { + content: "\f966"; } + +.fa-laptop-medical:before { + content: "\f812"; } + +.fa-laravel:before { + content: "\f3bd"; } + +.fa-lastfm:before { + content: "\f202"; } + +.fa-lastfm-square:before { + content: "\f203"; } + +.fa-laugh:before { + content: "\f599"; } + +.fa-laugh-beam:before { + content: "\f59a"; } + +.fa-laugh-squint:before { + content: "\f59b"; } + +.fa-laugh-wink:before { + content: "\f59c"; } + +.fa-layer-group:before { + content: "\f5fd"; } + +.fa-leaf:before { + content: "\f06c"; } + +.fa-leanpub:before { + content: "\f212"; } + +.fa-lemon:before { + content: "\f094"; } + +.fa-less:before { + content: "\f41d"; } + +.fa-less-than:before { + content: "\f536"; } + +.fa-less-than-equal:before { + content: "\f537"; } + +.fa-level-down-alt:before { + content: "\f3be"; } + +.fa-level-up-alt:before { + content: "\f3bf"; } + +.fa-life-ring:before { + content: "\f1cd"; } + +.fa-lightbulb:before { + content: "\f0eb"; } + +.fa-line:before { + content: "\f3c0"; } + +.fa-link:before { + content: "\f0c1"; } + +.fa-linkedin:before { + content: "\f08c"; } + +.fa-linkedin-in:before { + content: "\f0e1"; } + +.fa-linode:before { + content: "\f2b8"; } + +.fa-linux:before { + content: "\f17c"; } + +.fa-lira-sign:before { + content: "\f195"; } + +.fa-list:before { + content: "\f03a"; } + +.fa-list-alt:before { + content: "\f022"; } + +.fa-list-ol:before { + content: "\f0cb"; } + +.fa-list-ul:before { + content: "\f0ca"; } + +.fa-location-arrow:before { + content: "\f124"; } + +.fa-lock:before { + content: "\f023"; } + +.fa-lock-open:before { + content: "\f3c1"; } + +.fa-long-arrow-alt-down:before { + content: "\f309"; } + +.fa-long-arrow-alt-left:before { + content: "\f30a"; } + +.fa-long-arrow-alt-right:before { + content: "\f30b"; } + +.fa-long-arrow-alt-up:before { + content: "\f30c"; } + +.fa-low-vision:before { + content: "\f2a8"; } + +.fa-luggage-cart:before { + content: "\f59d"; } + +.fa-lungs:before { + content: "\f604"; } + +.fa-lungs-virus:before { + content: "\f967"; } + +.fa-lyft:before { + content: "\f3c3"; } + +.fa-magento:before { + content: "\f3c4"; } + +.fa-magic:before { + content: "\f0d0"; } + +.fa-magnet:before { + content: "\f076"; } + +.fa-mail-bulk:before { + content: "\f674"; } + +.fa-mailchimp:before { + content: "\f59e"; } + +.fa-male:before { + content: "\f183"; } + +.fa-mandalorian:before { + content: "\f50f"; } + +.fa-map:before { + content: "\f279"; } + +.fa-map-marked:before { + content: "\f59f"; } + +.fa-map-marked-alt:before { + content: "\f5a0"; } + +.fa-map-marker:before { + content: "\f041"; } + +.fa-map-marker-alt:before { + content: "\f3c5"; } + +.fa-map-pin:before { + content: "\f276"; } + +.fa-map-signs:before { + content: "\f277"; } + +.fa-markdown:before { + content: "\f60f"; } + +.fa-marker:before { + content: "\f5a1"; } + +.fa-mars:before { + content: "\f222"; } + +.fa-mars-double:before { + content: "\f227"; } + +.fa-mars-stroke:before { + content: "\f229"; } + +.fa-mars-stroke-h:before { + content: "\f22b"; } + +.fa-mars-stroke-v:before { + content: "\f22a"; } + +.fa-mask:before { + content: "\f6fa"; } + +.fa-mastodon:before { + content: "\f4f6"; } + +.fa-maxcdn:before { + content: "\f136"; } + +.fa-mdb:before { + content: "\f8ca"; } + +.fa-medal:before { + content: "\f5a2"; } + +.fa-medapps:before { + content: "\f3c6"; } + +.fa-medium:before { + content: "\f23a"; } + +.fa-medium-m:before { + content: "\f3c7"; } + +.fa-medkit:before { + content: "\f0fa"; } + +.fa-medrt:before { + content: "\f3c8"; } + +.fa-meetup:before { + content: "\f2e0"; } + +.fa-megaport:before { + content: "\f5a3"; } + +.fa-meh:before { + content: "\f11a"; } + +.fa-meh-blank:before { + content: "\f5a4"; } + +.fa-meh-rolling-eyes:before { + content: "\f5a5"; } + +.fa-memory:before { + content: "\f538"; } + +.fa-mendeley:before { + content: "\f7b3"; } + +.fa-menorah:before { + content: "\f676"; } + +.fa-mercury:before { + content: "\f223"; } + +.fa-meteor:before { + content: "\f753"; } + +.fa-microblog:before { + content: "\f91a"; } + +.fa-microchip:before { + content: "\f2db"; } + +.fa-microphone:before { + content: "\f130"; } + +.fa-microphone-alt:before { + content: "\f3c9"; } + +.fa-microphone-alt-slash:before { + content: "\f539"; } + +.fa-microphone-slash:before { + content: "\f131"; } + +.fa-microscope:before { + content: "\f610"; } + +.fa-microsoft:before { + content: "\f3ca"; } + +.fa-minus:before { + content: "\f068"; } + +.fa-minus-circle:before { + content: "\f056"; } + +.fa-minus-square:before { + content: "\f146"; } + +.fa-mitten:before { + content: "\f7b5"; } + +.fa-mix:before { + content: "\f3cb"; } + +.fa-mixcloud:before { + content: "\f289"; } + +.fa-mixer:before { + content: "\f956"; } + +.fa-mizuni:before { + content: "\f3cc"; } + +.fa-mobile:before { + content: "\f10b"; } + +.fa-mobile-alt:before { + content: "\f3cd"; } + +.fa-modx:before { + content: "\f285"; } + +.fa-monero:before { + content: "\f3d0"; } + +.fa-money-bill:before { + content: "\f0d6"; } + +.fa-money-bill-alt:before { + content: "\f3d1"; } + +.fa-money-bill-wave:before { + content: "\f53a"; } + +.fa-money-bill-wave-alt:before { + content: "\f53b"; } + +.fa-money-check:before { + content: "\f53c"; } + +.fa-money-check-alt:before { + content: "\f53d"; } + +.fa-monument:before { + content: "\f5a6"; } + +.fa-moon:before { + content: "\f186"; } + +.fa-mortar-pestle:before { + content: "\f5a7"; } + +.fa-mosque:before { + content: "\f678"; } + +.fa-motorcycle:before { + content: "\f21c"; } + +.fa-mountain:before { + content: "\f6fc"; } + +.fa-mouse:before { + content: "\f8cc"; } + +.fa-mouse-pointer:before { + content: "\f245"; } + +.fa-mug-hot:before { + content: "\f7b6"; } + +.fa-music:before { + content: "\f001"; } + +.fa-napster:before { + content: "\f3d2"; } + +.fa-neos:before { + content: "\f612"; } + +.fa-network-wired:before { + content: "\f6ff"; } + +.fa-neuter:before { + content: "\f22c"; } + +.fa-newspaper:before { + content: "\f1ea"; } + +.fa-nimblr:before { + content: "\f5a8"; } + +.fa-node:before { + content: "\f419"; } + +.fa-node-js:before { + content: "\f3d3"; } + +.fa-not-equal:before { + content: "\f53e"; } + +.fa-notes-medical:before { + content: "\f481"; } + +.fa-npm:before { + content: "\f3d4"; } + +.fa-ns8:before { + content: "\f3d5"; } + +.fa-nutritionix:before { + content: "\f3d6"; } + +.fa-object-group:before { + content: "\f247"; } + +.fa-object-ungroup:before { + content: "\f248"; } + +.fa-odnoklassniki:before { + content: "\f263"; } + +.fa-odnoklassniki-square:before { + content: "\f264"; } + +.fa-oil-can:before { + content: "\f613"; } + +.fa-old-republic:before { + content: "\f510"; } + +.fa-om:before { + content: "\f679"; } + +.fa-opencart:before { + content: "\f23d"; } + +.fa-openid:before { + content: "\f19b"; } + +.fa-opera:before { + content: "\f26a"; } + +.fa-optin-monster:before { + content: "\f23c"; } + +.fa-orcid:before { + content: "\f8d2"; } + +.fa-osi:before { + content: "\f41a"; } + +.fa-otter:before { + content: "\f700"; } + +.fa-outdent:before { + content: "\f03b"; } + +.fa-page4:before { + content: "\f3d7"; } + +.fa-pagelines:before { + content: "\f18c"; } + +.fa-pager:before { + content: "\f815"; } + +.fa-paint-brush:before { + content: "\f1fc"; } + +.fa-paint-roller:before { + content: "\f5aa"; } + +.fa-palette:before { + content: "\f53f"; } + +.fa-palfed:before { + content: "\f3d8"; } + +.fa-pallet:before { + content: "\f482"; } + +.fa-paper-plane:before { + content: "\f1d8"; } + +.fa-paperclip:before { + content: "\f0c6"; } + +.fa-parachute-box:before { + content: "\f4cd"; } + +.fa-paragraph:before { + content: "\f1dd"; } + +.fa-parking:before { + content: "\f540"; } + +.fa-passport:before { + content: "\f5ab"; } + +.fa-pastafarianism:before { + content: "\f67b"; } + +.fa-paste:before { + content: "\f0ea"; } + +.fa-patreon:before { + content: "\f3d9"; } + +.fa-pause:before { + content: "\f04c"; } + +.fa-pause-circle:before { + content: "\f28b"; } + +.fa-paw:before { + content: "\f1b0"; } + +.fa-paypal:before { + content: "\f1ed"; } + +.fa-peace:before { + content: "\f67c"; } + +.fa-pen:before { + content: "\f304"; } + +.fa-pen-alt:before { + content: "\f305"; } + +.fa-pen-fancy:before { + content: "\f5ac"; } + +.fa-pen-nib:before { + content: "\f5ad"; } + +.fa-pen-square:before { + content: "\f14b"; } + +.fa-pencil-alt:before { + content: "\f303"; } + +.fa-pencil-ruler:before { + content: "\f5ae"; } + +.fa-penny-arcade:before { + content: "\f704"; } + +.fa-people-arrows:before { + content: "\f968"; } + +.fa-people-carry:before { + content: "\f4ce"; } + +.fa-pepper-hot:before { + content: "\f816"; } + +.fa-percent:before { + content: "\f295"; } + +.fa-percentage:before { + content: "\f541"; } + +.fa-periscope:before { + content: "\f3da"; } + +.fa-person-booth:before { + content: "\f756"; } + +.fa-phabricator:before { + content: "\f3db"; } + +.fa-phoenix-framework:before { + content: "\f3dc"; } + +.fa-phoenix-squadron:before { + content: "\f511"; } + +.fa-phone:before { + content: "\f095"; } + +.fa-phone-alt:before { + content: "\f879"; } + +.fa-phone-slash:before { + content: "\f3dd"; } + +.fa-phone-square:before { + content: "\f098"; } + +.fa-phone-square-alt:before { + content: "\f87b"; } + +.fa-phone-volume:before { + content: "\f2a0"; } + +.fa-photo-video:before { + content: "\f87c"; } + +.fa-php:before { + content: "\f457"; } + +.fa-pied-piper:before { + content: "\f2ae"; } + +.fa-pied-piper-alt:before { + content: "\f1a8"; } + +.fa-pied-piper-hat:before { + content: "\f4e5"; } + +.fa-pied-piper-pp:before { + content: "\f1a7"; } + +.fa-pied-piper-square:before { + content: "\f91e"; } + +.fa-piggy-bank:before { + content: "\f4d3"; } + +.fa-pills:before { + content: "\f484"; } + +.fa-pinterest:before { + content: "\f0d2"; } + +.fa-pinterest-p:before { + content: "\f231"; } + +.fa-pinterest-square:before { + content: "\f0d3"; } + +.fa-pizza-slice:before { + content: "\f818"; } + +.fa-place-of-worship:before { + content: "\f67f"; } + +.fa-plane:before { + content: "\f072"; } + +.fa-plane-arrival:before { + content: "\f5af"; } + +.fa-plane-departure:before { + content: "\f5b0"; } + +.fa-plane-slash:before { + content: "\f969"; } + +.fa-play:before { + content: "\f04b"; } + +.fa-play-circle:before { + content: "\f144"; } + +.fa-playstation:before { + content: "\f3df"; } + +.fa-plug:before { + content: "\f1e6"; } + +.fa-plus:before { + content: "\f067"; } + +.fa-plus-circle:before { + content: "\f055"; } + +.fa-plus-square:before { + content: "\f0fe"; } + +.fa-podcast:before { + content: "\f2ce"; } + +.fa-poll:before { + content: "\f681"; } + +.fa-poll-h:before { + content: "\f682"; } + +.fa-poo:before { + content: "\f2fe"; } + +.fa-poo-storm:before { + content: "\f75a"; } + +.fa-poop:before { + content: "\f619"; } + +.fa-portrait:before { + content: "\f3e0"; } + +.fa-pound-sign:before { + content: "\f154"; } + +.fa-power-off:before { + content: "\f011"; } + +.fa-pray:before { + content: "\f683"; } + +.fa-praying-hands:before { + content: "\f684"; } + +.fa-prescription:before { + content: "\f5b1"; } + +.fa-prescription-bottle:before { + content: "\f485"; } + +.fa-prescription-bottle-alt:before { + content: "\f486"; } + +.fa-print:before { + content: "\f02f"; } + +.fa-procedures:before { + content: "\f487"; } + +.fa-product-hunt:before { + content: "\f288"; } + +.fa-project-diagram:before { + content: "\f542"; } + +.fa-pump-medical:before { + content: "\f96a"; } + +.fa-pump-soap:before { + content: "\f96b"; } + +.fa-pushed:before { + content: "\f3e1"; } + +.fa-puzzle-piece:before { + content: "\f12e"; } + +.fa-python:before { + content: "\f3e2"; } + +.fa-qq:before { + content: "\f1d6"; } + +.fa-qrcode:before { + content: "\f029"; } + +.fa-question:before { + content: "\f128"; } + +.fa-question-circle:before { + content: "\f059"; } + +.fa-quidditch:before { + content: "\f458"; } + +.fa-quinscape:before { + content: "\f459"; } + +.fa-quora:before { + content: "\f2c4"; } + +.fa-quote-left:before { + content: "\f10d"; } + +.fa-quote-right:before { + content: "\f10e"; } + +.fa-quran:before { + content: "\f687"; } + +.fa-r-project:before { + content: "\f4f7"; } + +.fa-radiation:before { + content: "\f7b9"; } + +.fa-radiation-alt:before { + content: "\f7ba"; } + +.fa-rainbow:before { + content: "\f75b"; } + +.fa-random:before { + content: "\f074"; } + +.fa-raspberry-pi:before { + content: "\f7bb"; } + +.fa-ravelry:before { + content: "\f2d9"; } + +.fa-react:before { + content: "\f41b"; } + +.fa-reacteurope:before { + content: "\f75d"; } + +.fa-readme:before { + content: "\f4d5"; } + +.fa-rebel:before { + content: "\f1d0"; } + +.fa-receipt:before { + content: "\f543"; } + +.fa-record-vinyl:before { + content: "\f8d9"; } + +.fa-recycle:before { + content: "\f1b8"; } + +.fa-red-river:before { + content: "\f3e3"; } + +.fa-reddit:before { + content: "\f1a1"; } + +.fa-reddit-alien:before { + content: "\f281"; } + +.fa-reddit-square:before { + content: "\f1a2"; } + +.fa-redhat:before { + content: "\f7bc"; } + +.fa-redo:before { + content: "\f01e"; } + +.fa-redo-alt:before { + content: "\f2f9"; } + +.fa-registered:before { + content: "\f25d"; } + +.fa-remove-format:before { + content: "\f87d"; } + +.fa-renren:before { + content: "\f18b"; } + +.fa-reply:before { + content: "\f3e5"; } + +.fa-reply-all:before { + content: "\f122"; } + +.fa-replyd:before { + content: "\f3e6"; } + +.fa-republican:before { + content: "\f75e"; } + +.fa-researchgate:before { + content: "\f4f8"; } + +.fa-resolving:before { + content: "\f3e7"; } + +.fa-restroom:before { + content: "\f7bd"; } + +.fa-retweet:before { + content: "\f079"; } + +.fa-rev:before { + content: "\f5b2"; } + +.fa-ribbon:before { + content: "\f4d6"; } + +.fa-ring:before { + content: "\f70b"; } + +.fa-road:before { + content: "\f018"; } + +.fa-robot:before { + content: "\f544"; } + +.fa-rocket:before { + content: "\f135"; } + +.fa-rocketchat:before { + content: "\f3e8"; } + +.fa-rockrms:before { + content: "\f3e9"; } + +.fa-route:before { + content: "\f4d7"; } + +.fa-rss:before { + content: "\f09e"; } + +.fa-rss-square:before { + content: "\f143"; } + +.fa-ruble-sign:before { + content: "\f158"; } + +.fa-ruler:before { + content: "\f545"; } + +.fa-ruler-combined:before { + content: "\f546"; } + +.fa-ruler-horizontal:before { + content: "\f547"; } + +.fa-ruler-vertical:before { + content: "\f548"; } + +.fa-running:before { + content: "\f70c"; } + +.fa-rupee-sign:before { + content: "\f156"; } + +.fa-sad-cry:before { + content: "\f5b3"; } + +.fa-sad-tear:before { + content: "\f5b4"; } + +.fa-safari:before { + content: "\f267"; } + +.fa-salesforce:before { + content: "\f83b"; } + +.fa-sass:before { + content: "\f41e"; } + +.fa-satellite:before { + content: "\f7bf"; } + +.fa-satellite-dish:before { + content: "\f7c0"; } + +.fa-save:before { + content: "\f0c7"; } + +.fa-schlix:before { + content: "\f3ea"; } + +.fa-school:before { + content: "\f549"; } + +.fa-screwdriver:before { + content: "\f54a"; } + +.fa-scribd:before { + content: "\f28a"; } + +.fa-scroll:before { + content: "\f70e"; } + +.fa-sd-card:before { + content: "\f7c2"; } + +.fa-search:before { + content: "\f002"; } + +.fa-search-dollar:before { + content: "\f688"; } + +.fa-search-location:before { + content: "\f689"; } + +.fa-search-minus:before { + content: "\f010"; } + +.fa-search-plus:before { + content: "\f00e"; } + +.fa-searchengin:before { + content: "\f3eb"; } + +.fa-seedling:before { + content: "\f4d8"; } + +.fa-sellcast:before { + content: "\f2da"; } + +.fa-sellsy:before { + content: "\f213"; } + +.fa-server:before { + content: "\f233"; } + +.fa-servicestack:before { + content: "\f3ec"; } + +.fa-shapes:before { + content: "\f61f"; } + +.fa-share:before { + content: "\f064"; } + +.fa-share-alt:before { + content: "\f1e0"; } + +.fa-share-alt-square:before { + content: "\f1e1"; } + +.fa-share-square:before { + content: "\f14d"; } + +.fa-shekel-sign:before { + content: "\f20b"; } + +.fa-shield-alt:before { + content: "\f3ed"; } + +.fa-shield-virus:before { + content: "\f96c"; } + +.fa-ship:before { + content: "\f21a"; } + +.fa-shipping-fast:before { + content: "\f48b"; } + +.fa-shirtsinbulk:before { + content: "\f214"; } + +.fa-shoe-prints:before { + content: "\f54b"; } + +.fa-shopify:before { + content: "\f957"; } + +.fa-shopping-bag:before { + content: "\f290"; } + +.fa-shopping-basket:before { + content: "\f291"; } + +.fa-shopping-cart:before { + content: "\f07a"; } + +.fa-shopware:before { + content: "\f5b5"; } + +.fa-shower:before { + content: "\f2cc"; } + +.fa-shuttle-van:before { + content: "\f5b6"; } + +.fa-sign:before { + content: "\f4d9"; } + +.fa-sign-in-alt:before { + content: "\f2f6"; } + +.fa-sign-language:before { + content: "\f2a7"; } + +.fa-sign-out-alt:before { + content: "\f2f5"; } + +.fa-signal:before { + content: "\f012"; } + +.fa-signature:before { + content: "\f5b7"; } + +.fa-sim-card:before { + content: "\f7c4"; } + +.fa-simplybuilt:before { + content: "\f215"; } + +.fa-sistrix:before { + content: "\f3ee"; } + +.fa-sitemap:before { + content: "\f0e8"; } + +.fa-sith:before { + content: "\f512"; } + +.fa-skating:before { + content: "\f7c5"; } + +.fa-sketch:before { + content: "\f7c6"; } + +.fa-skiing:before { + content: "\f7c9"; } + +.fa-skiing-nordic:before { + content: "\f7ca"; } + +.fa-skull:before { + content: "\f54c"; } + +.fa-skull-crossbones:before { + content: "\f714"; } + +.fa-skyatlas:before { + content: "\f216"; } + +.fa-skype:before { + content: "\f17e"; } + +.fa-slack:before { + content: "\f198"; } + +.fa-slack-hash:before { + content: "\f3ef"; } + +.fa-slash:before { + content: "\f715"; } + +.fa-sleigh:before { + content: "\f7cc"; } + +.fa-sliders-h:before { + content: "\f1de"; } + +.fa-slideshare:before { + content: "\f1e7"; } + +.fa-smile:before { + content: "\f118"; } + +.fa-smile-beam:before { + content: "\f5b8"; } + +.fa-smile-wink:before { + content: "\f4da"; } + +.fa-smog:before { + content: "\f75f"; } + +.fa-smoking:before { + content: "\f48d"; } + +.fa-smoking-ban:before { + content: "\f54d"; } + +.fa-sms:before { + content: "\f7cd"; } + +.fa-snapchat:before { + content: "\f2ab"; } + +.fa-snapchat-ghost:before { + content: "\f2ac"; } + +.fa-snapchat-square:before { + content: "\f2ad"; } + +.fa-snowboarding:before { + content: "\f7ce"; } + +.fa-snowflake:before { + content: "\f2dc"; } + +.fa-snowman:before { + content: "\f7d0"; } + +.fa-snowplow:before { + content: "\f7d2"; } + +.fa-soap:before { + content: "\f96e"; } + +.fa-socks:before { + content: "\f696"; } + +.fa-solar-panel:before { + content: "\f5ba"; } + +.fa-sort:before { + content: "\f0dc"; } + +.fa-sort-alpha-down:before { + content: "\f15d"; } + +.fa-sort-alpha-down-alt:before { + content: "\f881"; } + +.fa-sort-alpha-up:before { + content: "\f15e"; } + +.fa-sort-alpha-up-alt:before { + content: "\f882"; } + +.fa-sort-amount-down:before { + content: "\f160"; } + +.fa-sort-amount-down-alt:before { + content: "\f884"; } + +.fa-sort-amount-up:before { + content: "\f161"; } + +.fa-sort-amount-up-alt:before { + content: "\f885"; } + +.fa-sort-down:before { + content: "\f0dd"; } + +.fa-sort-numeric-down:before { + content: "\f162"; } + +.fa-sort-numeric-down-alt:before { + content: "\f886"; } + +.fa-sort-numeric-up:before { + content: "\f163"; } + +.fa-sort-numeric-up-alt:before { + content: "\f887"; } + +.fa-sort-up:before { + content: "\f0de"; } + +.fa-soundcloud:before { + content: "\f1be"; } + +.fa-sourcetree:before { + content: "\f7d3"; } + +.fa-spa:before { + content: "\f5bb"; } + +.fa-space-shuttle:before { + content: "\f197"; } + +.fa-speakap:before { + content: "\f3f3"; } + +.fa-speaker-deck:before { + content: "\f83c"; } + +.fa-spell-check:before { + content: "\f891"; } + +.fa-spider:before { + content: "\f717"; } + +.fa-spinner:before { + content: "\f110"; } + +.fa-splotch:before { + content: "\f5bc"; } + +.fa-spotify:before { + content: "\f1bc"; } + +.fa-spray-can:before { + content: "\f5bd"; } + +.fa-square:before { + content: "\f0c8"; } + +.fa-square-full:before { + content: "\f45c"; } + +.fa-square-root-alt:before { + content: "\f698"; } + +.fa-squarespace:before { + content: "\f5be"; } + +.fa-stack-exchange:before { + content: "\f18d"; } + +.fa-stack-overflow:before { + content: "\f16c"; } + +.fa-stackpath:before { + content: "\f842"; } + +.fa-stamp:before { + content: "\f5bf"; } + +.fa-star:before { + content: "\f005"; } + +.fa-star-and-crescent:before { + content: "\f699"; } + +.fa-star-half:before { + content: "\f089"; } + +.fa-star-half-alt:before { + content: "\f5c0"; } + +.fa-star-of-david:before { + content: "\f69a"; } + +.fa-star-of-life:before { + content: "\f621"; } + +.fa-staylinked:before { + content: "\f3f5"; } + +.fa-steam:before { + content: "\f1b6"; } + +.fa-steam-square:before { + content: "\f1b7"; } + +.fa-steam-symbol:before { + content: "\f3f6"; } + +.fa-step-backward:before { + content: "\f048"; } + +.fa-step-forward:before { + content: "\f051"; } + +.fa-stethoscope:before { + content: "\f0f1"; } + +.fa-sticker-mule:before { + content: "\f3f7"; } + +.fa-sticky-note:before { + content: "\f249"; } + +.fa-stop:before { + content: "\f04d"; } + +.fa-stop-circle:before { + content: "\f28d"; } + +.fa-stopwatch:before { + content: "\f2f2"; } + +.fa-stopwatch-20:before { + content: "\f96f"; } + +.fa-store:before { + content: "\f54e"; } + +.fa-store-alt:before { + content: "\f54f"; } + +.fa-store-alt-slash:before { + content: "\f970"; } + +.fa-store-slash:before { + content: "\f971"; } + +.fa-strava:before { + content: "\f428"; } + +.fa-stream:before { + content: "\f550"; } + +.fa-street-view:before { + content: "\f21d"; } + +.fa-strikethrough:before { + content: "\f0cc"; } + +.fa-stripe:before { + content: "\f429"; } + +.fa-stripe-s:before { + content: "\f42a"; } + +.fa-stroopwafel:before { + content: "\f551"; } + +.fa-studiovinari:before { + content: "\f3f8"; } + +.fa-stumbleupon:before { + content: "\f1a4"; } + +.fa-stumbleupon-circle:before { + content: "\f1a3"; } + +.fa-subscript:before { + content: "\f12c"; } + +.fa-subway:before { + content: "\f239"; } + +.fa-suitcase:before { + content: "\f0f2"; } + +.fa-suitcase-rolling:before { + content: "\f5c1"; } + +.fa-sun:before { + content: "\f185"; } + +.fa-superpowers:before { + content: "\f2dd"; } + +.fa-superscript:before { + content: "\f12b"; } + +.fa-supple:before { + content: "\f3f9"; } + +.fa-surprise:before { + content: "\f5c2"; } + +.fa-suse:before { + content: "\f7d6"; } + +.fa-swatchbook:before { + content: "\f5c3"; } + +.fa-swift:before { + content: "\f8e1"; } + +.fa-swimmer:before { + content: "\f5c4"; } + +.fa-swimming-pool:before { + content: "\f5c5"; } + +.fa-symfony:before { + content: "\f83d"; } + +.fa-synagogue:before { + content: "\f69b"; } + +.fa-sync:before { + content: "\f021"; } + +.fa-sync-alt:before { + content: "\f2f1"; } + +.fa-syringe:before { + content: "\f48e"; } + +.fa-table:before { + content: "\f0ce"; } + +.fa-table-tennis:before { + content: "\f45d"; } + +.fa-tablet:before { + content: "\f10a"; } + +.fa-tablet-alt:before { + content: "\f3fa"; } + +.fa-tablets:before { + content: "\f490"; } + +.fa-tachometer-alt:before { + content: "\f3fd"; } + +.fa-tag:before { + content: "\f02b"; } + +.fa-tags:before { + content: "\f02c"; } + +.fa-tape:before { + content: "\f4db"; } + +.fa-tasks:before { + content: "\f0ae"; } + +.fa-taxi:before { + content: "\f1ba"; } + +.fa-teamspeak:before { + content: "\f4f9"; } + +.fa-teeth:before { + content: "\f62e"; } + +.fa-teeth-open:before { + content: "\f62f"; } + +.fa-telegram:before { + content: "\f2c6"; } + +.fa-telegram-plane:before { + content: "\f3fe"; } + +.fa-temperature-high:before { + content: "\f769"; } + +.fa-temperature-low:before { + content: "\f76b"; } + +.fa-tencent-weibo:before { + content: "\f1d5"; } + +.fa-tenge:before { + content: "\f7d7"; } + +.fa-terminal:before { + content: "\f120"; } + +.fa-text-height:before { + content: "\f034"; } + +.fa-text-width:before { + content: "\f035"; } + +.fa-th:before { + content: "\f00a"; } + +.fa-th-large:before { + content: "\f009"; } + +.fa-th-list:before { + content: "\f00b"; } + +.fa-the-red-yeti:before { + content: "\f69d"; } + +.fa-theater-masks:before { + content: "\f630"; } + +.fa-themeco:before { + content: "\f5c6"; } + +.fa-themeisle:before { + content: "\f2b2"; } + +.fa-thermometer:before { + content: "\f491"; } + +.fa-thermometer-empty:before { + content: "\f2cb"; } + +.fa-thermometer-full:before { + content: "\f2c7"; } + +.fa-thermometer-half:before { + content: "\f2c9"; } + +.fa-thermometer-quarter:before { + content: "\f2ca"; } + +.fa-thermometer-three-quarters:before { + content: "\f2c8"; } + +.fa-think-peaks:before { + content: "\f731"; } + +.fa-thumbs-down:before { + content: "\f165"; } + +.fa-thumbs-up:before { + content: "\f164"; } + +.fa-thumbtack:before { + content: "\f08d"; } + +.fa-ticket-alt:before { + content: "\f3ff"; } + +.fa-times:before { + content: "\f00d"; } + +.fa-times-circle:before { + content: "\f057"; } + +.fa-tint:before { + content: "\f043"; } + +.fa-tint-slash:before { + content: "\f5c7"; } + +.fa-tired:before { + content: "\f5c8"; } + +.fa-toggle-off:before { + content: "\f204"; } + +.fa-toggle-on:before { + content: "\f205"; } + +.fa-toilet:before { + content: "\f7d8"; } + +.fa-toilet-paper:before { + content: "\f71e"; } + +.fa-toilet-paper-slash:before { + content: "\f972"; } + +.fa-toolbox:before { + content: "\f552"; } + +.fa-tools:before { + content: "\f7d9"; } + +.fa-tooth:before { + content: "\f5c9"; } + +.fa-torah:before { + content: "\f6a0"; } + +.fa-torii-gate:before { + content: "\f6a1"; } + +.fa-tractor:before { + content: "\f722"; } + +.fa-trade-federation:before { + content: "\f513"; } + +.fa-trademark:before { + content: "\f25c"; } + +.fa-traffic-light:before { + content: "\f637"; } + +.fa-trailer:before { + content: "\f941"; } + +.fa-train:before { + content: "\f238"; } + +.fa-tram:before { + content: "\f7da"; } + +.fa-transgender:before { + content: "\f224"; } + +.fa-transgender-alt:before { + content: "\f225"; } + +.fa-trash:before { + content: "\f1f8"; } + +.fa-trash-alt:before { + content: "\f2ed"; } + +.fa-trash-restore:before { + content: "\f829"; } + +.fa-trash-restore-alt:before { + content: "\f82a"; } + +.fa-tree:before { + content: "\f1bb"; } + +.fa-trello:before { + content: "\f181"; } + +.fa-tripadvisor:before { + content: "\f262"; } + +.fa-trophy:before { + content: "\f091"; } + +.fa-truck:before { + content: "\f0d1"; } + +.fa-truck-loading:before { + content: "\f4de"; } + +.fa-truck-monster:before { + content: "\f63b"; } + +.fa-truck-moving:before { + content: "\f4df"; } + +.fa-truck-pickup:before { + content: "\f63c"; } + +.fa-tshirt:before { + content: "\f553"; } + +.fa-tty:before { + content: "\f1e4"; } + +.fa-tumblr:before { + content: "\f173"; } + +.fa-tumblr-square:before { + content: "\f174"; } + +.fa-tv:before { + content: "\f26c"; } + +.fa-twitch:before { + content: "\f1e8"; } + +.fa-twitter:before { + content: "\f099"; } + +.fa-twitter-square:before { + content: "\f081"; } + +.fa-typo3:before { + content: "\f42b"; } + +.fa-uber:before { + content: "\f402"; } + +.fa-ubuntu:before { + content: "\f7df"; } + +.fa-uikit:before { + content: "\f403"; } + +.fa-umbraco:before { + content: "\f8e8"; } + +.fa-umbrella:before { + content: "\f0e9"; } + +.fa-umbrella-beach:before { + content: "\f5ca"; } + +.fa-underline:before { + content: "\f0cd"; } + +.fa-undo:before { + content: "\f0e2"; } + +.fa-undo-alt:before { + content: "\f2ea"; } + +.fa-uniregistry:before { + content: "\f404"; } + +.fa-unity:before { + content: "\f949"; } + +.fa-universal-access:before { + content: "\f29a"; } + +.fa-university:before { + content: "\f19c"; } + +.fa-unlink:before { + content: "\f127"; } + +.fa-unlock:before { + content: "\f09c"; } + +.fa-unlock-alt:before { + content: "\f13e"; } + +.fa-untappd:before { + content: "\f405"; } + +.fa-upload:before { + content: "\f093"; } + +.fa-ups:before { + content: "\f7e0"; } + +.fa-usb:before { + content: "\f287"; } + +.fa-user:before { + content: "\f007"; } + +.fa-user-alt:before { + content: "\f406"; } + +.fa-user-alt-slash:before { + content: "\f4fa"; } + +.fa-user-astronaut:before { + content: "\f4fb"; } + +.fa-user-check:before { + content: "\f4fc"; } + +.fa-user-circle:before { + content: "\f2bd"; } + +.fa-user-clock:before { + content: "\f4fd"; } + +.fa-user-cog:before { + content: "\f4fe"; } + +.fa-user-edit:before { + content: "\f4ff"; } + +.fa-user-friends:before { + content: "\f500"; } + +.fa-user-graduate:before { + content: "\f501"; } + +.fa-user-injured:before { + content: "\f728"; } + +.fa-user-lock:before { + content: "\f502"; } + +.fa-user-md:before { + content: "\f0f0"; } + +.fa-user-minus:before { + content: "\f503"; } + +.fa-user-ninja:before { + content: "\f504"; } + +.fa-user-nurse:before { + content: "\f82f"; } + +.fa-user-plus:before { + content: "\f234"; } + +.fa-user-secret:before { + content: "\f21b"; } + +.fa-user-shield:before { + content: "\f505"; } + +.fa-user-slash:before { + content: "\f506"; } + +.fa-user-tag:before { + content: "\f507"; } + +.fa-user-tie:before { + content: "\f508"; } + +.fa-user-times:before { + content: "\f235"; } + +.fa-users:before { + content: "\f0c0"; } + +.fa-users-cog:before { + content: "\f509"; } + +.fa-usps:before { + content: "\f7e1"; } + +.fa-ussunnah:before { + content: "\f407"; } + +.fa-utensil-spoon:before { + content: "\f2e5"; } + +.fa-utensils:before { + content: "\f2e7"; } + +.fa-vaadin:before { + content: "\f408"; } + +.fa-vector-square:before { + content: "\f5cb"; } + +.fa-venus:before { + content: "\f221"; } + +.fa-venus-double:before { + content: "\f226"; } + +.fa-venus-mars:before { + content: "\f228"; } + +.fa-viacoin:before { + content: "\f237"; } + +.fa-viadeo:before { + content: "\f2a9"; } + +.fa-viadeo-square:before { + content: "\f2aa"; } + +.fa-vial:before { + content: "\f492"; } + +.fa-vials:before { + content: "\f493"; } + +.fa-viber:before { + content: "\f409"; } + +.fa-video:before { + content: "\f03d"; } + +.fa-video-slash:before { + content: "\f4e2"; } + +.fa-vihara:before { + content: "\f6a7"; } + +.fa-vimeo:before { + content: "\f40a"; } + +.fa-vimeo-square:before { + content: "\f194"; } + +.fa-vimeo-v:before { + content: "\f27d"; } + +.fa-vine:before { + content: "\f1ca"; } + +.fa-virus:before { + content: "\f974"; } + +.fa-virus-slash:before { + content: "\f975"; } + +.fa-viruses:before { + content: "\f976"; } + +.fa-vk:before { + content: "\f189"; } + +.fa-vnv:before { + content: "\f40b"; } + +.fa-voicemail:before { + content: "\f897"; } + +.fa-volleyball-ball:before { + content: "\f45f"; } + +.fa-volume-down:before { + content: "\f027"; } + +.fa-volume-mute:before { + content: "\f6a9"; } + +.fa-volume-off:before { + content: "\f026"; } + +.fa-volume-up:before { + content: "\f028"; } + +.fa-vote-yea:before { + content: "\f772"; } + +.fa-vr-cardboard:before { + content: "\f729"; } + +.fa-vuejs:before { + content: "\f41f"; } + +.fa-walking:before { + content: "\f554"; } + +.fa-wallet:before { + content: "\f555"; } + +.fa-warehouse:before { + content: "\f494"; } + +.fa-water:before { + content: "\f773"; } + +.fa-wave-square:before { + content: "\f83e"; } + +.fa-waze:before { + content: "\f83f"; } + +.fa-weebly:before { + content: "\f5cc"; } + +.fa-weibo:before { + content: "\f18a"; } + +.fa-weight:before { + content: "\f496"; } + +.fa-weight-hanging:before { + content: "\f5cd"; } + +.fa-weixin:before { + content: "\f1d7"; } + +.fa-whatsapp:before { + content: "\f232"; } + +.fa-whatsapp-square:before { + content: "\f40c"; } + +.fa-wheelchair:before { + content: "\f193"; } + +.fa-whmcs:before { + content: "\f40d"; } + +.fa-wifi:before { + content: "\f1eb"; } + +.fa-wikipedia-w:before { + content: "\f266"; } + +.fa-wind:before { + content: "\f72e"; } + +.fa-window-close:before { + content: "\f410"; } + +.fa-window-maximize:before { + content: "\f2d0"; } + +.fa-window-minimize:before { + content: "\f2d1"; } + +.fa-window-restore:before { + content: "\f2d2"; } + +.fa-windows:before { + content: "\f17a"; } + +.fa-wine-bottle:before { + content: "\f72f"; } + +.fa-wine-glass:before { + content: "\f4e3"; } + +.fa-wine-glass-alt:before { + content: "\f5ce"; } + +.fa-wix:before { + content: "\f5cf"; } + +.fa-wizards-of-the-coast:before { + content: "\f730"; } + +.fa-wolf-pack-battalion:before { + content: "\f514"; } + +.fa-won-sign:before { + content: "\f159"; } + +.fa-wordpress:before { + content: "\f19a"; } + +.fa-wordpress-simple:before { + content: "\f411"; } + +.fa-wpbeginner:before { + content: "\f297"; } + +.fa-wpexplorer:before { + content: "\f2de"; } + +.fa-wpforms:before { + content: "\f298"; } + +.fa-wpressr:before { + content: "\f3e4"; } + +.fa-wrench:before { + content: "\f0ad"; } + +.fa-x-ray:before { + content: "\f497"; } + +.fa-xbox:before { + content: "\f412"; } + +.fa-xing:before { + content: "\f168"; } + +.fa-xing-square:before { + content: "\f169"; } + +.fa-y-combinator:before { + content: "\f23b"; } + +.fa-yahoo:before { + content: "\f19e"; } + +.fa-yammer:before { + content: "\f840"; } + +.fa-yandex:before { + content: "\f413"; } + +.fa-yandex-international:before { + content: "\f414"; } + +.fa-yarn:before { + content: "\f7e3"; } + +.fa-yelp:before { + content: "\f1e9"; } + +.fa-yen-sign:before { + content: "\f157"; } + +.fa-yin-yang:before { + content: "\f6ad"; } + +.fa-yoast:before { + content: "\f2b1"; } + +.fa-youtube:before { + content: "\f167"; } + +.fa-youtube-square:before { + content: "\f431"; } + +.fa-zhihu:before { + content: "\f63f"; } + +.sr-only { + border: 0; + clip: rect(0, 0, 0, 0); + height: 1px; + margin: -1px; + overflow: hidden; + padding: 0; + position: absolute; + width: 1px; } + +.sr-only-focusable:active, .sr-only-focusable:focus { + clip: auto; + height: auto; + margin: 0; + overflow: visible; + position: static; + width: auto; } +@font-face { + font-family: 'Font Awesome 5 Brands'; + font-style: normal; + font-weight: 400; + font-display: block; + src: url("../webfonts/fa-brands-400.eot"); + src: url("../webfonts/fa-brands-400.eot?#iefix") format("embedded-opentype"), url("../webfonts/fa-brands-400.woff2") format("woff2"), url("../webfonts/fa-brands-400.woff") format("woff"), url("../webfonts/fa-brands-400.ttf") format("truetype"), url("../webfonts/fa-brands-400.svg#fontawesome") format("svg"); } + +.fab { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } +@font-face { + font-family: 'Font Awesome 5 Free'; + font-style: normal; + font-weight: 400; + font-display: block; + src: url("../webfonts/fa-regular-400.eot"); + src: url("../webfonts/fa-regular-400.eot?#iefix") format("embedded-opentype"), url("../webfonts/fa-regular-400.woff2") format("woff2"), url("../webfonts/fa-regular-400.woff") format("woff"), url("../webfonts/fa-regular-400.ttf") format("truetype"), url("../webfonts/fa-regular-400.svg#fontawesome") format("svg"); } + +.far { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } +@font-face { + font-family: 'Font Awesome 5 Free'; + font-style: normal; + font-weight: 900; + font-display: block; + src: url("../webfonts/fa-solid-900.eot"); + src: url("../webfonts/fa-solid-900.eot?#iefix") format("embedded-opentype"), url("../webfonts/fa-solid-900.woff2") format("woff2"), url("../webfonts/fa-solid-900.woff") format("woff"), url("../webfonts/fa-solid-900.ttf") format("truetype"), url("../webfonts/fa-solid-900.svg#fontawesome") format("svg"); } + +.fa, +.fas { + font-family: 'Font Awesome 5 Free'; + font-weight: 900; } diff --git a/nlp_demo_riva/client/css/all.min.css b/nlp_demo_riva/client/css/all.min.css new file mode 100644 index 00000000..3d28ab20 --- /dev/null +++ b/nlp_demo_riva/client/css/all.min.css @@ -0,0 +1,5 @@ +/*! + * Font Awesome Free 5.13.0 by @fontawesome - https://fontawesome.com + * License - https://fontawesome.com/license/free (Icons: CC BY 4.0, Fonts: SIL OFL 1.1, Code: MIT License) + */ +.fa,.fab,.fad,.fal,.far,.fas{-moz-osx-font-smoothing:grayscale;-webkit-font-smoothing:antialiased;display:inline-block;font-style:normal;font-variant:normal;text-rendering:auto;line-height:1}.fa-lg{font-size:1.33333em;line-height:.75em;vertical-align:-.0667em}.fa-xs{font-size:.75em}.fa-sm{font-size:.875em}.fa-1x{font-size:1em}.fa-2x{font-size:2em}.fa-3x{font-size:3em}.fa-4x{font-size:4em}.fa-5x{font-size:5em}.fa-6x{font-size:6em}.fa-7x{font-size:7em}.fa-8x{font-size:8em}.fa-9x{font-size:9em}.fa-10x{font-size:10em}.fa-fw{text-align:center;width:1.25em}.fa-ul{list-style-type:none;margin-left:2.5em;padding-left:0}.fa-ul>li{position:relative}.fa-li{left:-2em;position:absolute;text-align:center;width:2em;line-height:inherit}.fa-border{border:.08em solid #eee;border-radius:.1em;padding:.2em .25em .15em}.fa-pull-left{float:left}.fa-pull-right{float:right}.fa.fa-pull-left,.fab.fa-pull-left,.fal.fa-pull-left,.far.fa-pull-left,.fas.fa-pull-left{margin-right:.3em}.fa.fa-pull-right,.fab.fa-pull-right,.fal.fa-pull-right,.far.fa-pull-right,.fas.fa-pull-right{margin-left:.3em}.fa-spin{-webkit-animation:fa-spin 2s linear infinite;animation:fa-spin 2s linear infinite}.fa-pulse{-webkit-animation:fa-spin 1s steps(8) infinite;animation:fa-spin 1s steps(8) infinite}@-webkit-keyframes fa-spin{0%{-webkit-transform:rotate(0deg);transform:rotate(0deg)}to{-webkit-transform:rotate(1turn);transform:rotate(1turn)}}@keyframes fa-spin{0%{-webkit-transform:rotate(0deg);transform:rotate(0deg)}to{-webkit-transform:rotate(1turn);transform:rotate(1turn)}}.fa-rotate-90{-ms-filter:"progid:DXImageTransform.Microsoft.BasicImage(rotation=1)";-webkit-transform:rotate(90deg);transform:rotate(90deg)}.fa-rotate-180{-ms-filter:"progid:DXImageTransform.Microsoft.BasicImage(rotation=2)";-webkit-transform:rotate(180deg);transform:rotate(180deg)}.fa-rotate-270{-ms-filter:"progid:DXImageTransform.Microsoft.BasicImage(rotation=3)";-webkit-transform:rotate(270deg);transform:rotate(270deg)}.fa-flip-horizontal{-ms-filter:"progid:DXImageTransform.Microsoft.BasicImage(rotation=0, mirror=1)";-webkit-transform:scaleX(-1);transform:scaleX(-1)}.fa-flip-vertical{-webkit-transform:scaleY(-1);transform:scaleY(-1)}.fa-flip-both,.fa-flip-horizontal.fa-flip-vertical,.fa-flip-vertical{-ms-filter:"progid:DXImageTransform.Microsoft.BasicImage(rotation=2, mirror=1)"}.fa-flip-both,.fa-flip-horizontal.fa-flip-vertical{-webkit-transform:scale(-1);transform:scale(-1)}:root .fa-flip-both,:root .fa-flip-horizontal,:root .fa-flip-vertical,:root .fa-rotate-90,:root .fa-rotate-180,:root .fa-rotate-270{-webkit-filter:none;filter:none}.fa-stack{display:inline-block;height:2em;line-height:2em;position:relative;vertical-align:middle;width:2.5em}.fa-stack-1x,.fa-stack-2x{left:0;position:absolute;text-align:center;width:100%}.fa-stack-1x{line-height:inherit}.fa-stack-2x{font-size:2em}.fa-inverse{color:#fff}.fa-500px:before{content:"\f26e"}.fa-accessible-icon:before{content:"\f368"}.fa-accusoft:before{content:"\f369"}.fa-acquisitions-incorporated:before{content:"\f6af"}.fa-ad:before{content:"\f641"}.fa-address-book:before{content:"\f2b9"}.fa-address-card:before{content:"\f2bb"}.fa-adjust:before{content:"\f042"}.fa-adn:before{content:"\f170"}.fa-adobe:before{content:"\f778"}.fa-adversal:before{content:"\f36a"}.fa-affiliatetheme:before{content:"\f36b"}.fa-air-freshener:before{content:"\f5d0"}.fa-airbnb:before{content:"\f834"}.fa-algolia:before{content:"\f36c"}.fa-align-center:before{content:"\f037"}.fa-align-justify:before{content:"\f039"}.fa-align-left:before{content:"\f036"}.fa-align-right:before{content:"\f038"}.fa-alipay:before{content:"\f642"}.fa-allergies:before{content:"\f461"}.fa-amazon:before{content:"\f270"}.fa-amazon-pay:before{content:"\f42c"}.fa-ambulance:before{content:"\f0f9"}.fa-american-sign-language-interpreting:before{content:"\f2a3"}.fa-amilia:before{content:"\f36d"}.fa-anchor:before{content:"\f13d"}.fa-android:before{content:"\f17b"}.fa-angellist:before{content:"\f209"}.fa-angle-double-down:before{content:"\f103"}.fa-angle-double-left:before{content:"\f100"}.fa-angle-double-right:before{content:"\f101"}.fa-angle-double-up:before{content:"\f102"}.fa-angle-down:before{content:"\f107"}.fa-angle-left:before{content:"\f104"}.fa-angle-right:before{content:"\f105"}.fa-angle-up:before{content:"\f106"}.fa-angry:before{content:"\f556"}.fa-angrycreative:before{content:"\f36e"}.fa-angular:before{content:"\f420"}.fa-ankh:before{content:"\f644"}.fa-app-store:before{content:"\f36f"}.fa-app-store-ios:before{content:"\f370"}.fa-apper:before{content:"\f371"}.fa-apple:before{content:"\f179"}.fa-apple-alt:before{content:"\f5d1"}.fa-apple-pay:before{content:"\f415"}.fa-archive:before{content:"\f187"}.fa-archway:before{content:"\f557"}.fa-arrow-alt-circle-down:before{content:"\f358"}.fa-arrow-alt-circle-left:before{content:"\f359"}.fa-arrow-alt-circle-right:before{content:"\f35a"}.fa-arrow-alt-circle-up:before{content:"\f35b"}.fa-arrow-circle-down:before{content:"\f0ab"}.fa-arrow-circle-left:before{content:"\f0a8"}.fa-arrow-circle-right:before{content:"\f0a9"}.fa-arrow-circle-up:before{content:"\f0aa"}.fa-arrow-down:before{content:"\f063"}.fa-arrow-left:before{content:"\f060"}.fa-arrow-right:before{content:"\f061"}.fa-arrow-up:before{content:"\f062"}.fa-arrows-alt:before{content:"\f0b2"}.fa-arrows-alt-h:before{content:"\f337"}.fa-arrows-alt-v:before{content:"\f338"}.fa-artstation:before{content:"\f77a"}.fa-assistive-listening-systems:before{content:"\f2a2"}.fa-asterisk:before{content:"\f069"}.fa-asymmetrik:before{content:"\f372"}.fa-at:before{content:"\f1fa"}.fa-atlas:before{content:"\f558"}.fa-atlassian:before{content:"\f77b"}.fa-atom:before{content:"\f5d2"}.fa-audible:before{content:"\f373"}.fa-audio-description:before{content:"\f29e"}.fa-autoprefixer:before{content:"\f41c"}.fa-avianex:before{content:"\f374"}.fa-aviato:before{content:"\f421"}.fa-award:before{content:"\f559"}.fa-aws:before{content:"\f375"}.fa-baby:before{content:"\f77c"}.fa-baby-carriage:before{content:"\f77d"}.fa-backspace:before{content:"\f55a"}.fa-backward:before{content:"\f04a"}.fa-bacon:before{content:"\f7e5"}.fa-bahai:before{content:"\f666"}.fa-balance-scale:before{content:"\f24e"}.fa-balance-scale-left:before{content:"\f515"}.fa-balance-scale-right:before{content:"\f516"}.fa-ban:before{content:"\f05e"}.fa-band-aid:before{content:"\f462"}.fa-bandcamp:before{content:"\f2d5"}.fa-barcode:before{content:"\f02a"}.fa-bars:before{content:"\f0c9"}.fa-baseball-ball:before{content:"\f433"}.fa-basketball-ball:before{content:"\f434"}.fa-bath:before{content:"\f2cd"}.fa-battery-empty:before{content:"\f244"}.fa-battery-full:before{content:"\f240"}.fa-battery-half:before{content:"\f242"}.fa-battery-quarter:before{content:"\f243"}.fa-battery-three-quarters:before{content:"\f241"}.fa-battle-net:before{content:"\f835"}.fa-bed:before{content:"\f236"}.fa-beer:before{content:"\f0fc"}.fa-behance:before{content:"\f1b4"}.fa-behance-square:before{content:"\f1b5"}.fa-bell:before{content:"\f0f3"}.fa-bell-slash:before{content:"\f1f6"}.fa-bezier-curve:before{content:"\f55b"}.fa-bible:before{content:"\f647"}.fa-bicycle:before{content:"\f206"}.fa-biking:before{content:"\f84a"}.fa-bimobject:before{content:"\f378"}.fa-binoculars:before{content:"\f1e5"}.fa-biohazard:before{content:"\f780"}.fa-birthday-cake:before{content:"\f1fd"}.fa-bitbucket:before{content:"\f171"}.fa-bitcoin:before{content:"\f379"}.fa-bity:before{content:"\f37a"}.fa-black-tie:before{content:"\f27e"}.fa-blackberry:before{content:"\f37b"}.fa-blender:before{content:"\f517"}.fa-blender-phone:before{content:"\f6b6"}.fa-blind:before{content:"\f29d"}.fa-blog:before{content:"\f781"}.fa-blogger:before{content:"\f37c"}.fa-blogger-b:before{content:"\f37d"}.fa-bluetooth:before{content:"\f293"}.fa-bluetooth-b:before{content:"\f294"}.fa-bold:before{content:"\f032"}.fa-bolt:before{content:"\f0e7"}.fa-bomb:before{content:"\f1e2"}.fa-bone:before{content:"\f5d7"}.fa-bong:before{content:"\f55c"}.fa-book:before{content:"\f02d"}.fa-book-dead:before{content:"\f6b7"}.fa-book-medical:before{content:"\f7e6"}.fa-book-open:before{content:"\f518"}.fa-book-reader:before{content:"\f5da"}.fa-bookmark:before{content:"\f02e"}.fa-bootstrap:before{content:"\f836"}.fa-border-all:before{content:"\f84c"}.fa-border-none:before{content:"\f850"}.fa-border-style:before{content:"\f853"}.fa-bowling-ball:before{content:"\f436"}.fa-box:before{content:"\f466"}.fa-box-open:before{content:"\f49e"}.fa-box-tissue:before{content:"\f95b"}.fa-boxes:before{content:"\f468"}.fa-braille:before{content:"\f2a1"}.fa-brain:before{content:"\f5dc"}.fa-bread-slice:before{content:"\f7ec"}.fa-briefcase:before{content:"\f0b1"}.fa-briefcase-medical:before{content:"\f469"}.fa-broadcast-tower:before{content:"\f519"}.fa-broom:before{content:"\f51a"}.fa-brush:before{content:"\f55d"}.fa-btc:before{content:"\f15a"}.fa-buffer:before{content:"\f837"}.fa-bug:before{content:"\f188"}.fa-building:before{content:"\f1ad"}.fa-bullhorn:before{content:"\f0a1"}.fa-bullseye:before{content:"\f140"}.fa-burn:before{content:"\f46a"}.fa-buromobelexperte:before{content:"\f37f"}.fa-bus:before{content:"\f207"}.fa-bus-alt:before{content:"\f55e"}.fa-business-time:before{content:"\f64a"}.fa-buy-n-large:before{content:"\f8a6"}.fa-buysellads:before{content:"\f20d"}.fa-calculator:before{content:"\f1ec"}.fa-calendar:before{content:"\f133"}.fa-calendar-alt:before{content:"\f073"}.fa-calendar-check:before{content:"\f274"}.fa-calendar-day:before{content:"\f783"}.fa-calendar-minus:before{content:"\f272"}.fa-calendar-plus:before{content:"\f271"}.fa-calendar-times:before{content:"\f273"}.fa-calendar-week:before{content:"\f784"}.fa-camera:before{content:"\f030"}.fa-camera-retro:before{content:"\f083"}.fa-campground:before{content:"\f6bb"}.fa-canadian-maple-leaf:before{content:"\f785"}.fa-candy-cane:before{content:"\f786"}.fa-cannabis:before{content:"\f55f"}.fa-capsules:before{content:"\f46b"}.fa-car:before{content:"\f1b9"}.fa-car-alt:before{content:"\f5de"}.fa-car-battery:before{content:"\f5df"}.fa-car-crash:before{content:"\f5e1"}.fa-car-side:before{content:"\f5e4"}.fa-caravan:before{content:"\f8ff"}.fa-caret-down:before{content:"\f0d7"}.fa-caret-left:before{content:"\f0d9"}.fa-caret-right:before{content:"\f0da"}.fa-caret-square-down:before{content:"\f150"}.fa-caret-square-left:before{content:"\f191"}.fa-caret-square-right:before{content:"\f152"}.fa-caret-square-up:before{content:"\f151"}.fa-caret-up:before{content:"\f0d8"}.fa-carrot:before{content:"\f787"}.fa-cart-arrow-down:before{content:"\f218"}.fa-cart-plus:before{content:"\f217"}.fa-cash-register:before{content:"\f788"}.fa-cat:before{content:"\f6be"}.fa-cc-amazon-pay:before{content:"\f42d"}.fa-cc-amex:before{content:"\f1f3"}.fa-cc-apple-pay:before{content:"\f416"}.fa-cc-diners-club:before{content:"\f24c"}.fa-cc-discover:before{content:"\f1f2"}.fa-cc-jcb:before{content:"\f24b"}.fa-cc-mastercard:before{content:"\f1f1"}.fa-cc-paypal:before{content:"\f1f4"}.fa-cc-stripe:before{content:"\f1f5"}.fa-cc-visa:before{content:"\f1f0"}.fa-centercode:before{content:"\f380"}.fa-centos:before{content:"\f789"}.fa-certificate:before{content:"\f0a3"}.fa-chair:before{content:"\f6c0"}.fa-chalkboard:before{content:"\f51b"}.fa-chalkboard-teacher:before{content:"\f51c"}.fa-charging-station:before{content:"\f5e7"}.fa-chart-area:before{content:"\f1fe"}.fa-chart-bar:before{content:"\f080"}.fa-chart-line:before{content:"\f201"}.fa-chart-pie:before{content:"\f200"}.fa-check:before{content:"\f00c"}.fa-check-circle:before{content:"\f058"}.fa-check-double:before{content:"\f560"}.fa-check-square:before{content:"\f14a"}.fa-cheese:before{content:"\f7ef"}.fa-chess:before{content:"\f439"}.fa-chess-bishop:before{content:"\f43a"}.fa-chess-board:before{content:"\f43c"}.fa-chess-king:before{content:"\f43f"}.fa-chess-knight:before{content:"\f441"}.fa-chess-pawn:before{content:"\f443"}.fa-chess-queen:before{content:"\f445"}.fa-chess-rook:before{content:"\f447"}.fa-chevron-circle-down:before{content:"\f13a"}.fa-chevron-circle-left:before{content:"\f137"}.fa-chevron-circle-right:before{content:"\f138"}.fa-chevron-circle-up:before{content:"\f139"}.fa-chevron-down:before{content:"\f078"}.fa-chevron-left:before{content:"\f053"}.fa-chevron-right:before{content:"\f054"}.fa-chevron-up:before{content:"\f077"}.fa-child:before{content:"\f1ae"}.fa-chrome:before{content:"\f268"}.fa-chromecast:before{content:"\f838"}.fa-church:before{content:"\f51d"}.fa-circle:before{content:"\f111"}.fa-circle-notch:before{content:"\f1ce"}.fa-city:before{content:"\f64f"}.fa-clinic-medical:before{content:"\f7f2"}.fa-clipboard:before{content:"\f328"}.fa-clipboard-check:before{content:"\f46c"}.fa-clipboard-list:before{content:"\f46d"}.fa-clock:before{content:"\f017"}.fa-clone:before{content:"\f24d"}.fa-closed-captioning:before{content:"\f20a"}.fa-cloud:before{content:"\f0c2"}.fa-cloud-download-alt:before{content:"\f381"}.fa-cloud-meatball:before{content:"\f73b"}.fa-cloud-moon:before{content:"\f6c3"}.fa-cloud-moon-rain:before{content:"\f73c"}.fa-cloud-rain:before{content:"\f73d"}.fa-cloud-showers-heavy:before{content:"\f740"}.fa-cloud-sun:before{content:"\f6c4"}.fa-cloud-sun-rain:before{content:"\f743"}.fa-cloud-upload-alt:before{content:"\f382"}.fa-cloudscale:before{content:"\f383"}.fa-cloudsmith:before{content:"\f384"}.fa-cloudversify:before{content:"\f385"}.fa-cocktail:before{content:"\f561"}.fa-code:before{content:"\f121"}.fa-code-branch:before{content:"\f126"}.fa-codepen:before{content:"\f1cb"}.fa-codiepie:before{content:"\f284"}.fa-coffee:before{content:"\f0f4"}.fa-cog:before{content:"\f013"}.fa-cogs:before{content:"\f085"}.fa-coins:before{content:"\f51e"}.fa-columns:before{content:"\f0db"}.fa-comment:before{content:"\f075"}.fa-comment-alt:before{content:"\f27a"}.fa-comment-dollar:before{content:"\f651"}.fa-comment-dots:before{content:"\f4ad"}.fa-comment-medical:before{content:"\f7f5"}.fa-comment-slash:before{content:"\f4b3"}.fa-comments:before{content:"\f086"}.fa-comments-dollar:before{content:"\f653"}.fa-compact-disc:before{content:"\f51f"}.fa-compass:before{content:"\f14e"}.fa-compress:before{content:"\f066"}.fa-compress-alt:before{content:"\f422"}.fa-compress-arrows-alt:before{content:"\f78c"}.fa-concierge-bell:before{content:"\f562"}.fa-confluence:before{content:"\f78d"}.fa-connectdevelop:before{content:"\f20e"}.fa-contao:before{content:"\f26d"}.fa-cookie:before{content:"\f563"}.fa-cookie-bite:before{content:"\f564"}.fa-copy:before{content:"\f0c5"}.fa-copyright:before{content:"\f1f9"}.fa-cotton-bureau:before{content:"\f89e"}.fa-couch:before{content:"\f4b8"}.fa-cpanel:before{content:"\f388"}.fa-creative-commons:before{content:"\f25e"}.fa-creative-commons-by:before{content:"\f4e7"}.fa-creative-commons-nc:before{content:"\f4e8"}.fa-creative-commons-nc-eu:before{content:"\f4e9"}.fa-creative-commons-nc-jp:before{content:"\f4ea"}.fa-creative-commons-nd:before{content:"\f4eb"}.fa-creative-commons-pd:before{content:"\f4ec"}.fa-creative-commons-pd-alt:before{content:"\f4ed"}.fa-creative-commons-remix:before{content:"\f4ee"}.fa-creative-commons-sa:before{content:"\f4ef"}.fa-creative-commons-sampling:before{content:"\f4f0"}.fa-creative-commons-sampling-plus:before{content:"\f4f1"}.fa-creative-commons-share:before{content:"\f4f2"}.fa-creative-commons-zero:before{content:"\f4f3"}.fa-credit-card:before{content:"\f09d"}.fa-critical-role:before{content:"\f6c9"}.fa-crop:before{content:"\f125"}.fa-crop-alt:before{content:"\f565"}.fa-cross:before{content:"\f654"}.fa-crosshairs:before{content:"\f05b"}.fa-crow:before{content:"\f520"}.fa-crown:before{content:"\f521"}.fa-crutch:before{content:"\f7f7"}.fa-css3:before{content:"\f13c"}.fa-css3-alt:before{content:"\f38b"}.fa-cube:before{content:"\f1b2"}.fa-cubes:before{content:"\f1b3"}.fa-cut:before{content:"\f0c4"}.fa-cuttlefish:before{content:"\f38c"}.fa-d-and-d:before{content:"\f38d"}.fa-d-and-d-beyond:before{content:"\f6ca"}.fa-dailymotion:before{content:"\f952"}.fa-dashcube:before{content:"\f210"}.fa-database:before{content:"\f1c0"}.fa-deaf:before{content:"\f2a4"}.fa-delicious:before{content:"\f1a5"}.fa-democrat:before{content:"\f747"}.fa-deploydog:before{content:"\f38e"}.fa-deskpro:before{content:"\f38f"}.fa-desktop:before{content:"\f108"}.fa-dev:before{content:"\f6cc"}.fa-deviantart:before{content:"\f1bd"}.fa-dharmachakra:before{content:"\f655"}.fa-dhl:before{content:"\f790"}.fa-diagnoses:before{content:"\f470"}.fa-diaspora:before{content:"\f791"}.fa-dice:before{content:"\f522"}.fa-dice-d20:before{content:"\f6cf"}.fa-dice-d6:before{content:"\f6d1"}.fa-dice-five:before{content:"\f523"}.fa-dice-four:before{content:"\f524"}.fa-dice-one:before{content:"\f525"}.fa-dice-six:before{content:"\f526"}.fa-dice-three:before{content:"\f527"}.fa-dice-two:before{content:"\f528"}.fa-digg:before{content:"\f1a6"}.fa-digital-ocean:before{content:"\f391"}.fa-digital-tachograph:before{content:"\f566"}.fa-directions:before{content:"\f5eb"}.fa-discord:before{content:"\f392"}.fa-discourse:before{content:"\f393"}.fa-disease:before{content:"\f7fa"}.fa-divide:before{content:"\f529"}.fa-dizzy:before{content:"\f567"}.fa-dna:before{content:"\f471"}.fa-dochub:before{content:"\f394"}.fa-docker:before{content:"\f395"}.fa-dog:before{content:"\f6d3"}.fa-dollar-sign:before{content:"\f155"}.fa-dolly:before{content:"\f472"}.fa-dolly-flatbed:before{content:"\f474"}.fa-donate:before{content:"\f4b9"}.fa-door-closed:before{content:"\f52a"}.fa-door-open:before{content:"\f52b"}.fa-dot-circle:before{content:"\f192"}.fa-dove:before{content:"\f4ba"}.fa-download:before{content:"\f019"}.fa-draft2digital:before{content:"\f396"}.fa-drafting-compass:before{content:"\f568"}.fa-dragon:before{content:"\f6d5"}.fa-draw-polygon:before{content:"\f5ee"}.fa-dribbble:before{content:"\f17d"}.fa-dribbble-square:before{content:"\f397"}.fa-dropbox:before{content:"\f16b"}.fa-drum:before{content:"\f569"}.fa-drum-steelpan:before{content:"\f56a"}.fa-drumstick-bite:before{content:"\f6d7"}.fa-drupal:before{content:"\f1a9"}.fa-dumbbell:before{content:"\f44b"}.fa-dumpster:before{content:"\f793"}.fa-dumpster-fire:before{content:"\f794"}.fa-dungeon:before{content:"\f6d9"}.fa-dyalog:before{content:"\f399"}.fa-earlybirds:before{content:"\f39a"}.fa-ebay:before{content:"\f4f4"}.fa-edge:before{content:"\f282"}.fa-edit:before{content:"\f044"}.fa-egg:before{content:"\f7fb"}.fa-eject:before{content:"\f052"}.fa-elementor:before{content:"\f430"}.fa-ellipsis-h:before{content:"\f141"}.fa-ellipsis-v:before{content:"\f142"}.fa-ello:before{content:"\f5f1"}.fa-ember:before{content:"\f423"}.fa-empire:before{content:"\f1d1"}.fa-envelope:before{content:"\f0e0"}.fa-envelope-open:before{content:"\f2b6"}.fa-envelope-open-text:before{content:"\f658"}.fa-envelope-square:before{content:"\f199"}.fa-envira:before{content:"\f299"}.fa-equals:before{content:"\f52c"}.fa-eraser:before{content:"\f12d"}.fa-erlang:before{content:"\f39d"}.fa-ethereum:before{content:"\f42e"}.fa-ethernet:before{content:"\f796"}.fa-etsy:before{content:"\f2d7"}.fa-euro-sign:before{content:"\f153"}.fa-evernote:before{content:"\f839"}.fa-exchange-alt:before{content:"\f362"}.fa-exclamation:before{content:"\f12a"}.fa-exclamation-circle:before{content:"\f06a"}.fa-exclamation-triangle:before{content:"\f071"}.fa-expand:before{content:"\f065"}.fa-expand-alt:before{content:"\f424"}.fa-expand-arrows-alt:before{content:"\f31e"}.fa-expeditedssl:before{content:"\f23e"}.fa-external-link-alt:before{content:"\f35d"}.fa-external-link-square-alt:before{content:"\f360"}.fa-eye:before{content:"\f06e"}.fa-eye-dropper:before{content:"\f1fb"}.fa-eye-slash:before{content:"\f070"}.fa-facebook:before{content:"\f09a"}.fa-facebook-f:before{content:"\f39e"}.fa-facebook-messenger:before{content:"\f39f"}.fa-facebook-square:before{content:"\f082"}.fa-fan:before{content:"\f863"}.fa-fantasy-flight-games:before{content:"\f6dc"}.fa-fast-backward:before{content:"\f049"}.fa-fast-forward:before{content:"\f050"}.fa-faucet:before{content:"\f905"}.fa-fax:before{content:"\f1ac"}.fa-feather:before{content:"\f52d"}.fa-feather-alt:before{content:"\f56b"}.fa-fedex:before{content:"\f797"}.fa-fedora:before{content:"\f798"}.fa-female:before{content:"\f182"}.fa-fighter-jet:before{content:"\f0fb"}.fa-figma:before{content:"\f799"}.fa-file:before{content:"\f15b"}.fa-file-alt:before{content:"\f15c"}.fa-file-archive:before{content:"\f1c6"}.fa-file-audio:before{content:"\f1c7"}.fa-file-code:before{content:"\f1c9"}.fa-file-contract:before{content:"\f56c"}.fa-file-csv:before{content:"\f6dd"}.fa-file-download:before{content:"\f56d"}.fa-file-excel:before{content:"\f1c3"}.fa-file-export:before{content:"\f56e"}.fa-file-image:before{content:"\f1c5"}.fa-file-import:before{content:"\f56f"}.fa-file-invoice:before{content:"\f570"}.fa-file-invoice-dollar:before{content:"\f571"}.fa-file-medical:before{content:"\f477"}.fa-file-medical-alt:before{content:"\f478"}.fa-file-pdf:before{content:"\f1c1"}.fa-file-powerpoint:before{content:"\f1c4"}.fa-file-prescription:before{content:"\f572"}.fa-file-signature:before{content:"\f573"}.fa-file-upload:before{content:"\f574"}.fa-file-video:before{content:"\f1c8"}.fa-file-word:before{content:"\f1c2"}.fa-fill:before{content:"\f575"}.fa-fill-drip:before{content:"\f576"}.fa-film:before{content:"\f008"}.fa-filter:before{content:"\f0b0"}.fa-fingerprint:before{content:"\f577"}.fa-fire:before{content:"\f06d"}.fa-fire-alt:before{content:"\f7e4"}.fa-fire-extinguisher:before{content:"\f134"}.fa-firefox:before{content:"\f269"}.fa-firefox-browser:before{content:"\f907"}.fa-first-aid:before{content:"\f479"}.fa-first-order:before{content:"\f2b0"}.fa-first-order-alt:before{content:"\f50a"}.fa-firstdraft:before{content:"\f3a1"}.fa-fish:before{content:"\f578"}.fa-fist-raised:before{content:"\f6de"}.fa-flag:before{content:"\f024"}.fa-flag-checkered:before{content:"\f11e"}.fa-flag-usa:before{content:"\f74d"}.fa-flask:before{content:"\f0c3"}.fa-flickr:before{content:"\f16e"}.fa-flipboard:before{content:"\f44d"}.fa-flushed:before{content:"\f579"}.fa-fly:before{content:"\f417"}.fa-folder:before{content:"\f07b"}.fa-folder-minus:before{content:"\f65d"}.fa-folder-open:before{content:"\f07c"}.fa-folder-plus:before{content:"\f65e"}.fa-font:before{content:"\f031"}.fa-font-awesome:before{content:"\f2b4"}.fa-font-awesome-alt:before{content:"\f35c"}.fa-font-awesome-flag:before{content:"\f425"}.fa-font-awesome-logo-full:before{content:"\f4e6"}.fa-fonticons:before{content:"\f280"}.fa-fonticons-fi:before{content:"\f3a2"}.fa-football-ball:before{content:"\f44e"}.fa-fort-awesome:before{content:"\f286"}.fa-fort-awesome-alt:before{content:"\f3a3"}.fa-forumbee:before{content:"\f211"}.fa-forward:before{content:"\f04e"}.fa-foursquare:before{content:"\f180"}.fa-free-code-camp:before{content:"\f2c5"}.fa-freebsd:before{content:"\f3a4"}.fa-frog:before{content:"\f52e"}.fa-frown:before{content:"\f119"}.fa-frown-open:before{content:"\f57a"}.fa-fulcrum:before{content:"\f50b"}.fa-funnel-dollar:before{content:"\f662"}.fa-futbol:before{content:"\f1e3"}.fa-galactic-republic:before{content:"\f50c"}.fa-galactic-senate:before{content:"\f50d"}.fa-gamepad:before{content:"\f11b"}.fa-gas-pump:before{content:"\f52f"}.fa-gavel:before{content:"\f0e3"}.fa-gem:before{content:"\f3a5"}.fa-genderless:before{content:"\f22d"}.fa-get-pocket:before{content:"\f265"}.fa-gg:before{content:"\f260"}.fa-gg-circle:before{content:"\f261"}.fa-ghost:before{content:"\f6e2"}.fa-gift:before{content:"\f06b"}.fa-gifts:before{content:"\f79c"}.fa-git:before{content:"\f1d3"}.fa-git-alt:before{content:"\f841"}.fa-git-square:before{content:"\f1d2"}.fa-github:before{content:"\f09b"}.fa-github-alt:before{content:"\f113"}.fa-github-square:before{content:"\f092"}.fa-gitkraken:before{content:"\f3a6"}.fa-gitlab:before{content:"\f296"}.fa-gitter:before{content:"\f426"}.fa-glass-cheers:before{content:"\f79f"}.fa-glass-martini:before{content:"\f000"}.fa-glass-martini-alt:before{content:"\f57b"}.fa-glass-whiskey:before{content:"\f7a0"}.fa-glasses:before{content:"\f530"}.fa-glide:before{content:"\f2a5"}.fa-glide-g:before{content:"\f2a6"}.fa-globe:before{content:"\f0ac"}.fa-globe-africa:before{content:"\f57c"}.fa-globe-americas:before{content:"\f57d"}.fa-globe-asia:before{content:"\f57e"}.fa-globe-europe:before{content:"\f7a2"}.fa-gofore:before{content:"\f3a7"}.fa-golf-ball:before{content:"\f450"}.fa-goodreads:before{content:"\f3a8"}.fa-goodreads-g:before{content:"\f3a9"}.fa-google:before{content:"\f1a0"}.fa-google-drive:before{content:"\f3aa"}.fa-google-play:before{content:"\f3ab"}.fa-google-plus:before{content:"\f2b3"}.fa-google-plus-g:before{content:"\f0d5"}.fa-google-plus-square:before{content:"\f0d4"}.fa-google-wallet:before{content:"\f1ee"}.fa-gopuram:before{content:"\f664"}.fa-graduation-cap:before{content:"\f19d"}.fa-gratipay:before{content:"\f184"}.fa-grav:before{content:"\f2d6"}.fa-greater-than:before{content:"\f531"}.fa-greater-than-equal:before{content:"\f532"}.fa-grimace:before{content:"\f57f"}.fa-grin:before{content:"\f580"}.fa-grin-alt:before{content:"\f581"}.fa-grin-beam:before{content:"\f582"}.fa-grin-beam-sweat:before{content:"\f583"}.fa-grin-hearts:before{content:"\f584"}.fa-grin-squint:before{content:"\f585"}.fa-grin-squint-tears:before{content:"\f586"}.fa-grin-stars:before{content:"\f587"}.fa-grin-tears:before{content:"\f588"}.fa-grin-tongue:before{content:"\f589"}.fa-grin-tongue-squint:before{content:"\f58a"}.fa-grin-tongue-wink:before{content:"\f58b"}.fa-grin-wink:before{content:"\f58c"}.fa-grip-horizontal:before{content:"\f58d"}.fa-grip-lines:before{content:"\f7a4"}.fa-grip-lines-vertical:before{content:"\f7a5"}.fa-grip-vertical:before{content:"\f58e"}.fa-gripfire:before{content:"\f3ac"}.fa-grunt:before{content:"\f3ad"}.fa-guitar:before{content:"\f7a6"}.fa-gulp:before{content:"\f3ae"}.fa-h-square:before{content:"\f0fd"}.fa-hacker-news:before{content:"\f1d4"}.fa-hacker-news-square:before{content:"\f3af"}.fa-hackerrank:before{content:"\f5f7"}.fa-hamburger:before{content:"\f805"}.fa-hammer:before{content:"\f6e3"}.fa-hamsa:before{content:"\f665"}.fa-hand-holding:before{content:"\f4bd"}.fa-hand-holding-heart:before{content:"\f4be"}.fa-hand-holding-medical:before{content:"\f95c"}.fa-hand-holding-usd:before{content:"\f4c0"}.fa-hand-holding-water:before{content:"\f4c1"}.fa-hand-lizard:before{content:"\f258"}.fa-hand-middle-finger:before{content:"\f806"}.fa-hand-paper:before{content:"\f256"}.fa-hand-peace:before{content:"\f25b"}.fa-hand-point-down:before{content:"\f0a7"}.fa-hand-point-left:before{content:"\f0a5"}.fa-hand-point-right:before{content:"\f0a4"}.fa-hand-point-up:before{content:"\f0a6"}.fa-hand-pointer:before{content:"\f25a"}.fa-hand-rock:before{content:"\f255"}.fa-hand-scissors:before{content:"\f257"}.fa-hand-sparkles:before{content:"\f95d"}.fa-hand-spock:before{content:"\f259"}.fa-hands:before{content:"\f4c2"}.fa-hands-helping:before{content:"\f4c4"}.fa-hands-wash:before{content:"\f95e"}.fa-handshake:before{content:"\f2b5"}.fa-handshake-alt-slash:before{content:"\f95f"}.fa-handshake-slash:before{content:"\f960"}.fa-hanukiah:before{content:"\f6e6"}.fa-hard-hat:before{content:"\f807"}.fa-hashtag:before{content:"\f292"}.fa-hat-cowboy:before{content:"\f8c0"}.fa-hat-cowboy-side:before{content:"\f8c1"}.fa-hat-wizard:before{content:"\f6e8"}.fa-hdd:before{content:"\f0a0"}.fa-head-side-cough:before{content:"\f961"}.fa-head-side-cough-slash:before{content:"\f962"}.fa-head-side-mask:before{content:"\f963"}.fa-head-side-virus:before{content:"\f964"}.fa-heading:before{content:"\f1dc"}.fa-headphones:before{content:"\f025"}.fa-headphones-alt:before{content:"\f58f"}.fa-headset:before{content:"\f590"}.fa-heart:before{content:"\f004"}.fa-heart-broken:before{content:"\f7a9"}.fa-heartbeat:before{content:"\f21e"}.fa-helicopter:before{content:"\f533"}.fa-highlighter:before{content:"\f591"}.fa-hiking:before{content:"\f6ec"}.fa-hippo:before{content:"\f6ed"}.fa-hips:before{content:"\f452"}.fa-hire-a-helper:before{content:"\f3b0"}.fa-history:before{content:"\f1da"}.fa-hockey-puck:before{content:"\f453"}.fa-holly-berry:before{content:"\f7aa"}.fa-home:before{content:"\f015"}.fa-hooli:before{content:"\f427"}.fa-hornbill:before{content:"\f592"}.fa-horse:before{content:"\f6f0"}.fa-horse-head:before{content:"\f7ab"}.fa-hospital:before{content:"\f0f8"}.fa-hospital-alt:before{content:"\f47d"}.fa-hospital-symbol:before{content:"\f47e"}.fa-hospital-user:before{content:"\f80d"}.fa-hot-tub:before{content:"\f593"}.fa-hotdog:before{content:"\f80f"}.fa-hotel:before{content:"\f594"}.fa-hotjar:before{content:"\f3b1"}.fa-hourglass:before{content:"\f254"}.fa-hourglass-end:before{content:"\f253"}.fa-hourglass-half:before{content:"\f252"}.fa-hourglass-start:before{content:"\f251"}.fa-house-damage:before{content:"\f6f1"}.fa-house-user:before{content:"\f965"}.fa-houzz:before{content:"\f27c"}.fa-hryvnia:before{content:"\f6f2"}.fa-html5:before{content:"\f13b"}.fa-hubspot:before{content:"\f3b2"}.fa-i-cursor:before{content:"\f246"}.fa-ice-cream:before{content:"\f810"}.fa-icicles:before{content:"\f7ad"}.fa-icons:before{content:"\f86d"}.fa-id-badge:before{content:"\f2c1"}.fa-id-card:before{content:"\f2c2"}.fa-id-card-alt:before{content:"\f47f"}.fa-ideal:before{content:"\f913"}.fa-igloo:before{content:"\f7ae"}.fa-image:before{content:"\f03e"}.fa-images:before{content:"\f302"}.fa-imdb:before{content:"\f2d8"}.fa-inbox:before{content:"\f01c"}.fa-indent:before{content:"\f03c"}.fa-industry:before{content:"\f275"}.fa-infinity:before{content:"\f534"}.fa-info:before{content:"\f129"}.fa-info-circle:before{content:"\f05a"}.fa-instagram:before{content:"\f16d"}.fa-instagram-square:before{content:"\f955"}.fa-intercom:before{content:"\f7af"}.fa-internet-explorer:before{content:"\f26b"}.fa-invision:before{content:"\f7b0"}.fa-ioxhost:before{content:"\f208"}.fa-italic:before{content:"\f033"}.fa-itch-io:before{content:"\f83a"}.fa-itunes:before{content:"\f3b4"}.fa-itunes-note:before{content:"\f3b5"}.fa-java:before{content:"\f4e4"}.fa-jedi:before{content:"\f669"}.fa-jedi-order:before{content:"\f50e"}.fa-jenkins:before{content:"\f3b6"}.fa-jira:before{content:"\f7b1"}.fa-joget:before{content:"\f3b7"}.fa-joint:before{content:"\f595"}.fa-joomla:before{content:"\f1aa"}.fa-journal-whills:before{content:"\f66a"}.fa-js:before{content:"\f3b8"}.fa-js-square:before{content:"\f3b9"}.fa-jsfiddle:before{content:"\f1cc"}.fa-kaaba:before{content:"\f66b"}.fa-kaggle:before{content:"\f5fa"}.fa-key:before{content:"\f084"}.fa-keybase:before{content:"\f4f5"}.fa-keyboard:before{content:"\f11c"}.fa-keycdn:before{content:"\f3ba"}.fa-khanda:before{content:"\f66d"}.fa-kickstarter:before{content:"\f3bb"}.fa-kickstarter-k:before{content:"\f3bc"}.fa-kiss:before{content:"\f596"}.fa-kiss-beam:before{content:"\f597"}.fa-kiss-wink-heart:before{content:"\f598"}.fa-kiwi-bird:before{content:"\f535"}.fa-korvue:before{content:"\f42f"}.fa-landmark:before{content:"\f66f"}.fa-language:before{content:"\f1ab"}.fa-laptop:before{content:"\f109"}.fa-laptop-code:before{content:"\f5fc"}.fa-laptop-house:before{content:"\f966"}.fa-laptop-medical:before{content:"\f812"}.fa-laravel:before{content:"\f3bd"}.fa-lastfm:before{content:"\f202"}.fa-lastfm-square:before{content:"\f203"}.fa-laugh:before{content:"\f599"}.fa-laugh-beam:before{content:"\f59a"}.fa-laugh-squint:before{content:"\f59b"}.fa-laugh-wink:before{content:"\f59c"}.fa-layer-group:before{content:"\f5fd"}.fa-leaf:before{content:"\f06c"}.fa-leanpub:before{content:"\f212"}.fa-lemon:before{content:"\f094"}.fa-less:before{content:"\f41d"}.fa-less-than:before{content:"\f536"}.fa-less-than-equal:before{content:"\f537"}.fa-level-down-alt:before{content:"\f3be"}.fa-level-up-alt:before{content:"\f3bf"}.fa-life-ring:before{content:"\f1cd"}.fa-lightbulb:before{content:"\f0eb"}.fa-line:before{content:"\f3c0"}.fa-link:before{content:"\f0c1"}.fa-linkedin:before{content:"\f08c"}.fa-linkedin-in:before{content:"\f0e1"}.fa-linode:before{content:"\f2b8"}.fa-linux:before{content:"\f17c"}.fa-lira-sign:before{content:"\f195"}.fa-list:before{content:"\f03a"}.fa-list-alt:before{content:"\f022"}.fa-list-ol:before{content:"\f0cb"}.fa-list-ul:before{content:"\f0ca"}.fa-location-arrow:before{content:"\f124"}.fa-lock:before{content:"\f023"}.fa-lock-open:before{content:"\f3c1"}.fa-long-arrow-alt-down:before{content:"\f309"}.fa-long-arrow-alt-left:before{content:"\f30a"}.fa-long-arrow-alt-right:before{content:"\f30b"}.fa-long-arrow-alt-up:before{content:"\f30c"}.fa-low-vision:before{content:"\f2a8"}.fa-luggage-cart:before{content:"\f59d"}.fa-lungs:before{content:"\f604"}.fa-lungs-virus:before{content:"\f967"}.fa-lyft:before{content:"\f3c3"}.fa-magento:before{content:"\f3c4"}.fa-magic:before{content:"\f0d0"}.fa-magnet:before{content:"\f076"}.fa-mail-bulk:before{content:"\f674"}.fa-mailchimp:before{content:"\f59e"}.fa-male:before{content:"\f183"}.fa-mandalorian:before{content:"\f50f"}.fa-map:before{content:"\f279"}.fa-map-marked:before{content:"\f59f"}.fa-map-marked-alt:before{content:"\f5a0"}.fa-map-marker:before{content:"\f041"}.fa-map-marker-alt:before{content:"\f3c5"}.fa-map-pin:before{content:"\f276"}.fa-map-signs:before{content:"\f277"}.fa-markdown:before{content:"\f60f"}.fa-marker:before{content:"\f5a1"}.fa-mars:before{content:"\f222"}.fa-mars-double:before{content:"\f227"}.fa-mars-stroke:before{content:"\f229"}.fa-mars-stroke-h:before{content:"\f22b"}.fa-mars-stroke-v:before{content:"\f22a"}.fa-mask:before{content:"\f6fa"}.fa-mastodon:before{content:"\f4f6"}.fa-maxcdn:before{content:"\f136"}.fa-mdb:before{content:"\f8ca"}.fa-medal:before{content:"\f5a2"}.fa-medapps:before{content:"\f3c6"}.fa-medium:before{content:"\f23a"}.fa-medium-m:before{content:"\f3c7"}.fa-medkit:before{content:"\f0fa"}.fa-medrt:before{content:"\f3c8"}.fa-meetup:before{content:"\f2e0"}.fa-megaport:before{content:"\f5a3"}.fa-meh:before{content:"\f11a"}.fa-meh-blank:before{content:"\f5a4"}.fa-meh-rolling-eyes:before{content:"\f5a5"}.fa-memory:before{content:"\f538"}.fa-mendeley:before{content:"\f7b3"}.fa-menorah:before{content:"\f676"}.fa-mercury:before{content:"\f223"}.fa-meteor:before{content:"\f753"}.fa-microblog:before{content:"\f91a"}.fa-microchip:before{content:"\f2db"}.fa-microphone:before{content:"\f130"}.fa-microphone-alt:before{content:"\f3c9"}.fa-microphone-alt-slash:before{content:"\f539"}.fa-microphone-slash:before{content:"\f131"}.fa-microscope:before{content:"\f610"}.fa-microsoft:before{content:"\f3ca"}.fa-minus:before{content:"\f068"}.fa-minus-circle:before{content:"\f056"}.fa-minus-square:before{content:"\f146"}.fa-mitten:before{content:"\f7b5"}.fa-mix:before{content:"\f3cb"}.fa-mixcloud:before{content:"\f289"}.fa-mixer:before{content:"\f956"}.fa-mizuni:before{content:"\f3cc"}.fa-mobile:before{content:"\f10b"}.fa-mobile-alt:before{content:"\f3cd"}.fa-modx:before{content:"\f285"}.fa-monero:before{content:"\f3d0"}.fa-money-bill:before{content:"\f0d6"}.fa-money-bill-alt:before{content:"\f3d1"}.fa-money-bill-wave:before{content:"\f53a"}.fa-money-bill-wave-alt:before{content:"\f53b"}.fa-money-check:before{content:"\f53c"}.fa-money-check-alt:before{content:"\f53d"}.fa-monument:before{content:"\f5a6"}.fa-moon:before{content:"\f186"}.fa-mortar-pestle:before{content:"\f5a7"}.fa-mosque:before{content:"\f678"}.fa-motorcycle:before{content:"\f21c"}.fa-mountain:before{content:"\f6fc"}.fa-mouse:before{content:"\f8cc"}.fa-mouse-pointer:before{content:"\f245"}.fa-mug-hot:before{content:"\f7b6"}.fa-music:before{content:"\f001"}.fa-napster:before{content:"\f3d2"}.fa-neos:before{content:"\f612"}.fa-network-wired:before{content:"\f6ff"}.fa-neuter:before{content:"\f22c"}.fa-newspaper:before{content:"\f1ea"}.fa-nimblr:before{content:"\f5a8"}.fa-node:before{content:"\f419"}.fa-node-js:before{content:"\f3d3"}.fa-not-equal:before{content:"\f53e"}.fa-notes-medical:before{content:"\f481"}.fa-npm:before{content:"\f3d4"}.fa-ns8:before{content:"\f3d5"}.fa-nutritionix:before{content:"\f3d6"}.fa-object-group:before{content:"\f247"}.fa-object-ungroup:before{content:"\f248"}.fa-odnoklassniki:before{content:"\f263"}.fa-odnoklassniki-square:before{content:"\f264"}.fa-oil-can:before{content:"\f613"}.fa-old-republic:before{content:"\f510"}.fa-om:before{content:"\f679"}.fa-opencart:before{content:"\f23d"}.fa-openid:before{content:"\f19b"}.fa-opera:before{content:"\f26a"}.fa-optin-monster:before{content:"\f23c"}.fa-orcid:before{content:"\f8d2"}.fa-osi:before{content:"\f41a"}.fa-otter:before{content:"\f700"}.fa-outdent:before{content:"\f03b"}.fa-page4:before{content:"\f3d7"}.fa-pagelines:before{content:"\f18c"}.fa-pager:before{content:"\f815"}.fa-paint-brush:before{content:"\f1fc"}.fa-paint-roller:before{content:"\f5aa"}.fa-palette:before{content:"\f53f"}.fa-palfed:before{content:"\f3d8"}.fa-pallet:before{content:"\f482"}.fa-paper-plane:before{content:"\f1d8"}.fa-paperclip:before{content:"\f0c6"}.fa-parachute-box:before{content:"\f4cd"}.fa-paragraph:before{content:"\f1dd"}.fa-parking:before{content:"\f540"}.fa-passport:before{content:"\f5ab"}.fa-pastafarianism:before{content:"\f67b"}.fa-paste:before{content:"\f0ea"}.fa-patreon:before{content:"\f3d9"}.fa-pause:before{content:"\f04c"}.fa-pause-circle:before{content:"\f28b"}.fa-paw:before{content:"\f1b0"}.fa-paypal:before{content:"\f1ed"}.fa-peace:before{content:"\f67c"}.fa-pen:before{content:"\f304"}.fa-pen-alt:before{content:"\f305"}.fa-pen-fancy:before{content:"\f5ac"}.fa-pen-nib:before{content:"\f5ad"}.fa-pen-square:before{content:"\f14b"}.fa-pencil-alt:before{content:"\f303"}.fa-pencil-ruler:before{content:"\f5ae"}.fa-penny-arcade:before{content:"\f704"}.fa-people-arrows:before{content:"\f968"}.fa-people-carry:before{content:"\f4ce"}.fa-pepper-hot:before{content:"\f816"}.fa-percent:before{content:"\f295"}.fa-percentage:before{content:"\f541"}.fa-periscope:before{content:"\f3da"}.fa-person-booth:before{content:"\f756"}.fa-phabricator:before{content:"\f3db"}.fa-phoenix-framework:before{content:"\f3dc"}.fa-phoenix-squadron:before{content:"\f511"}.fa-phone:before{content:"\f095"}.fa-phone-alt:before{content:"\f879"}.fa-phone-slash:before{content:"\f3dd"}.fa-phone-square:before{content:"\f098"}.fa-phone-square-alt:before{content:"\f87b"}.fa-phone-volume:before{content:"\f2a0"}.fa-photo-video:before{content:"\f87c"}.fa-php:before{content:"\f457"}.fa-pied-piper:before{content:"\f2ae"}.fa-pied-piper-alt:before{content:"\f1a8"}.fa-pied-piper-hat:before{content:"\f4e5"}.fa-pied-piper-pp:before{content:"\f1a7"}.fa-pied-piper-square:before{content:"\f91e"}.fa-piggy-bank:before{content:"\f4d3"}.fa-pills:before{content:"\f484"}.fa-pinterest:before{content:"\f0d2"}.fa-pinterest-p:before{content:"\f231"}.fa-pinterest-square:before{content:"\f0d3"}.fa-pizza-slice:before{content:"\f818"}.fa-place-of-worship:before{content:"\f67f"}.fa-plane:before{content:"\f072"}.fa-plane-arrival:before{content:"\f5af"}.fa-plane-departure:before{content:"\f5b0"}.fa-plane-slash:before{content:"\f969"}.fa-play:before{content:"\f04b"}.fa-play-circle:before{content:"\f144"}.fa-playstation:before{content:"\f3df"}.fa-plug:before{content:"\f1e6"}.fa-plus:before{content:"\f067"}.fa-plus-circle:before{content:"\f055"}.fa-plus-square:before{content:"\f0fe"}.fa-podcast:before{content:"\f2ce"}.fa-poll:before{content:"\f681"}.fa-poll-h:before{content:"\f682"}.fa-poo:before{content:"\f2fe"}.fa-poo-storm:before{content:"\f75a"}.fa-poop:before{content:"\f619"}.fa-portrait:before{content:"\f3e0"}.fa-pound-sign:before{content:"\f154"}.fa-power-off:before{content:"\f011"}.fa-pray:before{content:"\f683"}.fa-praying-hands:before{content:"\f684"}.fa-prescription:before{content:"\f5b1"}.fa-prescription-bottle:before{content:"\f485"}.fa-prescription-bottle-alt:before{content:"\f486"}.fa-print:before{content:"\f02f"}.fa-procedures:before{content:"\f487"}.fa-product-hunt:before{content:"\f288"}.fa-project-diagram:before{content:"\f542"}.fa-pump-medical:before{content:"\f96a"}.fa-pump-soap:before{content:"\f96b"}.fa-pushed:before{content:"\f3e1"}.fa-puzzle-piece:before{content:"\f12e"}.fa-python:before{content:"\f3e2"}.fa-qq:before{content:"\f1d6"}.fa-qrcode:before{content:"\f029"}.fa-question:before{content:"\f128"}.fa-question-circle:before{content:"\f059"}.fa-quidditch:before{content:"\f458"}.fa-quinscape:before{content:"\f459"}.fa-quora:before{content:"\f2c4"}.fa-quote-left:before{content:"\f10d"}.fa-quote-right:before{content:"\f10e"}.fa-quran:before{content:"\f687"}.fa-r-project:before{content:"\f4f7"}.fa-radiation:before{content:"\f7b9"}.fa-radiation-alt:before{content:"\f7ba"}.fa-rainbow:before{content:"\f75b"}.fa-random:before{content:"\f074"}.fa-raspberry-pi:before{content:"\f7bb"}.fa-ravelry:before{content:"\f2d9"}.fa-react:before{content:"\f41b"}.fa-reacteurope:before{content:"\f75d"}.fa-readme:before{content:"\f4d5"}.fa-rebel:before{content:"\f1d0"}.fa-receipt:before{content:"\f543"}.fa-record-vinyl:before{content:"\f8d9"}.fa-recycle:before{content:"\f1b8"}.fa-red-river:before{content:"\f3e3"}.fa-reddit:before{content:"\f1a1"}.fa-reddit-alien:before{content:"\f281"}.fa-reddit-square:before{content:"\f1a2"}.fa-redhat:before{content:"\f7bc"}.fa-redo:before{content:"\f01e"}.fa-redo-alt:before{content:"\f2f9"}.fa-registered:before{content:"\f25d"}.fa-remove-format:before{content:"\f87d"}.fa-renren:before{content:"\f18b"}.fa-reply:before{content:"\f3e5"}.fa-reply-all:before{content:"\f122"}.fa-replyd:before{content:"\f3e6"}.fa-republican:before{content:"\f75e"}.fa-researchgate:before{content:"\f4f8"}.fa-resolving:before{content:"\f3e7"}.fa-restroom:before{content:"\f7bd"}.fa-retweet:before{content:"\f079"}.fa-rev:before{content:"\f5b2"}.fa-ribbon:before{content:"\f4d6"}.fa-ring:before{content:"\f70b"}.fa-road:before{content:"\f018"}.fa-robot:before{content:"\f544"}.fa-rocket:before{content:"\f135"}.fa-rocketchat:before{content:"\f3e8"}.fa-rockrms:before{content:"\f3e9"}.fa-route:before{content:"\f4d7"}.fa-rss:before{content:"\f09e"}.fa-rss-square:before{content:"\f143"}.fa-ruble-sign:before{content:"\f158"}.fa-ruler:before{content:"\f545"}.fa-ruler-combined:before{content:"\f546"}.fa-ruler-horizontal:before{content:"\f547"}.fa-ruler-vertical:before{content:"\f548"}.fa-running:before{content:"\f70c"}.fa-rupee-sign:before{content:"\f156"}.fa-sad-cry:before{content:"\f5b3"}.fa-sad-tear:before{content:"\f5b4"}.fa-safari:before{content:"\f267"}.fa-salesforce:before{content:"\f83b"}.fa-sass:before{content:"\f41e"}.fa-satellite:before{content:"\f7bf"}.fa-satellite-dish:before{content:"\f7c0"}.fa-save:before{content:"\f0c7"}.fa-schlix:before{content:"\f3ea"}.fa-school:before{content:"\f549"}.fa-screwdriver:before{content:"\f54a"}.fa-scribd:before{content:"\f28a"}.fa-scroll:before{content:"\f70e"}.fa-sd-card:before{content:"\f7c2"}.fa-search:before{content:"\f002"}.fa-search-dollar:before{content:"\f688"}.fa-search-location:before{content:"\f689"}.fa-search-minus:before{content:"\f010"}.fa-search-plus:before{content:"\f00e"}.fa-searchengin:before{content:"\f3eb"}.fa-seedling:before{content:"\f4d8"}.fa-sellcast:before{content:"\f2da"}.fa-sellsy:before{content:"\f213"}.fa-server:before{content:"\f233"}.fa-servicestack:before{content:"\f3ec"}.fa-shapes:before{content:"\f61f"}.fa-share:before{content:"\f064"}.fa-share-alt:before{content:"\f1e0"}.fa-share-alt-square:before{content:"\f1e1"}.fa-share-square:before{content:"\f14d"}.fa-shekel-sign:before{content:"\f20b"}.fa-shield-alt:before{content:"\f3ed"}.fa-shield-virus:before{content:"\f96c"}.fa-ship:before{content:"\f21a"}.fa-shipping-fast:before{content:"\f48b"}.fa-shirtsinbulk:before{content:"\f214"}.fa-shoe-prints:before{content:"\f54b"}.fa-shopify:before{content:"\f957"}.fa-shopping-bag:before{content:"\f290"}.fa-shopping-basket:before{content:"\f291"}.fa-shopping-cart:before{content:"\f07a"}.fa-shopware:before{content:"\f5b5"}.fa-shower:before{content:"\f2cc"}.fa-shuttle-van:before{content:"\f5b6"}.fa-sign:before{content:"\f4d9"}.fa-sign-in-alt:before{content:"\f2f6"}.fa-sign-language:before{content:"\f2a7"}.fa-sign-out-alt:before{content:"\f2f5"}.fa-signal:before{content:"\f012"}.fa-signature:before{content:"\f5b7"}.fa-sim-card:before{content:"\f7c4"}.fa-simplybuilt:before{content:"\f215"}.fa-sistrix:before{content:"\f3ee"}.fa-sitemap:before{content:"\f0e8"}.fa-sith:before{content:"\f512"}.fa-skating:before{content:"\f7c5"}.fa-sketch:before{content:"\f7c6"}.fa-skiing:before{content:"\f7c9"}.fa-skiing-nordic:before{content:"\f7ca"}.fa-skull:before{content:"\f54c"}.fa-skull-crossbones:before{content:"\f714"}.fa-skyatlas:before{content:"\f216"}.fa-skype:before{content:"\f17e"}.fa-slack:before{content:"\f198"}.fa-slack-hash:before{content:"\f3ef"}.fa-slash:before{content:"\f715"}.fa-sleigh:before{content:"\f7cc"}.fa-sliders-h:before{content:"\f1de"}.fa-slideshare:before{content:"\f1e7"}.fa-smile:before{content:"\f118"}.fa-smile-beam:before{content:"\f5b8"}.fa-smile-wink:before{content:"\f4da"}.fa-smog:before{content:"\f75f"}.fa-smoking:before{content:"\f48d"}.fa-smoking-ban:before{content:"\f54d"}.fa-sms:before{content:"\f7cd"}.fa-snapchat:before{content:"\f2ab"}.fa-snapchat-ghost:before{content:"\f2ac"}.fa-snapchat-square:before{content:"\f2ad"}.fa-snowboarding:before{content:"\f7ce"}.fa-snowflake:before{content:"\f2dc"}.fa-snowman:before{content:"\f7d0"}.fa-snowplow:before{content:"\f7d2"}.fa-soap:before{content:"\f96e"}.fa-socks:before{content:"\f696"}.fa-solar-panel:before{content:"\f5ba"}.fa-sort:before{content:"\f0dc"}.fa-sort-alpha-down:before{content:"\f15d"}.fa-sort-alpha-down-alt:before{content:"\f881"}.fa-sort-alpha-up:before{content:"\f15e"}.fa-sort-alpha-up-alt:before{content:"\f882"}.fa-sort-amount-down:before{content:"\f160"}.fa-sort-amount-down-alt:before{content:"\f884"}.fa-sort-amount-up:before{content:"\f161"}.fa-sort-amount-up-alt:before{content:"\f885"}.fa-sort-down:before{content:"\f0dd"}.fa-sort-numeric-down:before{content:"\f162"}.fa-sort-numeric-down-alt:before{content:"\f886"}.fa-sort-numeric-up:before{content:"\f163"}.fa-sort-numeric-up-alt:before{content:"\f887"}.fa-sort-up:before{content:"\f0de"}.fa-soundcloud:before{content:"\f1be"}.fa-sourcetree:before{content:"\f7d3"}.fa-spa:before{content:"\f5bb"}.fa-space-shuttle:before{content:"\f197"}.fa-speakap:before{content:"\f3f3"}.fa-speaker-deck:before{content:"\f83c"}.fa-spell-check:before{content:"\f891"}.fa-spider:before{content:"\f717"}.fa-spinner:before{content:"\f110"}.fa-splotch:before{content:"\f5bc"}.fa-spotify:before{content:"\f1bc"}.fa-spray-can:before{content:"\f5bd"}.fa-square:before{content:"\f0c8"}.fa-square-full:before{content:"\f45c"}.fa-square-root-alt:before{content:"\f698"}.fa-squarespace:before{content:"\f5be"}.fa-stack-exchange:before{content:"\f18d"}.fa-stack-overflow:before{content:"\f16c"}.fa-stackpath:before{content:"\f842"}.fa-stamp:before{content:"\f5bf"}.fa-star:before{content:"\f005"}.fa-star-and-crescent:before{content:"\f699"}.fa-star-half:before{content:"\f089"}.fa-star-half-alt:before{content:"\f5c0"}.fa-star-of-david:before{content:"\f69a"}.fa-star-of-life:before{content:"\f621"}.fa-staylinked:before{content:"\f3f5"}.fa-steam:before{content:"\f1b6"}.fa-steam-square:before{content:"\f1b7"}.fa-steam-symbol:before{content:"\f3f6"}.fa-step-backward:before{content:"\f048"}.fa-step-forward:before{content:"\f051"}.fa-stethoscope:before{content:"\f0f1"}.fa-sticker-mule:before{content:"\f3f7"}.fa-sticky-note:before{content:"\f249"}.fa-stop:before{content:"\f04d"}.fa-stop-circle:before{content:"\f28d"}.fa-stopwatch:before{content:"\f2f2"}.fa-stopwatch-20:before{content:"\f96f"}.fa-store:before{content:"\f54e"}.fa-store-alt:before{content:"\f54f"}.fa-store-alt-slash:before{content:"\f970"}.fa-store-slash:before{content:"\f971"}.fa-strava:before{content:"\f428"}.fa-stream:before{content:"\f550"}.fa-street-view:before{content:"\f21d"}.fa-strikethrough:before{content:"\f0cc"}.fa-stripe:before{content:"\f429"}.fa-stripe-s:before{content:"\f42a"}.fa-stroopwafel:before{content:"\f551"}.fa-studiovinari:before{content:"\f3f8"}.fa-stumbleupon:before{content:"\f1a4"}.fa-stumbleupon-circle:before{content:"\f1a3"}.fa-subscript:before{content:"\f12c"}.fa-subway:before{content:"\f239"}.fa-suitcase:before{content:"\f0f2"}.fa-suitcase-rolling:before{content:"\f5c1"}.fa-sun:before{content:"\f185"}.fa-superpowers:before{content:"\f2dd"}.fa-superscript:before{content:"\f12b"}.fa-supple:before{content:"\f3f9"}.fa-surprise:before{content:"\f5c2"}.fa-suse:before{content:"\f7d6"}.fa-swatchbook:before{content:"\f5c3"}.fa-swift:before{content:"\f8e1"}.fa-swimmer:before{content:"\f5c4"}.fa-swimming-pool:before{content:"\f5c5"}.fa-symfony:before{content:"\f83d"}.fa-synagogue:before{content:"\f69b"}.fa-sync:before{content:"\f021"}.fa-sync-alt:before{content:"\f2f1"}.fa-syringe:before{content:"\f48e"}.fa-table:before{content:"\f0ce"}.fa-table-tennis:before{content:"\f45d"}.fa-tablet:before{content:"\f10a"}.fa-tablet-alt:before{content:"\f3fa"}.fa-tablets:before{content:"\f490"}.fa-tachometer-alt:before{content:"\f3fd"}.fa-tag:before{content:"\f02b"}.fa-tags:before{content:"\f02c"}.fa-tape:before{content:"\f4db"}.fa-tasks:before{content:"\f0ae"}.fa-taxi:before{content:"\f1ba"}.fa-teamspeak:before{content:"\f4f9"}.fa-teeth:before{content:"\f62e"}.fa-teeth-open:before{content:"\f62f"}.fa-telegram:before{content:"\f2c6"}.fa-telegram-plane:before{content:"\f3fe"}.fa-temperature-high:before{content:"\f769"}.fa-temperature-low:before{content:"\f76b"}.fa-tencent-weibo:before{content:"\f1d5"}.fa-tenge:before{content:"\f7d7"}.fa-terminal:before{content:"\f120"}.fa-text-height:before{content:"\f034"}.fa-text-width:before{content:"\f035"}.fa-th:before{content:"\f00a"}.fa-th-large:before{content:"\f009"}.fa-th-list:before{content:"\f00b"}.fa-the-red-yeti:before{content:"\f69d"}.fa-theater-masks:before{content:"\f630"}.fa-themeco:before{content:"\f5c6"}.fa-themeisle:before{content:"\f2b2"}.fa-thermometer:before{content:"\f491"}.fa-thermometer-empty:before{content:"\f2cb"}.fa-thermometer-full:before{content:"\f2c7"}.fa-thermometer-half:before{content:"\f2c9"}.fa-thermometer-quarter:before{content:"\f2ca"}.fa-thermometer-three-quarters:before{content:"\f2c8"}.fa-think-peaks:before{content:"\f731"}.fa-thumbs-down:before{content:"\f165"}.fa-thumbs-up:before{content:"\f164"}.fa-thumbtack:before{content:"\f08d"}.fa-ticket-alt:before{content:"\f3ff"}.fa-times:before{content:"\f00d"}.fa-times-circle:before{content:"\f057"}.fa-tint:before{content:"\f043"}.fa-tint-slash:before{content:"\f5c7"}.fa-tired:before{content:"\f5c8"}.fa-toggle-off:before{content:"\f204"}.fa-toggle-on:before{content:"\f205"}.fa-toilet:before{content:"\f7d8"}.fa-toilet-paper:before{content:"\f71e"}.fa-toilet-paper-slash:before{content:"\f972"}.fa-toolbox:before{content:"\f552"}.fa-tools:before{content:"\f7d9"}.fa-tooth:before{content:"\f5c9"}.fa-torah:before{content:"\f6a0"}.fa-torii-gate:before{content:"\f6a1"}.fa-tractor:before{content:"\f722"}.fa-trade-federation:before{content:"\f513"}.fa-trademark:before{content:"\f25c"}.fa-traffic-light:before{content:"\f637"}.fa-trailer:before{content:"\f941"}.fa-train:before{content:"\f238"}.fa-tram:before{content:"\f7da"}.fa-transgender:before{content:"\f224"}.fa-transgender-alt:before{content:"\f225"}.fa-trash:before{content:"\f1f8"}.fa-trash-alt:before{content:"\f2ed"}.fa-trash-restore:before{content:"\f829"}.fa-trash-restore-alt:before{content:"\f82a"}.fa-tree:before{content:"\f1bb"}.fa-trello:before{content:"\f181"}.fa-tripadvisor:before{content:"\f262"}.fa-trophy:before{content:"\f091"}.fa-truck:before{content:"\f0d1"}.fa-truck-loading:before{content:"\f4de"}.fa-truck-monster:before{content:"\f63b"}.fa-truck-moving:before{content:"\f4df"}.fa-truck-pickup:before{content:"\f63c"}.fa-tshirt:before{content:"\f553"}.fa-tty:before{content:"\f1e4"}.fa-tumblr:before{content:"\f173"}.fa-tumblr-square:before{content:"\f174"}.fa-tv:before{content:"\f26c"}.fa-twitch:before{content:"\f1e8"}.fa-twitter:before{content:"\f099"}.fa-twitter-square:before{content:"\f081"}.fa-typo3:before{content:"\f42b"}.fa-uber:before{content:"\f402"}.fa-ubuntu:before{content:"\f7df"}.fa-uikit:before{content:"\f403"}.fa-umbraco:before{content:"\f8e8"}.fa-umbrella:before{content:"\f0e9"}.fa-umbrella-beach:before{content:"\f5ca"}.fa-underline:before{content:"\f0cd"}.fa-undo:before{content:"\f0e2"}.fa-undo-alt:before{content:"\f2ea"}.fa-uniregistry:before{content:"\f404"}.fa-unity:before{content:"\f949"}.fa-universal-access:before{content:"\f29a"}.fa-university:before{content:"\f19c"}.fa-unlink:before{content:"\f127"}.fa-unlock:before{content:"\f09c"}.fa-unlock-alt:before{content:"\f13e"}.fa-untappd:before{content:"\f405"}.fa-upload:before{content:"\f093"}.fa-ups:before{content:"\f7e0"}.fa-usb:before{content:"\f287"}.fa-user:before{content:"\f007"}.fa-user-alt:before{content:"\f406"}.fa-user-alt-slash:before{content:"\f4fa"}.fa-user-astronaut:before{content:"\f4fb"}.fa-user-check:before{content:"\f4fc"}.fa-user-circle:before{content:"\f2bd"}.fa-user-clock:before{content:"\f4fd"}.fa-user-cog:before{content:"\f4fe"}.fa-user-edit:before{content:"\f4ff"}.fa-user-friends:before{content:"\f500"}.fa-user-graduate:before{content:"\f501"}.fa-user-injured:before{content:"\f728"}.fa-user-lock:before{content:"\f502"}.fa-user-md:before{content:"\f0f0"}.fa-user-minus:before{content:"\f503"}.fa-user-ninja:before{content:"\f504"}.fa-user-nurse:before{content:"\f82f"}.fa-user-plus:before{content:"\f234"}.fa-user-secret:before{content:"\f21b"}.fa-user-shield:before{content:"\f505"}.fa-user-slash:before{content:"\f506"}.fa-user-tag:before{content:"\f507"}.fa-user-tie:before{content:"\f508"}.fa-user-times:before{content:"\f235"}.fa-users:before{content:"\f0c0"}.fa-users-cog:before{content:"\f509"}.fa-usps:before{content:"\f7e1"}.fa-ussunnah:before{content:"\f407"}.fa-utensil-spoon:before{content:"\f2e5"}.fa-utensils:before{content:"\f2e7"}.fa-vaadin:before{content:"\f408"}.fa-vector-square:before{content:"\f5cb"}.fa-venus:before{content:"\f221"}.fa-venus-double:before{content:"\f226"}.fa-venus-mars:before{content:"\f228"}.fa-viacoin:before{content:"\f237"}.fa-viadeo:before{content:"\f2a9"}.fa-viadeo-square:before{content:"\f2aa"}.fa-vial:before{content:"\f492"}.fa-vials:before{content:"\f493"}.fa-viber:before{content:"\f409"}.fa-video:before{content:"\f03d"}.fa-video-slash:before{content:"\f4e2"}.fa-vihara:before{content:"\f6a7"}.fa-vimeo:before{content:"\f40a"}.fa-vimeo-square:before{content:"\f194"}.fa-vimeo-v:before{content:"\f27d"}.fa-vine:before{content:"\f1ca"}.fa-virus:before{content:"\f974"}.fa-virus-slash:before{content:"\f975"}.fa-viruses:before{content:"\f976"}.fa-vk:before{content:"\f189"}.fa-vnv:before{content:"\f40b"}.fa-voicemail:before{content:"\f897"}.fa-volleyball-ball:before{content:"\f45f"}.fa-volume-down:before{content:"\f027"}.fa-volume-mute:before{content:"\f6a9"}.fa-volume-off:before{content:"\f026"}.fa-volume-up:before{content:"\f028"}.fa-vote-yea:before{content:"\f772"}.fa-vr-cardboard:before{content:"\f729"}.fa-vuejs:before{content:"\f41f"}.fa-walking:before{content:"\f554"}.fa-wallet:before{content:"\f555"}.fa-warehouse:before{content:"\f494"}.fa-water:before{content:"\f773"}.fa-wave-square:before{content:"\f83e"}.fa-waze:before{content:"\f83f"}.fa-weebly:before{content:"\f5cc"}.fa-weibo:before{content:"\f18a"}.fa-weight:before{content:"\f496"}.fa-weight-hanging:before{content:"\f5cd"}.fa-weixin:before{content:"\f1d7"}.fa-whatsapp:before{content:"\f232"}.fa-whatsapp-square:before{content:"\f40c"}.fa-wheelchair:before{content:"\f193"}.fa-whmcs:before{content:"\f40d"}.fa-wifi:before{content:"\f1eb"}.fa-wikipedia-w:before{content:"\f266"}.fa-wind:before{content:"\f72e"}.fa-window-close:before{content:"\f410"}.fa-window-maximize:before{content:"\f2d0"}.fa-window-minimize:before{content:"\f2d1"}.fa-window-restore:before{content:"\f2d2"}.fa-windows:before{content:"\f17a"}.fa-wine-bottle:before{content:"\f72f"}.fa-wine-glass:before{content:"\f4e3"}.fa-wine-glass-alt:before{content:"\f5ce"}.fa-wix:before{content:"\f5cf"}.fa-wizards-of-the-coast:before{content:"\f730"}.fa-wolf-pack-battalion:before{content:"\f514"}.fa-won-sign:before{content:"\f159"}.fa-wordpress:before{content:"\f19a"}.fa-wordpress-simple:before{content:"\f411"}.fa-wpbeginner:before{content:"\f297"}.fa-wpexplorer:before{content:"\f2de"}.fa-wpforms:before{content:"\f298"}.fa-wpressr:before{content:"\f3e4"}.fa-wrench:before{content:"\f0ad"}.fa-x-ray:before{content:"\f497"}.fa-xbox:before{content:"\f412"}.fa-xing:before{content:"\f168"}.fa-xing-square:before{content:"\f169"}.fa-y-combinator:before{content:"\f23b"}.fa-yahoo:before{content:"\f19e"}.fa-yammer:before{content:"\f840"}.fa-yandex:before{content:"\f413"}.fa-yandex-international:before{content:"\f414"}.fa-yarn:before{content:"\f7e3"}.fa-yelp:before{content:"\f1e9"}.fa-yen-sign:before{content:"\f157"}.fa-yin-yang:before{content:"\f6ad"}.fa-yoast:before{content:"\f2b1"}.fa-youtube:before{content:"\f167"}.fa-youtube-square:before{content:"\f431"}.fa-zhihu:before{content:"\f63f"}.sr-only{border:0;clip:rect(0,0,0,0);height:1px;margin:-1px;overflow:hidden;padding:0;position:absolute;width:1px}.sr-only-focusable:active,.sr-only-focusable:focus{clip:auto;height:auto;margin:0;overflow:visible;position:static;width:auto}@font-face{font-family:"Font Awesome 5 Brands";font-style:normal;font-weight:400;font-display:block;src:url(../webfonts/fa-brands-400.eot);src:url(../webfonts/fa-brands-400.eot?#iefix) format("embedded-opentype"),url(../webfonts/fa-brands-400.woff2) format("woff2"),url(../webfonts/fa-brands-400.woff) format("woff"),url(../webfonts/fa-brands-400.ttf) format("truetype"),url(../webfonts/fa-brands-400.svg#fontawesome) format("svg")}.fab{font-family:"Font Awesome 5 Brands"}@font-face{font-family:"Font Awesome 5 Free";font-style:normal;font-weight:400;font-display:block;src:url(../webfonts/fa-regular-400.eot);src:url(../webfonts/fa-regular-400.eot?#iefix) format("embedded-opentype"),url(../webfonts/fa-regular-400.woff2) format("woff2"),url(../webfonts/fa-regular-400.woff) format("woff"),url(../webfonts/fa-regular-400.ttf) format("truetype"),url(../webfonts/fa-regular-400.svg#fontawesome) format("svg")}.fab,.far{font-weight:400}@font-face{font-family:"Font Awesome 5 Free";font-style:normal;font-weight:900;font-display:block;src:url(../webfonts/fa-solid-900.eot);src:url(../webfonts/fa-solid-900.eot?#iefix) format("embedded-opentype"),url(../webfonts/fa-solid-900.woff2) format("woff2"),url(../webfonts/fa-solid-900.woff) format("woff"),url(../webfonts/fa-solid-900.ttf) format("truetype"),url(../webfonts/fa-solid-900.svg#fontawesome) format("svg")}.fa,.far,.fas{font-family:"Font Awesome 5 Free"}.fa,.fas{font-weight:900} \ No newline at end of file diff --git a/nlp_demo_riva/client/css/brands.css b/nlp_demo_riva/client/css/brands.css new file mode 100644 index 00000000..ed4b7398 --- /dev/null +++ b/nlp_demo_riva/client/css/brands.css @@ -0,0 +1,15 @@ +/*! + * Font Awesome Free 5.13.0 by @fontawesome - https://fontawesome.com + * License - https://fontawesome.com/license/free (Icons: CC BY 4.0, Fonts: SIL OFL 1.1, Code: MIT License) + */ +@font-face { + font-family: 'Font Awesome 5 Brands'; + font-style: normal; + font-weight: 400; + font-display: block; + src: url("../webfonts/fa-brands-400.eot"); + src: url("../webfonts/fa-brands-400.eot?#iefix") format("embedded-opentype"), url("../webfonts/fa-brands-400.woff2") format("woff2"), url("../webfonts/fa-brands-400.woff") format("woff"), url("../webfonts/fa-brands-400.ttf") format("truetype"), url("../webfonts/fa-brands-400.svg#fontawesome") format("svg"); } + +.fab { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } diff --git a/nlp_demo_riva/client/css/brands.min.css b/nlp_demo_riva/client/css/brands.min.css new file mode 100644 index 00000000..c8942c22 --- /dev/null +++ b/nlp_demo_riva/client/css/brands.min.css @@ -0,0 +1,5 @@ +/*! + * Font Awesome Free 5.13.0 by @fontawesome - https://fontawesome.com + * License - https://fontawesome.com/license/free (Icons: CC BY 4.0, Fonts: SIL OFL 1.1, Code: MIT License) + */ +@font-face{font-family:"Font Awesome 5 Brands";font-style:normal;font-weight:400;font-display:block;src:url(../webfonts/fa-brands-400.eot);src:url(../webfonts/fa-brands-400.eot?#iefix) format("embedded-opentype"),url(../webfonts/fa-brands-400.woff2) format("woff2"),url(../webfonts/fa-brands-400.woff) format("woff"),url(../webfonts/fa-brands-400.ttf) format("truetype"),url(../webfonts/fa-brands-400.svg#fontawesome) format("svg")}.fab{font-family:"Font Awesome 5 Brands";font-weight:400} \ No newline at end of file diff --git a/nlp_demo_riva/client/css/fontawesome.css b/nlp_demo_riva/client/css/fontawesome.css new file mode 100644 index 00000000..c73d7c04 --- /dev/null +++ b/nlp_demo_riva/client/css/fontawesome.css @@ -0,0 +1,4522 @@ +/*! + * Font Awesome Free 5.13.0 by @fontawesome - https://fontawesome.com + * License - https://fontawesome.com/license/free (Icons: CC BY 4.0, Fonts: SIL OFL 1.1, Code: MIT License) + */ +.fa, +.fas, +.far, +.fal, +.fad, +.fab { + -moz-osx-font-smoothing: grayscale; + -webkit-font-smoothing: antialiased; + display: inline-block; + font-style: normal; + font-variant: normal; + text-rendering: auto; + line-height: 1; } + +.fa-lg { + font-size: 1.33333em; + line-height: 0.75em; + vertical-align: -.0667em; } + +.fa-xs { + font-size: .75em; } + +.fa-sm { + font-size: .875em; } + +.fa-1x { + font-size: 1em; } + +.fa-2x { + font-size: 2em; } + +.fa-3x { + font-size: 3em; } + +.fa-4x { + font-size: 4em; } + +.fa-5x { + font-size: 5em; } + +.fa-6x { + font-size: 6em; } + +.fa-7x { + font-size: 7em; } + +.fa-8x { + font-size: 8em; } + +.fa-9x { + font-size: 9em; } + +.fa-10x { + font-size: 10em; } + +.fa-fw { + text-align: center; + width: 1.25em; } + +.fa-ul { + list-style-type: none; + margin-left: 2.5em; + padding-left: 0; } + .fa-ul > li { + position: relative; } + +.fa-li { + left: -2em; + position: absolute; + text-align: center; + width: 2em; + line-height: inherit; } + +.fa-border { + border: solid 0.08em #eee; + border-radius: .1em; + padding: .2em .25em .15em; } + +.fa-pull-left { + float: left; } + +.fa-pull-right { + float: right; } + +.fa.fa-pull-left, +.fas.fa-pull-left, +.far.fa-pull-left, +.fal.fa-pull-left, +.fab.fa-pull-left { + margin-right: .3em; } + +.fa.fa-pull-right, +.fas.fa-pull-right, +.far.fa-pull-right, +.fal.fa-pull-right, +.fab.fa-pull-right { + margin-left: .3em; } + +.fa-spin { + -webkit-animation: fa-spin 2s infinite linear; + animation: fa-spin 2s infinite linear; } + +.fa-pulse { + -webkit-animation: fa-spin 1s infinite steps(8); + animation: fa-spin 1s infinite steps(8); } + +@-webkit-keyframes fa-spin { + 0% { + -webkit-transform: rotate(0deg); + transform: rotate(0deg); } + 100% { + -webkit-transform: rotate(360deg); + transform: rotate(360deg); } } + +@keyframes fa-spin { + 0% { + -webkit-transform: rotate(0deg); + transform: rotate(0deg); } + 100% { + -webkit-transform: rotate(360deg); + transform: rotate(360deg); } } + +.fa-rotate-90 { + -ms-filter: "progid:DXImageTransform.Microsoft.BasicImage(rotation=1)"; + -webkit-transform: rotate(90deg); + transform: rotate(90deg); } + +.fa-rotate-180 { + -ms-filter: "progid:DXImageTransform.Microsoft.BasicImage(rotation=2)"; + -webkit-transform: rotate(180deg); + transform: rotate(180deg); } + +.fa-rotate-270 { + -ms-filter: "progid:DXImageTransform.Microsoft.BasicImage(rotation=3)"; + -webkit-transform: rotate(270deg); + transform: rotate(270deg); } + +.fa-flip-horizontal { + -ms-filter: "progid:DXImageTransform.Microsoft.BasicImage(rotation=0, mirror=1)"; + -webkit-transform: scale(-1, 1); + transform: scale(-1, 1); } + +.fa-flip-vertical { + -ms-filter: "progid:DXImageTransform.Microsoft.BasicImage(rotation=2, mirror=1)"; + -webkit-transform: scale(1, -1); + transform: scale(1, -1); } + +.fa-flip-both, .fa-flip-horizontal.fa-flip-vertical { + -ms-filter: "progid:DXImageTransform.Microsoft.BasicImage(rotation=2, mirror=1)"; + -webkit-transform: scale(-1, -1); + transform: scale(-1, -1); } + +:root .fa-rotate-90, +:root .fa-rotate-180, +:root .fa-rotate-270, +:root .fa-flip-horizontal, +:root .fa-flip-vertical, +:root .fa-flip-both { + -webkit-filter: none; + filter: none; } + +.fa-stack { + display: inline-block; + height: 2em; + line-height: 2em; + position: relative; + vertical-align: middle; + width: 2.5em; } + +.fa-stack-1x, +.fa-stack-2x { + left: 0; + position: absolute; + text-align: center; + width: 100%; } + +.fa-stack-1x { + line-height: inherit; } + +.fa-stack-2x { + font-size: 2em; } + +.fa-inverse { + color: #fff; } + +/* Font Awesome uses the Unicode Private Use Area (PUA) to ensure screen +readers do not read off random characters that represent icons */ +.fa-500px:before { + content: "\f26e"; } + +.fa-accessible-icon:before { + content: "\f368"; } + +.fa-accusoft:before { + content: "\f369"; } + +.fa-acquisitions-incorporated:before { + content: "\f6af"; } + +.fa-ad:before { + content: "\f641"; } + +.fa-address-book:before { + content: "\f2b9"; } + +.fa-address-card:before { + content: "\f2bb"; } + +.fa-adjust:before { + content: "\f042"; } + +.fa-adn:before { + content: "\f170"; } + +.fa-adobe:before { + content: "\f778"; } + +.fa-adversal:before { + content: "\f36a"; } + +.fa-affiliatetheme:before { + content: "\f36b"; } + +.fa-air-freshener:before { + content: "\f5d0"; } + +.fa-airbnb:before { + content: "\f834"; } + +.fa-algolia:before { + content: "\f36c"; } + +.fa-align-center:before { + content: "\f037"; } + +.fa-align-justify:before { + content: "\f039"; } + +.fa-align-left:before { + content: "\f036"; } + +.fa-align-right:before { + content: "\f038"; } + +.fa-alipay:before { + content: "\f642"; } + +.fa-allergies:before { + content: "\f461"; } + +.fa-amazon:before { + content: "\f270"; } + +.fa-amazon-pay:before { + content: "\f42c"; } + +.fa-ambulance:before { + content: "\f0f9"; } + +.fa-american-sign-language-interpreting:before { + content: "\f2a3"; } + +.fa-amilia:before { + content: "\f36d"; } + +.fa-anchor:before { + content: "\f13d"; } + +.fa-android:before { + content: "\f17b"; } + +.fa-angellist:before { + content: "\f209"; } + +.fa-angle-double-down:before { + content: "\f103"; } + +.fa-angle-double-left:before { + content: "\f100"; } + +.fa-angle-double-right:before { + content: "\f101"; } + +.fa-angle-double-up:before { + content: "\f102"; } + +.fa-angle-down:before { + content: "\f107"; } + +.fa-angle-left:before { + content: "\f104"; } + +.fa-angle-right:before { + content: "\f105"; } + +.fa-angle-up:before { + content: "\f106"; } + +.fa-angry:before { + content: "\f556"; } + +.fa-angrycreative:before { + content: "\f36e"; } + +.fa-angular:before { + content: "\f420"; } + +.fa-ankh:before { + content: "\f644"; } + +.fa-app-store:before { + content: "\f36f"; } + +.fa-app-store-ios:before { + content: "\f370"; } + +.fa-apper:before { + content: "\f371"; } + +.fa-apple:before { + content: "\f179"; } + +.fa-apple-alt:before { + content: "\f5d1"; } + +.fa-apple-pay:before { + content: "\f415"; } + +.fa-archive:before { + content: "\f187"; } + +.fa-archway:before { + content: "\f557"; } + +.fa-arrow-alt-circle-down:before { + content: "\f358"; } + +.fa-arrow-alt-circle-left:before { + content: "\f359"; } + +.fa-arrow-alt-circle-right:before { + content: "\f35a"; } + +.fa-arrow-alt-circle-up:before { + content: "\f35b"; } + +.fa-arrow-circle-down:before { + content: "\f0ab"; } + +.fa-arrow-circle-left:before { + content: "\f0a8"; } + +.fa-arrow-circle-right:before { + content: "\f0a9"; } + +.fa-arrow-circle-up:before { + content: "\f0aa"; } + +.fa-arrow-down:before { + content: "\f063"; } + +.fa-arrow-left:before { + content: "\f060"; } + +.fa-arrow-right:before { + content: "\f061"; } + +.fa-arrow-up:before { + content: "\f062"; } + +.fa-arrows-alt:before { + content: "\f0b2"; } + +.fa-arrows-alt-h:before { + content: "\f337"; } + +.fa-arrows-alt-v:before { + content: "\f338"; } + +.fa-artstation:before { + content: "\f77a"; } + +.fa-assistive-listening-systems:before { + content: "\f2a2"; } + +.fa-asterisk:before { + content: "\f069"; } + +.fa-asymmetrik:before { + content: "\f372"; } + +.fa-at:before { + content: "\f1fa"; } + +.fa-atlas:before { + content: "\f558"; } + +.fa-atlassian:before { + content: "\f77b"; } + +.fa-atom:before { + content: "\f5d2"; } + +.fa-audible:before { + content: "\f373"; } + +.fa-audio-description:before { + content: "\f29e"; } + +.fa-autoprefixer:before { + content: "\f41c"; } + +.fa-avianex:before { + content: "\f374"; } + +.fa-aviato:before { + content: "\f421"; } + +.fa-award:before { + content: "\f559"; } + +.fa-aws:before { + content: "\f375"; } + +.fa-baby:before { + content: "\f77c"; } + +.fa-baby-carriage:before { + content: "\f77d"; } + +.fa-backspace:before { + content: "\f55a"; } + +.fa-backward:before { + content: "\f04a"; } + +.fa-bacon:before { + content: "\f7e5"; } + +.fa-bahai:before { + content: "\f666"; } + +.fa-balance-scale:before { + content: "\f24e"; } + +.fa-balance-scale-left:before { + content: "\f515"; } + +.fa-balance-scale-right:before { + content: "\f516"; } + +.fa-ban:before { + content: "\f05e"; } + +.fa-band-aid:before { + content: "\f462"; } + +.fa-bandcamp:before { + content: "\f2d5"; } + +.fa-barcode:before { + content: "\f02a"; } + +.fa-bars:before { + content: "\f0c9"; } + +.fa-baseball-ball:before { + content: "\f433"; } + +.fa-basketball-ball:before { + content: "\f434"; } + +.fa-bath:before { + content: "\f2cd"; } + +.fa-battery-empty:before { + content: "\f244"; } + +.fa-battery-full:before { + content: "\f240"; } + +.fa-battery-half:before { + content: "\f242"; } + +.fa-battery-quarter:before { + content: "\f243"; } + +.fa-battery-three-quarters:before { + content: "\f241"; } + +.fa-battle-net:before { + content: "\f835"; } + +.fa-bed:before { + content: "\f236"; } + +.fa-beer:before { + content: "\f0fc"; } + +.fa-behance:before { + content: "\f1b4"; } + +.fa-behance-square:before { + content: "\f1b5"; } + +.fa-bell:before { + content: "\f0f3"; } + +.fa-bell-slash:before { + content: "\f1f6"; } + +.fa-bezier-curve:before { + content: "\f55b"; } + +.fa-bible:before { + content: "\f647"; } + +.fa-bicycle:before { + content: "\f206"; } + +.fa-biking:before { + content: "\f84a"; } + +.fa-bimobject:before { + content: "\f378"; } + +.fa-binoculars:before { + content: "\f1e5"; } + +.fa-biohazard:before { + content: "\f780"; } + +.fa-birthday-cake:before { + content: "\f1fd"; } + +.fa-bitbucket:before { + content: "\f171"; } + +.fa-bitcoin:before { + content: "\f379"; } + +.fa-bity:before { + content: "\f37a"; } + +.fa-black-tie:before { + content: "\f27e"; } + +.fa-blackberry:before { + content: "\f37b"; } + +.fa-blender:before { + content: "\f517"; } + +.fa-blender-phone:before { + content: "\f6b6"; } + +.fa-blind:before { + content: "\f29d"; } + +.fa-blog:before { + content: "\f781"; } + +.fa-blogger:before { + content: "\f37c"; } + +.fa-blogger-b:before { + content: "\f37d"; } + +.fa-bluetooth:before { + content: "\f293"; } + +.fa-bluetooth-b:before { + content: "\f294"; } + +.fa-bold:before { + content: "\f032"; } + +.fa-bolt:before { + content: "\f0e7"; } + +.fa-bomb:before { + content: "\f1e2"; } + +.fa-bone:before { + content: "\f5d7"; } + +.fa-bong:before { + content: "\f55c"; } + +.fa-book:before { + content: "\f02d"; } + +.fa-book-dead:before { + content: "\f6b7"; } + +.fa-book-medical:before { + content: "\f7e6"; } + +.fa-book-open:before { + content: "\f518"; } + +.fa-book-reader:before { + content: "\f5da"; } + +.fa-bookmark:before { + content: "\f02e"; } + +.fa-bootstrap:before { + content: "\f836"; } + +.fa-border-all:before { + content: "\f84c"; } + +.fa-border-none:before { + content: "\f850"; } + +.fa-border-style:before { + content: "\f853"; } + +.fa-bowling-ball:before { + content: "\f436"; } + +.fa-box:before { + content: "\f466"; } + +.fa-box-open:before { + content: "\f49e"; } + +.fa-box-tissue:before { + content: "\f95b"; } + +.fa-boxes:before { + content: "\f468"; } + +.fa-braille:before { + content: "\f2a1"; } + +.fa-brain:before { + content: "\f5dc"; } + +.fa-bread-slice:before { + content: "\f7ec"; } + +.fa-briefcase:before { + content: "\f0b1"; } + +.fa-briefcase-medical:before { + content: "\f469"; } + +.fa-broadcast-tower:before { + content: "\f519"; } + +.fa-broom:before { + content: "\f51a"; } + +.fa-brush:before { + content: "\f55d"; } + +.fa-btc:before { + content: "\f15a"; } + +.fa-buffer:before { + content: "\f837"; } + +.fa-bug:before { + content: "\f188"; } + +.fa-building:before { + content: "\f1ad"; } + +.fa-bullhorn:before { + content: "\f0a1"; } + +.fa-bullseye:before { + content: "\f140"; } + +.fa-burn:before { + content: "\f46a"; } + +.fa-buromobelexperte:before { + content: "\f37f"; } + +.fa-bus:before { + content: "\f207"; } + +.fa-bus-alt:before { + content: "\f55e"; } + +.fa-business-time:before { + content: "\f64a"; } + +.fa-buy-n-large:before { + content: "\f8a6"; } + +.fa-buysellads:before { + content: "\f20d"; } + +.fa-calculator:before { + content: "\f1ec"; } + +.fa-calendar:before { + content: "\f133"; } + +.fa-calendar-alt:before { + content: "\f073"; } + +.fa-calendar-check:before { + content: "\f274"; } + +.fa-calendar-day:before { + content: "\f783"; } + +.fa-calendar-minus:before { + content: "\f272"; } + +.fa-calendar-plus:before { + content: "\f271"; } + +.fa-calendar-times:before { + content: "\f273"; } + +.fa-calendar-week:before { + content: "\f784"; } + +.fa-camera:before { + content: "\f030"; } + +.fa-camera-retro:before { + content: "\f083"; } + +.fa-campground:before { + content: "\f6bb"; } + +.fa-canadian-maple-leaf:before { + content: "\f785"; } + +.fa-candy-cane:before { + content: "\f786"; } + +.fa-cannabis:before { + content: "\f55f"; } + +.fa-capsules:before { + content: "\f46b"; } + +.fa-car:before { + content: "\f1b9"; } + +.fa-car-alt:before { + content: "\f5de"; } + +.fa-car-battery:before { + content: "\f5df"; } + +.fa-car-crash:before { + content: "\f5e1"; } + +.fa-car-side:before { + content: "\f5e4"; } + +.fa-caravan:before { + content: "\f8ff"; } + +.fa-caret-down:before { + content: "\f0d7"; } + +.fa-caret-left:before { + content: "\f0d9"; } + +.fa-caret-right:before { + content: "\f0da"; } + +.fa-caret-square-down:before { + content: "\f150"; } + +.fa-caret-square-left:before { + content: "\f191"; } + +.fa-caret-square-right:before { + content: "\f152"; } + +.fa-caret-square-up:before { + content: "\f151"; } + +.fa-caret-up:before { + content: "\f0d8"; } + +.fa-carrot:before { + content: "\f787"; } + +.fa-cart-arrow-down:before { + content: "\f218"; } + +.fa-cart-plus:before { + content: "\f217"; } + +.fa-cash-register:before { + content: "\f788"; } + +.fa-cat:before { + content: "\f6be"; } + +.fa-cc-amazon-pay:before { + content: "\f42d"; } + +.fa-cc-amex:before { + content: "\f1f3"; } + +.fa-cc-apple-pay:before { + content: "\f416"; } + +.fa-cc-diners-club:before { + content: "\f24c"; } + +.fa-cc-discover:before { + content: "\f1f2"; } + +.fa-cc-jcb:before { + content: "\f24b"; } + +.fa-cc-mastercard:before { + content: "\f1f1"; } + +.fa-cc-paypal:before { + content: "\f1f4"; } + +.fa-cc-stripe:before { + content: "\f1f5"; } + +.fa-cc-visa:before { + content: "\f1f0"; } + +.fa-centercode:before { + content: "\f380"; } + +.fa-centos:before { + content: "\f789"; } + +.fa-certificate:before { + content: "\f0a3"; } + +.fa-chair:before { + content: "\f6c0"; } + +.fa-chalkboard:before { + content: "\f51b"; } + +.fa-chalkboard-teacher:before { + content: "\f51c"; } + +.fa-charging-station:before { + content: "\f5e7"; } + +.fa-chart-area:before { + content: "\f1fe"; } + +.fa-chart-bar:before { + content: "\f080"; } + +.fa-chart-line:before { + content: "\f201"; } + +.fa-chart-pie:before { + content: "\f200"; } + +.fa-check:before { + content: "\f00c"; } + +.fa-check-circle:before { + content: "\f058"; } + +.fa-check-double:before { + content: "\f560"; } + +.fa-check-square:before { + content: "\f14a"; } + +.fa-cheese:before { + content: "\f7ef"; } + +.fa-chess:before { + content: "\f439"; } + +.fa-chess-bishop:before { + content: "\f43a"; } + +.fa-chess-board:before { + content: "\f43c"; } + +.fa-chess-king:before { + content: "\f43f"; } + +.fa-chess-knight:before { + content: "\f441"; } + +.fa-chess-pawn:before { + content: "\f443"; } + +.fa-chess-queen:before { + content: "\f445"; } + +.fa-chess-rook:before { + content: "\f447"; } + +.fa-chevron-circle-down:before { + content: "\f13a"; } + +.fa-chevron-circle-left:before { + content: "\f137"; } + +.fa-chevron-circle-right:before { + content: "\f138"; } + +.fa-chevron-circle-up:before { + content: "\f139"; } + +.fa-chevron-down:before { + content: "\f078"; } + +.fa-chevron-left:before { + content: "\f053"; } + +.fa-chevron-right:before { + content: "\f054"; } + +.fa-chevron-up:before { + content: "\f077"; } + +.fa-child:before { + content: "\f1ae"; } + +.fa-chrome:before { + content: "\f268"; } + +.fa-chromecast:before { + content: "\f838"; } + +.fa-church:before { + content: "\f51d"; } + +.fa-circle:before { + content: "\f111"; } + +.fa-circle-notch:before { + content: "\f1ce"; } + +.fa-city:before { + content: "\f64f"; } + +.fa-clinic-medical:before { + content: "\f7f2"; } + +.fa-clipboard:before { + content: "\f328"; } + +.fa-clipboard-check:before { + content: "\f46c"; } + +.fa-clipboard-list:before { + content: "\f46d"; } + +.fa-clock:before { + content: "\f017"; } + +.fa-clone:before { + content: "\f24d"; } + +.fa-closed-captioning:before { + content: "\f20a"; } + +.fa-cloud:before { + content: "\f0c2"; } + +.fa-cloud-download-alt:before { + content: "\f381"; } + +.fa-cloud-meatball:before { + content: "\f73b"; } + +.fa-cloud-moon:before { + content: "\f6c3"; } + +.fa-cloud-moon-rain:before { + content: "\f73c"; } + +.fa-cloud-rain:before { + content: "\f73d"; } + +.fa-cloud-showers-heavy:before { + content: "\f740"; } + +.fa-cloud-sun:before { + content: "\f6c4"; } + +.fa-cloud-sun-rain:before { + content: "\f743"; } + +.fa-cloud-upload-alt:before { + content: "\f382"; } + +.fa-cloudscale:before { + content: "\f383"; } + +.fa-cloudsmith:before { + content: "\f384"; } + +.fa-cloudversify:before { + content: "\f385"; } + +.fa-cocktail:before { + content: "\f561"; } + +.fa-code:before { + content: "\f121"; } + +.fa-code-branch:before { + content: "\f126"; } + +.fa-codepen:before { + content: "\f1cb"; } + +.fa-codiepie:before { + content: "\f284"; } + +.fa-coffee:before { + content: "\f0f4"; } + +.fa-cog:before { + content: "\f013"; } + +.fa-cogs:before { + content: "\f085"; } + +.fa-coins:before { + content: "\f51e"; } + +.fa-columns:before { + content: "\f0db"; } + +.fa-comment:before { + content: "\f075"; } + +.fa-comment-alt:before { + content: "\f27a"; } + +.fa-comment-dollar:before { + content: "\f651"; } + +.fa-comment-dots:before { + content: "\f4ad"; } + +.fa-comment-medical:before { + content: "\f7f5"; } + +.fa-comment-slash:before { + content: "\f4b3"; } + +.fa-comments:before { + content: "\f086"; } + +.fa-comments-dollar:before { + content: "\f653"; } + +.fa-compact-disc:before { + content: "\f51f"; } + +.fa-compass:before { + content: "\f14e"; } + +.fa-compress:before { + content: "\f066"; } + +.fa-compress-alt:before { + content: "\f422"; } + +.fa-compress-arrows-alt:before { + content: "\f78c"; } + +.fa-concierge-bell:before { + content: "\f562"; } + +.fa-confluence:before { + content: "\f78d"; } + +.fa-connectdevelop:before { + content: "\f20e"; } + +.fa-contao:before { + content: "\f26d"; } + +.fa-cookie:before { + content: "\f563"; } + +.fa-cookie-bite:before { + content: "\f564"; } + +.fa-copy:before { + content: "\f0c5"; } + +.fa-copyright:before { + content: "\f1f9"; } + +.fa-cotton-bureau:before { + content: "\f89e"; } + +.fa-couch:before { + content: "\f4b8"; } + +.fa-cpanel:before { + content: "\f388"; } + +.fa-creative-commons:before { + content: "\f25e"; } + +.fa-creative-commons-by:before { + content: "\f4e7"; } + +.fa-creative-commons-nc:before { + content: "\f4e8"; } + +.fa-creative-commons-nc-eu:before { + content: "\f4e9"; } + +.fa-creative-commons-nc-jp:before { + content: "\f4ea"; } + +.fa-creative-commons-nd:before { + content: "\f4eb"; } + +.fa-creative-commons-pd:before { + content: "\f4ec"; } + +.fa-creative-commons-pd-alt:before { + content: "\f4ed"; } + +.fa-creative-commons-remix:before { + content: "\f4ee"; } + +.fa-creative-commons-sa:before { + content: "\f4ef"; } + +.fa-creative-commons-sampling:before { + content: "\f4f0"; } + +.fa-creative-commons-sampling-plus:before { + content: "\f4f1"; } + +.fa-creative-commons-share:before { + content: "\f4f2"; } + +.fa-creative-commons-zero:before { + content: "\f4f3"; } + +.fa-credit-card:before { + content: "\f09d"; } + +.fa-critical-role:before { + content: "\f6c9"; } + +.fa-crop:before { + content: "\f125"; } + +.fa-crop-alt:before { + content: "\f565"; } + +.fa-cross:before { + content: "\f654"; } + +.fa-crosshairs:before { + content: "\f05b"; } + +.fa-crow:before { + content: "\f520"; } + +.fa-crown:before { + content: "\f521"; } + +.fa-crutch:before { + content: "\f7f7"; } + +.fa-css3:before { + content: "\f13c"; } + +.fa-css3-alt:before { + content: "\f38b"; } + +.fa-cube:before { + content: "\f1b2"; } + +.fa-cubes:before { + content: "\f1b3"; } + +.fa-cut:before { + content: "\f0c4"; } + +.fa-cuttlefish:before { + content: "\f38c"; } + +.fa-d-and-d:before { + content: "\f38d"; } + +.fa-d-and-d-beyond:before { + content: "\f6ca"; } + +.fa-dailymotion:before { + content: "\f952"; } + +.fa-dashcube:before { + content: "\f210"; } + +.fa-database:before { + content: "\f1c0"; } + +.fa-deaf:before { + content: "\f2a4"; } + +.fa-delicious:before { + content: "\f1a5"; } + +.fa-democrat:before { + content: "\f747"; } + +.fa-deploydog:before { + content: "\f38e"; } + +.fa-deskpro:before { + content: "\f38f"; } + +.fa-desktop:before { + content: "\f108"; } + +.fa-dev:before { + content: "\f6cc"; } + +.fa-deviantart:before { + content: "\f1bd"; } + +.fa-dharmachakra:before { + content: "\f655"; } + +.fa-dhl:before { + content: "\f790"; } + +.fa-diagnoses:before { + content: "\f470"; } + +.fa-diaspora:before { + content: "\f791"; } + +.fa-dice:before { + content: "\f522"; } + +.fa-dice-d20:before { + content: "\f6cf"; } + +.fa-dice-d6:before { + content: "\f6d1"; } + +.fa-dice-five:before { + content: "\f523"; } + +.fa-dice-four:before { + content: "\f524"; } + +.fa-dice-one:before { + content: "\f525"; } + +.fa-dice-six:before { + content: "\f526"; } + +.fa-dice-three:before { + content: "\f527"; } + +.fa-dice-two:before { + content: "\f528"; } + +.fa-digg:before { + content: "\f1a6"; } + +.fa-digital-ocean:before { + content: "\f391"; } + +.fa-digital-tachograph:before { + content: "\f566"; } + +.fa-directions:before { + content: "\f5eb"; } + +.fa-discord:before { + content: "\f392"; } + +.fa-discourse:before { + content: "\f393"; } + +.fa-disease:before { + content: "\f7fa"; } + +.fa-divide:before { + content: "\f529"; } + +.fa-dizzy:before { + content: "\f567"; } + +.fa-dna:before { + content: "\f471"; } + +.fa-dochub:before { + content: "\f394"; } + +.fa-docker:before { + content: "\f395"; } + +.fa-dog:before { + content: "\f6d3"; } + +.fa-dollar-sign:before { + content: "\f155"; } + +.fa-dolly:before { + content: "\f472"; } + +.fa-dolly-flatbed:before { + content: "\f474"; } + +.fa-donate:before { + content: "\f4b9"; } + +.fa-door-closed:before { + content: "\f52a"; } + +.fa-door-open:before { + content: "\f52b"; } + +.fa-dot-circle:before { + content: "\f192"; } + +.fa-dove:before { + content: "\f4ba"; } + +.fa-download:before { + content: "\f019"; } + +.fa-draft2digital:before { + content: "\f396"; } + +.fa-drafting-compass:before { + content: "\f568"; } + +.fa-dragon:before { + content: "\f6d5"; } + +.fa-draw-polygon:before { + content: "\f5ee"; } + +.fa-dribbble:before { + content: "\f17d"; } + +.fa-dribbble-square:before { + content: "\f397"; } + +.fa-dropbox:before { + content: "\f16b"; } + +.fa-drum:before { + content: "\f569"; } + +.fa-drum-steelpan:before { + content: "\f56a"; } + +.fa-drumstick-bite:before { + content: "\f6d7"; } + +.fa-drupal:before { + content: "\f1a9"; } + +.fa-dumbbell:before { + content: "\f44b"; } + +.fa-dumpster:before { + content: "\f793"; } + +.fa-dumpster-fire:before { + content: "\f794"; } + +.fa-dungeon:before { + content: "\f6d9"; } + +.fa-dyalog:before { + content: "\f399"; } + +.fa-earlybirds:before { + content: "\f39a"; } + +.fa-ebay:before { + content: "\f4f4"; } + +.fa-edge:before { + content: "\f282"; } + +.fa-edit:before { + content: "\f044"; } + +.fa-egg:before { + content: "\f7fb"; } + +.fa-eject:before { + content: "\f052"; } + +.fa-elementor:before { + content: "\f430"; } + +.fa-ellipsis-h:before { + content: "\f141"; } + +.fa-ellipsis-v:before { + content: "\f142"; } + +.fa-ello:before { + content: "\f5f1"; } + +.fa-ember:before { + content: "\f423"; } + +.fa-empire:before { + content: "\f1d1"; } + +.fa-envelope:before { + content: "\f0e0"; } + +.fa-envelope-open:before { + content: "\f2b6"; } + +.fa-envelope-open-text:before { + content: "\f658"; } + +.fa-envelope-square:before { + content: "\f199"; } + +.fa-envira:before { + content: "\f299"; } + +.fa-equals:before { + content: "\f52c"; } + +.fa-eraser:before { + content: "\f12d"; } + +.fa-erlang:before { + content: "\f39d"; } + +.fa-ethereum:before { + content: "\f42e"; } + +.fa-ethernet:before { + content: "\f796"; } + +.fa-etsy:before { + content: "\f2d7"; } + +.fa-euro-sign:before { + content: "\f153"; } + +.fa-evernote:before { + content: "\f839"; } + +.fa-exchange-alt:before { + content: "\f362"; } + +.fa-exclamation:before { + content: "\f12a"; } + +.fa-exclamation-circle:before { + content: "\f06a"; } + +.fa-exclamation-triangle:before { + content: "\f071"; } + +.fa-expand:before { + content: "\f065"; } + +.fa-expand-alt:before { + content: "\f424"; } + +.fa-expand-arrows-alt:before { + content: "\f31e"; } + +.fa-expeditedssl:before { + content: "\f23e"; } + +.fa-external-link-alt:before { + content: "\f35d"; } + +.fa-external-link-square-alt:before { + content: "\f360"; } + +.fa-eye:before { + content: "\f06e"; } + +.fa-eye-dropper:before { + content: "\f1fb"; } + +.fa-eye-slash:before { + content: "\f070"; } + +.fa-facebook:before { + content: "\f09a"; } + +.fa-facebook-f:before { + content: "\f39e"; } + +.fa-facebook-messenger:before { + content: "\f39f"; } + +.fa-facebook-square:before { + content: "\f082"; } + +.fa-fan:before { + content: "\f863"; } + +.fa-fantasy-flight-games:before { + content: "\f6dc"; } + +.fa-fast-backward:before { + content: "\f049"; } + +.fa-fast-forward:before { + content: "\f050"; } + +.fa-faucet:before { + content: "\f905"; } + +.fa-fax:before { + content: "\f1ac"; } + +.fa-feather:before { + content: "\f52d"; } + +.fa-feather-alt:before { + content: "\f56b"; } + +.fa-fedex:before { + content: "\f797"; } + +.fa-fedora:before { + content: "\f798"; } + +.fa-female:before { + content: "\f182"; } + +.fa-fighter-jet:before { + content: "\f0fb"; } + +.fa-figma:before { + content: "\f799"; } + +.fa-file:before { + content: "\f15b"; } + +.fa-file-alt:before { + content: "\f15c"; } + +.fa-file-archive:before { + content: "\f1c6"; } + +.fa-file-audio:before { + content: "\f1c7"; } + +.fa-file-code:before { + content: "\f1c9"; } + +.fa-file-contract:before { + content: "\f56c"; } + +.fa-file-csv:before { + content: "\f6dd"; } + +.fa-file-download:before { + content: "\f56d"; } + +.fa-file-excel:before { + content: "\f1c3"; } + +.fa-file-export:before { + content: "\f56e"; } + +.fa-file-image:before { + content: "\f1c5"; } + +.fa-file-import:before { + content: "\f56f"; } + +.fa-file-invoice:before { + content: "\f570"; } + +.fa-file-invoice-dollar:before { + content: "\f571"; } + +.fa-file-medical:before { + content: "\f477"; } + +.fa-file-medical-alt:before { + content: "\f478"; } + +.fa-file-pdf:before { + content: "\f1c1"; } + +.fa-file-powerpoint:before { + content: "\f1c4"; } + +.fa-file-prescription:before { + content: "\f572"; } + +.fa-file-signature:before { + content: "\f573"; } + +.fa-file-upload:before { + content: "\f574"; } + +.fa-file-video:before { + content: "\f1c8"; } + +.fa-file-word:before { + content: "\f1c2"; } + +.fa-fill:before { + content: "\f575"; } + +.fa-fill-drip:before { + content: "\f576"; } + +.fa-film:before { + content: "\f008"; } + +.fa-filter:before { + content: "\f0b0"; } + +.fa-fingerprint:before { + content: "\f577"; } + +.fa-fire:before { + content: "\f06d"; } + +.fa-fire-alt:before { + content: "\f7e4"; } + +.fa-fire-extinguisher:before { + content: "\f134"; } + +.fa-firefox:before { + content: "\f269"; } + +.fa-firefox-browser:before { + content: "\f907"; } + +.fa-first-aid:before { + content: "\f479"; } + +.fa-first-order:before { + content: "\f2b0"; } + +.fa-first-order-alt:before { + content: "\f50a"; } + +.fa-firstdraft:before { + content: "\f3a1"; } + +.fa-fish:before { + content: "\f578"; } + +.fa-fist-raised:before { + content: "\f6de"; } + +.fa-flag:before { + content: "\f024"; } + +.fa-flag-checkered:before { + content: "\f11e"; } + +.fa-flag-usa:before { + content: "\f74d"; } + +.fa-flask:before { + content: "\f0c3"; } + +.fa-flickr:before { + content: "\f16e"; } + +.fa-flipboard:before { + content: "\f44d"; } + +.fa-flushed:before { + content: "\f579"; } + +.fa-fly:before { + content: "\f417"; } + +.fa-folder:before { + content: "\f07b"; } + +.fa-folder-minus:before { + content: "\f65d"; } + +.fa-folder-open:before { + content: "\f07c"; } + +.fa-folder-plus:before { + content: "\f65e"; } + +.fa-font:before { + content: "\f031"; } + +.fa-font-awesome:before { + content: "\f2b4"; } + +.fa-font-awesome-alt:before { + content: "\f35c"; } + +.fa-font-awesome-flag:before { + content: "\f425"; } + +.fa-font-awesome-logo-full:before { + content: "\f4e6"; } + +.fa-fonticons:before { + content: "\f280"; } + +.fa-fonticons-fi:before { + content: "\f3a2"; } + +.fa-football-ball:before { + content: "\f44e"; } + +.fa-fort-awesome:before { + content: "\f286"; } + +.fa-fort-awesome-alt:before { + content: "\f3a3"; } + +.fa-forumbee:before { + content: "\f211"; } + +.fa-forward:before { + content: "\f04e"; } + +.fa-foursquare:before { + content: "\f180"; } + +.fa-free-code-camp:before { + content: "\f2c5"; } + +.fa-freebsd:before { + content: "\f3a4"; } + +.fa-frog:before { + content: "\f52e"; } + +.fa-frown:before { + content: "\f119"; } + +.fa-frown-open:before { + content: "\f57a"; } + +.fa-fulcrum:before { + content: "\f50b"; } + +.fa-funnel-dollar:before { + content: "\f662"; } + +.fa-futbol:before { + content: "\f1e3"; } + +.fa-galactic-republic:before { + content: "\f50c"; } + +.fa-galactic-senate:before { + content: "\f50d"; } + +.fa-gamepad:before { + content: "\f11b"; } + +.fa-gas-pump:before { + content: "\f52f"; } + +.fa-gavel:before { + content: "\f0e3"; } + +.fa-gem:before { + content: "\f3a5"; } + +.fa-genderless:before { + content: "\f22d"; } + +.fa-get-pocket:before { + content: "\f265"; } + +.fa-gg:before { + content: "\f260"; } + +.fa-gg-circle:before { + content: "\f261"; } + +.fa-ghost:before { + content: "\f6e2"; } + +.fa-gift:before { + content: "\f06b"; } + +.fa-gifts:before { + content: "\f79c"; } + +.fa-git:before { + content: "\f1d3"; } + +.fa-git-alt:before { + content: "\f841"; } + +.fa-git-square:before { + content: "\f1d2"; } + +.fa-github:before { + content: "\f09b"; } + +.fa-github-alt:before { + content: "\f113"; } + +.fa-github-square:before { + content: "\f092"; } + +.fa-gitkraken:before { + content: "\f3a6"; } + +.fa-gitlab:before { + content: "\f296"; } + +.fa-gitter:before { + content: "\f426"; } + +.fa-glass-cheers:before { + content: "\f79f"; } + +.fa-glass-martini:before { + content: "\f000"; } + +.fa-glass-martini-alt:before { + content: "\f57b"; } + +.fa-glass-whiskey:before { + content: "\f7a0"; } + +.fa-glasses:before { + content: "\f530"; } + +.fa-glide:before { + content: "\f2a5"; } + +.fa-glide-g:before { + content: "\f2a6"; } + +.fa-globe:before { + content: "\f0ac"; } + +.fa-globe-africa:before { + content: "\f57c"; } + +.fa-globe-americas:before { + content: "\f57d"; } + +.fa-globe-asia:before { + content: "\f57e"; } + +.fa-globe-europe:before { + content: "\f7a2"; } + +.fa-gofore:before { + content: "\f3a7"; } + +.fa-golf-ball:before { + content: "\f450"; } + +.fa-goodreads:before { + content: "\f3a8"; } + +.fa-goodreads-g:before { + content: "\f3a9"; } + +.fa-google:before { + content: "\f1a0"; } + +.fa-google-drive:before { + content: "\f3aa"; } + +.fa-google-play:before { + content: "\f3ab"; } + +.fa-google-plus:before { + content: "\f2b3"; } + +.fa-google-plus-g:before { + content: "\f0d5"; } + +.fa-google-plus-square:before { + content: "\f0d4"; } + +.fa-google-wallet:before { + content: "\f1ee"; } + +.fa-gopuram:before { + content: "\f664"; } + +.fa-graduation-cap:before { + content: "\f19d"; } + +.fa-gratipay:before { + content: "\f184"; } + +.fa-grav:before { + content: "\f2d6"; } + +.fa-greater-than:before { + content: "\f531"; } + +.fa-greater-than-equal:before { + content: "\f532"; } + +.fa-grimace:before { + content: "\f57f"; } + +.fa-grin:before { + content: "\f580"; } + +.fa-grin-alt:before { + content: "\f581"; } + +.fa-grin-beam:before { + content: "\f582"; } + +.fa-grin-beam-sweat:before { + content: "\f583"; } + +.fa-grin-hearts:before { + content: "\f584"; } + +.fa-grin-squint:before { + content: "\f585"; } + +.fa-grin-squint-tears:before { + content: "\f586"; } + +.fa-grin-stars:before { + content: "\f587"; } + +.fa-grin-tears:before { + content: "\f588"; } + +.fa-grin-tongue:before { + content: "\f589"; } + +.fa-grin-tongue-squint:before { + content: "\f58a"; } + +.fa-grin-tongue-wink:before { + content: "\f58b"; } + +.fa-grin-wink:before { + content: "\f58c"; } + +.fa-grip-horizontal:before { + content: "\f58d"; } + +.fa-grip-lines:before { + content: "\f7a4"; } + +.fa-grip-lines-vertical:before { + content: "\f7a5"; } + +.fa-grip-vertical:before { + content: "\f58e"; } + +.fa-gripfire:before { + content: "\f3ac"; } + +.fa-grunt:before { + content: "\f3ad"; } + +.fa-guitar:before { + content: "\f7a6"; } + +.fa-gulp:before { + content: "\f3ae"; } + +.fa-h-square:before { + content: "\f0fd"; } + +.fa-hacker-news:before { + content: "\f1d4"; } + +.fa-hacker-news-square:before { + content: "\f3af"; } + +.fa-hackerrank:before { + content: "\f5f7"; } + +.fa-hamburger:before { + content: "\f805"; } + +.fa-hammer:before { + content: "\f6e3"; } + +.fa-hamsa:before { + content: "\f665"; } + +.fa-hand-holding:before { + content: "\f4bd"; } + +.fa-hand-holding-heart:before { + content: "\f4be"; } + +.fa-hand-holding-medical:before { + content: "\f95c"; } + +.fa-hand-holding-usd:before { + content: "\f4c0"; } + +.fa-hand-holding-water:before { + content: "\f4c1"; } + +.fa-hand-lizard:before { + content: "\f258"; } + +.fa-hand-middle-finger:before { + content: "\f806"; } + +.fa-hand-paper:before { + content: "\f256"; } + +.fa-hand-peace:before { + content: "\f25b"; } + +.fa-hand-point-down:before { + content: "\f0a7"; } + +.fa-hand-point-left:before { + content: "\f0a5"; } + +.fa-hand-point-right:before { + content: "\f0a4"; } + +.fa-hand-point-up:before { + content: "\f0a6"; } + +.fa-hand-pointer:before { + content: "\f25a"; } + +.fa-hand-rock:before { + content: "\f255"; } + +.fa-hand-scissors:before { + content: "\f257"; } + +.fa-hand-sparkles:before { + content: "\f95d"; } + +.fa-hand-spock:before { + content: "\f259"; } + +.fa-hands:before { + content: "\f4c2"; } + +.fa-hands-helping:before { + content: "\f4c4"; } + +.fa-hands-wash:before { + content: "\f95e"; } + +.fa-handshake:before { + content: "\f2b5"; } + +.fa-handshake-alt-slash:before { + content: "\f95f"; } + +.fa-handshake-slash:before { + content: "\f960"; } + +.fa-hanukiah:before { + content: "\f6e6"; } + +.fa-hard-hat:before { + content: "\f807"; } + +.fa-hashtag:before { + content: "\f292"; } + +.fa-hat-cowboy:before { + content: "\f8c0"; } + +.fa-hat-cowboy-side:before { + content: "\f8c1"; } + +.fa-hat-wizard:before { + content: "\f6e8"; } + +.fa-hdd:before { + content: "\f0a0"; } + +.fa-head-side-cough:before { + content: "\f961"; } + +.fa-head-side-cough-slash:before { + content: "\f962"; } + +.fa-head-side-mask:before { + content: "\f963"; } + +.fa-head-side-virus:before { + content: "\f964"; } + +.fa-heading:before { + content: "\f1dc"; } + +.fa-headphones:before { + content: "\f025"; } + +.fa-headphones-alt:before { + content: "\f58f"; } + +.fa-headset:before { + content: "\f590"; } + +.fa-heart:before { + content: "\f004"; } + +.fa-heart-broken:before { + content: "\f7a9"; } + +.fa-heartbeat:before { + content: "\f21e"; } + +.fa-helicopter:before { + content: "\f533"; } + +.fa-highlighter:before { + content: "\f591"; } + +.fa-hiking:before { + content: "\f6ec"; } + +.fa-hippo:before { + content: "\f6ed"; } + +.fa-hips:before { + content: "\f452"; } + +.fa-hire-a-helper:before { + content: "\f3b0"; } + +.fa-history:before { + content: "\f1da"; } + +.fa-hockey-puck:before { + content: "\f453"; } + +.fa-holly-berry:before { + content: "\f7aa"; } + +.fa-home:before { + content: "\f015"; } + +.fa-hooli:before { + content: "\f427"; } + +.fa-hornbill:before { + content: "\f592"; } + +.fa-horse:before { + content: "\f6f0"; } + +.fa-horse-head:before { + content: "\f7ab"; } + +.fa-hospital:before { + content: "\f0f8"; } + +.fa-hospital-alt:before { + content: "\f47d"; } + +.fa-hospital-symbol:before { + content: "\f47e"; } + +.fa-hospital-user:before { + content: "\f80d"; } + +.fa-hot-tub:before { + content: "\f593"; } + +.fa-hotdog:before { + content: "\f80f"; } + +.fa-hotel:before { + content: "\f594"; } + +.fa-hotjar:before { + content: "\f3b1"; } + +.fa-hourglass:before { + content: "\f254"; } + +.fa-hourglass-end:before { + content: "\f253"; } + +.fa-hourglass-half:before { + content: "\f252"; } + +.fa-hourglass-start:before { + content: "\f251"; } + +.fa-house-damage:before { + content: "\f6f1"; } + +.fa-house-user:before { + content: "\f965"; } + +.fa-houzz:before { + content: "\f27c"; } + +.fa-hryvnia:before { + content: "\f6f2"; } + +.fa-html5:before { + content: "\f13b"; } + +.fa-hubspot:before { + content: "\f3b2"; } + +.fa-i-cursor:before { + content: "\f246"; } + +.fa-ice-cream:before { + content: "\f810"; } + +.fa-icicles:before { + content: "\f7ad"; } + +.fa-icons:before { + content: "\f86d"; } + +.fa-id-badge:before { + content: "\f2c1"; } + +.fa-id-card:before { + content: "\f2c2"; } + +.fa-id-card-alt:before { + content: "\f47f"; } + +.fa-ideal:before { + content: "\f913"; } + +.fa-igloo:before { + content: "\f7ae"; } + +.fa-image:before { + content: "\f03e"; } + +.fa-images:before { + content: "\f302"; } + +.fa-imdb:before { + content: "\f2d8"; } + +.fa-inbox:before { + content: "\f01c"; } + +.fa-indent:before { + content: "\f03c"; } + +.fa-industry:before { + content: "\f275"; } + +.fa-infinity:before { + content: "\f534"; } + +.fa-info:before { + content: "\f129"; } + +.fa-info-circle:before { + content: "\f05a"; } + +.fa-instagram:before { + content: "\f16d"; } + +.fa-instagram-square:before { + content: "\f955"; } + +.fa-intercom:before { + content: "\f7af"; } + +.fa-internet-explorer:before { + content: "\f26b"; } + +.fa-invision:before { + content: "\f7b0"; } + +.fa-ioxhost:before { + content: "\f208"; } + +.fa-italic:before { + content: "\f033"; } + +.fa-itch-io:before { + content: "\f83a"; } + +.fa-itunes:before { + content: "\f3b4"; } + +.fa-itunes-note:before { + content: "\f3b5"; } + +.fa-java:before { + content: "\f4e4"; } + +.fa-jedi:before { + content: "\f669"; } + +.fa-jedi-order:before { + content: "\f50e"; } + +.fa-jenkins:before { + content: "\f3b6"; } + +.fa-jira:before { + content: "\f7b1"; } + +.fa-joget:before { + content: "\f3b7"; } + +.fa-joint:before { + content: "\f595"; } + +.fa-joomla:before { + content: "\f1aa"; } + +.fa-journal-whills:before { + content: "\f66a"; } + +.fa-js:before { + content: "\f3b8"; } + +.fa-js-square:before { + content: "\f3b9"; } + +.fa-jsfiddle:before { + content: "\f1cc"; } + +.fa-kaaba:before { + content: "\f66b"; } + +.fa-kaggle:before { + content: "\f5fa"; } + +.fa-key:before { + content: "\f084"; } + +.fa-keybase:before { + content: "\f4f5"; } + +.fa-keyboard:before { + content: "\f11c"; } + +.fa-keycdn:before { + content: "\f3ba"; } + +.fa-khanda:before { + content: "\f66d"; } + +.fa-kickstarter:before { + content: "\f3bb"; } + +.fa-kickstarter-k:before { + content: "\f3bc"; } + +.fa-kiss:before { + content: "\f596"; } + +.fa-kiss-beam:before { + content: "\f597"; } + +.fa-kiss-wink-heart:before { + content: "\f598"; } + +.fa-kiwi-bird:before { + content: "\f535"; } + +.fa-korvue:before { + content: "\f42f"; } + +.fa-landmark:before { + content: "\f66f"; } + +.fa-language:before { + content: "\f1ab"; } + +.fa-laptop:before { + content: "\f109"; } + +.fa-laptop-code:before { + content: "\f5fc"; } + +.fa-laptop-house:before { + content: "\f966"; } + +.fa-laptop-medical:before { + content: "\f812"; } + +.fa-laravel:before { + content: "\f3bd"; } + +.fa-lastfm:before { + content: "\f202"; } + +.fa-lastfm-square:before { + content: "\f203"; } + +.fa-laugh:before { + content: "\f599"; } + +.fa-laugh-beam:before { + content: "\f59a"; } + +.fa-laugh-squint:before { + content: "\f59b"; } + +.fa-laugh-wink:before { + content: "\f59c"; } + +.fa-layer-group:before { + content: "\f5fd"; } + +.fa-leaf:before { + content: "\f06c"; } + +.fa-leanpub:before { + content: "\f212"; } + +.fa-lemon:before { + content: "\f094"; } + +.fa-less:before { + content: "\f41d"; } + +.fa-less-than:before { + content: "\f536"; } + +.fa-less-than-equal:before { + content: "\f537"; } + +.fa-level-down-alt:before { + content: "\f3be"; } + +.fa-level-up-alt:before { + content: "\f3bf"; } + +.fa-life-ring:before { + content: "\f1cd"; } + +.fa-lightbulb:before { + content: "\f0eb"; } + +.fa-line:before { + content: "\f3c0"; } + +.fa-link:before { + content: "\f0c1"; } + +.fa-linkedin:before { + content: "\f08c"; } + +.fa-linkedin-in:before { + content: "\f0e1"; } + +.fa-linode:before { + content: "\f2b8"; } + +.fa-linux:before { + content: "\f17c"; } + +.fa-lira-sign:before { + content: "\f195"; } + +.fa-list:before { + content: "\f03a"; } + +.fa-list-alt:before { + content: "\f022"; } + +.fa-list-ol:before { + content: "\f0cb"; } + +.fa-list-ul:before { + content: "\f0ca"; } + +.fa-location-arrow:before { + content: "\f124"; } + +.fa-lock:before { + content: "\f023"; } + +.fa-lock-open:before { + content: "\f3c1"; } + +.fa-long-arrow-alt-down:before { + content: "\f309"; } + +.fa-long-arrow-alt-left:before { + content: "\f30a"; } + +.fa-long-arrow-alt-right:before { + content: "\f30b"; } + +.fa-long-arrow-alt-up:before { + content: "\f30c"; } + +.fa-low-vision:before { + content: "\f2a8"; } + +.fa-luggage-cart:before { + content: "\f59d"; } + +.fa-lungs:before { + content: "\f604"; } + +.fa-lungs-virus:before { + content: "\f967"; } + +.fa-lyft:before { + content: "\f3c3"; } + +.fa-magento:before { + content: "\f3c4"; } + +.fa-magic:before { + content: "\f0d0"; } + +.fa-magnet:before { + content: "\f076"; } + +.fa-mail-bulk:before { + content: "\f674"; } + +.fa-mailchimp:before { + content: "\f59e"; } + +.fa-male:before { + content: "\f183"; } + +.fa-mandalorian:before { + content: "\f50f"; } + +.fa-map:before { + content: "\f279"; } + +.fa-map-marked:before { + content: "\f59f"; } + +.fa-map-marked-alt:before { + content: "\f5a0"; } + +.fa-map-marker:before { + content: "\f041"; } + +.fa-map-marker-alt:before { + content: "\f3c5"; } + +.fa-map-pin:before { + content: "\f276"; } + +.fa-map-signs:before { + content: "\f277"; } + +.fa-markdown:before { + content: "\f60f"; } + +.fa-marker:before { + content: "\f5a1"; } + +.fa-mars:before { + content: "\f222"; } + +.fa-mars-double:before { + content: "\f227"; } + +.fa-mars-stroke:before { + content: "\f229"; } + +.fa-mars-stroke-h:before { + content: "\f22b"; } + +.fa-mars-stroke-v:before { + content: "\f22a"; } + +.fa-mask:before { + content: "\f6fa"; } + +.fa-mastodon:before { + content: "\f4f6"; } + +.fa-maxcdn:before { + content: "\f136"; } + +.fa-mdb:before { + content: "\f8ca"; } + +.fa-medal:before { + content: "\f5a2"; } + +.fa-medapps:before { + content: "\f3c6"; } + +.fa-medium:before { + content: "\f23a"; } + +.fa-medium-m:before { + content: "\f3c7"; } + +.fa-medkit:before { + content: "\f0fa"; } + +.fa-medrt:before { + content: "\f3c8"; } + +.fa-meetup:before { + content: "\f2e0"; } + +.fa-megaport:before { + content: "\f5a3"; } + +.fa-meh:before { + content: "\f11a"; } + +.fa-meh-blank:before { + content: "\f5a4"; } + +.fa-meh-rolling-eyes:before { + content: "\f5a5"; } + +.fa-memory:before { + content: "\f538"; } + +.fa-mendeley:before { + content: "\f7b3"; } + +.fa-menorah:before { + content: "\f676"; } + +.fa-mercury:before { + content: "\f223"; } + +.fa-meteor:before { + content: "\f753"; } + +.fa-microblog:before { + content: "\f91a"; } + +.fa-microchip:before { + content: "\f2db"; } + +.fa-microphone:before { + content: "\f130"; } + +.fa-microphone-alt:before { + content: "\f3c9"; } + +.fa-microphone-alt-slash:before { + content: "\f539"; } + +.fa-microphone-slash:before { + content: "\f131"; } + +.fa-microscope:before { + content: "\f610"; } + +.fa-microsoft:before { + content: "\f3ca"; } + +.fa-minus:before { + content: "\f068"; } + +.fa-minus-circle:before { + content: "\f056"; } + +.fa-minus-square:before { + content: "\f146"; } + +.fa-mitten:before { + content: "\f7b5"; } + +.fa-mix:before { + content: "\f3cb"; } + +.fa-mixcloud:before { + content: "\f289"; } + +.fa-mixer:before { + content: "\f956"; } + +.fa-mizuni:before { + content: "\f3cc"; } + +.fa-mobile:before { + content: "\f10b"; } + +.fa-mobile-alt:before { + content: "\f3cd"; } + +.fa-modx:before { + content: "\f285"; } + +.fa-monero:before { + content: "\f3d0"; } + +.fa-money-bill:before { + content: "\f0d6"; } + +.fa-money-bill-alt:before { + content: "\f3d1"; } + +.fa-money-bill-wave:before { + content: "\f53a"; } + +.fa-money-bill-wave-alt:before { + content: "\f53b"; } + +.fa-money-check:before { + content: "\f53c"; } + +.fa-money-check-alt:before { + content: "\f53d"; } + +.fa-monument:before { + content: "\f5a6"; } + +.fa-moon:before { + content: "\f186"; } + +.fa-mortar-pestle:before { + content: "\f5a7"; } + +.fa-mosque:before { + content: "\f678"; } + +.fa-motorcycle:before { + content: "\f21c"; } + +.fa-mountain:before { + content: "\f6fc"; } + +.fa-mouse:before { + content: "\f8cc"; } + +.fa-mouse-pointer:before { + content: "\f245"; } + +.fa-mug-hot:before { + content: "\f7b6"; } + +.fa-music:before { + content: "\f001"; } + +.fa-napster:before { + content: "\f3d2"; } + +.fa-neos:before { + content: "\f612"; } + +.fa-network-wired:before { + content: "\f6ff"; } + +.fa-neuter:before { + content: "\f22c"; } + +.fa-newspaper:before { + content: "\f1ea"; } + +.fa-nimblr:before { + content: "\f5a8"; } + +.fa-node:before { + content: "\f419"; } + +.fa-node-js:before { + content: "\f3d3"; } + +.fa-not-equal:before { + content: "\f53e"; } + +.fa-notes-medical:before { + content: "\f481"; } + +.fa-npm:before { + content: "\f3d4"; } + +.fa-ns8:before { + content: "\f3d5"; } + +.fa-nutritionix:before { + content: "\f3d6"; } + +.fa-object-group:before { + content: "\f247"; } + +.fa-object-ungroup:before { + content: "\f248"; } + +.fa-odnoklassniki:before { + content: "\f263"; } + +.fa-odnoklassniki-square:before { + content: "\f264"; } + +.fa-oil-can:before { + content: "\f613"; } + +.fa-old-republic:before { + content: "\f510"; } + +.fa-om:before { + content: "\f679"; } + +.fa-opencart:before { + content: "\f23d"; } + +.fa-openid:before { + content: "\f19b"; } + +.fa-opera:before { + content: "\f26a"; } + +.fa-optin-monster:before { + content: "\f23c"; } + +.fa-orcid:before { + content: "\f8d2"; } + +.fa-osi:before { + content: "\f41a"; } + +.fa-otter:before { + content: "\f700"; } + +.fa-outdent:before { + content: "\f03b"; } + +.fa-page4:before { + content: "\f3d7"; } + +.fa-pagelines:before { + content: "\f18c"; } + +.fa-pager:before { + content: "\f815"; } + +.fa-paint-brush:before { + content: "\f1fc"; } + +.fa-paint-roller:before { + content: "\f5aa"; } + +.fa-palette:before { + content: "\f53f"; } + +.fa-palfed:before { + content: "\f3d8"; } + +.fa-pallet:before { + content: "\f482"; } + +.fa-paper-plane:before { + content: "\f1d8"; } + +.fa-paperclip:before { + content: "\f0c6"; } + +.fa-parachute-box:before { + content: "\f4cd"; } + +.fa-paragraph:before { + content: "\f1dd"; } + +.fa-parking:before { + content: "\f540"; } + +.fa-passport:before { + content: "\f5ab"; } + +.fa-pastafarianism:before { + content: "\f67b"; } + +.fa-paste:before { + content: "\f0ea"; } + +.fa-patreon:before { + content: "\f3d9"; } + +.fa-pause:before { + content: "\f04c"; } + +.fa-pause-circle:before { + content: "\f28b"; } + +.fa-paw:before { + content: "\f1b0"; } + +.fa-paypal:before { + content: "\f1ed"; } + +.fa-peace:before { + content: "\f67c"; } + +.fa-pen:before { + content: "\f304"; } + +.fa-pen-alt:before { + content: "\f305"; } + +.fa-pen-fancy:before { + content: "\f5ac"; } + +.fa-pen-nib:before { + content: "\f5ad"; } + +.fa-pen-square:before { + content: "\f14b"; } + +.fa-pencil-alt:before { + content: "\f303"; } + +.fa-pencil-ruler:before { + content: "\f5ae"; } + +.fa-penny-arcade:before { + content: "\f704"; } + +.fa-people-arrows:before { + content: "\f968"; } + +.fa-people-carry:before { + content: "\f4ce"; } + +.fa-pepper-hot:before { + content: "\f816"; } + +.fa-percent:before { + content: "\f295"; } + +.fa-percentage:before { + content: "\f541"; } + +.fa-periscope:before { + content: "\f3da"; } + +.fa-person-booth:before { + content: "\f756"; } + +.fa-phabricator:before { + content: "\f3db"; } + +.fa-phoenix-framework:before { + content: "\f3dc"; } + +.fa-phoenix-squadron:before { + content: "\f511"; } + +.fa-phone:before { + content: "\f095"; } + +.fa-phone-alt:before { + content: "\f879"; } + +.fa-phone-slash:before { + content: "\f3dd"; } + +.fa-phone-square:before { + content: "\f098"; } + +.fa-phone-square-alt:before { + content: "\f87b"; } + +.fa-phone-volume:before { + content: "\f2a0"; } + +.fa-photo-video:before { + content: "\f87c"; } + +.fa-php:before { + content: "\f457"; } + +.fa-pied-piper:before { + content: "\f2ae"; } + +.fa-pied-piper-alt:before { + content: "\f1a8"; } + +.fa-pied-piper-hat:before { + content: "\f4e5"; } + +.fa-pied-piper-pp:before { + content: "\f1a7"; } + +.fa-pied-piper-square:before { + content: "\f91e"; } + +.fa-piggy-bank:before { + content: "\f4d3"; } + +.fa-pills:before { + content: "\f484"; } + +.fa-pinterest:before { + content: "\f0d2"; } + +.fa-pinterest-p:before { + content: "\f231"; } + +.fa-pinterest-square:before { + content: "\f0d3"; } + +.fa-pizza-slice:before { + content: "\f818"; } + +.fa-place-of-worship:before { + content: "\f67f"; } + +.fa-plane:before { + content: "\f072"; } + +.fa-plane-arrival:before { + content: "\f5af"; } + +.fa-plane-departure:before { + content: "\f5b0"; } + +.fa-plane-slash:before { + content: "\f969"; } + +.fa-play:before { + content: "\f04b"; } + +.fa-play-circle:before { + content: "\f144"; } + +.fa-playstation:before { + content: "\f3df"; } + +.fa-plug:before { + content: "\f1e6"; } + +.fa-plus:before { + content: "\f067"; } + +.fa-plus-circle:before { + content: "\f055"; } + +.fa-plus-square:before { + content: "\f0fe"; } + +.fa-podcast:before { + content: "\f2ce"; } + +.fa-poll:before { + content: "\f681"; } + +.fa-poll-h:before { + content: "\f682"; } + +.fa-poo:before { + content: "\f2fe"; } + +.fa-poo-storm:before { + content: "\f75a"; } + +.fa-poop:before { + content: "\f619"; } + +.fa-portrait:before { + content: "\f3e0"; } + +.fa-pound-sign:before { + content: "\f154"; } + +.fa-power-off:before { + content: "\f011"; } + +.fa-pray:before { + content: "\f683"; } + +.fa-praying-hands:before { + content: "\f684"; } + +.fa-prescription:before { + content: "\f5b1"; } + +.fa-prescription-bottle:before { + content: "\f485"; } + +.fa-prescription-bottle-alt:before { + content: "\f486"; } + +.fa-print:before { + content: "\f02f"; } + +.fa-procedures:before { + content: "\f487"; } + +.fa-product-hunt:before { + content: "\f288"; } + +.fa-project-diagram:before { + content: "\f542"; } + +.fa-pump-medical:before { + content: "\f96a"; } + +.fa-pump-soap:before { + content: "\f96b"; } + +.fa-pushed:before { + content: "\f3e1"; } + +.fa-puzzle-piece:before { + content: "\f12e"; } + +.fa-python:before { + content: "\f3e2"; } + +.fa-qq:before { + content: "\f1d6"; } + +.fa-qrcode:before { + content: "\f029"; } + +.fa-question:before { + content: "\f128"; } + +.fa-question-circle:before { + content: "\f059"; } + +.fa-quidditch:before { + content: "\f458"; } + +.fa-quinscape:before { + content: "\f459"; } + +.fa-quora:before { + content: "\f2c4"; } + +.fa-quote-left:before { + content: "\f10d"; } + +.fa-quote-right:before { + content: "\f10e"; } + +.fa-quran:before { + content: "\f687"; } + +.fa-r-project:before { + content: "\f4f7"; } + +.fa-radiation:before { + content: "\f7b9"; } + +.fa-radiation-alt:before { + content: "\f7ba"; } + +.fa-rainbow:before { + content: "\f75b"; } + +.fa-random:before { + content: "\f074"; } + +.fa-raspberry-pi:before { + content: "\f7bb"; } + +.fa-ravelry:before { + content: "\f2d9"; } + +.fa-react:before { + content: "\f41b"; } + +.fa-reacteurope:before { + content: "\f75d"; } + +.fa-readme:before { + content: "\f4d5"; } + +.fa-rebel:before { + content: "\f1d0"; } + +.fa-receipt:before { + content: "\f543"; } + +.fa-record-vinyl:before { + content: "\f8d9"; } + +.fa-recycle:before { + content: "\f1b8"; } + +.fa-red-river:before { + content: "\f3e3"; } + +.fa-reddit:before { + content: "\f1a1"; } + +.fa-reddit-alien:before { + content: "\f281"; } + +.fa-reddit-square:before { + content: "\f1a2"; } + +.fa-redhat:before { + content: "\f7bc"; } + +.fa-redo:before { + content: "\f01e"; } + +.fa-redo-alt:before { + content: "\f2f9"; } + +.fa-registered:before { + content: "\f25d"; } + +.fa-remove-format:before { + content: "\f87d"; } + +.fa-renren:before { + content: "\f18b"; } + +.fa-reply:before { + content: "\f3e5"; } + +.fa-reply-all:before { + content: "\f122"; } + +.fa-replyd:before { + content: "\f3e6"; } + +.fa-republican:before { + content: "\f75e"; } + +.fa-researchgate:before { + content: "\f4f8"; } + +.fa-resolving:before { + content: "\f3e7"; } + +.fa-restroom:before { + content: "\f7bd"; } + +.fa-retweet:before { + content: "\f079"; } + +.fa-rev:before { + content: "\f5b2"; } + +.fa-ribbon:before { + content: "\f4d6"; } + +.fa-ring:before { + content: "\f70b"; } + +.fa-road:before { + content: "\f018"; } + +.fa-robot:before { + content: "\f544"; } + +.fa-rocket:before { + content: "\f135"; } + +.fa-rocketchat:before { + content: "\f3e8"; } + +.fa-rockrms:before { + content: "\f3e9"; } + +.fa-route:before { + content: "\f4d7"; } + +.fa-rss:before { + content: "\f09e"; } + +.fa-rss-square:before { + content: "\f143"; } + +.fa-ruble-sign:before { + content: "\f158"; } + +.fa-ruler:before { + content: "\f545"; } + +.fa-ruler-combined:before { + content: "\f546"; } + +.fa-ruler-horizontal:before { + content: "\f547"; } + +.fa-ruler-vertical:before { + content: "\f548"; } + +.fa-running:before { + content: "\f70c"; } + +.fa-rupee-sign:before { + content: "\f156"; } + +.fa-sad-cry:before { + content: "\f5b3"; } + +.fa-sad-tear:before { + content: "\f5b4"; } + +.fa-safari:before { + content: "\f267"; } + +.fa-salesforce:before { + content: "\f83b"; } + +.fa-sass:before { + content: "\f41e"; } + +.fa-satellite:before { + content: "\f7bf"; } + +.fa-satellite-dish:before { + content: "\f7c0"; } + +.fa-save:before { + content: "\f0c7"; } + +.fa-schlix:before { + content: "\f3ea"; } + +.fa-school:before { + content: "\f549"; } + +.fa-screwdriver:before { + content: "\f54a"; } + +.fa-scribd:before { + content: "\f28a"; } + +.fa-scroll:before { + content: "\f70e"; } + +.fa-sd-card:before { + content: "\f7c2"; } + +.fa-search:before { + content: "\f002"; } + +.fa-search-dollar:before { + content: "\f688"; } + +.fa-search-location:before { + content: "\f689"; } + +.fa-search-minus:before { + content: "\f010"; } + +.fa-search-plus:before { + content: "\f00e"; } + +.fa-searchengin:before { + content: "\f3eb"; } + +.fa-seedling:before { + content: "\f4d8"; } + +.fa-sellcast:before { + content: "\f2da"; } + +.fa-sellsy:before { + content: "\f213"; } + +.fa-server:before { + content: "\f233"; } + +.fa-servicestack:before { + content: "\f3ec"; } + +.fa-shapes:before { + content: "\f61f"; } + +.fa-share:before { + content: "\f064"; } + +.fa-share-alt:before { + content: "\f1e0"; } + +.fa-share-alt-square:before { + content: "\f1e1"; } + +.fa-share-square:before { + content: "\f14d"; } + +.fa-shekel-sign:before { + content: "\f20b"; } + +.fa-shield-alt:before { + content: "\f3ed"; } + +.fa-shield-virus:before { + content: "\f96c"; } + +.fa-ship:before { + content: "\f21a"; } + +.fa-shipping-fast:before { + content: "\f48b"; } + +.fa-shirtsinbulk:before { + content: "\f214"; } + +.fa-shoe-prints:before { + content: "\f54b"; } + +.fa-shopify:before { + content: "\f957"; } + +.fa-shopping-bag:before { + content: "\f290"; } + +.fa-shopping-basket:before { + content: "\f291"; } + +.fa-shopping-cart:before { + content: "\f07a"; } + +.fa-shopware:before { + content: "\f5b5"; } + +.fa-shower:before { + content: "\f2cc"; } + +.fa-shuttle-van:before { + content: "\f5b6"; } + +.fa-sign:before { + content: "\f4d9"; } + +.fa-sign-in-alt:before { + content: "\f2f6"; } + +.fa-sign-language:before { + content: "\f2a7"; } + +.fa-sign-out-alt:before { + content: "\f2f5"; } + +.fa-signal:before { + content: "\f012"; } + +.fa-signature:before { + content: "\f5b7"; } + +.fa-sim-card:before { + content: "\f7c4"; } + +.fa-simplybuilt:before { + content: "\f215"; } + +.fa-sistrix:before { + content: "\f3ee"; } + +.fa-sitemap:before { + content: "\f0e8"; } + +.fa-sith:before { + content: "\f512"; } + +.fa-skating:before { + content: "\f7c5"; } + +.fa-sketch:before { + content: "\f7c6"; } + +.fa-skiing:before { + content: "\f7c9"; } + +.fa-skiing-nordic:before { + content: "\f7ca"; } + +.fa-skull:before { + content: "\f54c"; } + +.fa-skull-crossbones:before { + content: "\f714"; } + +.fa-skyatlas:before { + content: "\f216"; } + +.fa-skype:before { + content: "\f17e"; } + +.fa-slack:before { + content: "\f198"; } + +.fa-slack-hash:before { + content: "\f3ef"; } + +.fa-slash:before { + content: "\f715"; } + +.fa-sleigh:before { + content: "\f7cc"; } + +.fa-sliders-h:before { + content: "\f1de"; } + +.fa-slideshare:before { + content: "\f1e7"; } + +.fa-smile:before { + content: "\f118"; } + +.fa-smile-beam:before { + content: "\f5b8"; } + +.fa-smile-wink:before { + content: "\f4da"; } + +.fa-smog:before { + content: "\f75f"; } + +.fa-smoking:before { + content: "\f48d"; } + +.fa-smoking-ban:before { + content: "\f54d"; } + +.fa-sms:before { + content: "\f7cd"; } + +.fa-snapchat:before { + content: "\f2ab"; } + +.fa-snapchat-ghost:before { + content: "\f2ac"; } + +.fa-snapchat-square:before { + content: "\f2ad"; } + +.fa-snowboarding:before { + content: "\f7ce"; } + +.fa-snowflake:before { + content: "\f2dc"; } + +.fa-snowman:before { + content: "\f7d0"; } + +.fa-snowplow:before { + content: "\f7d2"; } + +.fa-soap:before { + content: "\f96e"; } + +.fa-socks:before { + content: "\f696"; } + +.fa-solar-panel:before { + content: "\f5ba"; } + +.fa-sort:before { + content: "\f0dc"; } + +.fa-sort-alpha-down:before { + content: "\f15d"; } + +.fa-sort-alpha-down-alt:before { + content: "\f881"; } + +.fa-sort-alpha-up:before { + content: "\f15e"; } + +.fa-sort-alpha-up-alt:before { + content: "\f882"; } + +.fa-sort-amount-down:before { + content: "\f160"; } + +.fa-sort-amount-down-alt:before { + content: "\f884"; } + +.fa-sort-amount-up:before { + content: "\f161"; } + +.fa-sort-amount-up-alt:before { + content: "\f885"; } + +.fa-sort-down:before { + content: "\f0dd"; } + +.fa-sort-numeric-down:before { + content: "\f162"; } + +.fa-sort-numeric-down-alt:before { + content: "\f886"; } + +.fa-sort-numeric-up:before { + content: "\f163"; } + +.fa-sort-numeric-up-alt:before { + content: "\f887"; } + +.fa-sort-up:before { + content: "\f0de"; } + +.fa-soundcloud:before { + content: "\f1be"; } + +.fa-sourcetree:before { + content: "\f7d3"; } + +.fa-spa:before { + content: "\f5bb"; } + +.fa-space-shuttle:before { + content: "\f197"; } + +.fa-speakap:before { + content: "\f3f3"; } + +.fa-speaker-deck:before { + content: "\f83c"; } + +.fa-spell-check:before { + content: "\f891"; } + +.fa-spider:before { + content: "\f717"; } + +.fa-spinner:before { + content: "\f110"; } + +.fa-splotch:before { + content: "\f5bc"; } + +.fa-spotify:before { + content: "\f1bc"; } + +.fa-spray-can:before { + content: "\f5bd"; } + +.fa-square:before { + content: "\f0c8"; } + +.fa-square-full:before { + content: "\f45c"; } + +.fa-square-root-alt:before { + content: "\f698"; } + +.fa-squarespace:before { + content: "\f5be"; } + +.fa-stack-exchange:before { + content: "\f18d"; } + +.fa-stack-overflow:before { + content: "\f16c"; } + +.fa-stackpath:before { + content: "\f842"; } + +.fa-stamp:before { + content: "\f5bf"; } + +.fa-star:before { + content: "\f005"; } + +.fa-star-and-crescent:before { + content: "\f699"; } + +.fa-star-half:before { + content: "\f089"; } + +.fa-star-half-alt:before { + content: "\f5c0"; } + +.fa-star-of-david:before { + content: "\f69a"; } + +.fa-star-of-life:before { + content: "\f621"; } + +.fa-staylinked:before { + content: "\f3f5"; } + +.fa-steam:before { + content: "\f1b6"; } + +.fa-steam-square:before { + content: "\f1b7"; } + +.fa-steam-symbol:before { + content: "\f3f6"; } + +.fa-step-backward:before { + content: "\f048"; } + +.fa-step-forward:before { + content: "\f051"; } + +.fa-stethoscope:before { + content: "\f0f1"; } + +.fa-sticker-mule:before { + content: "\f3f7"; } + +.fa-sticky-note:before { + content: "\f249"; } + +.fa-stop:before { + content: "\f04d"; } + +.fa-stop-circle:before { + content: "\f28d"; } + +.fa-stopwatch:before { + content: "\f2f2"; } + +.fa-stopwatch-20:before { + content: "\f96f"; } + +.fa-store:before { + content: "\f54e"; } + +.fa-store-alt:before { + content: "\f54f"; } + +.fa-store-alt-slash:before { + content: "\f970"; } + +.fa-store-slash:before { + content: "\f971"; } + +.fa-strava:before { + content: "\f428"; } + +.fa-stream:before { + content: "\f550"; } + +.fa-street-view:before { + content: "\f21d"; } + +.fa-strikethrough:before { + content: "\f0cc"; } + +.fa-stripe:before { + content: "\f429"; } + +.fa-stripe-s:before { + content: "\f42a"; } + +.fa-stroopwafel:before { + content: "\f551"; } + +.fa-studiovinari:before { + content: "\f3f8"; } + +.fa-stumbleupon:before { + content: "\f1a4"; } + +.fa-stumbleupon-circle:before { + content: "\f1a3"; } + +.fa-subscript:before { + content: "\f12c"; } + +.fa-subway:before { + content: "\f239"; } + +.fa-suitcase:before { + content: "\f0f2"; } + +.fa-suitcase-rolling:before { + content: "\f5c1"; } + +.fa-sun:before { + content: "\f185"; } + +.fa-superpowers:before { + content: "\f2dd"; } + +.fa-superscript:before { + content: "\f12b"; } + +.fa-supple:before { + content: "\f3f9"; } + +.fa-surprise:before { + content: "\f5c2"; } + +.fa-suse:before { + content: "\f7d6"; } + +.fa-swatchbook:before { + content: "\f5c3"; } + +.fa-swift:before { + content: "\f8e1"; } + +.fa-swimmer:before { + content: "\f5c4"; } + +.fa-swimming-pool:before { + content: "\f5c5"; } + +.fa-symfony:before { + content: "\f83d"; } + +.fa-synagogue:before { + content: "\f69b"; } + +.fa-sync:before { + content: "\f021"; } + +.fa-sync-alt:before { + content: "\f2f1"; } + +.fa-syringe:before { + content: "\f48e"; } + +.fa-table:before { + content: "\f0ce"; } + +.fa-table-tennis:before { + content: "\f45d"; } + +.fa-tablet:before { + content: "\f10a"; } + +.fa-tablet-alt:before { + content: "\f3fa"; } + +.fa-tablets:before { + content: "\f490"; } + +.fa-tachometer-alt:before { + content: "\f3fd"; } + +.fa-tag:before { + content: "\f02b"; } + +.fa-tags:before { + content: "\f02c"; } + +.fa-tape:before { + content: "\f4db"; } + +.fa-tasks:before { + content: "\f0ae"; } + +.fa-taxi:before { + content: "\f1ba"; } + +.fa-teamspeak:before { + content: "\f4f9"; } + +.fa-teeth:before { + content: "\f62e"; } + +.fa-teeth-open:before { + content: "\f62f"; } + +.fa-telegram:before { + content: "\f2c6"; } + +.fa-telegram-plane:before { + content: "\f3fe"; } + +.fa-temperature-high:before { + content: "\f769"; } + +.fa-temperature-low:before { + content: "\f76b"; } + +.fa-tencent-weibo:before { + content: "\f1d5"; } + +.fa-tenge:before { + content: "\f7d7"; } + +.fa-terminal:before { + content: "\f120"; } + +.fa-text-height:before { + content: "\f034"; } + +.fa-text-width:before { + content: "\f035"; } + +.fa-th:before { + content: "\f00a"; } + +.fa-th-large:before { + content: "\f009"; } + +.fa-th-list:before { + content: "\f00b"; } + +.fa-the-red-yeti:before { + content: "\f69d"; } + +.fa-theater-masks:before { + content: "\f630"; } + +.fa-themeco:before { + content: "\f5c6"; } + +.fa-themeisle:before { + content: "\f2b2"; } + +.fa-thermometer:before { + content: "\f491"; } + +.fa-thermometer-empty:before { + content: "\f2cb"; } + +.fa-thermometer-full:before { + content: "\f2c7"; } + +.fa-thermometer-half:before { + content: "\f2c9"; } + +.fa-thermometer-quarter:before { + content: "\f2ca"; } + +.fa-thermometer-three-quarters:before { + content: "\f2c8"; } + +.fa-think-peaks:before { + content: "\f731"; } + +.fa-thumbs-down:before { + content: "\f165"; } + +.fa-thumbs-up:before { + content: "\f164"; } + +.fa-thumbtack:before { + content: "\f08d"; } + +.fa-ticket-alt:before { + content: "\f3ff"; } + +.fa-times:before { + content: "\f00d"; } + +.fa-times-circle:before { + content: "\f057"; } + +.fa-tint:before { + content: "\f043"; } + +.fa-tint-slash:before { + content: "\f5c7"; } + +.fa-tired:before { + content: "\f5c8"; } + +.fa-toggle-off:before { + content: "\f204"; } + +.fa-toggle-on:before { + content: "\f205"; } + +.fa-toilet:before { + content: "\f7d8"; } + +.fa-toilet-paper:before { + content: "\f71e"; } + +.fa-toilet-paper-slash:before { + content: "\f972"; } + +.fa-toolbox:before { + content: "\f552"; } + +.fa-tools:before { + content: "\f7d9"; } + +.fa-tooth:before { + content: "\f5c9"; } + +.fa-torah:before { + content: "\f6a0"; } + +.fa-torii-gate:before { + content: "\f6a1"; } + +.fa-tractor:before { + content: "\f722"; } + +.fa-trade-federation:before { + content: "\f513"; } + +.fa-trademark:before { + content: "\f25c"; } + +.fa-traffic-light:before { + content: "\f637"; } + +.fa-trailer:before { + content: "\f941"; } + +.fa-train:before { + content: "\f238"; } + +.fa-tram:before { + content: "\f7da"; } + +.fa-transgender:before { + content: "\f224"; } + +.fa-transgender-alt:before { + content: "\f225"; } + +.fa-trash:before { + content: "\f1f8"; } + +.fa-trash-alt:before { + content: "\f2ed"; } + +.fa-trash-restore:before { + content: "\f829"; } + +.fa-trash-restore-alt:before { + content: "\f82a"; } + +.fa-tree:before { + content: "\f1bb"; } + +.fa-trello:before { + content: "\f181"; } + +.fa-tripadvisor:before { + content: "\f262"; } + +.fa-trophy:before { + content: "\f091"; } + +.fa-truck:before { + content: "\f0d1"; } + +.fa-truck-loading:before { + content: "\f4de"; } + +.fa-truck-monster:before { + content: "\f63b"; } + +.fa-truck-moving:before { + content: "\f4df"; } + +.fa-truck-pickup:before { + content: "\f63c"; } + +.fa-tshirt:before { + content: "\f553"; } + +.fa-tty:before { + content: "\f1e4"; } + +.fa-tumblr:before { + content: "\f173"; } + +.fa-tumblr-square:before { + content: "\f174"; } + +.fa-tv:before { + content: "\f26c"; } + +.fa-twitch:before { + content: "\f1e8"; } + +.fa-twitter:before { + content: "\f099"; } + +.fa-twitter-square:before { + content: "\f081"; } + +.fa-typo3:before { + content: "\f42b"; } + +.fa-uber:before { + content: "\f402"; } + +.fa-ubuntu:before { + content: "\f7df"; } + +.fa-uikit:before { + content: "\f403"; } + +.fa-umbraco:before { + content: "\f8e8"; } + +.fa-umbrella:before { + content: "\f0e9"; } + +.fa-umbrella-beach:before { + content: "\f5ca"; } + +.fa-underline:before { + content: "\f0cd"; } + +.fa-undo:before { + content: "\f0e2"; } + +.fa-undo-alt:before { + content: "\f2ea"; } + +.fa-uniregistry:before { + content: "\f404"; } + +.fa-unity:before { + content: "\f949"; } + +.fa-universal-access:before { + content: "\f29a"; } + +.fa-university:before { + content: "\f19c"; } + +.fa-unlink:before { + content: "\f127"; } + +.fa-unlock:before { + content: "\f09c"; } + +.fa-unlock-alt:before { + content: "\f13e"; } + +.fa-untappd:before { + content: "\f405"; } + +.fa-upload:before { + content: "\f093"; } + +.fa-ups:before { + content: "\f7e0"; } + +.fa-usb:before { + content: "\f287"; } + +.fa-user:before { + content: "\f007"; } + +.fa-user-alt:before { + content: "\f406"; } + +.fa-user-alt-slash:before { + content: "\f4fa"; } + +.fa-user-astronaut:before { + content: "\f4fb"; } + +.fa-user-check:before { + content: "\f4fc"; } + +.fa-user-circle:before { + content: "\f2bd"; } + +.fa-user-clock:before { + content: "\f4fd"; } + +.fa-user-cog:before { + content: "\f4fe"; } + +.fa-user-edit:before { + content: "\f4ff"; } + +.fa-user-friends:before { + content: "\f500"; } + +.fa-user-graduate:before { + content: "\f501"; } + +.fa-user-injured:before { + content: "\f728"; } + +.fa-user-lock:before { + content: "\f502"; } + +.fa-user-md:before { + content: "\f0f0"; } + +.fa-user-minus:before { + content: "\f503"; } + +.fa-user-ninja:before { + content: "\f504"; } + +.fa-user-nurse:before { + content: "\f82f"; } + +.fa-user-plus:before { + content: "\f234"; } + +.fa-user-secret:before { + content: "\f21b"; } + +.fa-user-shield:before { + content: "\f505"; } + +.fa-user-slash:before { + content: "\f506"; } + +.fa-user-tag:before { + content: "\f507"; } + +.fa-user-tie:before { + content: "\f508"; } + +.fa-user-times:before { + content: "\f235"; } + +.fa-users:before { + content: "\f0c0"; } + +.fa-users-cog:before { + content: "\f509"; } + +.fa-usps:before { + content: "\f7e1"; } + +.fa-ussunnah:before { + content: "\f407"; } + +.fa-utensil-spoon:before { + content: "\f2e5"; } + +.fa-utensils:before { + content: "\f2e7"; } + +.fa-vaadin:before { + content: "\f408"; } + +.fa-vector-square:before { + content: "\f5cb"; } + +.fa-venus:before { + content: "\f221"; } + +.fa-venus-double:before { + content: "\f226"; } + +.fa-venus-mars:before { + content: "\f228"; } + +.fa-viacoin:before { + content: "\f237"; } + +.fa-viadeo:before { + content: "\f2a9"; } + +.fa-viadeo-square:before { + content: "\f2aa"; } + +.fa-vial:before { + content: "\f492"; } + +.fa-vials:before { + content: "\f493"; } + +.fa-viber:before { + content: "\f409"; } + +.fa-video:before { + content: "\f03d"; } + +.fa-video-slash:before { + content: "\f4e2"; } + +.fa-vihara:before { + content: "\f6a7"; } + +.fa-vimeo:before { + content: "\f40a"; } + +.fa-vimeo-square:before { + content: "\f194"; } + +.fa-vimeo-v:before { + content: "\f27d"; } + +.fa-vine:before { + content: "\f1ca"; } + +.fa-virus:before { + content: "\f974"; } + +.fa-virus-slash:before { + content: "\f975"; } + +.fa-viruses:before { + content: "\f976"; } + +.fa-vk:before { + content: "\f189"; } + +.fa-vnv:before { + content: "\f40b"; } + +.fa-voicemail:before { + content: "\f897"; } + +.fa-volleyball-ball:before { + content: "\f45f"; } + +.fa-volume-down:before { + content: "\f027"; } + +.fa-volume-mute:before { + content: "\f6a9"; } + +.fa-volume-off:before { + content: "\f026"; } + +.fa-volume-up:before { + content: "\f028"; } + +.fa-vote-yea:before { + content: "\f772"; } + +.fa-vr-cardboard:before { + content: "\f729"; } + +.fa-vuejs:before { + content: "\f41f"; } + +.fa-walking:before { + content: "\f554"; } + +.fa-wallet:before { + content: "\f555"; } + +.fa-warehouse:before { + content: "\f494"; } + +.fa-water:before { + content: "\f773"; } + +.fa-wave-square:before { + content: "\f83e"; } + +.fa-waze:before { + content: "\f83f"; } + +.fa-weebly:before { + content: "\f5cc"; } + +.fa-weibo:before { + content: "\f18a"; } + +.fa-weight:before { + content: "\f496"; } + +.fa-weight-hanging:before { + content: "\f5cd"; } + +.fa-weixin:before { + content: "\f1d7"; } + +.fa-whatsapp:before { + content: "\f232"; } + +.fa-whatsapp-square:before { + content: "\f40c"; } + +.fa-wheelchair:before { + content: "\f193"; } + +.fa-whmcs:before { + content: "\f40d"; } + +.fa-wifi:before { + content: "\f1eb"; } + +.fa-wikipedia-w:before { + content: "\f266"; } + +.fa-wind:before { + content: "\f72e"; } + +.fa-window-close:before { + content: "\f410"; } + +.fa-window-maximize:before { + content: "\f2d0"; } + +.fa-window-minimize:before { + content: "\f2d1"; } + +.fa-window-restore:before { + content: "\f2d2"; } + +.fa-windows:before { + content: "\f17a"; } + +.fa-wine-bottle:before { + content: "\f72f"; } + +.fa-wine-glass:before { + content: "\f4e3"; } + +.fa-wine-glass-alt:before { + content: "\f5ce"; } + +.fa-wix:before { + content: "\f5cf"; } + +.fa-wizards-of-the-coast:before { + content: "\f730"; } + +.fa-wolf-pack-battalion:before { + content: "\f514"; } + +.fa-won-sign:before { + content: "\f159"; } + +.fa-wordpress:before { + content: "\f19a"; } + +.fa-wordpress-simple:before { + content: "\f411"; } + +.fa-wpbeginner:before { + content: "\f297"; } + +.fa-wpexplorer:before { + content: "\f2de"; } + +.fa-wpforms:before { + content: "\f298"; } + +.fa-wpressr:before { + content: "\f3e4"; } + +.fa-wrench:before { + content: "\f0ad"; } + +.fa-x-ray:before { + content: "\f497"; } + +.fa-xbox:before { + content: "\f412"; } + +.fa-xing:before { + content: "\f168"; } + +.fa-xing-square:before { + content: "\f169"; } + +.fa-y-combinator:before { + content: "\f23b"; } + +.fa-yahoo:before { + content: "\f19e"; } + +.fa-yammer:before { + content: "\f840"; } + +.fa-yandex:before { + content: "\f413"; } + +.fa-yandex-international:before { + content: "\f414"; } + +.fa-yarn:before { + content: "\f7e3"; } + +.fa-yelp:before { + content: "\f1e9"; } + +.fa-yen-sign:before { + content: "\f157"; } + +.fa-yin-yang:before { + content: "\f6ad"; } + +.fa-yoast:before { + content: "\f2b1"; } + +.fa-youtube:before { + content: "\f167"; } + +.fa-youtube-square:before { + content: "\f431"; } + +.fa-zhihu:before { + content: "\f63f"; } + +.sr-only { + border: 0; + clip: rect(0, 0, 0, 0); + height: 1px; + margin: -1px; + overflow: hidden; + padding: 0; + position: absolute; + width: 1px; } + +.sr-only-focusable:active, .sr-only-focusable:focus { + clip: auto; + height: auto; + margin: 0; + overflow: visible; + position: static; + width: auto; } diff --git a/nlp_demo_riva/client/css/fontawesome.min.css b/nlp_demo_riva/client/css/fontawesome.min.css new file mode 100644 index 00000000..06a13c55 --- /dev/null +++ b/nlp_demo_riva/client/css/fontawesome.min.css @@ -0,0 +1,5 @@ +/*! + * Font Awesome Free 5.13.0 by @fontawesome - https://fontawesome.com + * License - https://fontawesome.com/license/free (Icons: CC BY 4.0, Fonts: SIL OFL 1.1, Code: MIT License) + */ +.fa,.fab,.fad,.fal,.far,.fas{-moz-osx-font-smoothing:grayscale;-webkit-font-smoothing:antialiased;display:inline-block;font-style:normal;font-variant:normal;text-rendering:auto;line-height:1}.fa-lg{font-size:1.33333em;line-height:.75em;vertical-align:-.0667em}.fa-xs{font-size:.75em}.fa-sm{font-size:.875em}.fa-1x{font-size:1em}.fa-2x{font-size:2em}.fa-3x{font-size:3em}.fa-4x{font-size:4em}.fa-5x{font-size:5em}.fa-6x{font-size:6em}.fa-7x{font-size:7em}.fa-8x{font-size:8em}.fa-9x{font-size:9em}.fa-10x{font-size:10em}.fa-fw{text-align:center;width:1.25em}.fa-ul{list-style-type:none;margin-left:2.5em;padding-left:0}.fa-ul>li{position:relative}.fa-li{left:-2em;position:absolute;text-align:center;width:2em;line-height:inherit}.fa-border{border:.08em solid #eee;border-radius:.1em;padding:.2em .25em .15em}.fa-pull-left{float:left}.fa-pull-right{float:right}.fa.fa-pull-left,.fab.fa-pull-left,.fal.fa-pull-left,.far.fa-pull-left,.fas.fa-pull-left{margin-right:.3em}.fa.fa-pull-right,.fab.fa-pull-right,.fal.fa-pull-right,.far.fa-pull-right,.fas.fa-pull-right{margin-left:.3em}.fa-spin{-webkit-animation:fa-spin 2s linear infinite;animation:fa-spin 2s linear infinite}.fa-pulse{-webkit-animation:fa-spin 1s steps(8) infinite;animation:fa-spin 1s steps(8) infinite}@-webkit-keyframes fa-spin{0%{-webkit-transform:rotate(0deg);transform:rotate(0deg)}to{-webkit-transform:rotate(1turn);transform:rotate(1turn)}}@keyframes fa-spin{0%{-webkit-transform:rotate(0deg);transform:rotate(0deg)}to{-webkit-transform:rotate(1turn);transform:rotate(1turn)}}.fa-rotate-90{-ms-filter:"progid:DXImageTransform.Microsoft.BasicImage(rotation=1)";-webkit-transform:rotate(90deg);transform:rotate(90deg)}.fa-rotate-180{-ms-filter:"progid:DXImageTransform.Microsoft.BasicImage(rotation=2)";-webkit-transform:rotate(180deg);transform:rotate(180deg)}.fa-rotate-270{-ms-filter:"progid:DXImageTransform.Microsoft.BasicImage(rotation=3)";-webkit-transform:rotate(270deg);transform:rotate(270deg)}.fa-flip-horizontal{-ms-filter:"progid:DXImageTransform.Microsoft.BasicImage(rotation=0, mirror=1)";-webkit-transform:scaleX(-1);transform:scaleX(-1)}.fa-flip-vertical{-webkit-transform:scaleY(-1);transform:scaleY(-1)}.fa-flip-both,.fa-flip-horizontal.fa-flip-vertical,.fa-flip-vertical{-ms-filter:"progid:DXImageTransform.Microsoft.BasicImage(rotation=2, mirror=1)"}.fa-flip-both,.fa-flip-horizontal.fa-flip-vertical{-webkit-transform:scale(-1);transform:scale(-1)}:root .fa-flip-both,:root .fa-flip-horizontal,:root .fa-flip-vertical,:root .fa-rotate-90,:root .fa-rotate-180,:root .fa-rotate-270{-webkit-filter:none;filter:none}.fa-stack{display:inline-block;height:2em;line-height:2em;position:relative;vertical-align:middle;width:2.5em}.fa-stack-1x,.fa-stack-2x{left:0;position:absolute;text-align:center;width:100%}.fa-stack-1x{line-height:inherit}.fa-stack-2x{font-size:2em}.fa-inverse{color:#fff}.fa-500px:before{content:"\f26e"}.fa-accessible-icon:before{content:"\f368"}.fa-accusoft:before{content:"\f369"}.fa-acquisitions-incorporated:before{content:"\f6af"}.fa-ad:before{content:"\f641"}.fa-address-book:before{content:"\f2b9"}.fa-address-card:before{content:"\f2bb"}.fa-adjust:before{content:"\f042"}.fa-adn:before{content:"\f170"}.fa-adobe:before{content:"\f778"}.fa-adversal:before{content:"\f36a"}.fa-affiliatetheme:before{content:"\f36b"}.fa-air-freshener:before{content:"\f5d0"}.fa-airbnb:before{content:"\f834"}.fa-algolia:before{content:"\f36c"}.fa-align-center:before{content:"\f037"}.fa-align-justify:before{content:"\f039"}.fa-align-left:before{content:"\f036"}.fa-align-right:before{content:"\f038"}.fa-alipay:before{content:"\f642"}.fa-allergies:before{content:"\f461"}.fa-amazon:before{content:"\f270"}.fa-amazon-pay:before{content:"\f42c"}.fa-ambulance:before{content:"\f0f9"}.fa-american-sign-language-interpreting:before{content:"\f2a3"}.fa-amilia:before{content:"\f36d"}.fa-anchor:before{content:"\f13d"}.fa-android:before{content:"\f17b"}.fa-angellist:before{content:"\f209"}.fa-angle-double-down:before{content:"\f103"}.fa-angle-double-left:before{content:"\f100"}.fa-angle-double-right:before{content:"\f101"}.fa-angle-double-up:before{content:"\f102"}.fa-angle-down:before{content:"\f107"}.fa-angle-left:before{content:"\f104"}.fa-angle-right:before{content:"\f105"}.fa-angle-up:before{content:"\f106"}.fa-angry:before{content:"\f556"}.fa-angrycreative:before{content:"\f36e"}.fa-angular:before{content:"\f420"}.fa-ankh:before{content:"\f644"}.fa-app-store:before{content:"\f36f"}.fa-app-store-ios:before{content:"\f370"}.fa-apper:before{content:"\f371"}.fa-apple:before{content:"\f179"}.fa-apple-alt:before{content:"\f5d1"}.fa-apple-pay:before{content:"\f415"}.fa-archive:before{content:"\f187"}.fa-archway:before{content:"\f557"}.fa-arrow-alt-circle-down:before{content:"\f358"}.fa-arrow-alt-circle-left:before{content:"\f359"}.fa-arrow-alt-circle-right:before{content:"\f35a"}.fa-arrow-alt-circle-up:before{content:"\f35b"}.fa-arrow-circle-down:before{content:"\f0ab"}.fa-arrow-circle-left:before{content:"\f0a8"}.fa-arrow-circle-right:before{content:"\f0a9"}.fa-arrow-circle-up:before{content:"\f0aa"}.fa-arrow-down:before{content:"\f063"}.fa-arrow-left:before{content:"\f060"}.fa-arrow-right:before{content:"\f061"}.fa-arrow-up:before{content:"\f062"}.fa-arrows-alt:before{content:"\f0b2"}.fa-arrows-alt-h:before{content:"\f337"}.fa-arrows-alt-v:before{content:"\f338"}.fa-artstation:before{content:"\f77a"}.fa-assistive-listening-systems:before{content:"\f2a2"}.fa-asterisk:before{content:"\f069"}.fa-asymmetrik:before{content:"\f372"}.fa-at:before{content:"\f1fa"}.fa-atlas:before{content:"\f558"}.fa-atlassian:before{content:"\f77b"}.fa-atom:before{content:"\f5d2"}.fa-audible:before{content:"\f373"}.fa-audio-description:before{content:"\f29e"}.fa-autoprefixer:before{content:"\f41c"}.fa-avianex:before{content:"\f374"}.fa-aviato:before{content:"\f421"}.fa-award:before{content:"\f559"}.fa-aws:before{content:"\f375"}.fa-baby:before{content:"\f77c"}.fa-baby-carriage:before{content:"\f77d"}.fa-backspace:before{content:"\f55a"}.fa-backward:before{content:"\f04a"}.fa-bacon:before{content:"\f7e5"}.fa-bahai:before{content:"\f666"}.fa-balance-scale:before{content:"\f24e"}.fa-balance-scale-left:before{content:"\f515"}.fa-balance-scale-right:before{content:"\f516"}.fa-ban:before{content:"\f05e"}.fa-band-aid:before{content:"\f462"}.fa-bandcamp:before{content:"\f2d5"}.fa-barcode:before{content:"\f02a"}.fa-bars:before{content:"\f0c9"}.fa-baseball-ball:before{content:"\f433"}.fa-basketball-ball:before{content:"\f434"}.fa-bath:before{content:"\f2cd"}.fa-battery-empty:before{content:"\f244"}.fa-battery-full:before{content:"\f240"}.fa-battery-half:before{content:"\f242"}.fa-battery-quarter:before{content:"\f243"}.fa-battery-three-quarters:before{content:"\f241"}.fa-battle-net:before{content:"\f835"}.fa-bed:before{content:"\f236"}.fa-beer:before{content:"\f0fc"}.fa-behance:before{content:"\f1b4"}.fa-behance-square:before{content:"\f1b5"}.fa-bell:before{content:"\f0f3"}.fa-bell-slash:before{content:"\f1f6"}.fa-bezier-curve:before{content:"\f55b"}.fa-bible:before{content:"\f647"}.fa-bicycle:before{content:"\f206"}.fa-biking:before{content:"\f84a"}.fa-bimobject:before{content:"\f378"}.fa-binoculars:before{content:"\f1e5"}.fa-biohazard:before{content:"\f780"}.fa-birthday-cake:before{content:"\f1fd"}.fa-bitbucket:before{content:"\f171"}.fa-bitcoin:before{content:"\f379"}.fa-bity:before{content:"\f37a"}.fa-black-tie:before{content:"\f27e"}.fa-blackberry:before{content:"\f37b"}.fa-blender:before{content:"\f517"}.fa-blender-phone:before{content:"\f6b6"}.fa-blind:before{content:"\f29d"}.fa-blog:before{content:"\f781"}.fa-blogger:before{content:"\f37c"}.fa-blogger-b:before{content:"\f37d"}.fa-bluetooth:before{content:"\f293"}.fa-bluetooth-b:before{content:"\f294"}.fa-bold:before{content:"\f032"}.fa-bolt:before{content:"\f0e7"}.fa-bomb:before{content:"\f1e2"}.fa-bone:before{content:"\f5d7"}.fa-bong:before{content:"\f55c"}.fa-book:before{content:"\f02d"}.fa-book-dead:before{content:"\f6b7"}.fa-book-medical:before{content:"\f7e6"}.fa-book-open:before{content:"\f518"}.fa-book-reader:before{content:"\f5da"}.fa-bookmark:before{content:"\f02e"}.fa-bootstrap:before{content:"\f836"}.fa-border-all:before{content:"\f84c"}.fa-border-none:before{content:"\f850"}.fa-border-style:before{content:"\f853"}.fa-bowling-ball:before{content:"\f436"}.fa-box:before{content:"\f466"}.fa-box-open:before{content:"\f49e"}.fa-box-tissue:before{content:"\f95b"}.fa-boxes:before{content:"\f468"}.fa-braille:before{content:"\f2a1"}.fa-brain:before{content:"\f5dc"}.fa-bread-slice:before{content:"\f7ec"}.fa-briefcase:before{content:"\f0b1"}.fa-briefcase-medical:before{content:"\f469"}.fa-broadcast-tower:before{content:"\f519"}.fa-broom:before{content:"\f51a"}.fa-brush:before{content:"\f55d"}.fa-btc:before{content:"\f15a"}.fa-buffer:before{content:"\f837"}.fa-bug:before{content:"\f188"}.fa-building:before{content:"\f1ad"}.fa-bullhorn:before{content:"\f0a1"}.fa-bullseye:before{content:"\f140"}.fa-burn:before{content:"\f46a"}.fa-buromobelexperte:before{content:"\f37f"}.fa-bus:before{content:"\f207"}.fa-bus-alt:before{content:"\f55e"}.fa-business-time:before{content:"\f64a"}.fa-buy-n-large:before{content:"\f8a6"}.fa-buysellads:before{content:"\f20d"}.fa-calculator:before{content:"\f1ec"}.fa-calendar:before{content:"\f133"}.fa-calendar-alt:before{content:"\f073"}.fa-calendar-check:before{content:"\f274"}.fa-calendar-day:before{content:"\f783"}.fa-calendar-minus:before{content:"\f272"}.fa-calendar-plus:before{content:"\f271"}.fa-calendar-times:before{content:"\f273"}.fa-calendar-week:before{content:"\f784"}.fa-camera:before{content:"\f030"}.fa-camera-retro:before{content:"\f083"}.fa-campground:before{content:"\f6bb"}.fa-canadian-maple-leaf:before{content:"\f785"}.fa-candy-cane:before{content:"\f786"}.fa-cannabis:before{content:"\f55f"}.fa-capsules:before{content:"\f46b"}.fa-car:before{content:"\f1b9"}.fa-car-alt:before{content:"\f5de"}.fa-car-battery:before{content:"\f5df"}.fa-car-crash:before{content:"\f5e1"}.fa-car-side:before{content:"\f5e4"}.fa-caravan:before{content:"\f8ff"}.fa-caret-down:before{content:"\f0d7"}.fa-caret-left:before{content:"\f0d9"}.fa-caret-right:before{content:"\f0da"}.fa-caret-square-down:before{content:"\f150"}.fa-caret-square-left:before{content:"\f191"}.fa-caret-square-right:before{content:"\f152"}.fa-caret-square-up:before{content:"\f151"}.fa-caret-up:before{content:"\f0d8"}.fa-carrot:before{content:"\f787"}.fa-cart-arrow-down:before{content:"\f218"}.fa-cart-plus:before{content:"\f217"}.fa-cash-register:before{content:"\f788"}.fa-cat:before{content:"\f6be"}.fa-cc-amazon-pay:before{content:"\f42d"}.fa-cc-amex:before{content:"\f1f3"}.fa-cc-apple-pay:before{content:"\f416"}.fa-cc-diners-club:before{content:"\f24c"}.fa-cc-discover:before{content:"\f1f2"}.fa-cc-jcb:before{content:"\f24b"}.fa-cc-mastercard:before{content:"\f1f1"}.fa-cc-paypal:before{content:"\f1f4"}.fa-cc-stripe:before{content:"\f1f5"}.fa-cc-visa:before{content:"\f1f0"}.fa-centercode:before{content:"\f380"}.fa-centos:before{content:"\f789"}.fa-certificate:before{content:"\f0a3"}.fa-chair:before{content:"\f6c0"}.fa-chalkboard:before{content:"\f51b"}.fa-chalkboard-teacher:before{content:"\f51c"}.fa-charging-station:before{content:"\f5e7"}.fa-chart-area:before{content:"\f1fe"}.fa-chart-bar:before{content:"\f080"}.fa-chart-line:before{content:"\f201"}.fa-chart-pie:before{content:"\f200"}.fa-check:before{content:"\f00c"}.fa-check-circle:before{content:"\f058"}.fa-check-double:before{content:"\f560"}.fa-check-square:before{content:"\f14a"}.fa-cheese:before{content:"\f7ef"}.fa-chess:before{content:"\f439"}.fa-chess-bishop:before{content:"\f43a"}.fa-chess-board:before{content:"\f43c"}.fa-chess-king:before{content:"\f43f"}.fa-chess-knight:before{content:"\f441"}.fa-chess-pawn:before{content:"\f443"}.fa-chess-queen:before{content:"\f445"}.fa-chess-rook:before{content:"\f447"}.fa-chevron-circle-down:before{content:"\f13a"}.fa-chevron-circle-left:before{content:"\f137"}.fa-chevron-circle-right:before{content:"\f138"}.fa-chevron-circle-up:before{content:"\f139"}.fa-chevron-down:before{content:"\f078"}.fa-chevron-left:before{content:"\f053"}.fa-chevron-right:before{content:"\f054"}.fa-chevron-up:before{content:"\f077"}.fa-child:before{content:"\f1ae"}.fa-chrome:before{content:"\f268"}.fa-chromecast:before{content:"\f838"}.fa-church:before{content:"\f51d"}.fa-circle:before{content:"\f111"}.fa-circle-notch:before{content:"\f1ce"}.fa-city:before{content:"\f64f"}.fa-clinic-medical:before{content:"\f7f2"}.fa-clipboard:before{content:"\f328"}.fa-clipboard-check:before{content:"\f46c"}.fa-clipboard-list:before{content:"\f46d"}.fa-clock:before{content:"\f017"}.fa-clone:before{content:"\f24d"}.fa-closed-captioning:before{content:"\f20a"}.fa-cloud:before{content:"\f0c2"}.fa-cloud-download-alt:before{content:"\f381"}.fa-cloud-meatball:before{content:"\f73b"}.fa-cloud-moon:before{content:"\f6c3"}.fa-cloud-moon-rain:before{content:"\f73c"}.fa-cloud-rain:before{content:"\f73d"}.fa-cloud-showers-heavy:before{content:"\f740"}.fa-cloud-sun:before{content:"\f6c4"}.fa-cloud-sun-rain:before{content:"\f743"}.fa-cloud-upload-alt:before{content:"\f382"}.fa-cloudscale:before{content:"\f383"}.fa-cloudsmith:before{content:"\f384"}.fa-cloudversify:before{content:"\f385"}.fa-cocktail:before{content:"\f561"}.fa-code:before{content:"\f121"}.fa-code-branch:before{content:"\f126"}.fa-codepen:before{content:"\f1cb"}.fa-codiepie:before{content:"\f284"}.fa-coffee:before{content:"\f0f4"}.fa-cog:before{content:"\f013"}.fa-cogs:before{content:"\f085"}.fa-coins:before{content:"\f51e"}.fa-columns:before{content:"\f0db"}.fa-comment:before{content:"\f075"}.fa-comment-alt:before{content:"\f27a"}.fa-comment-dollar:before{content:"\f651"}.fa-comment-dots:before{content:"\f4ad"}.fa-comment-medical:before{content:"\f7f5"}.fa-comment-slash:before{content:"\f4b3"}.fa-comments:before{content:"\f086"}.fa-comments-dollar:before{content:"\f653"}.fa-compact-disc:before{content:"\f51f"}.fa-compass:before{content:"\f14e"}.fa-compress:before{content:"\f066"}.fa-compress-alt:before{content:"\f422"}.fa-compress-arrows-alt:before{content:"\f78c"}.fa-concierge-bell:before{content:"\f562"}.fa-confluence:before{content:"\f78d"}.fa-connectdevelop:before{content:"\f20e"}.fa-contao:before{content:"\f26d"}.fa-cookie:before{content:"\f563"}.fa-cookie-bite:before{content:"\f564"}.fa-copy:before{content:"\f0c5"}.fa-copyright:before{content:"\f1f9"}.fa-cotton-bureau:before{content:"\f89e"}.fa-couch:before{content:"\f4b8"}.fa-cpanel:before{content:"\f388"}.fa-creative-commons:before{content:"\f25e"}.fa-creative-commons-by:before{content:"\f4e7"}.fa-creative-commons-nc:before{content:"\f4e8"}.fa-creative-commons-nc-eu:before{content:"\f4e9"}.fa-creative-commons-nc-jp:before{content:"\f4ea"}.fa-creative-commons-nd:before{content:"\f4eb"}.fa-creative-commons-pd:before{content:"\f4ec"}.fa-creative-commons-pd-alt:before{content:"\f4ed"}.fa-creative-commons-remix:before{content:"\f4ee"}.fa-creative-commons-sa:before{content:"\f4ef"}.fa-creative-commons-sampling:before{content:"\f4f0"}.fa-creative-commons-sampling-plus:before{content:"\f4f1"}.fa-creative-commons-share:before{content:"\f4f2"}.fa-creative-commons-zero:before{content:"\f4f3"}.fa-credit-card:before{content:"\f09d"}.fa-critical-role:before{content:"\f6c9"}.fa-crop:before{content:"\f125"}.fa-crop-alt:before{content:"\f565"}.fa-cross:before{content:"\f654"}.fa-crosshairs:before{content:"\f05b"}.fa-crow:before{content:"\f520"}.fa-crown:before{content:"\f521"}.fa-crutch:before{content:"\f7f7"}.fa-css3:before{content:"\f13c"}.fa-css3-alt:before{content:"\f38b"}.fa-cube:before{content:"\f1b2"}.fa-cubes:before{content:"\f1b3"}.fa-cut:before{content:"\f0c4"}.fa-cuttlefish:before{content:"\f38c"}.fa-d-and-d:before{content:"\f38d"}.fa-d-and-d-beyond:before{content:"\f6ca"}.fa-dailymotion:before{content:"\f952"}.fa-dashcube:before{content:"\f210"}.fa-database:before{content:"\f1c0"}.fa-deaf:before{content:"\f2a4"}.fa-delicious:before{content:"\f1a5"}.fa-democrat:before{content:"\f747"}.fa-deploydog:before{content:"\f38e"}.fa-deskpro:before{content:"\f38f"}.fa-desktop:before{content:"\f108"}.fa-dev:before{content:"\f6cc"}.fa-deviantart:before{content:"\f1bd"}.fa-dharmachakra:before{content:"\f655"}.fa-dhl:before{content:"\f790"}.fa-diagnoses:before{content:"\f470"}.fa-diaspora:before{content:"\f791"}.fa-dice:before{content:"\f522"}.fa-dice-d20:before{content:"\f6cf"}.fa-dice-d6:before{content:"\f6d1"}.fa-dice-five:before{content:"\f523"}.fa-dice-four:before{content:"\f524"}.fa-dice-one:before{content:"\f525"}.fa-dice-six:before{content:"\f526"}.fa-dice-three:before{content:"\f527"}.fa-dice-two:before{content:"\f528"}.fa-digg:before{content:"\f1a6"}.fa-digital-ocean:before{content:"\f391"}.fa-digital-tachograph:before{content:"\f566"}.fa-directions:before{content:"\f5eb"}.fa-discord:before{content:"\f392"}.fa-discourse:before{content:"\f393"}.fa-disease:before{content:"\f7fa"}.fa-divide:before{content:"\f529"}.fa-dizzy:before{content:"\f567"}.fa-dna:before{content:"\f471"}.fa-dochub:before{content:"\f394"}.fa-docker:before{content:"\f395"}.fa-dog:before{content:"\f6d3"}.fa-dollar-sign:before{content:"\f155"}.fa-dolly:before{content:"\f472"}.fa-dolly-flatbed:before{content:"\f474"}.fa-donate:before{content:"\f4b9"}.fa-door-closed:before{content:"\f52a"}.fa-door-open:before{content:"\f52b"}.fa-dot-circle:before{content:"\f192"}.fa-dove:before{content:"\f4ba"}.fa-download:before{content:"\f019"}.fa-draft2digital:before{content:"\f396"}.fa-drafting-compass:before{content:"\f568"}.fa-dragon:before{content:"\f6d5"}.fa-draw-polygon:before{content:"\f5ee"}.fa-dribbble:before{content:"\f17d"}.fa-dribbble-square:before{content:"\f397"}.fa-dropbox:before{content:"\f16b"}.fa-drum:before{content:"\f569"}.fa-drum-steelpan:before{content:"\f56a"}.fa-drumstick-bite:before{content:"\f6d7"}.fa-drupal:before{content:"\f1a9"}.fa-dumbbell:before{content:"\f44b"}.fa-dumpster:before{content:"\f793"}.fa-dumpster-fire:before{content:"\f794"}.fa-dungeon:before{content:"\f6d9"}.fa-dyalog:before{content:"\f399"}.fa-earlybirds:before{content:"\f39a"}.fa-ebay:before{content:"\f4f4"}.fa-edge:before{content:"\f282"}.fa-edit:before{content:"\f044"}.fa-egg:before{content:"\f7fb"}.fa-eject:before{content:"\f052"}.fa-elementor:before{content:"\f430"}.fa-ellipsis-h:before{content:"\f141"}.fa-ellipsis-v:before{content:"\f142"}.fa-ello:before{content:"\f5f1"}.fa-ember:before{content:"\f423"}.fa-empire:before{content:"\f1d1"}.fa-envelope:before{content:"\f0e0"}.fa-envelope-open:before{content:"\f2b6"}.fa-envelope-open-text:before{content:"\f658"}.fa-envelope-square:before{content:"\f199"}.fa-envira:before{content:"\f299"}.fa-equals:before{content:"\f52c"}.fa-eraser:before{content:"\f12d"}.fa-erlang:before{content:"\f39d"}.fa-ethereum:before{content:"\f42e"}.fa-ethernet:before{content:"\f796"}.fa-etsy:before{content:"\f2d7"}.fa-euro-sign:before{content:"\f153"}.fa-evernote:before{content:"\f839"}.fa-exchange-alt:before{content:"\f362"}.fa-exclamation:before{content:"\f12a"}.fa-exclamation-circle:before{content:"\f06a"}.fa-exclamation-triangle:before{content:"\f071"}.fa-expand:before{content:"\f065"}.fa-expand-alt:before{content:"\f424"}.fa-expand-arrows-alt:before{content:"\f31e"}.fa-expeditedssl:before{content:"\f23e"}.fa-external-link-alt:before{content:"\f35d"}.fa-external-link-square-alt:before{content:"\f360"}.fa-eye:before{content:"\f06e"}.fa-eye-dropper:before{content:"\f1fb"}.fa-eye-slash:before{content:"\f070"}.fa-facebook:before{content:"\f09a"}.fa-facebook-f:before{content:"\f39e"}.fa-facebook-messenger:before{content:"\f39f"}.fa-facebook-square:before{content:"\f082"}.fa-fan:before{content:"\f863"}.fa-fantasy-flight-games:before{content:"\f6dc"}.fa-fast-backward:before{content:"\f049"}.fa-fast-forward:before{content:"\f050"}.fa-faucet:before{content:"\f905"}.fa-fax:before{content:"\f1ac"}.fa-feather:before{content:"\f52d"}.fa-feather-alt:before{content:"\f56b"}.fa-fedex:before{content:"\f797"}.fa-fedora:before{content:"\f798"}.fa-female:before{content:"\f182"}.fa-fighter-jet:before{content:"\f0fb"}.fa-figma:before{content:"\f799"}.fa-file:before{content:"\f15b"}.fa-file-alt:before{content:"\f15c"}.fa-file-archive:before{content:"\f1c6"}.fa-file-audio:before{content:"\f1c7"}.fa-file-code:before{content:"\f1c9"}.fa-file-contract:before{content:"\f56c"}.fa-file-csv:before{content:"\f6dd"}.fa-file-download:before{content:"\f56d"}.fa-file-excel:before{content:"\f1c3"}.fa-file-export:before{content:"\f56e"}.fa-file-image:before{content:"\f1c5"}.fa-file-import:before{content:"\f56f"}.fa-file-invoice:before{content:"\f570"}.fa-file-invoice-dollar:before{content:"\f571"}.fa-file-medical:before{content:"\f477"}.fa-file-medical-alt:before{content:"\f478"}.fa-file-pdf:before{content:"\f1c1"}.fa-file-powerpoint:before{content:"\f1c4"}.fa-file-prescription:before{content:"\f572"}.fa-file-signature:before{content:"\f573"}.fa-file-upload:before{content:"\f574"}.fa-file-video:before{content:"\f1c8"}.fa-file-word:before{content:"\f1c2"}.fa-fill:before{content:"\f575"}.fa-fill-drip:before{content:"\f576"}.fa-film:before{content:"\f008"}.fa-filter:before{content:"\f0b0"}.fa-fingerprint:before{content:"\f577"}.fa-fire:before{content:"\f06d"}.fa-fire-alt:before{content:"\f7e4"}.fa-fire-extinguisher:before{content:"\f134"}.fa-firefox:before{content:"\f269"}.fa-firefox-browser:before{content:"\f907"}.fa-first-aid:before{content:"\f479"}.fa-first-order:before{content:"\f2b0"}.fa-first-order-alt:before{content:"\f50a"}.fa-firstdraft:before{content:"\f3a1"}.fa-fish:before{content:"\f578"}.fa-fist-raised:before{content:"\f6de"}.fa-flag:before{content:"\f024"}.fa-flag-checkered:before{content:"\f11e"}.fa-flag-usa:before{content:"\f74d"}.fa-flask:before{content:"\f0c3"}.fa-flickr:before{content:"\f16e"}.fa-flipboard:before{content:"\f44d"}.fa-flushed:before{content:"\f579"}.fa-fly:before{content:"\f417"}.fa-folder:before{content:"\f07b"}.fa-folder-minus:before{content:"\f65d"}.fa-folder-open:before{content:"\f07c"}.fa-folder-plus:before{content:"\f65e"}.fa-font:before{content:"\f031"}.fa-font-awesome:before{content:"\f2b4"}.fa-font-awesome-alt:before{content:"\f35c"}.fa-font-awesome-flag:before{content:"\f425"}.fa-font-awesome-logo-full:before{content:"\f4e6"}.fa-fonticons:before{content:"\f280"}.fa-fonticons-fi:before{content:"\f3a2"}.fa-football-ball:before{content:"\f44e"}.fa-fort-awesome:before{content:"\f286"}.fa-fort-awesome-alt:before{content:"\f3a3"}.fa-forumbee:before{content:"\f211"}.fa-forward:before{content:"\f04e"}.fa-foursquare:before{content:"\f180"}.fa-free-code-camp:before{content:"\f2c5"}.fa-freebsd:before{content:"\f3a4"}.fa-frog:before{content:"\f52e"}.fa-frown:before{content:"\f119"}.fa-frown-open:before{content:"\f57a"}.fa-fulcrum:before{content:"\f50b"}.fa-funnel-dollar:before{content:"\f662"}.fa-futbol:before{content:"\f1e3"}.fa-galactic-republic:before{content:"\f50c"}.fa-galactic-senate:before{content:"\f50d"}.fa-gamepad:before{content:"\f11b"}.fa-gas-pump:before{content:"\f52f"}.fa-gavel:before{content:"\f0e3"}.fa-gem:before{content:"\f3a5"}.fa-genderless:before{content:"\f22d"}.fa-get-pocket:before{content:"\f265"}.fa-gg:before{content:"\f260"}.fa-gg-circle:before{content:"\f261"}.fa-ghost:before{content:"\f6e2"}.fa-gift:before{content:"\f06b"}.fa-gifts:before{content:"\f79c"}.fa-git:before{content:"\f1d3"}.fa-git-alt:before{content:"\f841"}.fa-git-square:before{content:"\f1d2"}.fa-github:before{content:"\f09b"}.fa-github-alt:before{content:"\f113"}.fa-github-square:before{content:"\f092"}.fa-gitkraken:before{content:"\f3a6"}.fa-gitlab:before{content:"\f296"}.fa-gitter:before{content:"\f426"}.fa-glass-cheers:before{content:"\f79f"}.fa-glass-martini:before{content:"\f000"}.fa-glass-martini-alt:before{content:"\f57b"}.fa-glass-whiskey:before{content:"\f7a0"}.fa-glasses:before{content:"\f530"}.fa-glide:before{content:"\f2a5"}.fa-glide-g:before{content:"\f2a6"}.fa-globe:before{content:"\f0ac"}.fa-globe-africa:before{content:"\f57c"}.fa-globe-americas:before{content:"\f57d"}.fa-globe-asia:before{content:"\f57e"}.fa-globe-europe:before{content:"\f7a2"}.fa-gofore:before{content:"\f3a7"}.fa-golf-ball:before{content:"\f450"}.fa-goodreads:before{content:"\f3a8"}.fa-goodreads-g:before{content:"\f3a9"}.fa-google:before{content:"\f1a0"}.fa-google-drive:before{content:"\f3aa"}.fa-google-play:before{content:"\f3ab"}.fa-google-plus:before{content:"\f2b3"}.fa-google-plus-g:before{content:"\f0d5"}.fa-google-plus-square:before{content:"\f0d4"}.fa-google-wallet:before{content:"\f1ee"}.fa-gopuram:before{content:"\f664"}.fa-graduation-cap:before{content:"\f19d"}.fa-gratipay:before{content:"\f184"}.fa-grav:before{content:"\f2d6"}.fa-greater-than:before{content:"\f531"}.fa-greater-than-equal:before{content:"\f532"}.fa-grimace:before{content:"\f57f"}.fa-grin:before{content:"\f580"}.fa-grin-alt:before{content:"\f581"}.fa-grin-beam:before{content:"\f582"}.fa-grin-beam-sweat:before{content:"\f583"}.fa-grin-hearts:before{content:"\f584"}.fa-grin-squint:before{content:"\f585"}.fa-grin-squint-tears:before{content:"\f586"}.fa-grin-stars:before{content:"\f587"}.fa-grin-tears:before{content:"\f588"}.fa-grin-tongue:before{content:"\f589"}.fa-grin-tongue-squint:before{content:"\f58a"}.fa-grin-tongue-wink:before{content:"\f58b"}.fa-grin-wink:before{content:"\f58c"}.fa-grip-horizontal:before{content:"\f58d"}.fa-grip-lines:before{content:"\f7a4"}.fa-grip-lines-vertical:before{content:"\f7a5"}.fa-grip-vertical:before{content:"\f58e"}.fa-gripfire:before{content:"\f3ac"}.fa-grunt:before{content:"\f3ad"}.fa-guitar:before{content:"\f7a6"}.fa-gulp:before{content:"\f3ae"}.fa-h-square:before{content:"\f0fd"}.fa-hacker-news:before{content:"\f1d4"}.fa-hacker-news-square:before{content:"\f3af"}.fa-hackerrank:before{content:"\f5f7"}.fa-hamburger:before{content:"\f805"}.fa-hammer:before{content:"\f6e3"}.fa-hamsa:before{content:"\f665"}.fa-hand-holding:before{content:"\f4bd"}.fa-hand-holding-heart:before{content:"\f4be"}.fa-hand-holding-medical:before{content:"\f95c"}.fa-hand-holding-usd:before{content:"\f4c0"}.fa-hand-holding-water:before{content:"\f4c1"}.fa-hand-lizard:before{content:"\f258"}.fa-hand-middle-finger:before{content:"\f806"}.fa-hand-paper:before{content:"\f256"}.fa-hand-peace:before{content:"\f25b"}.fa-hand-point-down:before{content:"\f0a7"}.fa-hand-point-left:before{content:"\f0a5"}.fa-hand-point-right:before{content:"\f0a4"}.fa-hand-point-up:before{content:"\f0a6"}.fa-hand-pointer:before{content:"\f25a"}.fa-hand-rock:before{content:"\f255"}.fa-hand-scissors:before{content:"\f257"}.fa-hand-sparkles:before{content:"\f95d"}.fa-hand-spock:before{content:"\f259"}.fa-hands:before{content:"\f4c2"}.fa-hands-helping:before{content:"\f4c4"}.fa-hands-wash:before{content:"\f95e"}.fa-handshake:before{content:"\f2b5"}.fa-handshake-alt-slash:before{content:"\f95f"}.fa-handshake-slash:before{content:"\f960"}.fa-hanukiah:before{content:"\f6e6"}.fa-hard-hat:before{content:"\f807"}.fa-hashtag:before{content:"\f292"}.fa-hat-cowboy:before{content:"\f8c0"}.fa-hat-cowboy-side:before{content:"\f8c1"}.fa-hat-wizard:before{content:"\f6e8"}.fa-hdd:before{content:"\f0a0"}.fa-head-side-cough:before{content:"\f961"}.fa-head-side-cough-slash:before{content:"\f962"}.fa-head-side-mask:before{content:"\f963"}.fa-head-side-virus:before{content:"\f964"}.fa-heading:before{content:"\f1dc"}.fa-headphones:before{content:"\f025"}.fa-headphones-alt:before{content:"\f58f"}.fa-headset:before{content:"\f590"}.fa-heart:before{content:"\f004"}.fa-heart-broken:before{content:"\f7a9"}.fa-heartbeat:before{content:"\f21e"}.fa-helicopter:before{content:"\f533"}.fa-highlighter:before{content:"\f591"}.fa-hiking:before{content:"\f6ec"}.fa-hippo:before{content:"\f6ed"}.fa-hips:before{content:"\f452"}.fa-hire-a-helper:before{content:"\f3b0"}.fa-history:before{content:"\f1da"}.fa-hockey-puck:before{content:"\f453"}.fa-holly-berry:before{content:"\f7aa"}.fa-home:before{content:"\f015"}.fa-hooli:before{content:"\f427"}.fa-hornbill:before{content:"\f592"}.fa-horse:before{content:"\f6f0"}.fa-horse-head:before{content:"\f7ab"}.fa-hospital:before{content:"\f0f8"}.fa-hospital-alt:before{content:"\f47d"}.fa-hospital-symbol:before{content:"\f47e"}.fa-hospital-user:before{content:"\f80d"}.fa-hot-tub:before{content:"\f593"}.fa-hotdog:before{content:"\f80f"}.fa-hotel:before{content:"\f594"}.fa-hotjar:before{content:"\f3b1"}.fa-hourglass:before{content:"\f254"}.fa-hourglass-end:before{content:"\f253"}.fa-hourglass-half:before{content:"\f252"}.fa-hourglass-start:before{content:"\f251"}.fa-house-damage:before{content:"\f6f1"}.fa-house-user:before{content:"\f965"}.fa-houzz:before{content:"\f27c"}.fa-hryvnia:before{content:"\f6f2"}.fa-html5:before{content:"\f13b"}.fa-hubspot:before{content:"\f3b2"}.fa-i-cursor:before{content:"\f246"}.fa-ice-cream:before{content:"\f810"}.fa-icicles:before{content:"\f7ad"}.fa-icons:before{content:"\f86d"}.fa-id-badge:before{content:"\f2c1"}.fa-id-card:before{content:"\f2c2"}.fa-id-card-alt:before{content:"\f47f"}.fa-ideal:before{content:"\f913"}.fa-igloo:before{content:"\f7ae"}.fa-image:before{content:"\f03e"}.fa-images:before{content:"\f302"}.fa-imdb:before{content:"\f2d8"}.fa-inbox:before{content:"\f01c"}.fa-indent:before{content:"\f03c"}.fa-industry:before{content:"\f275"}.fa-infinity:before{content:"\f534"}.fa-info:before{content:"\f129"}.fa-info-circle:before{content:"\f05a"}.fa-instagram:before{content:"\f16d"}.fa-instagram-square:before{content:"\f955"}.fa-intercom:before{content:"\f7af"}.fa-internet-explorer:before{content:"\f26b"}.fa-invision:before{content:"\f7b0"}.fa-ioxhost:before{content:"\f208"}.fa-italic:before{content:"\f033"}.fa-itch-io:before{content:"\f83a"}.fa-itunes:before{content:"\f3b4"}.fa-itunes-note:before{content:"\f3b5"}.fa-java:before{content:"\f4e4"}.fa-jedi:before{content:"\f669"}.fa-jedi-order:before{content:"\f50e"}.fa-jenkins:before{content:"\f3b6"}.fa-jira:before{content:"\f7b1"}.fa-joget:before{content:"\f3b7"}.fa-joint:before{content:"\f595"}.fa-joomla:before{content:"\f1aa"}.fa-journal-whills:before{content:"\f66a"}.fa-js:before{content:"\f3b8"}.fa-js-square:before{content:"\f3b9"}.fa-jsfiddle:before{content:"\f1cc"}.fa-kaaba:before{content:"\f66b"}.fa-kaggle:before{content:"\f5fa"}.fa-key:before{content:"\f084"}.fa-keybase:before{content:"\f4f5"}.fa-keyboard:before{content:"\f11c"}.fa-keycdn:before{content:"\f3ba"}.fa-khanda:before{content:"\f66d"}.fa-kickstarter:before{content:"\f3bb"}.fa-kickstarter-k:before{content:"\f3bc"}.fa-kiss:before{content:"\f596"}.fa-kiss-beam:before{content:"\f597"}.fa-kiss-wink-heart:before{content:"\f598"}.fa-kiwi-bird:before{content:"\f535"}.fa-korvue:before{content:"\f42f"}.fa-landmark:before{content:"\f66f"}.fa-language:before{content:"\f1ab"}.fa-laptop:before{content:"\f109"}.fa-laptop-code:before{content:"\f5fc"}.fa-laptop-house:before{content:"\f966"}.fa-laptop-medical:before{content:"\f812"}.fa-laravel:before{content:"\f3bd"}.fa-lastfm:before{content:"\f202"}.fa-lastfm-square:before{content:"\f203"}.fa-laugh:before{content:"\f599"}.fa-laugh-beam:before{content:"\f59a"}.fa-laugh-squint:before{content:"\f59b"}.fa-laugh-wink:before{content:"\f59c"}.fa-layer-group:before{content:"\f5fd"}.fa-leaf:before{content:"\f06c"}.fa-leanpub:before{content:"\f212"}.fa-lemon:before{content:"\f094"}.fa-less:before{content:"\f41d"}.fa-less-than:before{content:"\f536"}.fa-less-than-equal:before{content:"\f537"}.fa-level-down-alt:before{content:"\f3be"}.fa-level-up-alt:before{content:"\f3bf"}.fa-life-ring:before{content:"\f1cd"}.fa-lightbulb:before{content:"\f0eb"}.fa-line:before{content:"\f3c0"}.fa-link:before{content:"\f0c1"}.fa-linkedin:before{content:"\f08c"}.fa-linkedin-in:before{content:"\f0e1"}.fa-linode:before{content:"\f2b8"}.fa-linux:before{content:"\f17c"}.fa-lira-sign:before{content:"\f195"}.fa-list:before{content:"\f03a"}.fa-list-alt:before{content:"\f022"}.fa-list-ol:before{content:"\f0cb"}.fa-list-ul:before{content:"\f0ca"}.fa-location-arrow:before{content:"\f124"}.fa-lock:before{content:"\f023"}.fa-lock-open:before{content:"\f3c1"}.fa-long-arrow-alt-down:before{content:"\f309"}.fa-long-arrow-alt-left:before{content:"\f30a"}.fa-long-arrow-alt-right:before{content:"\f30b"}.fa-long-arrow-alt-up:before{content:"\f30c"}.fa-low-vision:before{content:"\f2a8"}.fa-luggage-cart:before{content:"\f59d"}.fa-lungs:before{content:"\f604"}.fa-lungs-virus:before{content:"\f967"}.fa-lyft:before{content:"\f3c3"}.fa-magento:before{content:"\f3c4"}.fa-magic:before{content:"\f0d0"}.fa-magnet:before{content:"\f076"}.fa-mail-bulk:before{content:"\f674"}.fa-mailchimp:before{content:"\f59e"}.fa-male:before{content:"\f183"}.fa-mandalorian:before{content:"\f50f"}.fa-map:before{content:"\f279"}.fa-map-marked:before{content:"\f59f"}.fa-map-marked-alt:before{content:"\f5a0"}.fa-map-marker:before{content:"\f041"}.fa-map-marker-alt:before{content:"\f3c5"}.fa-map-pin:before{content:"\f276"}.fa-map-signs:before{content:"\f277"}.fa-markdown:before{content:"\f60f"}.fa-marker:before{content:"\f5a1"}.fa-mars:before{content:"\f222"}.fa-mars-double:before{content:"\f227"}.fa-mars-stroke:before{content:"\f229"}.fa-mars-stroke-h:before{content:"\f22b"}.fa-mars-stroke-v:before{content:"\f22a"}.fa-mask:before{content:"\f6fa"}.fa-mastodon:before{content:"\f4f6"}.fa-maxcdn:before{content:"\f136"}.fa-mdb:before{content:"\f8ca"}.fa-medal:before{content:"\f5a2"}.fa-medapps:before{content:"\f3c6"}.fa-medium:before{content:"\f23a"}.fa-medium-m:before{content:"\f3c7"}.fa-medkit:before{content:"\f0fa"}.fa-medrt:before{content:"\f3c8"}.fa-meetup:before{content:"\f2e0"}.fa-megaport:before{content:"\f5a3"}.fa-meh:before{content:"\f11a"}.fa-meh-blank:before{content:"\f5a4"}.fa-meh-rolling-eyes:before{content:"\f5a5"}.fa-memory:before{content:"\f538"}.fa-mendeley:before{content:"\f7b3"}.fa-menorah:before{content:"\f676"}.fa-mercury:before{content:"\f223"}.fa-meteor:before{content:"\f753"}.fa-microblog:before{content:"\f91a"}.fa-microchip:before{content:"\f2db"}.fa-microphone:before{content:"\f130"}.fa-microphone-alt:before{content:"\f3c9"}.fa-microphone-alt-slash:before{content:"\f539"}.fa-microphone-slash:before{content:"\f131"}.fa-microscope:before{content:"\f610"}.fa-microsoft:before{content:"\f3ca"}.fa-minus:before{content:"\f068"}.fa-minus-circle:before{content:"\f056"}.fa-minus-square:before{content:"\f146"}.fa-mitten:before{content:"\f7b5"}.fa-mix:before{content:"\f3cb"}.fa-mixcloud:before{content:"\f289"}.fa-mixer:before{content:"\f956"}.fa-mizuni:before{content:"\f3cc"}.fa-mobile:before{content:"\f10b"}.fa-mobile-alt:before{content:"\f3cd"}.fa-modx:before{content:"\f285"}.fa-monero:before{content:"\f3d0"}.fa-money-bill:before{content:"\f0d6"}.fa-money-bill-alt:before{content:"\f3d1"}.fa-money-bill-wave:before{content:"\f53a"}.fa-money-bill-wave-alt:before{content:"\f53b"}.fa-money-check:before{content:"\f53c"}.fa-money-check-alt:before{content:"\f53d"}.fa-monument:before{content:"\f5a6"}.fa-moon:before{content:"\f186"}.fa-mortar-pestle:before{content:"\f5a7"}.fa-mosque:before{content:"\f678"}.fa-motorcycle:before{content:"\f21c"}.fa-mountain:before{content:"\f6fc"}.fa-mouse:before{content:"\f8cc"}.fa-mouse-pointer:before{content:"\f245"}.fa-mug-hot:before{content:"\f7b6"}.fa-music:before{content:"\f001"}.fa-napster:before{content:"\f3d2"}.fa-neos:before{content:"\f612"}.fa-network-wired:before{content:"\f6ff"}.fa-neuter:before{content:"\f22c"}.fa-newspaper:before{content:"\f1ea"}.fa-nimblr:before{content:"\f5a8"}.fa-node:before{content:"\f419"}.fa-node-js:before{content:"\f3d3"}.fa-not-equal:before{content:"\f53e"}.fa-notes-medical:before{content:"\f481"}.fa-npm:before{content:"\f3d4"}.fa-ns8:before{content:"\f3d5"}.fa-nutritionix:before{content:"\f3d6"}.fa-object-group:before{content:"\f247"}.fa-object-ungroup:before{content:"\f248"}.fa-odnoklassniki:before{content:"\f263"}.fa-odnoklassniki-square:before{content:"\f264"}.fa-oil-can:before{content:"\f613"}.fa-old-republic:before{content:"\f510"}.fa-om:before{content:"\f679"}.fa-opencart:before{content:"\f23d"}.fa-openid:before{content:"\f19b"}.fa-opera:before{content:"\f26a"}.fa-optin-monster:before{content:"\f23c"}.fa-orcid:before{content:"\f8d2"}.fa-osi:before{content:"\f41a"}.fa-otter:before{content:"\f700"}.fa-outdent:before{content:"\f03b"}.fa-page4:before{content:"\f3d7"}.fa-pagelines:before{content:"\f18c"}.fa-pager:before{content:"\f815"}.fa-paint-brush:before{content:"\f1fc"}.fa-paint-roller:before{content:"\f5aa"}.fa-palette:before{content:"\f53f"}.fa-palfed:before{content:"\f3d8"}.fa-pallet:before{content:"\f482"}.fa-paper-plane:before{content:"\f1d8"}.fa-paperclip:before{content:"\f0c6"}.fa-parachute-box:before{content:"\f4cd"}.fa-paragraph:before{content:"\f1dd"}.fa-parking:before{content:"\f540"}.fa-passport:before{content:"\f5ab"}.fa-pastafarianism:before{content:"\f67b"}.fa-paste:before{content:"\f0ea"}.fa-patreon:before{content:"\f3d9"}.fa-pause:before{content:"\f04c"}.fa-pause-circle:before{content:"\f28b"}.fa-paw:before{content:"\f1b0"}.fa-paypal:before{content:"\f1ed"}.fa-peace:before{content:"\f67c"}.fa-pen:before{content:"\f304"}.fa-pen-alt:before{content:"\f305"}.fa-pen-fancy:before{content:"\f5ac"}.fa-pen-nib:before{content:"\f5ad"}.fa-pen-square:before{content:"\f14b"}.fa-pencil-alt:before{content:"\f303"}.fa-pencil-ruler:before{content:"\f5ae"}.fa-penny-arcade:before{content:"\f704"}.fa-people-arrows:before{content:"\f968"}.fa-people-carry:before{content:"\f4ce"}.fa-pepper-hot:before{content:"\f816"}.fa-percent:before{content:"\f295"}.fa-percentage:before{content:"\f541"}.fa-periscope:before{content:"\f3da"}.fa-person-booth:before{content:"\f756"}.fa-phabricator:before{content:"\f3db"}.fa-phoenix-framework:before{content:"\f3dc"}.fa-phoenix-squadron:before{content:"\f511"}.fa-phone:before{content:"\f095"}.fa-phone-alt:before{content:"\f879"}.fa-phone-slash:before{content:"\f3dd"}.fa-phone-square:before{content:"\f098"}.fa-phone-square-alt:before{content:"\f87b"}.fa-phone-volume:before{content:"\f2a0"}.fa-photo-video:before{content:"\f87c"}.fa-php:before{content:"\f457"}.fa-pied-piper:before{content:"\f2ae"}.fa-pied-piper-alt:before{content:"\f1a8"}.fa-pied-piper-hat:before{content:"\f4e5"}.fa-pied-piper-pp:before{content:"\f1a7"}.fa-pied-piper-square:before{content:"\f91e"}.fa-piggy-bank:before{content:"\f4d3"}.fa-pills:before{content:"\f484"}.fa-pinterest:before{content:"\f0d2"}.fa-pinterest-p:before{content:"\f231"}.fa-pinterest-square:before{content:"\f0d3"}.fa-pizza-slice:before{content:"\f818"}.fa-place-of-worship:before{content:"\f67f"}.fa-plane:before{content:"\f072"}.fa-plane-arrival:before{content:"\f5af"}.fa-plane-departure:before{content:"\f5b0"}.fa-plane-slash:before{content:"\f969"}.fa-play:before{content:"\f04b"}.fa-play-circle:before{content:"\f144"}.fa-playstation:before{content:"\f3df"}.fa-plug:before{content:"\f1e6"}.fa-plus:before{content:"\f067"}.fa-plus-circle:before{content:"\f055"}.fa-plus-square:before{content:"\f0fe"}.fa-podcast:before{content:"\f2ce"}.fa-poll:before{content:"\f681"}.fa-poll-h:before{content:"\f682"}.fa-poo:before{content:"\f2fe"}.fa-poo-storm:before{content:"\f75a"}.fa-poop:before{content:"\f619"}.fa-portrait:before{content:"\f3e0"}.fa-pound-sign:before{content:"\f154"}.fa-power-off:before{content:"\f011"}.fa-pray:before{content:"\f683"}.fa-praying-hands:before{content:"\f684"}.fa-prescription:before{content:"\f5b1"}.fa-prescription-bottle:before{content:"\f485"}.fa-prescription-bottle-alt:before{content:"\f486"}.fa-print:before{content:"\f02f"}.fa-procedures:before{content:"\f487"}.fa-product-hunt:before{content:"\f288"}.fa-project-diagram:before{content:"\f542"}.fa-pump-medical:before{content:"\f96a"}.fa-pump-soap:before{content:"\f96b"}.fa-pushed:before{content:"\f3e1"}.fa-puzzle-piece:before{content:"\f12e"}.fa-python:before{content:"\f3e2"}.fa-qq:before{content:"\f1d6"}.fa-qrcode:before{content:"\f029"}.fa-question:before{content:"\f128"}.fa-question-circle:before{content:"\f059"}.fa-quidditch:before{content:"\f458"}.fa-quinscape:before{content:"\f459"}.fa-quora:before{content:"\f2c4"}.fa-quote-left:before{content:"\f10d"}.fa-quote-right:before{content:"\f10e"}.fa-quran:before{content:"\f687"}.fa-r-project:before{content:"\f4f7"}.fa-radiation:before{content:"\f7b9"}.fa-radiation-alt:before{content:"\f7ba"}.fa-rainbow:before{content:"\f75b"}.fa-random:before{content:"\f074"}.fa-raspberry-pi:before{content:"\f7bb"}.fa-ravelry:before{content:"\f2d9"}.fa-react:before{content:"\f41b"}.fa-reacteurope:before{content:"\f75d"}.fa-readme:before{content:"\f4d5"}.fa-rebel:before{content:"\f1d0"}.fa-receipt:before{content:"\f543"}.fa-record-vinyl:before{content:"\f8d9"}.fa-recycle:before{content:"\f1b8"}.fa-red-river:before{content:"\f3e3"}.fa-reddit:before{content:"\f1a1"}.fa-reddit-alien:before{content:"\f281"}.fa-reddit-square:before{content:"\f1a2"}.fa-redhat:before{content:"\f7bc"}.fa-redo:before{content:"\f01e"}.fa-redo-alt:before{content:"\f2f9"}.fa-registered:before{content:"\f25d"}.fa-remove-format:before{content:"\f87d"}.fa-renren:before{content:"\f18b"}.fa-reply:before{content:"\f3e5"}.fa-reply-all:before{content:"\f122"}.fa-replyd:before{content:"\f3e6"}.fa-republican:before{content:"\f75e"}.fa-researchgate:before{content:"\f4f8"}.fa-resolving:before{content:"\f3e7"}.fa-restroom:before{content:"\f7bd"}.fa-retweet:before{content:"\f079"}.fa-rev:before{content:"\f5b2"}.fa-ribbon:before{content:"\f4d6"}.fa-ring:before{content:"\f70b"}.fa-road:before{content:"\f018"}.fa-robot:before{content:"\f544"}.fa-rocket:before{content:"\f135"}.fa-rocketchat:before{content:"\f3e8"}.fa-rockrms:before{content:"\f3e9"}.fa-route:before{content:"\f4d7"}.fa-rss:before{content:"\f09e"}.fa-rss-square:before{content:"\f143"}.fa-ruble-sign:before{content:"\f158"}.fa-ruler:before{content:"\f545"}.fa-ruler-combined:before{content:"\f546"}.fa-ruler-horizontal:before{content:"\f547"}.fa-ruler-vertical:before{content:"\f548"}.fa-running:before{content:"\f70c"}.fa-rupee-sign:before{content:"\f156"}.fa-sad-cry:before{content:"\f5b3"}.fa-sad-tear:before{content:"\f5b4"}.fa-safari:before{content:"\f267"}.fa-salesforce:before{content:"\f83b"}.fa-sass:before{content:"\f41e"}.fa-satellite:before{content:"\f7bf"}.fa-satellite-dish:before{content:"\f7c0"}.fa-save:before{content:"\f0c7"}.fa-schlix:before{content:"\f3ea"}.fa-school:before{content:"\f549"}.fa-screwdriver:before{content:"\f54a"}.fa-scribd:before{content:"\f28a"}.fa-scroll:before{content:"\f70e"}.fa-sd-card:before{content:"\f7c2"}.fa-search:before{content:"\f002"}.fa-search-dollar:before{content:"\f688"}.fa-search-location:before{content:"\f689"}.fa-search-minus:before{content:"\f010"}.fa-search-plus:before{content:"\f00e"}.fa-searchengin:before{content:"\f3eb"}.fa-seedling:before{content:"\f4d8"}.fa-sellcast:before{content:"\f2da"}.fa-sellsy:before{content:"\f213"}.fa-server:before{content:"\f233"}.fa-servicestack:before{content:"\f3ec"}.fa-shapes:before{content:"\f61f"}.fa-share:before{content:"\f064"}.fa-share-alt:before{content:"\f1e0"}.fa-share-alt-square:before{content:"\f1e1"}.fa-share-square:before{content:"\f14d"}.fa-shekel-sign:before{content:"\f20b"}.fa-shield-alt:before{content:"\f3ed"}.fa-shield-virus:before{content:"\f96c"}.fa-ship:before{content:"\f21a"}.fa-shipping-fast:before{content:"\f48b"}.fa-shirtsinbulk:before{content:"\f214"}.fa-shoe-prints:before{content:"\f54b"}.fa-shopify:before{content:"\f957"}.fa-shopping-bag:before{content:"\f290"}.fa-shopping-basket:before{content:"\f291"}.fa-shopping-cart:before{content:"\f07a"}.fa-shopware:before{content:"\f5b5"}.fa-shower:before{content:"\f2cc"}.fa-shuttle-van:before{content:"\f5b6"}.fa-sign:before{content:"\f4d9"}.fa-sign-in-alt:before{content:"\f2f6"}.fa-sign-language:before{content:"\f2a7"}.fa-sign-out-alt:before{content:"\f2f5"}.fa-signal:before{content:"\f012"}.fa-signature:before{content:"\f5b7"}.fa-sim-card:before{content:"\f7c4"}.fa-simplybuilt:before{content:"\f215"}.fa-sistrix:before{content:"\f3ee"}.fa-sitemap:before{content:"\f0e8"}.fa-sith:before{content:"\f512"}.fa-skating:before{content:"\f7c5"}.fa-sketch:before{content:"\f7c6"}.fa-skiing:before{content:"\f7c9"}.fa-skiing-nordic:before{content:"\f7ca"}.fa-skull:before{content:"\f54c"}.fa-skull-crossbones:before{content:"\f714"}.fa-skyatlas:before{content:"\f216"}.fa-skype:before{content:"\f17e"}.fa-slack:before{content:"\f198"}.fa-slack-hash:before{content:"\f3ef"}.fa-slash:before{content:"\f715"}.fa-sleigh:before{content:"\f7cc"}.fa-sliders-h:before{content:"\f1de"}.fa-slideshare:before{content:"\f1e7"}.fa-smile:before{content:"\f118"}.fa-smile-beam:before{content:"\f5b8"}.fa-smile-wink:before{content:"\f4da"}.fa-smog:before{content:"\f75f"}.fa-smoking:before{content:"\f48d"}.fa-smoking-ban:before{content:"\f54d"}.fa-sms:before{content:"\f7cd"}.fa-snapchat:before{content:"\f2ab"}.fa-snapchat-ghost:before{content:"\f2ac"}.fa-snapchat-square:before{content:"\f2ad"}.fa-snowboarding:before{content:"\f7ce"}.fa-snowflake:before{content:"\f2dc"}.fa-snowman:before{content:"\f7d0"}.fa-snowplow:before{content:"\f7d2"}.fa-soap:before{content:"\f96e"}.fa-socks:before{content:"\f696"}.fa-solar-panel:before{content:"\f5ba"}.fa-sort:before{content:"\f0dc"}.fa-sort-alpha-down:before{content:"\f15d"}.fa-sort-alpha-down-alt:before{content:"\f881"}.fa-sort-alpha-up:before{content:"\f15e"}.fa-sort-alpha-up-alt:before{content:"\f882"}.fa-sort-amount-down:before{content:"\f160"}.fa-sort-amount-down-alt:before{content:"\f884"}.fa-sort-amount-up:before{content:"\f161"}.fa-sort-amount-up-alt:before{content:"\f885"}.fa-sort-down:before{content:"\f0dd"}.fa-sort-numeric-down:before{content:"\f162"}.fa-sort-numeric-down-alt:before{content:"\f886"}.fa-sort-numeric-up:before{content:"\f163"}.fa-sort-numeric-up-alt:before{content:"\f887"}.fa-sort-up:before{content:"\f0de"}.fa-soundcloud:before{content:"\f1be"}.fa-sourcetree:before{content:"\f7d3"}.fa-spa:before{content:"\f5bb"}.fa-space-shuttle:before{content:"\f197"}.fa-speakap:before{content:"\f3f3"}.fa-speaker-deck:before{content:"\f83c"}.fa-spell-check:before{content:"\f891"}.fa-spider:before{content:"\f717"}.fa-spinner:before{content:"\f110"}.fa-splotch:before{content:"\f5bc"}.fa-spotify:before{content:"\f1bc"}.fa-spray-can:before{content:"\f5bd"}.fa-square:before{content:"\f0c8"}.fa-square-full:before{content:"\f45c"}.fa-square-root-alt:before{content:"\f698"}.fa-squarespace:before{content:"\f5be"}.fa-stack-exchange:before{content:"\f18d"}.fa-stack-overflow:before{content:"\f16c"}.fa-stackpath:before{content:"\f842"}.fa-stamp:before{content:"\f5bf"}.fa-star:before{content:"\f005"}.fa-star-and-crescent:before{content:"\f699"}.fa-star-half:before{content:"\f089"}.fa-star-half-alt:before{content:"\f5c0"}.fa-star-of-david:before{content:"\f69a"}.fa-star-of-life:before{content:"\f621"}.fa-staylinked:before{content:"\f3f5"}.fa-steam:before{content:"\f1b6"}.fa-steam-square:before{content:"\f1b7"}.fa-steam-symbol:before{content:"\f3f6"}.fa-step-backward:before{content:"\f048"}.fa-step-forward:before{content:"\f051"}.fa-stethoscope:before{content:"\f0f1"}.fa-sticker-mule:before{content:"\f3f7"}.fa-sticky-note:before{content:"\f249"}.fa-stop:before{content:"\f04d"}.fa-stop-circle:before{content:"\f28d"}.fa-stopwatch:before{content:"\f2f2"}.fa-stopwatch-20:before{content:"\f96f"}.fa-store:before{content:"\f54e"}.fa-store-alt:before{content:"\f54f"}.fa-store-alt-slash:before{content:"\f970"}.fa-store-slash:before{content:"\f971"}.fa-strava:before{content:"\f428"}.fa-stream:before{content:"\f550"}.fa-street-view:before{content:"\f21d"}.fa-strikethrough:before{content:"\f0cc"}.fa-stripe:before{content:"\f429"}.fa-stripe-s:before{content:"\f42a"}.fa-stroopwafel:before{content:"\f551"}.fa-studiovinari:before{content:"\f3f8"}.fa-stumbleupon:before{content:"\f1a4"}.fa-stumbleupon-circle:before{content:"\f1a3"}.fa-subscript:before{content:"\f12c"}.fa-subway:before{content:"\f239"}.fa-suitcase:before{content:"\f0f2"}.fa-suitcase-rolling:before{content:"\f5c1"}.fa-sun:before{content:"\f185"}.fa-superpowers:before{content:"\f2dd"}.fa-superscript:before{content:"\f12b"}.fa-supple:before{content:"\f3f9"}.fa-surprise:before{content:"\f5c2"}.fa-suse:before{content:"\f7d6"}.fa-swatchbook:before{content:"\f5c3"}.fa-swift:before{content:"\f8e1"}.fa-swimmer:before{content:"\f5c4"}.fa-swimming-pool:before{content:"\f5c5"}.fa-symfony:before{content:"\f83d"}.fa-synagogue:before{content:"\f69b"}.fa-sync:before{content:"\f021"}.fa-sync-alt:before{content:"\f2f1"}.fa-syringe:before{content:"\f48e"}.fa-table:before{content:"\f0ce"}.fa-table-tennis:before{content:"\f45d"}.fa-tablet:before{content:"\f10a"}.fa-tablet-alt:before{content:"\f3fa"}.fa-tablets:before{content:"\f490"}.fa-tachometer-alt:before{content:"\f3fd"}.fa-tag:before{content:"\f02b"}.fa-tags:before{content:"\f02c"}.fa-tape:before{content:"\f4db"}.fa-tasks:before{content:"\f0ae"}.fa-taxi:before{content:"\f1ba"}.fa-teamspeak:before{content:"\f4f9"}.fa-teeth:before{content:"\f62e"}.fa-teeth-open:before{content:"\f62f"}.fa-telegram:before{content:"\f2c6"}.fa-telegram-plane:before{content:"\f3fe"}.fa-temperature-high:before{content:"\f769"}.fa-temperature-low:before{content:"\f76b"}.fa-tencent-weibo:before{content:"\f1d5"}.fa-tenge:before{content:"\f7d7"}.fa-terminal:before{content:"\f120"}.fa-text-height:before{content:"\f034"}.fa-text-width:before{content:"\f035"}.fa-th:before{content:"\f00a"}.fa-th-large:before{content:"\f009"}.fa-th-list:before{content:"\f00b"}.fa-the-red-yeti:before{content:"\f69d"}.fa-theater-masks:before{content:"\f630"}.fa-themeco:before{content:"\f5c6"}.fa-themeisle:before{content:"\f2b2"}.fa-thermometer:before{content:"\f491"}.fa-thermometer-empty:before{content:"\f2cb"}.fa-thermometer-full:before{content:"\f2c7"}.fa-thermometer-half:before{content:"\f2c9"}.fa-thermometer-quarter:before{content:"\f2ca"}.fa-thermometer-three-quarters:before{content:"\f2c8"}.fa-think-peaks:before{content:"\f731"}.fa-thumbs-down:before{content:"\f165"}.fa-thumbs-up:before{content:"\f164"}.fa-thumbtack:before{content:"\f08d"}.fa-ticket-alt:before{content:"\f3ff"}.fa-times:before{content:"\f00d"}.fa-times-circle:before{content:"\f057"}.fa-tint:before{content:"\f043"}.fa-tint-slash:before{content:"\f5c7"}.fa-tired:before{content:"\f5c8"}.fa-toggle-off:before{content:"\f204"}.fa-toggle-on:before{content:"\f205"}.fa-toilet:before{content:"\f7d8"}.fa-toilet-paper:before{content:"\f71e"}.fa-toilet-paper-slash:before{content:"\f972"}.fa-toolbox:before{content:"\f552"}.fa-tools:before{content:"\f7d9"}.fa-tooth:before{content:"\f5c9"}.fa-torah:before{content:"\f6a0"}.fa-torii-gate:before{content:"\f6a1"}.fa-tractor:before{content:"\f722"}.fa-trade-federation:before{content:"\f513"}.fa-trademark:before{content:"\f25c"}.fa-traffic-light:before{content:"\f637"}.fa-trailer:before{content:"\f941"}.fa-train:before{content:"\f238"}.fa-tram:before{content:"\f7da"}.fa-transgender:before{content:"\f224"}.fa-transgender-alt:before{content:"\f225"}.fa-trash:before{content:"\f1f8"}.fa-trash-alt:before{content:"\f2ed"}.fa-trash-restore:before{content:"\f829"}.fa-trash-restore-alt:before{content:"\f82a"}.fa-tree:before{content:"\f1bb"}.fa-trello:before{content:"\f181"}.fa-tripadvisor:before{content:"\f262"}.fa-trophy:before{content:"\f091"}.fa-truck:before{content:"\f0d1"}.fa-truck-loading:before{content:"\f4de"}.fa-truck-monster:before{content:"\f63b"}.fa-truck-moving:before{content:"\f4df"}.fa-truck-pickup:before{content:"\f63c"}.fa-tshirt:before{content:"\f553"}.fa-tty:before{content:"\f1e4"}.fa-tumblr:before{content:"\f173"}.fa-tumblr-square:before{content:"\f174"}.fa-tv:before{content:"\f26c"}.fa-twitch:before{content:"\f1e8"}.fa-twitter:before{content:"\f099"}.fa-twitter-square:before{content:"\f081"}.fa-typo3:before{content:"\f42b"}.fa-uber:before{content:"\f402"}.fa-ubuntu:before{content:"\f7df"}.fa-uikit:before{content:"\f403"}.fa-umbraco:before{content:"\f8e8"}.fa-umbrella:before{content:"\f0e9"}.fa-umbrella-beach:before{content:"\f5ca"}.fa-underline:before{content:"\f0cd"}.fa-undo:before{content:"\f0e2"}.fa-undo-alt:before{content:"\f2ea"}.fa-uniregistry:before{content:"\f404"}.fa-unity:before{content:"\f949"}.fa-universal-access:before{content:"\f29a"}.fa-university:before{content:"\f19c"}.fa-unlink:before{content:"\f127"}.fa-unlock:before{content:"\f09c"}.fa-unlock-alt:before{content:"\f13e"}.fa-untappd:before{content:"\f405"}.fa-upload:before{content:"\f093"}.fa-ups:before{content:"\f7e0"}.fa-usb:before{content:"\f287"}.fa-user:before{content:"\f007"}.fa-user-alt:before{content:"\f406"}.fa-user-alt-slash:before{content:"\f4fa"}.fa-user-astronaut:before{content:"\f4fb"}.fa-user-check:before{content:"\f4fc"}.fa-user-circle:before{content:"\f2bd"}.fa-user-clock:before{content:"\f4fd"}.fa-user-cog:before{content:"\f4fe"}.fa-user-edit:before{content:"\f4ff"}.fa-user-friends:before{content:"\f500"}.fa-user-graduate:before{content:"\f501"}.fa-user-injured:before{content:"\f728"}.fa-user-lock:before{content:"\f502"}.fa-user-md:before{content:"\f0f0"}.fa-user-minus:before{content:"\f503"}.fa-user-ninja:before{content:"\f504"}.fa-user-nurse:before{content:"\f82f"}.fa-user-plus:before{content:"\f234"}.fa-user-secret:before{content:"\f21b"}.fa-user-shield:before{content:"\f505"}.fa-user-slash:before{content:"\f506"}.fa-user-tag:before{content:"\f507"}.fa-user-tie:before{content:"\f508"}.fa-user-times:before{content:"\f235"}.fa-users:before{content:"\f0c0"}.fa-users-cog:before{content:"\f509"}.fa-usps:before{content:"\f7e1"}.fa-ussunnah:before{content:"\f407"}.fa-utensil-spoon:before{content:"\f2e5"}.fa-utensils:before{content:"\f2e7"}.fa-vaadin:before{content:"\f408"}.fa-vector-square:before{content:"\f5cb"}.fa-venus:before{content:"\f221"}.fa-venus-double:before{content:"\f226"}.fa-venus-mars:before{content:"\f228"}.fa-viacoin:before{content:"\f237"}.fa-viadeo:before{content:"\f2a9"}.fa-viadeo-square:before{content:"\f2aa"}.fa-vial:before{content:"\f492"}.fa-vials:before{content:"\f493"}.fa-viber:before{content:"\f409"}.fa-video:before{content:"\f03d"}.fa-video-slash:before{content:"\f4e2"}.fa-vihara:before{content:"\f6a7"}.fa-vimeo:before{content:"\f40a"}.fa-vimeo-square:before{content:"\f194"}.fa-vimeo-v:before{content:"\f27d"}.fa-vine:before{content:"\f1ca"}.fa-virus:before{content:"\f974"}.fa-virus-slash:before{content:"\f975"}.fa-viruses:before{content:"\f976"}.fa-vk:before{content:"\f189"}.fa-vnv:before{content:"\f40b"}.fa-voicemail:before{content:"\f897"}.fa-volleyball-ball:before{content:"\f45f"}.fa-volume-down:before{content:"\f027"}.fa-volume-mute:before{content:"\f6a9"}.fa-volume-off:before{content:"\f026"}.fa-volume-up:before{content:"\f028"}.fa-vote-yea:before{content:"\f772"}.fa-vr-cardboard:before{content:"\f729"}.fa-vuejs:before{content:"\f41f"}.fa-walking:before{content:"\f554"}.fa-wallet:before{content:"\f555"}.fa-warehouse:before{content:"\f494"}.fa-water:before{content:"\f773"}.fa-wave-square:before{content:"\f83e"}.fa-waze:before{content:"\f83f"}.fa-weebly:before{content:"\f5cc"}.fa-weibo:before{content:"\f18a"}.fa-weight:before{content:"\f496"}.fa-weight-hanging:before{content:"\f5cd"}.fa-weixin:before{content:"\f1d7"}.fa-whatsapp:before{content:"\f232"}.fa-whatsapp-square:before{content:"\f40c"}.fa-wheelchair:before{content:"\f193"}.fa-whmcs:before{content:"\f40d"}.fa-wifi:before{content:"\f1eb"}.fa-wikipedia-w:before{content:"\f266"}.fa-wind:before{content:"\f72e"}.fa-window-close:before{content:"\f410"}.fa-window-maximize:before{content:"\f2d0"}.fa-window-minimize:before{content:"\f2d1"}.fa-window-restore:before{content:"\f2d2"}.fa-windows:before{content:"\f17a"}.fa-wine-bottle:before{content:"\f72f"}.fa-wine-glass:before{content:"\f4e3"}.fa-wine-glass-alt:before{content:"\f5ce"}.fa-wix:before{content:"\f5cf"}.fa-wizards-of-the-coast:before{content:"\f730"}.fa-wolf-pack-battalion:before{content:"\f514"}.fa-won-sign:before{content:"\f159"}.fa-wordpress:before{content:"\f19a"}.fa-wordpress-simple:before{content:"\f411"}.fa-wpbeginner:before{content:"\f297"}.fa-wpexplorer:before{content:"\f2de"}.fa-wpforms:before{content:"\f298"}.fa-wpressr:before{content:"\f3e4"}.fa-wrench:before{content:"\f0ad"}.fa-x-ray:before{content:"\f497"}.fa-xbox:before{content:"\f412"}.fa-xing:before{content:"\f168"}.fa-xing-square:before{content:"\f169"}.fa-y-combinator:before{content:"\f23b"}.fa-yahoo:before{content:"\f19e"}.fa-yammer:before{content:"\f840"}.fa-yandex:before{content:"\f413"}.fa-yandex-international:before{content:"\f414"}.fa-yarn:before{content:"\f7e3"}.fa-yelp:before{content:"\f1e9"}.fa-yen-sign:before{content:"\f157"}.fa-yin-yang:before{content:"\f6ad"}.fa-yoast:before{content:"\f2b1"}.fa-youtube:before{content:"\f167"}.fa-youtube-square:before{content:"\f431"}.fa-zhihu:before{content:"\f63f"}.sr-only{border:0;clip:rect(0,0,0,0);height:1px;margin:-1px;overflow:hidden;padding:0;position:absolute;width:1px}.sr-only-focusable:active,.sr-only-focusable:focus{clip:auto;height:auto;margin:0;overflow:visible;position:static;width:auto} \ No newline at end of file diff --git a/nlp_demo_riva/client/css/regular.css b/nlp_demo_riva/client/css/regular.css new file mode 100644 index 00000000..9914a007 --- /dev/null +++ b/nlp_demo_riva/client/css/regular.css @@ -0,0 +1,15 @@ +/*! + * Font Awesome Free 5.13.0 by @fontawesome - https://fontawesome.com + * License - https://fontawesome.com/license/free (Icons: CC BY 4.0, Fonts: SIL OFL 1.1, Code: MIT License) + */ +@font-face { + font-family: 'Font Awesome 5 Free'; + font-style: normal; + font-weight: 400; + font-display: block; + src: url("../webfonts/fa-regular-400.eot"); + src: url("../webfonts/fa-regular-400.eot?#iefix") format("embedded-opentype"), url("../webfonts/fa-regular-400.woff2") format("woff2"), url("../webfonts/fa-regular-400.woff") format("woff"), url("../webfonts/fa-regular-400.ttf") format("truetype"), url("../webfonts/fa-regular-400.svg#fontawesome") format("svg"); } + +.far { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } diff --git a/nlp_demo_riva/client/css/regular.min.css b/nlp_demo_riva/client/css/regular.min.css new file mode 100644 index 00000000..e247cb19 --- /dev/null +++ b/nlp_demo_riva/client/css/regular.min.css @@ -0,0 +1,5 @@ +/*! + * Font Awesome Free 5.13.0 by @fontawesome - https://fontawesome.com + * License - https://fontawesome.com/license/free (Icons: CC BY 4.0, Fonts: SIL OFL 1.1, Code: MIT License) + */ +@font-face{font-family:"Font Awesome 5 Free";font-style:normal;font-weight:400;font-display:block;src:url(../webfonts/fa-regular-400.eot);src:url(../webfonts/fa-regular-400.eot?#iefix) format("embedded-opentype"),url(../webfonts/fa-regular-400.woff2) format("woff2"),url(../webfonts/fa-regular-400.woff) format("woff"),url(../webfonts/fa-regular-400.ttf) format("truetype"),url(../webfonts/fa-regular-400.svg#fontawesome) format("svg")}.far{font-family:"Font Awesome 5 Free";font-weight:400} \ No newline at end of file diff --git a/nlp_demo_riva/client/css/solid.css b/nlp_demo_riva/client/css/solid.css new file mode 100644 index 00000000..252d7757 --- /dev/null +++ b/nlp_demo_riva/client/css/solid.css @@ -0,0 +1,16 @@ +/*! + * Font Awesome Free 5.13.0 by @fontawesome - https://fontawesome.com + * License - https://fontawesome.com/license/free (Icons: CC BY 4.0, Fonts: SIL OFL 1.1, Code: MIT License) + */ +@font-face { + font-family: 'Font Awesome 5 Free'; + font-style: normal; + font-weight: 900; + font-display: block; + src: url("../webfonts/fa-solid-900.eot"); + src: url("../webfonts/fa-solid-900.eot?#iefix") format("embedded-opentype"), url("../webfonts/fa-solid-900.woff2") format("woff2"), url("../webfonts/fa-solid-900.woff") format("woff"), url("../webfonts/fa-solid-900.ttf") format("truetype"), url("../webfonts/fa-solid-900.svg#fontawesome") format("svg"); } + +.fa, +.fas { + font-family: 'Font Awesome 5 Free'; + font-weight: 900; } diff --git a/nlp_demo_riva/client/css/solid.min.css b/nlp_demo_riva/client/css/solid.min.css new file mode 100644 index 00000000..c26a3ae6 --- /dev/null +++ b/nlp_demo_riva/client/css/solid.min.css @@ -0,0 +1,5 @@ +/*! + * Font Awesome Free 5.13.0 by @fontawesome - https://fontawesome.com + * License - https://fontawesome.com/license/free (Icons: CC BY 4.0, Fonts: SIL OFL 1.1, Code: MIT License) + */ +@font-face{font-family:"Font Awesome 5 Free";font-style:normal;font-weight:900;font-display:block;src:url(../webfonts/fa-solid-900.eot);src:url(../webfonts/fa-solid-900.eot?#iefix) format("embedded-opentype"),url(../webfonts/fa-solid-900.woff2) format("woff2"),url(../webfonts/fa-solid-900.woff) format("woff"),url(../webfonts/fa-solid-900.ttf) format("truetype"),url(../webfonts/fa-solid-900.svg#fontawesome) format("svg")}.fa,.fas{font-family:"Font Awesome 5 Free";font-weight:900} \ No newline at end of file diff --git a/nlp_demo_riva/client/css/styles.css b/nlp_demo_riva/client/css/styles.css new file mode 100644 index 00000000..d1b1cc06 --- /dev/null +++ b/nlp_demo_riva/client/css/styles.css @@ -0,0 +1,252 @@ +body { + font-family: 'Open Sans', sans-serif; + font-size: 14px; + font-weight: 400; + font-style: normal; + line-height: 21px; + text-align: left; + letter-spacing: 0; + text-transform: none; + color: #050505; + background-color: #FAFAFA; +} + +.bar { + background-color: black; + height: 30px; + margin-bottom: 10px; +} + +b { + font-size: 18px; +} + + + +.container { + width:80%; + margin: auto; +} + +.ui.textarea .textarea:hover { + border: 1px solid transparent; + outline: 1px solid #76b900; + box-shadow: none; +} + +.ui.textarea .textarea { + font-size: 14px; + width: 100%; + height: 300px; + padding: 4px; +} + +textarea { + overflow: auto; +} + +*, *::before, *::after { + box-sizing: inherit; +} + +textarea { + -webkit-writing-mode: horizontal-tb !important; + text-rendering: auto; + color: -internal-light-dark-color(black, white); + letter-spacing: normal; + word-spacing: normal; + text-transform: none; + text-indent: 0px; + text-shadow: none; + display: inline-block; + text-align: start; + -webkit-appearance: textarea; + background-color: -internal-light-dark-color(white, black); + -webkit-rtl-ordering: logical; + flex-direction: column; + resize: auto; + cursor: text; + white-space: pre-wrap; + overflow-wrap: break-word; + margin: 0em; + font: 400 11px system-ui; + border-width: 1px; + border-style: solid; + border-color: initial; + border-image: initial; + padding: 2px; +} + +.ui.textarea .metadata { + display: flex; + flex-direction: row; + width: 100%; + justify-content: space-between; +} + +div { + display: block; +} + +label { + font-family: 'Open Sans', sans-serif; + font-size: 12px; + font-weight: 700; + font-style: normal; + line-height: 21px; + text-align: left; + text-decoration: none; + letter-spacing: 0.4px; + text-transform: none; + color: #050505; +} + +.ui.textarea .metadata .sublabel { + font-size: 12px; + display: block; + color: #9e9e9e; +} + +html { + line-height: 1.15; + -webkit-text-size-adjust: 100%; + -ms-text-size-adjust: 100%; +} + +.ui.textarea .textarea::after { + box-shadow: none; +} + +button i { + font-size: 12px; + border: none; + padding: 3px; +} + +button i.fa-microphone { + color: #76B900; +} + +button i.fa-play { + color: #76B900; +} + + +p { + font-family: 'Open Sans', sans-serif; + font-size: 11px; + font-style: normal; + text-align: left; + text-decoration: none; + letter-spacing: 0.0px; +} + +h2, h2.dark { + font-family: 'Open Sans', sans-serif; + font-size: 15px; + font-weight: 200; + font-style: normal; + line-height: 28px; + text-align: left; + text-decoration: none; + letter-spacing: -0.4px; + text-transform: none; + color: #9E9E9E; + margin-bottom: -5px; +} + +h1, h1.dark { + font-family: 'DINWebPro', 'Open Sans', sans-serif; + font-size: 20px; + font-weight: 200; + font-style: normal; + line-height: 28px; + text-align: left; + text-decoration: none; + letter-spacing: -0.4px; + text-transform: none; + color: #050505; +} + +h1{ + margin: 0; + padding: 0; +} + +input { + font-family: 'Open Sans', sans-serif; + font-size: 14px; + font-weight: 400; + font-style: normal; + line-height: 18px; + width: 95%; + margin: 0; + text-align: left; + text-decoration: none; + letter-spacing: 0; + text-transform: none; + color: #050505; +} + +.ui.textfield label { + display: block; +} + +.ui.textfield { + width: 100%; + padding: 4px; + +} + +.ui.buttons { + display: flex; + flex-direction: row; + align-items: flex-start; + justify-content: flex-start; +} + +.ui.button { + font-family: 'Open Sans', sans-serif; + font-style: normal; + text-align: center; + text-decoration: none; + letter-spacing: 0; + text-transform: none; + padding: 6px 12px; + font-size: 11px; + font-weight: 400; + cursor: pointer; + user-select: none; + white-space: nowrap; + border-radius: 0; + outline: none; + will-change: auto; +} + +.ui.button.primary { + color: #fff; + background: #76b900; + width: 60px; +} + +.ui.selection { + display: flex; + flex-direction: row; + align-items: flex-start; + justify-content: flex-start; +} + +.ui.select { + font-family: 'Open Sans', sans-serif; + font-style: normal; + line-height: 18px; + text-align: center; + text-decoration: none; + letter-spacing: 0; + text-transform: none; + padding: 7px 14px; + font-size: 14px; + font-weight: 400; +} + + diff --git a/nlp_demo_riva/client/css/svg-with-js.css b/nlp_demo_riva/client/css/svg-with-js.css new file mode 100644 index 00000000..dbca9475 --- /dev/null +++ b/nlp_demo_riva/client/css/svg-with-js.css @@ -0,0 +1,371 @@ +/*! + * Font Awesome Free 5.13.0 by @fontawesome - https://fontawesome.com + * License - https://fontawesome.com/license/free (Icons: CC BY 4.0, Fonts: SIL OFL 1.1, Code: MIT License) + */ +svg:not(:root).svg-inline--fa { + overflow: visible; } + +.svg-inline--fa { + display: inline-block; + font-size: inherit; + height: 1em; + overflow: visible; + vertical-align: -.125em; } + .svg-inline--fa.fa-lg { + vertical-align: -.225em; } + .svg-inline--fa.fa-w-1 { + width: 0.0625em; } + .svg-inline--fa.fa-w-2 { + width: 0.125em; } + .svg-inline--fa.fa-w-3 { + width: 0.1875em; } + .svg-inline--fa.fa-w-4 { + width: 0.25em; } + .svg-inline--fa.fa-w-5 { + width: 0.3125em; } + .svg-inline--fa.fa-w-6 { + width: 0.375em; } + .svg-inline--fa.fa-w-7 { + width: 0.4375em; } + .svg-inline--fa.fa-w-8 { + width: 0.5em; } + .svg-inline--fa.fa-w-9 { + width: 0.5625em; } + .svg-inline--fa.fa-w-10 { + width: 0.625em; } + .svg-inline--fa.fa-w-11 { + width: 0.6875em; } + .svg-inline--fa.fa-w-12 { + width: 0.75em; } + .svg-inline--fa.fa-w-13 { + width: 0.8125em; } + .svg-inline--fa.fa-w-14 { + width: 0.875em; } + .svg-inline--fa.fa-w-15 { + width: 0.9375em; } + .svg-inline--fa.fa-w-16 { + width: 1em; } + .svg-inline--fa.fa-w-17 { + width: 1.0625em; } + .svg-inline--fa.fa-w-18 { + width: 1.125em; } + .svg-inline--fa.fa-w-19 { + width: 1.1875em; } + .svg-inline--fa.fa-w-20 { + width: 1.25em; } + .svg-inline--fa.fa-pull-left { + margin-right: .3em; + width: auto; } + .svg-inline--fa.fa-pull-right { + margin-left: .3em; + width: auto; } + .svg-inline--fa.fa-border { + height: 1.5em; } + .svg-inline--fa.fa-li { + width: 2em; } + .svg-inline--fa.fa-fw { + width: 1.25em; } + +.fa-layers svg.svg-inline--fa { + bottom: 0; + left: 0; + margin: auto; + position: absolute; + right: 0; + top: 0; } + +.fa-layers { + display: inline-block; + height: 1em; + position: relative; + text-align: center; + vertical-align: -.125em; + width: 1em; } + .fa-layers svg.svg-inline--fa { + -webkit-transform-origin: center center; + transform-origin: center center; } + +.fa-layers-text, .fa-layers-counter { + display: inline-block; + position: absolute; + text-align: center; } + +.fa-layers-text { + left: 50%; + top: 50%; + -webkit-transform: translate(-50%, -50%); + transform: translate(-50%, -50%); + -webkit-transform-origin: center center; + transform-origin: center center; } + +.fa-layers-counter { + background-color: #ff253a; + border-radius: 1em; + -webkit-box-sizing: border-box; + box-sizing: border-box; + color: #fff; + height: 1.5em; + line-height: 1; + max-width: 5em; + min-width: 1.5em; + overflow: hidden; + padding: .25em; + right: 0; + text-overflow: ellipsis; + top: 0; + -webkit-transform: scale(0.25); + transform: scale(0.25); + -webkit-transform-origin: top right; + transform-origin: top right; } + +.fa-layers-bottom-right { + bottom: 0; + right: 0; + top: auto; + -webkit-transform: scale(0.25); + transform: scale(0.25); + -webkit-transform-origin: bottom right; + transform-origin: bottom right; } + +.fa-layers-bottom-left { + bottom: 0; + left: 0; + right: auto; + top: auto; + -webkit-transform: scale(0.25); + transform: scale(0.25); + -webkit-transform-origin: bottom left; + transform-origin: bottom left; } + +.fa-layers-top-right { + right: 0; + top: 0; + -webkit-transform: scale(0.25); + transform: scale(0.25); + -webkit-transform-origin: top right; + transform-origin: top right; } + +.fa-layers-top-left { + left: 0; + right: auto; + top: 0; + -webkit-transform: scale(0.25); + transform: scale(0.25); + -webkit-transform-origin: top left; + transform-origin: top left; } + +.fa-lg { + font-size: 1.33333em; + line-height: 0.75em; + vertical-align: -.0667em; } + +.fa-xs { + font-size: .75em; } + +.fa-sm { + font-size: .875em; } + +.fa-1x { + font-size: 1em; } + +.fa-2x { + font-size: 2em; } + +.fa-3x { + font-size: 3em; } + +.fa-4x { + font-size: 4em; } + +.fa-5x { + font-size: 5em; } + +.fa-6x { + font-size: 6em; } + +.fa-7x { + font-size: 7em; } + +.fa-8x { + font-size: 8em; } + +.fa-9x { + font-size: 9em; } + +.fa-10x { + font-size: 10em; } + +.fa-fw { + text-align: center; + width: 1.25em; } + +.fa-ul { + list-style-type: none; + margin-left: 2.5em; + padding-left: 0; } + .fa-ul > li { + position: relative; } + +.fa-li { + left: -2em; + position: absolute; + text-align: center; + width: 2em; + line-height: inherit; } + +.fa-border { + border: solid 0.08em #eee; + border-radius: .1em; + padding: .2em .25em .15em; } + +.fa-pull-left { + float: left; } + +.fa-pull-right { + float: right; } + +.fa.fa-pull-left, +.fas.fa-pull-left, +.far.fa-pull-left, +.fal.fa-pull-left, +.fab.fa-pull-left { + margin-right: .3em; } + +.fa.fa-pull-right, +.fas.fa-pull-right, +.far.fa-pull-right, +.fal.fa-pull-right, +.fab.fa-pull-right { + margin-left: .3em; } + +.fa-spin { + -webkit-animation: fa-spin 2s infinite linear; + animation: fa-spin 2s infinite linear; } + +.fa-pulse { + -webkit-animation: fa-spin 1s infinite steps(8); + animation: fa-spin 1s infinite steps(8); } + +@-webkit-keyframes fa-spin { + 0% { + -webkit-transform: rotate(0deg); + transform: rotate(0deg); } + 100% { + -webkit-transform: rotate(360deg); + transform: rotate(360deg); } } + +@keyframes fa-spin { + 0% { + -webkit-transform: rotate(0deg); + transform: rotate(0deg); } + 100% { + -webkit-transform: rotate(360deg); + transform: rotate(360deg); } } + +.fa-rotate-90 { + -ms-filter: "progid:DXImageTransform.Microsoft.BasicImage(rotation=1)"; + -webkit-transform: rotate(90deg); + transform: rotate(90deg); } + +.fa-rotate-180 { + -ms-filter: "progid:DXImageTransform.Microsoft.BasicImage(rotation=2)"; + -webkit-transform: rotate(180deg); + transform: rotate(180deg); } + +.fa-rotate-270 { + -ms-filter: "progid:DXImageTransform.Microsoft.BasicImage(rotation=3)"; + -webkit-transform: rotate(270deg); + transform: rotate(270deg); } + +.fa-flip-horizontal { + -ms-filter: "progid:DXImageTransform.Microsoft.BasicImage(rotation=0, mirror=1)"; + -webkit-transform: scale(-1, 1); + transform: scale(-1, 1); } + +.fa-flip-vertical { + -ms-filter: "progid:DXImageTransform.Microsoft.BasicImage(rotation=2, mirror=1)"; + -webkit-transform: scale(1, -1); + transform: scale(1, -1); } + +.fa-flip-both, .fa-flip-horizontal.fa-flip-vertical { + -ms-filter: "progid:DXImageTransform.Microsoft.BasicImage(rotation=2, mirror=1)"; + -webkit-transform: scale(-1, -1); + transform: scale(-1, -1); } + +:root .fa-rotate-90, +:root .fa-rotate-180, +:root .fa-rotate-270, +:root .fa-flip-horizontal, +:root .fa-flip-vertical, +:root .fa-flip-both { + -webkit-filter: none; + filter: none; } + +.fa-stack { + display: inline-block; + height: 2em; + position: relative; + width: 2.5em; } + +.fa-stack-1x, +.fa-stack-2x { + bottom: 0; + left: 0; + margin: auto; + position: absolute; + right: 0; + top: 0; } + +.svg-inline--fa.fa-stack-1x { + height: 1em; + width: 1.25em; } + +.svg-inline--fa.fa-stack-2x { + height: 2em; + width: 2.5em; } + +.fa-inverse { + color: #fff; } + +.sr-only { + border: 0; + clip: rect(0, 0, 0, 0); + height: 1px; + margin: -1px; + overflow: hidden; + padding: 0; + position: absolute; + width: 1px; } + +.sr-only-focusable:active, .sr-only-focusable:focus { + clip: auto; + height: auto; + margin: 0; + overflow: visible; + position: static; + width: auto; } + +.svg-inline--fa .fa-primary { + fill: var(--fa-primary-color, currentColor); + opacity: 1; + opacity: var(--fa-primary-opacity, 1); } + +.svg-inline--fa .fa-secondary { + fill: var(--fa-secondary-color, currentColor); + opacity: 0.4; + opacity: var(--fa-secondary-opacity, 0.4); } + +.svg-inline--fa.fa-swap-opacity .fa-primary { + opacity: 0.4; + opacity: var(--fa-secondary-opacity, 0.4); } + +.svg-inline--fa.fa-swap-opacity .fa-secondary { + opacity: 1; + opacity: var(--fa-primary-opacity, 1); } + +.svg-inline--fa mask .fa-primary, +.svg-inline--fa mask .fa-secondary { + fill: black; } + +.fad.fa-inverse { + color: #fff; } diff --git a/nlp_demo_riva/client/css/svg-with-js.min.css b/nlp_demo_riva/client/css/svg-with-js.min.css new file mode 100644 index 00000000..08ef08c9 --- /dev/null +++ b/nlp_demo_riva/client/css/svg-with-js.min.css @@ -0,0 +1,5 @@ +/*! + * Font Awesome Free 5.13.0 by @fontawesome - https://fontawesome.com + * License - https://fontawesome.com/license/free (Icons: CC BY 4.0, Fonts: SIL OFL 1.1, Code: MIT License) + */ +.svg-inline--fa,svg:not(:root).svg-inline--fa{overflow:visible}.svg-inline--fa{display:inline-block;font-size:inherit;height:1em;vertical-align:-.125em}.svg-inline--fa.fa-lg{vertical-align:-.225em}.svg-inline--fa.fa-w-1{width:.0625em}.svg-inline--fa.fa-w-2{width:.125em}.svg-inline--fa.fa-w-3{width:.1875em}.svg-inline--fa.fa-w-4{width:.25em}.svg-inline--fa.fa-w-5{width:.3125em}.svg-inline--fa.fa-w-6{width:.375em}.svg-inline--fa.fa-w-7{width:.4375em}.svg-inline--fa.fa-w-8{width:.5em}.svg-inline--fa.fa-w-9{width:.5625em}.svg-inline--fa.fa-w-10{width:.625em}.svg-inline--fa.fa-w-11{width:.6875em}.svg-inline--fa.fa-w-12{width:.75em}.svg-inline--fa.fa-w-13{width:.8125em}.svg-inline--fa.fa-w-14{width:.875em}.svg-inline--fa.fa-w-15{width:.9375em}.svg-inline--fa.fa-w-16{width:1em}.svg-inline--fa.fa-w-17{width:1.0625em}.svg-inline--fa.fa-w-18{width:1.125em}.svg-inline--fa.fa-w-19{width:1.1875em}.svg-inline--fa.fa-w-20{width:1.25em}.svg-inline--fa.fa-pull-left{margin-right:.3em;width:auto}.svg-inline--fa.fa-pull-right{margin-left:.3em;width:auto}.svg-inline--fa.fa-border{height:1.5em}.svg-inline--fa.fa-li{width:2em}.svg-inline--fa.fa-fw{width:1.25em}.fa-layers svg.svg-inline--fa{bottom:0;left:0;margin:auto;position:absolute;right:0;top:0}.fa-layers{display:inline-block;height:1em;position:relative;text-align:center;vertical-align:-.125em;width:1em}.fa-layers svg.svg-inline--fa{-webkit-transform-origin:center center;transform-origin:center center}.fa-layers-counter,.fa-layers-text{display:inline-block;position:absolute;text-align:center}.fa-layers-text{left:50%;top:50%;-webkit-transform:translate(-50%,-50%);transform:translate(-50%,-50%);-webkit-transform-origin:center center;transform-origin:center center}.fa-layers-counter{background-color:#ff253a;border-radius:1em;-webkit-box-sizing:border-box;box-sizing:border-box;color:#fff;height:1.5em;line-height:1;max-width:5em;min-width:1.5em;overflow:hidden;padding:.25em;right:0;text-overflow:ellipsis;top:0;-webkit-transform:scale(.25);transform:scale(.25);-webkit-transform-origin:top right;transform-origin:top right}.fa-layers-bottom-right{bottom:0;right:0;top:auto;-webkit-transform:scale(.25);transform:scale(.25);-webkit-transform-origin:bottom right;transform-origin:bottom right}.fa-layers-bottom-left{bottom:0;left:0;right:auto;top:auto;-webkit-transform:scale(.25);transform:scale(.25);-webkit-transform-origin:bottom left;transform-origin:bottom left}.fa-layers-top-right{right:0;top:0;-webkit-transform:scale(.25);transform:scale(.25);-webkit-transform-origin:top right;transform-origin:top right}.fa-layers-top-left{left:0;right:auto;top:0;-webkit-transform:scale(.25);transform:scale(.25);-webkit-transform-origin:top left;transform-origin:top left}.fa-lg{font-size:1.33333em;line-height:.75em;vertical-align:-.0667em}.fa-xs{font-size:.75em}.fa-sm{font-size:.875em}.fa-1x{font-size:1em}.fa-2x{font-size:2em}.fa-3x{font-size:3em}.fa-4x{font-size:4em}.fa-5x{font-size:5em}.fa-6x{font-size:6em}.fa-7x{font-size:7em}.fa-8x{font-size:8em}.fa-9x{font-size:9em}.fa-10x{font-size:10em}.fa-fw{text-align:center;width:1.25em}.fa-ul{list-style-type:none;margin-left:2.5em;padding-left:0}.fa-ul>li{position:relative}.fa-li{left:-2em;position:absolute;text-align:center;width:2em;line-height:inherit}.fa-border{border:.08em solid #eee;border-radius:.1em;padding:.2em .25em .15em}.fa-pull-left{float:left}.fa-pull-right{float:right}.fa.fa-pull-left,.fab.fa-pull-left,.fal.fa-pull-left,.far.fa-pull-left,.fas.fa-pull-left{margin-right:.3em}.fa.fa-pull-right,.fab.fa-pull-right,.fal.fa-pull-right,.far.fa-pull-right,.fas.fa-pull-right{margin-left:.3em}.fa-spin{-webkit-animation:fa-spin 2s linear infinite;animation:fa-spin 2s linear infinite}.fa-pulse{-webkit-animation:fa-spin 1s steps(8) infinite;animation:fa-spin 1s steps(8) infinite}@-webkit-keyframes fa-spin{0%{-webkit-transform:rotate(0deg);transform:rotate(0deg)}to{-webkit-transform:rotate(1turn);transform:rotate(1turn)}}@keyframes fa-spin{0%{-webkit-transform:rotate(0deg);transform:rotate(0deg)}to{-webkit-transform:rotate(1turn);transform:rotate(1turn)}}.fa-rotate-90{-ms-filter:"progid:DXImageTransform.Microsoft.BasicImage(rotation=1)";-webkit-transform:rotate(90deg);transform:rotate(90deg)}.fa-rotate-180{-ms-filter:"progid:DXImageTransform.Microsoft.BasicImage(rotation=2)";-webkit-transform:rotate(180deg);transform:rotate(180deg)}.fa-rotate-270{-ms-filter:"progid:DXImageTransform.Microsoft.BasicImage(rotation=3)";-webkit-transform:rotate(270deg);transform:rotate(270deg)}.fa-flip-horizontal{-ms-filter:"progid:DXImageTransform.Microsoft.BasicImage(rotation=0, mirror=1)";-webkit-transform:scaleX(-1);transform:scaleX(-1)}.fa-flip-vertical{-webkit-transform:scaleY(-1);transform:scaleY(-1)}.fa-flip-both,.fa-flip-horizontal.fa-flip-vertical,.fa-flip-vertical{-ms-filter:"progid:DXImageTransform.Microsoft.BasicImage(rotation=2, mirror=1)"}.fa-flip-both,.fa-flip-horizontal.fa-flip-vertical{-webkit-transform:scale(-1);transform:scale(-1)}:root .fa-flip-both,:root .fa-flip-horizontal,:root .fa-flip-vertical,:root .fa-rotate-90,:root .fa-rotate-180,:root .fa-rotate-270{-webkit-filter:none;filter:none}.fa-stack{display:inline-block;height:2em;position:relative;width:2.5em}.fa-stack-1x,.fa-stack-2x{bottom:0;left:0;margin:auto;position:absolute;right:0;top:0}.svg-inline--fa.fa-stack-1x{height:1em;width:1.25em}.svg-inline--fa.fa-stack-2x{height:2em;width:2.5em}.fa-inverse{color:#fff}.sr-only{border:0;clip:rect(0,0,0,0);height:1px;margin:-1px;overflow:hidden;padding:0;position:absolute;width:1px}.sr-only-focusable:active,.sr-only-focusable:focus{clip:auto;height:auto;margin:0;overflow:visible;position:static;width:auto}.svg-inline--fa .fa-primary{fill:var(--fa-primary-color,currentColor);opacity:1;opacity:var(--fa-primary-opacity,1)}.svg-inline--fa .fa-secondary{fill:var(--fa-secondary-color,currentColor)}.svg-inline--fa .fa-secondary,.svg-inline--fa.fa-swap-opacity .fa-primary{opacity:.4;opacity:var(--fa-secondary-opacity,.4)}.svg-inline--fa.fa-swap-opacity .fa-secondary{opacity:1;opacity:var(--fa-primary-opacity,1)}.svg-inline--fa mask .fa-primary,.svg-inline--fa mask .fa-secondary{fill:#000}.fad.fa-inverse{color:#fff} \ No newline at end of file diff --git a/nlp_demo_riva/client/css/v4-shims.css b/nlp_demo_riva/client/css/v4-shims.css new file mode 100644 index 00000000..1070fbe7 --- /dev/null +++ b/nlp_demo_riva/client/css/v4-shims.css @@ -0,0 +1,2172 @@ +/*! + * Font Awesome Free 5.13.0 by @fontawesome - https://fontawesome.com + * License - https://fontawesome.com/license/free (Icons: CC BY 4.0, Fonts: SIL OFL 1.1, Code: MIT License) + */ +.fa.fa-glass:before { + content: "\f000"; } + +.fa.fa-meetup { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-star-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-star-o:before { + content: "\f005"; } + +.fa.fa-remove:before { + content: "\f00d"; } + +.fa.fa-close:before { + content: "\f00d"; } + +.fa.fa-gear:before { + content: "\f013"; } + +.fa.fa-trash-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-trash-o:before { + content: "\f2ed"; } + +.fa.fa-file-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-file-o:before { + content: "\f15b"; } + +.fa.fa-clock-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-clock-o:before { + content: "\f017"; } + +.fa.fa-arrow-circle-o-down { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-arrow-circle-o-down:before { + content: "\f358"; } + +.fa.fa-arrow-circle-o-up { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-arrow-circle-o-up:before { + content: "\f35b"; } + +.fa.fa-play-circle-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-play-circle-o:before { + content: "\f144"; } + +.fa.fa-repeat:before { + content: "\f01e"; } + +.fa.fa-rotate-right:before { + content: "\f01e"; } + +.fa.fa-refresh:before { + content: "\f021"; } + +.fa.fa-list-alt { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-dedent:before { + content: "\f03b"; } + +.fa.fa-video-camera:before { + content: "\f03d"; } + +.fa.fa-picture-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-picture-o:before { + content: "\f03e"; } + +.fa.fa-photo { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-photo:before { + content: "\f03e"; } + +.fa.fa-image { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-image:before { + content: "\f03e"; } + +.fa.fa-pencil:before { + content: "\f303"; } + +.fa.fa-map-marker:before { + content: "\f3c5"; } + +.fa.fa-pencil-square-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-pencil-square-o:before { + content: "\f044"; } + +.fa.fa-share-square-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-share-square-o:before { + content: "\f14d"; } + +.fa.fa-check-square-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-check-square-o:before { + content: "\f14a"; } + +.fa.fa-arrows:before { + content: "\f0b2"; } + +.fa.fa-times-circle-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-times-circle-o:before { + content: "\f057"; } + +.fa.fa-check-circle-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-check-circle-o:before { + content: "\f058"; } + +.fa.fa-mail-forward:before { + content: "\f064"; } + +.fa.fa-expand:before { + content: "\f424"; } + +.fa.fa-compress:before { + content: "\f422"; } + +.fa.fa-eye { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-eye-slash { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-warning:before { + content: "\f071"; } + +.fa.fa-calendar:before { + content: "\f073"; } + +.fa.fa-arrows-v:before { + content: "\f338"; } + +.fa.fa-arrows-h:before { + content: "\f337"; } + +.fa.fa-bar-chart { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-bar-chart:before { + content: "\f080"; } + +.fa.fa-bar-chart-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-bar-chart-o:before { + content: "\f080"; } + +.fa.fa-twitter-square { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-facebook-square { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-gears:before { + content: "\f085"; } + +.fa.fa-thumbs-o-up { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-thumbs-o-up:before { + content: "\f164"; } + +.fa.fa-thumbs-o-down { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-thumbs-o-down:before { + content: "\f165"; } + +.fa.fa-heart-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-heart-o:before { + content: "\f004"; } + +.fa.fa-sign-out:before { + content: "\f2f5"; } + +.fa.fa-linkedin-square { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-linkedin-square:before { + content: "\f08c"; } + +.fa.fa-thumb-tack:before { + content: "\f08d"; } + +.fa.fa-external-link:before { + content: "\f35d"; } + +.fa.fa-sign-in:before { + content: "\f2f6"; } + +.fa.fa-github-square { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-lemon-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-lemon-o:before { + content: "\f094"; } + +.fa.fa-square-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-square-o:before { + content: "\f0c8"; } + +.fa.fa-bookmark-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-bookmark-o:before { + content: "\f02e"; } + +.fa.fa-twitter { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-facebook { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-facebook:before { + content: "\f39e"; } + +.fa.fa-facebook-f { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-facebook-f:before { + content: "\f39e"; } + +.fa.fa-github { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-credit-card { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-feed:before { + content: "\f09e"; } + +.fa.fa-hdd-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-hdd-o:before { + content: "\f0a0"; } + +.fa.fa-hand-o-right { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-hand-o-right:before { + content: "\f0a4"; } + +.fa.fa-hand-o-left { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-hand-o-left:before { + content: "\f0a5"; } + +.fa.fa-hand-o-up { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-hand-o-up:before { + content: "\f0a6"; } + +.fa.fa-hand-o-down { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-hand-o-down:before { + content: "\f0a7"; } + +.fa.fa-arrows-alt:before { + content: "\f31e"; } + +.fa.fa-group:before { + content: "\f0c0"; } + +.fa.fa-chain:before { + content: "\f0c1"; } + +.fa.fa-scissors:before { + content: "\f0c4"; } + +.fa.fa-files-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-files-o:before { + content: "\f0c5"; } + +.fa.fa-floppy-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-floppy-o:before { + content: "\f0c7"; } + +.fa.fa-navicon:before { + content: "\f0c9"; } + +.fa.fa-reorder:before { + content: "\f0c9"; } + +.fa.fa-pinterest { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-pinterest-square { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-google-plus-square { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-google-plus { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-google-plus:before { + content: "\f0d5"; } + +.fa.fa-money { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-money:before { + content: "\f3d1"; } + +.fa.fa-unsorted:before { + content: "\f0dc"; } + +.fa.fa-sort-desc:before { + content: "\f0dd"; } + +.fa.fa-sort-asc:before { + content: "\f0de"; } + +.fa.fa-linkedin { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-linkedin:before { + content: "\f0e1"; } + +.fa.fa-rotate-left:before { + content: "\f0e2"; } + +.fa.fa-legal:before { + content: "\f0e3"; } + +.fa.fa-tachometer:before { + content: "\f3fd"; } + +.fa.fa-dashboard:before { + content: "\f3fd"; } + +.fa.fa-comment-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-comment-o:before { + content: "\f075"; } + +.fa.fa-comments-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-comments-o:before { + content: "\f086"; } + +.fa.fa-flash:before { + content: "\f0e7"; } + +.fa.fa-clipboard { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-paste { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-paste:before { + content: "\f328"; } + +.fa.fa-lightbulb-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-lightbulb-o:before { + content: "\f0eb"; } + +.fa.fa-exchange:before { + content: "\f362"; } + +.fa.fa-cloud-download:before { + content: "\f381"; } + +.fa.fa-cloud-upload:before { + content: "\f382"; } + +.fa.fa-bell-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-bell-o:before { + content: "\f0f3"; } + +.fa.fa-cutlery:before { + content: "\f2e7"; } + +.fa.fa-file-text-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-file-text-o:before { + content: "\f15c"; } + +.fa.fa-building-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-building-o:before { + content: "\f1ad"; } + +.fa.fa-hospital-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-hospital-o:before { + content: "\f0f8"; } + +.fa.fa-tablet:before { + content: "\f3fa"; } + +.fa.fa-mobile:before { + content: "\f3cd"; } + +.fa.fa-mobile-phone:before { + content: "\f3cd"; } + +.fa.fa-circle-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-circle-o:before { + content: "\f111"; } + +.fa.fa-mail-reply:before { + content: "\f3e5"; } + +.fa.fa-github-alt { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-folder-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-folder-o:before { + content: "\f07b"; } + +.fa.fa-folder-open-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-folder-open-o:before { + content: "\f07c"; } + +.fa.fa-smile-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-smile-o:before { + content: "\f118"; } + +.fa.fa-frown-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-frown-o:before { + content: "\f119"; } + +.fa.fa-meh-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-meh-o:before { + content: "\f11a"; } + +.fa.fa-keyboard-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-keyboard-o:before { + content: "\f11c"; } + +.fa.fa-flag-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-flag-o:before { + content: "\f024"; } + +.fa.fa-mail-reply-all:before { + content: "\f122"; } + +.fa.fa-star-half-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-star-half-o:before { + content: "\f089"; } + +.fa.fa-star-half-empty { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-star-half-empty:before { + content: "\f089"; } + +.fa.fa-star-half-full { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-star-half-full:before { + content: "\f089"; } + +.fa.fa-code-fork:before { + content: "\f126"; } + +.fa.fa-chain-broken:before { + content: "\f127"; } + +.fa.fa-shield:before { + content: "\f3ed"; } + +.fa.fa-calendar-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-calendar-o:before { + content: "\f133"; } + +.fa.fa-maxcdn { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-html5 { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-css3 { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-ticket:before { + content: "\f3ff"; } + +.fa.fa-minus-square-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-minus-square-o:before { + content: "\f146"; } + +.fa.fa-level-up:before { + content: "\f3bf"; } + +.fa.fa-level-down:before { + content: "\f3be"; } + +.fa.fa-pencil-square:before { + content: "\f14b"; } + +.fa.fa-external-link-square:before { + content: "\f360"; } + +.fa.fa-compass { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-caret-square-o-down { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-caret-square-o-down:before { + content: "\f150"; } + +.fa.fa-toggle-down { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-toggle-down:before { + content: "\f150"; } + +.fa.fa-caret-square-o-up { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-caret-square-o-up:before { + content: "\f151"; } + +.fa.fa-toggle-up { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-toggle-up:before { + content: "\f151"; } + +.fa.fa-caret-square-o-right { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-caret-square-o-right:before { + content: "\f152"; } + +.fa.fa-toggle-right { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-toggle-right:before { + content: "\f152"; } + +.fa.fa-eur:before { + content: "\f153"; } + +.fa.fa-euro:before { + content: "\f153"; } + +.fa.fa-gbp:before { + content: "\f154"; } + +.fa.fa-usd:before { + content: "\f155"; } + +.fa.fa-dollar:before { + content: "\f155"; } + +.fa.fa-inr:before { + content: "\f156"; } + +.fa.fa-rupee:before { + content: "\f156"; } + +.fa.fa-jpy:before { + content: "\f157"; } + +.fa.fa-cny:before { + content: "\f157"; } + +.fa.fa-rmb:before { + content: "\f157"; } + +.fa.fa-yen:before { + content: "\f157"; } + +.fa.fa-rub:before { + content: "\f158"; } + +.fa.fa-ruble:before { + content: "\f158"; } + +.fa.fa-rouble:before { + content: "\f158"; } + +.fa.fa-krw:before { + content: "\f159"; } + +.fa.fa-won:before { + content: "\f159"; } + +.fa.fa-btc { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-bitcoin { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-bitcoin:before { + content: "\f15a"; } + +.fa.fa-file-text:before { + content: "\f15c"; } + +.fa.fa-sort-alpha-asc:before { + content: "\f15d"; } + +.fa.fa-sort-alpha-desc:before { + content: "\f881"; } + +.fa.fa-sort-amount-asc:before { + content: "\f160"; } + +.fa.fa-sort-amount-desc:before { + content: "\f884"; } + +.fa.fa-sort-numeric-asc:before { + content: "\f162"; } + +.fa.fa-sort-numeric-desc:before { + content: "\f886"; } + +.fa.fa-youtube-square { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-youtube { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-xing { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-xing-square { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-youtube-play { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-youtube-play:before { + content: "\f167"; } + +.fa.fa-dropbox { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-stack-overflow { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-instagram { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-flickr { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-adn { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-bitbucket { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-bitbucket-square { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-bitbucket-square:before { + content: "\f171"; } + +.fa.fa-tumblr { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-tumblr-square { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-long-arrow-down:before { + content: "\f309"; } + +.fa.fa-long-arrow-up:before { + content: "\f30c"; } + +.fa.fa-long-arrow-left:before { + content: "\f30a"; } + +.fa.fa-long-arrow-right:before { + content: "\f30b"; } + +.fa.fa-apple { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-windows { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-android { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-linux { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-dribbble { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-skype { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-foursquare { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-trello { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-gratipay { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-gittip { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-gittip:before { + content: "\f184"; } + +.fa.fa-sun-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-sun-o:before { + content: "\f185"; } + +.fa.fa-moon-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-moon-o:before { + content: "\f186"; } + +.fa.fa-vk { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-weibo { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-renren { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-pagelines { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-stack-exchange { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-arrow-circle-o-right { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-arrow-circle-o-right:before { + content: "\f35a"; } + +.fa.fa-arrow-circle-o-left { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-arrow-circle-o-left:before { + content: "\f359"; } + +.fa.fa-caret-square-o-left { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-caret-square-o-left:before { + content: "\f191"; } + +.fa.fa-toggle-left { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-toggle-left:before { + content: "\f191"; } + +.fa.fa-dot-circle-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-dot-circle-o:before { + content: "\f192"; } + +.fa.fa-vimeo-square { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-try:before { + content: "\f195"; } + +.fa.fa-turkish-lira:before { + content: "\f195"; } + +.fa.fa-plus-square-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-plus-square-o:before { + content: "\f0fe"; } + +.fa.fa-slack { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-wordpress { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-openid { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-institution:before { + content: "\f19c"; } + +.fa.fa-bank:before { + content: "\f19c"; } + +.fa.fa-mortar-board:before { + content: "\f19d"; } + +.fa.fa-yahoo { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-google { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-reddit { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-reddit-square { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-stumbleupon-circle { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-stumbleupon { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-delicious { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-digg { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-pied-piper-pp { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-pied-piper-alt { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-drupal { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-joomla { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-spoon:before { + content: "\f2e5"; } + +.fa.fa-behance { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-behance-square { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-steam { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-steam-square { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-automobile:before { + content: "\f1b9"; } + +.fa.fa-envelope-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-envelope-o:before { + content: "\f0e0"; } + +.fa.fa-spotify { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-deviantart { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-soundcloud { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-file-pdf-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-file-pdf-o:before { + content: "\f1c1"; } + +.fa.fa-file-word-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-file-word-o:before { + content: "\f1c2"; } + +.fa.fa-file-excel-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-file-excel-o:before { + content: "\f1c3"; } + +.fa.fa-file-powerpoint-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-file-powerpoint-o:before { + content: "\f1c4"; } + +.fa.fa-file-image-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-file-image-o:before { + content: "\f1c5"; } + +.fa.fa-file-photo-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-file-photo-o:before { + content: "\f1c5"; } + +.fa.fa-file-picture-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-file-picture-o:before { + content: "\f1c5"; } + +.fa.fa-file-archive-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-file-archive-o:before { + content: "\f1c6"; } + +.fa.fa-file-zip-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-file-zip-o:before { + content: "\f1c6"; } + +.fa.fa-file-audio-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-file-audio-o:before { + content: "\f1c7"; } + +.fa.fa-file-sound-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-file-sound-o:before { + content: "\f1c7"; } + +.fa.fa-file-video-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-file-video-o:before { + content: "\f1c8"; } + +.fa.fa-file-movie-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-file-movie-o:before { + content: "\f1c8"; } + +.fa.fa-file-code-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-file-code-o:before { + content: "\f1c9"; } + +.fa.fa-vine { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-codepen { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-jsfiddle { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-life-ring { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-life-bouy { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-life-bouy:before { + content: "\f1cd"; } + +.fa.fa-life-buoy { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-life-buoy:before { + content: "\f1cd"; } + +.fa.fa-life-saver { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-life-saver:before { + content: "\f1cd"; } + +.fa.fa-support { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-support:before { + content: "\f1cd"; } + +.fa.fa-circle-o-notch:before { + content: "\f1ce"; } + +.fa.fa-rebel { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-ra { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-ra:before { + content: "\f1d0"; } + +.fa.fa-resistance { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-resistance:before { + content: "\f1d0"; } + +.fa.fa-empire { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-ge { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-ge:before { + content: "\f1d1"; } + +.fa.fa-git-square { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-git { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-hacker-news { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-y-combinator-square { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-y-combinator-square:before { + content: "\f1d4"; } + +.fa.fa-yc-square { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-yc-square:before { + content: "\f1d4"; } + +.fa.fa-tencent-weibo { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-qq { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-weixin { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-wechat { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-wechat:before { + content: "\f1d7"; } + +.fa.fa-send:before { + content: "\f1d8"; } + +.fa.fa-paper-plane-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-paper-plane-o:before { + content: "\f1d8"; } + +.fa.fa-send-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-send-o:before { + content: "\f1d8"; } + +.fa.fa-circle-thin { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-circle-thin:before { + content: "\f111"; } + +.fa.fa-header:before { + content: "\f1dc"; } + +.fa.fa-sliders:before { + content: "\f1de"; } + +.fa.fa-futbol-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-futbol-o:before { + content: "\f1e3"; } + +.fa.fa-soccer-ball-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-soccer-ball-o:before { + content: "\f1e3"; } + +.fa.fa-slideshare { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-twitch { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-yelp { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-newspaper-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-newspaper-o:before { + content: "\f1ea"; } + +.fa.fa-paypal { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-google-wallet { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-cc-visa { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-cc-mastercard { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-cc-discover { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-cc-amex { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-cc-paypal { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-cc-stripe { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-bell-slash-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-bell-slash-o:before { + content: "\f1f6"; } + +.fa.fa-trash:before { + content: "\f2ed"; } + +.fa.fa-copyright { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-eyedropper:before { + content: "\f1fb"; } + +.fa.fa-area-chart:before { + content: "\f1fe"; } + +.fa.fa-pie-chart:before { + content: "\f200"; } + +.fa.fa-line-chart:before { + content: "\f201"; } + +.fa.fa-lastfm { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-lastfm-square { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-ioxhost { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-angellist { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-cc { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-cc:before { + content: "\f20a"; } + +.fa.fa-ils:before { + content: "\f20b"; } + +.fa.fa-shekel:before { + content: "\f20b"; } + +.fa.fa-sheqel:before { + content: "\f20b"; } + +.fa.fa-meanpath { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-meanpath:before { + content: "\f2b4"; } + +.fa.fa-buysellads { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-connectdevelop { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-dashcube { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-forumbee { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-leanpub { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-sellsy { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-shirtsinbulk { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-simplybuilt { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-skyatlas { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-diamond { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-diamond:before { + content: "\f3a5"; } + +.fa.fa-intersex:before { + content: "\f224"; } + +.fa.fa-facebook-official { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-facebook-official:before { + content: "\f09a"; } + +.fa.fa-pinterest-p { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-whatsapp { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-hotel:before { + content: "\f236"; } + +.fa.fa-viacoin { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-medium { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-y-combinator { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-yc { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-yc:before { + content: "\f23b"; } + +.fa.fa-optin-monster { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-opencart { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-expeditedssl { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-battery-4:before { + content: "\f240"; } + +.fa.fa-battery:before { + content: "\f240"; } + +.fa.fa-battery-3:before { + content: "\f241"; } + +.fa.fa-battery-2:before { + content: "\f242"; } + +.fa.fa-battery-1:before { + content: "\f243"; } + +.fa.fa-battery-0:before { + content: "\f244"; } + +.fa.fa-object-group { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-object-ungroup { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-sticky-note-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-sticky-note-o:before { + content: "\f249"; } + +.fa.fa-cc-jcb { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-cc-diners-club { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-clone { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-hourglass-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-hourglass-o:before { + content: "\f254"; } + +.fa.fa-hourglass-1:before { + content: "\f251"; } + +.fa.fa-hourglass-2:before { + content: "\f252"; } + +.fa.fa-hourglass-3:before { + content: "\f253"; } + +.fa.fa-hand-rock-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-hand-rock-o:before { + content: "\f255"; } + +.fa.fa-hand-grab-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-hand-grab-o:before { + content: "\f255"; } + +.fa.fa-hand-paper-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-hand-paper-o:before { + content: "\f256"; } + +.fa.fa-hand-stop-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-hand-stop-o:before { + content: "\f256"; } + +.fa.fa-hand-scissors-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-hand-scissors-o:before { + content: "\f257"; } + +.fa.fa-hand-lizard-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-hand-lizard-o:before { + content: "\f258"; } + +.fa.fa-hand-spock-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-hand-spock-o:before { + content: "\f259"; } + +.fa.fa-hand-pointer-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-hand-pointer-o:before { + content: "\f25a"; } + +.fa.fa-hand-peace-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-hand-peace-o:before { + content: "\f25b"; } + +.fa.fa-registered { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-creative-commons { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-gg { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-gg-circle { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-tripadvisor { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-odnoklassniki { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-odnoklassniki-square { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-get-pocket { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-wikipedia-w { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-safari { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-chrome { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-firefox { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-opera { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-internet-explorer { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-television:before { + content: "\f26c"; } + +.fa.fa-contao { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-500px { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-amazon { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-calendar-plus-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-calendar-plus-o:before { + content: "\f271"; } + +.fa.fa-calendar-minus-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-calendar-minus-o:before { + content: "\f272"; } + +.fa.fa-calendar-times-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-calendar-times-o:before { + content: "\f273"; } + +.fa.fa-calendar-check-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-calendar-check-o:before { + content: "\f274"; } + +.fa.fa-map-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-map-o:before { + content: "\f279"; } + +.fa.fa-commenting:before { + content: "\f4ad"; } + +.fa.fa-commenting-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-commenting-o:before { + content: "\f4ad"; } + +.fa.fa-houzz { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-vimeo { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-vimeo:before { + content: "\f27d"; } + +.fa.fa-black-tie { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-fonticons { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-reddit-alien { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-edge { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-credit-card-alt:before { + content: "\f09d"; } + +.fa.fa-codiepie { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-modx { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-fort-awesome { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-usb { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-product-hunt { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-mixcloud { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-scribd { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-pause-circle-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-pause-circle-o:before { + content: "\f28b"; } + +.fa.fa-stop-circle-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-stop-circle-o:before { + content: "\f28d"; } + +.fa.fa-bluetooth { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-bluetooth-b { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-gitlab { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-wpbeginner { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-wpforms { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-envira { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-wheelchair-alt { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-wheelchair-alt:before { + content: "\f368"; } + +.fa.fa-question-circle-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-question-circle-o:before { + content: "\f059"; } + +.fa.fa-volume-control-phone:before { + content: "\f2a0"; } + +.fa.fa-asl-interpreting:before { + content: "\f2a3"; } + +.fa.fa-deafness:before { + content: "\f2a4"; } + +.fa.fa-hard-of-hearing:before { + content: "\f2a4"; } + +.fa.fa-glide { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-glide-g { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-signing:before { + content: "\f2a7"; } + +.fa.fa-viadeo { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-viadeo-square { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-snapchat { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-snapchat-ghost { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-snapchat-square { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-pied-piper { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-first-order { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-yoast { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-themeisle { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-google-plus-official { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-google-plus-official:before { + content: "\f2b3"; } + +.fa.fa-google-plus-circle { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-google-plus-circle:before { + content: "\f2b3"; } + +.fa.fa-font-awesome { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-fa { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-fa:before { + content: "\f2b4"; } + +.fa.fa-handshake-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-handshake-o:before { + content: "\f2b5"; } + +.fa.fa-envelope-open-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-envelope-open-o:before { + content: "\f2b6"; } + +.fa.fa-linode { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-address-book-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-address-book-o:before { + content: "\f2b9"; } + +.fa.fa-vcard:before { + content: "\f2bb"; } + +.fa.fa-address-card-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-address-card-o:before { + content: "\f2bb"; } + +.fa.fa-vcard-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-vcard-o:before { + content: "\f2bb"; } + +.fa.fa-user-circle-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-user-circle-o:before { + content: "\f2bd"; } + +.fa.fa-user-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-user-o:before { + content: "\f007"; } + +.fa.fa-id-badge { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-drivers-license:before { + content: "\f2c2"; } + +.fa.fa-id-card-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-id-card-o:before { + content: "\f2c2"; } + +.fa.fa-drivers-license-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-drivers-license-o:before { + content: "\f2c2"; } + +.fa.fa-quora { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-free-code-camp { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-telegram { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-thermometer-4:before { + content: "\f2c7"; } + +.fa.fa-thermometer:before { + content: "\f2c7"; } + +.fa.fa-thermometer-3:before { + content: "\f2c8"; } + +.fa.fa-thermometer-2:before { + content: "\f2c9"; } + +.fa.fa-thermometer-1:before { + content: "\f2ca"; } + +.fa.fa-thermometer-0:before { + content: "\f2cb"; } + +.fa.fa-bathtub:before { + content: "\f2cd"; } + +.fa.fa-s15:before { + content: "\f2cd"; } + +.fa.fa-window-maximize { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-window-restore { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-times-rectangle:before { + content: "\f410"; } + +.fa.fa-window-close-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-window-close-o:before { + content: "\f410"; } + +.fa.fa-times-rectangle-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-times-rectangle-o:before { + content: "\f410"; } + +.fa.fa-bandcamp { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-grav { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-etsy { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-imdb { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-ravelry { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-eercast { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-eercast:before { + content: "\f2da"; } + +.fa.fa-snowflake-o { + font-family: 'Font Awesome 5 Free'; + font-weight: 400; } + +.fa.fa-snowflake-o:before { + content: "\f2dc"; } + +.fa.fa-superpowers { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-wpexplorer { + font-family: 'Font Awesome 5 Brands'; + font-weight: 400; } + +.fa.fa-cab:before { + content: "\f1ba"; } diff --git a/nlp_demo_riva/client/css/v4-shims.min.css b/nlp_demo_riva/client/css/v4-shims.min.css new file mode 100644 index 00000000..974cb4de --- /dev/null +++ b/nlp_demo_riva/client/css/v4-shims.min.css @@ -0,0 +1,5 @@ +/*! + * Font Awesome Free 5.13.0 by @fontawesome - https://fontawesome.com + * License - https://fontawesome.com/license/free (Icons: CC BY 4.0, Fonts: SIL OFL 1.1, Code: MIT License) + */ +.fa.fa-glass:before{content:"\f000"}.fa.fa-meetup{font-family:"Font Awesome 5 Brands";font-weight:400}.fa.fa-star-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-star-o:before{content:"\f005"}.fa.fa-close:before,.fa.fa-remove:before{content:"\f00d"}.fa.fa-gear:before{content:"\f013"}.fa.fa-trash-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-trash-o:before{content:"\f2ed"}.fa.fa-file-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-file-o:before{content:"\f15b"}.fa.fa-clock-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-clock-o:before{content:"\f017"}.fa.fa-arrow-circle-o-down{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-arrow-circle-o-down:before{content:"\f358"}.fa.fa-arrow-circle-o-up{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-arrow-circle-o-up:before{content:"\f35b"}.fa.fa-play-circle-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-play-circle-o:before{content:"\f144"}.fa.fa-repeat:before,.fa.fa-rotate-right:before{content:"\f01e"}.fa.fa-refresh:before{content:"\f021"}.fa.fa-list-alt{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-dedent:before{content:"\f03b"}.fa.fa-video-camera:before{content:"\f03d"}.fa.fa-picture-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-picture-o:before{content:"\f03e"}.fa.fa-photo{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-photo:before{content:"\f03e"}.fa.fa-image{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-image:before{content:"\f03e"}.fa.fa-pencil:before{content:"\f303"}.fa.fa-map-marker:before{content:"\f3c5"}.fa.fa-pencil-square-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-pencil-square-o:before{content:"\f044"}.fa.fa-share-square-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-share-square-o:before{content:"\f14d"}.fa.fa-check-square-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-check-square-o:before{content:"\f14a"}.fa.fa-arrows:before{content:"\f0b2"}.fa.fa-times-circle-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-times-circle-o:before{content:"\f057"}.fa.fa-check-circle-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-check-circle-o:before{content:"\f058"}.fa.fa-mail-forward:before{content:"\f064"}.fa.fa-expand:before{content:"\f424"}.fa.fa-compress:before{content:"\f422"}.fa.fa-eye,.fa.fa-eye-slash{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-warning:before{content:"\f071"}.fa.fa-calendar:before{content:"\f073"}.fa.fa-arrows-v:before{content:"\f338"}.fa.fa-arrows-h:before{content:"\f337"}.fa.fa-bar-chart{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-bar-chart:before{content:"\f080"}.fa.fa-bar-chart-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-bar-chart-o:before{content:"\f080"}.fa.fa-facebook-square,.fa.fa-twitter-square{font-family:"Font Awesome 5 Brands";font-weight:400}.fa.fa-gears:before{content:"\f085"}.fa.fa-thumbs-o-up{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-thumbs-o-up:before{content:"\f164"}.fa.fa-thumbs-o-down{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-thumbs-o-down:before{content:"\f165"}.fa.fa-heart-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-heart-o:before{content:"\f004"}.fa.fa-sign-out:before{content:"\f2f5"}.fa.fa-linkedin-square{font-family:"Font Awesome 5 Brands";font-weight:400}.fa.fa-linkedin-square:before{content:"\f08c"}.fa.fa-thumb-tack:before{content:"\f08d"}.fa.fa-external-link:before{content:"\f35d"}.fa.fa-sign-in:before{content:"\f2f6"}.fa.fa-github-square{font-family:"Font Awesome 5 Brands";font-weight:400}.fa.fa-lemon-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-lemon-o:before{content:"\f094"}.fa.fa-square-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-square-o:before{content:"\f0c8"}.fa.fa-bookmark-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-bookmark-o:before{content:"\f02e"}.fa.fa-facebook,.fa.fa-twitter{font-family:"Font Awesome 5 Brands";font-weight:400}.fa.fa-facebook:before{content:"\f39e"}.fa.fa-facebook-f{font-family:"Font Awesome 5 Brands";font-weight:400}.fa.fa-facebook-f:before{content:"\f39e"}.fa.fa-github{font-family:"Font Awesome 5 Brands";font-weight:400}.fa.fa-credit-card{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-feed:before{content:"\f09e"}.fa.fa-hdd-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-hdd-o:before{content:"\f0a0"}.fa.fa-hand-o-right{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-hand-o-right:before{content:"\f0a4"}.fa.fa-hand-o-left{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-hand-o-left:before{content:"\f0a5"}.fa.fa-hand-o-up{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-hand-o-up:before{content:"\f0a6"}.fa.fa-hand-o-down{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-hand-o-down:before{content:"\f0a7"}.fa.fa-arrows-alt:before{content:"\f31e"}.fa.fa-group:before{content:"\f0c0"}.fa.fa-chain:before{content:"\f0c1"}.fa.fa-scissors:before{content:"\f0c4"}.fa.fa-files-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-files-o:before{content:"\f0c5"}.fa.fa-floppy-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-floppy-o:before{content:"\f0c7"}.fa.fa-navicon:before,.fa.fa-reorder:before{content:"\f0c9"}.fa.fa-google-plus,.fa.fa-google-plus-square,.fa.fa-pinterest,.fa.fa-pinterest-square{font-family:"Font Awesome 5 Brands";font-weight:400}.fa.fa-google-plus:before{content:"\f0d5"}.fa.fa-money{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-money:before{content:"\f3d1"}.fa.fa-unsorted:before{content:"\f0dc"}.fa.fa-sort-desc:before{content:"\f0dd"}.fa.fa-sort-asc:before{content:"\f0de"}.fa.fa-linkedin{font-family:"Font Awesome 5 Brands";font-weight:400}.fa.fa-linkedin:before{content:"\f0e1"}.fa.fa-rotate-left:before{content:"\f0e2"}.fa.fa-legal:before{content:"\f0e3"}.fa.fa-dashboard:before,.fa.fa-tachometer:before{content:"\f3fd"}.fa.fa-comment-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-comment-o:before{content:"\f075"}.fa.fa-comments-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-comments-o:before{content:"\f086"}.fa.fa-flash:before{content:"\f0e7"}.fa.fa-clipboard,.fa.fa-paste{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-paste:before{content:"\f328"}.fa.fa-lightbulb-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-lightbulb-o:before{content:"\f0eb"}.fa.fa-exchange:before{content:"\f362"}.fa.fa-cloud-download:before{content:"\f381"}.fa.fa-cloud-upload:before{content:"\f382"}.fa.fa-bell-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-bell-o:before{content:"\f0f3"}.fa.fa-cutlery:before{content:"\f2e7"}.fa.fa-file-text-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-file-text-o:before{content:"\f15c"}.fa.fa-building-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-building-o:before{content:"\f1ad"}.fa.fa-hospital-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-hospital-o:before{content:"\f0f8"}.fa.fa-tablet:before{content:"\f3fa"}.fa.fa-mobile-phone:before,.fa.fa-mobile:before{content:"\f3cd"}.fa.fa-circle-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-circle-o:before{content:"\f111"}.fa.fa-mail-reply:before{content:"\f3e5"}.fa.fa-github-alt{font-family:"Font Awesome 5 Brands";font-weight:400}.fa.fa-folder-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-folder-o:before{content:"\f07b"}.fa.fa-folder-open-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-folder-open-o:before{content:"\f07c"}.fa.fa-smile-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-smile-o:before{content:"\f118"}.fa.fa-frown-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-frown-o:before{content:"\f119"}.fa.fa-meh-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-meh-o:before{content:"\f11a"}.fa.fa-keyboard-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-keyboard-o:before{content:"\f11c"}.fa.fa-flag-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-flag-o:before{content:"\f024"}.fa.fa-mail-reply-all:before{content:"\f122"}.fa.fa-star-half-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-star-half-o:before{content:"\f089"}.fa.fa-star-half-empty{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-star-half-empty:before{content:"\f089"}.fa.fa-star-half-full{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-star-half-full:before{content:"\f089"}.fa.fa-code-fork:before{content:"\f126"}.fa.fa-chain-broken:before{content:"\f127"}.fa.fa-shield:before{content:"\f3ed"}.fa.fa-calendar-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-calendar-o:before{content:"\f133"}.fa.fa-css3,.fa.fa-html5,.fa.fa-maxcdn{font-family:"Font Awesome 5 Brands";font-weight:400}.fa.fa-ticket:before{content:"\f3ff"}.fa.fa-minus-square-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-minus-square-o:before{content:"\f146"}.fa.fa-level-up:before{content:"\f3bf"}.fa.fa-level-down:before{content:"\f3be"}.fa.fa-pencil-square:before{content:"\f14b"}.fa.fa-external-link-square:before{content:"\f360"}.fa.fa-compass{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-caret-square-o-down{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-caret-square-o-down:before{content:"\f150"}.fa.fa-toggle-down{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-toggle-down:before{content:"\f150"}.fa.fa-caret-square-o-up{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-caret-square-o-up:before{content:"\f151"}.fa.fa-toggle-up{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-toggle-up:before{content:"\f151"}.fa.fa-caret-square-o-right{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-caret-square-o-right:before{content:"\f152"}.fa.fa-toggle-right{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-toggle-right:before{content:"\f152"}.fa.fa-eur:before,.fa.fa-euro:before{content:"\f153"}.fa.fa-gbp:before{content:"\f154"}.fa.fa-dollar:before,.fa.fa-usd:before{content:"\f155"}.fa.fa-inr:before,.fa.fa-rupee:before{content:"\f156"}.fa.fa-cny:before,.fa.fa-jpy:before,.fa.fa-rmb:before,.fa.fa-yen:before{content:"\f157"}.fa.fa-rouble:before,.fa.fa-rub:before,.fa.fa-ruble:before{content:"\f158"}.fa.fa-krw:before,.fa.fa-won:before{content:"\f159"}.fa.fa-bitcoin,.fa.fa-btc{font-family:"Font Awesome 5 Brands";font-weight:400}.fa.fa-bitcoin:before{content:"\f15a"}.fa.fa-file-text:before{content:"\f15c"}.fa.fa-sort-alpha-asc:before{content:"\f15d"}.fa.fa-sort-alpha-desc:before{content:"\f881"}.fa.fa-sort-amount-asc:before{content:"\f160"}.fa.fa-sort-amount-desc:before{content:"\f884"}.fa.fa-sort-numeric-asc:before{content:"\f162"}.fa.fa-sort-numeric-desc:before{content:"\f886"}.fa.fa-xing,.fa.fa-xing-square,.fa.fa-youtube,.fa.fa-youtube-play,.fa.fa-youtube-square{font-family:"Font Awesome 5 Brands";font-weight:400}.fa.fa-youtube-play:before{content:"\f167"}.fa.fa-adn,.fa.fa-bitbucket,.fa.fa-bitbucket-square,.fa.fa-dropbox,.fa.fa-flickr,.fa.fa-instagram,.fa.fa-stack-overflow{font-family:"Font Awesome 5 Brands";font-weight:400}.fa.fa-bitbucket-square:before{content:"\f171"}.fa.fa-tumblr,.fa.fa-tumblr-square{font-family:"Font Awesome 5 Brands";font-weight:400}.fa.fa-long-arrow-down:before{content:"\f309"}.fa.fa-long-arrow-up:before{content:"\f30c"}.fa.fa-long-arrow-left:before{content:"\f30a"}.fa.fa-long-arrow-right:before{content:"\f30b"}.fa.fa-android,.fa.fa-apple,.fa.fa-dribbble,.fa.fa-foursquare,.fa.fa-gittip,.fa.fa-gratipay,.fa.fa-linux,.fa.fa-skype,.fa.fa-trello,.fa.fa-windows{font-family:"Font Awesome 5 Brands";font-weight:400}.fa.fa-gittip:before{content:"\f184"}.fa.fa-sun-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-sun-o:before{content:"\f185"}.fa.fa-moon-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-moon-o:before{content:"\f186"}.fa.fa-pagelines,.fa.fa-renren,.fa.fa-stack-exchange,.fa.fa-vk,.fa.fa-weibo{font-family:"Font Awesome 5 Brands";font-weight:400}.fa.fa-arrow-circle-o-right{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-arrow-circle-o-right:before{content:"\f35a"}.fa.fa-arrow-circle-o-left{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-arrow-circle-o-left:before{content:"\f359"}.fa.fa-caret-square-o-left{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-caret-square-o-left:before{content:"\f191"}.fa.fa-toggle-left{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-toggle-left:before{content:"\f191"}.fa.fa-dot-circle-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-dot-circle-o:before{content:"\f192"}.fa.fa-vimeo-square{font-family:"Font Awesome 5 Brands";font-weight:400}.fa.fa-try:before,.fa.fa-turkish-lira:before{content:"\f195"}.fa.fa-plus-square-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-plus-square-o:before{content:"\f0fe"}.fa.fa-openid,.fa.fa-slack,.fa.fa-wordpress{font-family:"Font Awesome 5 Brands";font-weight:400}.fa.fa-bank:before,.fa.fa-institution:before{content:"\f19c"}.fa.fa-mortar-board:before{content:"\f19d"}.fa.fa-delicious,.fa.fa-digg,.fa.fa-drupal,.fa.fa-google,.fa.fa-joomla,.fa.fa-pied-piper-alt,.fa.fa-pied-piper-pp,.fa.fa-reddit,.fa.fa-reddit-square,.fa.fa-stumbleupon,.fa.fa-stumbleupon-circle,.fa.fa-yahoo{font-family:"Font Awesome 5 Brands";font-weight:400}.fa.fa-spoon:before{content:"\f2e5"}.fa.fa-behance,.fa.fa-behance-square,.fa.fa-steam,.fa.fa-steam-square{font-family:"Font Awesome 5 Brands";font-weight:400}.fa.fa-automobile:before{content:"\f1b9"}.fa.fa-envelope-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-envelope-o:before{content:"\f0e0"}.fa.fa-deviantart,.fa.fa-soundcloud,.fa.fa-spotify{font-family:"Font Awesome 5 Brands";font-weight:400}.fa.fa-file-pdf-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-file-pdf-o:before{content:"\f1c1"}.fa.fa-file-word-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-file-word-o:before{content:"\f1c2"}.fa.fa-file-excel-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-file-excel-o:before{content:"\f1c3"}.fa.fa-file-powerpoint-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-file-powerpoint-o:before{content:"\f1c4"}.fa.fa-file-image-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-file-image-o:before{content:"\f1c5"}.fa.fa-file-photo-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-file-photo-o:before{content:"\f1c5"}.fa.fa-file-picture-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-file-picture-o:before{content:"\f1c5"}.fa.fa-file-archive-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-file-archive-o:before{content:"\f1c6"}.fa.fa-file-zip-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-file-zip-o:before{content:"\f1c6"}.fa.fa-file-audio-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-file-audio-o:before{content:"\f1c7"}.fa.fa-file-sound-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-file-sound-o:before{content:"\f1c7"}.fa.fa-file-video-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-file-video-o:before{content:"\f1c8"}.fa.fa-file-movie-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-file-movie-o:before{content:"\f1c8"}.fa.fa-file-code-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-file-code-o:before{content:"\f1c9"}.fa.fa-codepen,.fa.fa-jsfiddle,.fa.fa-vine{font-family:"Font Awesome 5 Brands";font-weight:400}.fa.fa-life-bouy,.fa.fa-life-ring{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-life-bouy:before{content:"\f1cd"}.fa.fa-life-buoy{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-life-buoy:before{content:"\f1cd"}.fa.fa-life-saver{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-life-saver:before{content:"\f1cd"}.fa.fa-support{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-support:before{content:"\f1cd"}.fa.fa-circle-o-notch:before{content:"\f1ce"}.fa.fa-ra,.fa.fa-rebel{font-family:"Font Awesome 5 Brands";font-weight:400}.fa.fa-ra:before{content:"\f1d0"}.fa.fa-resistance{font-family:"Font Awesome 5 Brands";font-weight:400}.fa.fa-resistance:before{content:"\f1d0"}.fa.fa-empire,.fa.fa-ge{font-family:"Font Awesome 5 Brands";font-weight:400}.fa.fa-ge:before{content:"\f1d1"}.fa.fa-git,.fa.fa-git-square,.fa.fa-hacker-news,.fa.fa-y-combinator-square{font-family:"Font Awesome 5 Brands";font-weight:400}.fa.fa-y-combinator-square:before{content:"\f1d4"}.fa.fa-yc-square{font-family:"Font Awesome 5 Brands";font-weight:400}.fa.fa-yc-square:before{content:"\f1d4"}.fa.fa-qq,.fa.fa-tencent-weibo,.fa.fa-wechat,.fa.fa-weixin{font-family:"Font Awesome 5 Brands";font-weight:400}.fa.fa-wechat:before{content:"\f1d7"}.fa.fa-send:before{content:"\f1d8"}.fa.fa-paper-plane-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-paper-plane-o:before{content:"\f1d8"}.fa.fa-send-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-send-o:before{content:"\f1d8"}.fa.fa-circle-thin{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-circle-thin:before{content:"\f111"}.fa.fa-header:before{content:"\f1dc"}.fa.fa-sliders:before{content:"\f1de"}.fa.fa-futbol-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-futbol-o:before{content:"\f1e3"}.fa.fa-soccer-ball-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-soccer-ball-o:before{content:"\f1e3"}.fa.fa-slideshare,.fa.fa-twitch,.fa.fa-yelp{font-family:"Font Awesome 5 Brands";font-weight:400}.fa.fa-newspaper-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-newspaper-o:before{content:"\f1ea"}.fa.fa-cc-amex,.fa.fa-cc-discover,.fa.fa-cc-mastercard,.fa.fa-cc-paypal,.fa.fa-cc-stripe,.fa.fa-cc-visa,.fa.fa-google-wallet,.fa.fa-paypal{font-family:"Font Awesome 5 Brands";font-weight:400}.fa.fa-bell-slash-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-bell-slash-o:before{content:"\f1f6"}.fa.fa-trash:before{content:"\f2ed"}.fa.fa-copyright{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-eyedropper:before{content:"\f1fb"}.fa.fa-area-chart:before{content:"\f1fe"}.fa.fa-pie-chart:before{content:"\f200"}.fa.fa-line-chart:before{content:"\f201"}.fa.fa-angellist,.fa.fa-ioxhost,.fa.fa-lastfm,.fa.fa-lastfm-square{font-family:"Font Awesome 5 Brands";font-weight:400}.fa.fa-cc{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-cc:before{content:"\f20a"}.fa.fa-ils:before,.fa.fa-shekel:before,.fa.fa-sheqel:before{content:"\f20b"}.fa.fa-meanpath{font-family:"Font Awesome 5 Brands";font-weight:400}.fa.fa-meanpath:before{content:"\f2b4"}.fa.fa-buysellads,.fa.fa-connectdevelop,.fa.fa-dashcube,.fa.fa-forumbee,.fa.fa-leanpub,.fa.fa-sellsy,.fa.fa-shirtsinbulk,.fa.fa-simplybuilt,.fa.fa-skyatlas{font-family:"Font Awesome 5 Brands";font-weight:400}.fa.fa-diamond{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-diamond:before{content:"\f3a5"}.fa.fa-intersex:before{content:"\f224"}.fa.fa-facebook-official{font-family:"Font Awesome 5 Brands";font-weight:400}.fa.fa-facebook-official:before{content:"\f09a"}.fa.fa-pinterest-p,.fa.fa-whatsapp{font-family:"Font Awesome 5 Brands";font-weight:400}.fa.fa-hotel:before{content:"\f236"}.fa.fa-medium,.fa.fa-viacoin,.fa.fa-y-combinator,.fa.fa-yc{font-family:"Font Awesome 5 Brands";font-weight:400}.fa.fa-yc:before{content:"\f23b"}.fa.fa-expeditedssl,.fa.fa-opencart,.fa.fa-optin-monster{font-family:"Font Awesome 5 Brands";font-weight:400}.fa.fa-battery-4:before,.fa.fa-battery:before{content:"\f240"}.fa.fa-battery-3:before{content:"\f241"}.fa.fa-battery-2:before{content:"\f242"}.fa.fa-battery-1:before{content:"\f243"}.fa.fa-battery-0:before{content:"\f244"}.fa.fa-object-group,.fa.fa-object-ungroup,.fa.fa-sticky-note-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-sticky-note-o:before{content:"\f249"}.fa.fa-cc-diners-club,.fa.fa-cc-jcb{font-family:"Font Awesome 5 Brands";font-weight:400}.fa.fa-clone,.fa.fa-hourglass-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-hourglass-o:before{content:"\f254"}.fa.fa-hourglass-1:before{content:"\f251"}.fa.fa-hourglass-2:before{content:"\f252"}.fa.fa-hourglass-3:before{content:"\f253"}.fa.fa-hand-rock-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-hand-rock-o:before{content:"\f255"}.fa.fa-hand-grab-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-hand-grab-o:before{content:"\f255"}.fa.fa-hand-paper-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-hand-paper-o:before{content:"\f256"}.fa.fa-hand-stop-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-hand-stop-o:before{content:"\f256"}.fa.fa-hand-scissors-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-hand-scissors-o:before{content:"\f257"}.fa.fa-hand-lizard-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-hand-lizard-o:before{content:"\f258"}.fa.fa-hand-spock-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-hand-spock-o:before{content:"\f259"}.fa.fa-hand-pointer-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-hand-pointer-o:before{content:"\f25a"}.fa.fa-hand-peace-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-hand-peace-o:before{content:"\f25b"}.fa.fa-registered{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-chrome,.fa.fa-creative-commons,.fa.fa-firefox,.fa.fa-get-pocket,.fa.fa-gg,.fa.fa-gg-circle,.fa.fa-internet-explorer,.fa.fa-odnoklassniki,.fa.fa-odnoklassniki-square,.fa.fa-opera,.fa.fa-safari,.fa.fa-tripadvisor,.fa.fa-wikipedia-w{font-family:"Font Awesome 5 Brands";font-weight:400}.fa.fa-television:before{content:"\f26c"}.fa.fa-500px,.fa.fa-amazon,.fa.fa-contao{font-family:"Font Awesome 5 Brands";font-weight:400}.fa.fa-calendar-plus-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-calendar-plus-o:before{content:"\f271"}.fa.fa-calendar-minus-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-calendar-minus-o:before{content:"\f272"}.fa.fa-calendar-times-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-calendar-times-o:before{content:"\f273"}.fa.fa-calendar-check-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-calendar-check-o:before{content:"\f274"}.fa.fa-map-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-map-o:before{content:"\f279"}.fa.fa-commenting:before{content:"\f4ad"}.fa.fa-commenting-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-commenting-o:before{content:"\f4ad"}.fa.fa-houzz,.fa.fa-vimeo{font-family:"Font Awesome 5 Brands";font-weight:400}.fa.fa-vimeo:before{content:"\f27d"}.fa.fa-black-tie,.fa.fa-edge,.fa.fa-fonticons,.fa.fa-reddit-alien{font-family:"Font Awesome 5 Brands";font-weight:400}.fa.fa-credit-card-alt:before{content:"\f09d"}.fa.fa-codiepie,.fa.fa-fort-awesome,.fa.fa-mixcloud,.fa.fa-modx,.fa.fa-product-hunt,.fa.fa-scribd,.fa.fa-usb{font-family:"Font Awesome 5 Brands";font-weight:400}.fa.fa-pause-circle-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-pause-circle-o:before{content:"\f28b"}.fa.fa-stop-circle-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-stop-circle-o:before{content:"\f28d"}.fa.fa-bluetooth,.fa.fa-bluetooth-b,.fa.fa-envira,.fa.fa-gitlab,.fa.fa-wheelchair-alt,.fa.fa-wpbeginner,.fa.fa-wpforms{font-family:"Font Awesome 5 Brands";font-weight:400}.fa.fa-wheelchair-alt:before{content:"\f368"}.fa.fa-question-circle-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-question-circle-o:before{content:"\f059"}.fa.fa-volume-control-phone:before{content:"\f2a0"}.fa.fa-asl-interpreting:before{content:"\f2a3"}.fa.fa-deafness:before,.fa.fa-hard-of-hearing:before{content:"\f2a4"}.fa.fa-glide,.fa.fa-glide-g{font-family:"Font Awesome 5 Brands";font-weight:400}.fa.fa-signing:before{content:"\f2a7"}.fa.fa-first-order,.fa.fa-google-plus-official,.fa.fa-pied-piper,.fa.fa-snapchat,.fa.fa-snapchat-ghost,.fa.fa-snapchat-square,.fa.fa-themeisle,.fa.fa-viadeo,.fa.fa-viadeo-square,.fa.fa-yoast{font-family:"Font Awesome 5 Brands";font-weight:400}.fa.fa-google-plus-official:before{content:"\f2b3"}.fa.fa-google-plus-circle{font-family:"Font Awesome 5 Brands";font-weight:400}.fa.fa-google-plus-circle:before{content:"\f2b3"}.fa.fa-fa,.fa.fa-font-awesome{font-family:"Font Awesome 5 Brands";font-weight:400}.fa.fa-fa:before{content:"\f2b4"}.fa.fa-handshake-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-handshake-o:before{content:"\f2b5"}.fa.fa-envelope-open-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-envelope-open-o:before{content:"\f2b6"}.fa.fa-linode{font-family:"Font Awesome 5 Brands";font-weight:400}.fa.fa-address-book-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-address-book-o:before{content:"\f2b9"}.fa.fa-vcard:before{content:"\f2bb"}.fa.fa-address-card-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-address-card-o:before{content:"\f2bb"}.fa.fa-vcard-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-vcard-o:before{content:"\f2bb"}.fa.fa-user-circle-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-user-circle-o:before{content:"\f2bd"}.fa.fa-user-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-user-o:before{content:"\f007"}.fa.fa-id-badge{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-drivers-license:before{content:"\f2c2"}.fa.fa-id-card-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-id-card-o:before{content:"\f2c2"}.fa.fa-drivers-license-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-drivers-license-o:before{content:"\f2c2"}.fa.fa-free-code-camp,.fa.fa-quora,.fa.fa-telegram{font-family:"Font Awesome 5 Brands";font-weight:400}.fa.fa-thermometer-4:before,.fa.fa-thermometer:before{content:"\f2c7"}.fa.fa-thermometer-3:before{content:"\f2c8"}.fa.fa-thermometer-2:before{content:"\f2c9"}.fa.fa-thermometer-1:before{content:"\f2ca"}.fa.fa-thermometer-0:before{content:"\f2cb"}.fa.fa-bathtub:before,.fa.fa-s15:before{content:"\f2cd"}.fa.fa-window-maximize,.fa.fa-window-restore{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-times-rectangle:before{content:"\f410"}.fa.fa-window-close-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-window-close-o:before{content:"\f410"}.fa.fa-times-rectangle-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-times-rectangle-o:before{content:"\f410"}.fa.fa-bandcamp,.fa.fa-eercast,.fa.fa-etsy,.fa.fa-grav,.fa.fa-imdb,.fa.fa-ravelry{font-family:"Font Awesome 5 Brands";font-weight:400}.fa.fa-eercast:before{content:"\f2da"}.fa.fa-snowflake-o{font-family:"Font Awesome 5 Free";font-weight:400}.fa.fa-snowflake-o:before{content:"\f2dc"}.fa.fa-superpowers,.fa.fa-wpexplorer{font-family:"Font Awesome 5 Brands";font-weight:400}.fa.fa-cab:before{content:"\f1ba"} \ No newline at end of file diff --git a/nlp_demo_riva/client/index.html b/nlp_demo_riva/client/index.html new file mode 100644 index 00000000..b295bf5b --- /dev/null +++ b/nlp_demo_riva/client/index.html @@ -0,0 +1,59 @@ + + + + + + + + + + +
+ +
+

Conversational AI

+

What is the context of the conversation?

+ +
+
+ + 10000 characters +
+ +
+ +

Ask a question

+

+ Press to record your audio via Microphone. Press the when finished. Press "ask" to ask the AI a contextual question. Press to play the question. +

+ +
+ + + +
+ +
+
+ +
+ +
+
+ +
+

Get an Answer

+

+

+
+ +
+
+ +
+
+ + + + diff --git a/nlp_demo_riva/client/js/app.js b/nlp_demo_riva/client/js/app.js new file mode 100755 index 00000000..26c6a344 --- /dev/null +++ b/nlp_demo_riva/client/js/app.js @@ -0,0 +1,132 @@ +//webkitURL is deprecated but nevertheless +URL = window.URL || window.webkitURL; + +var gumStream; //stream from getUserMedia() +var rec; //Recorder.js object +var input; //MediaStreamAudioSourceNode we'll be recording + +// shim for AudioContext when it's not avb. +var AudioContext = window.AudioContext || window.webkitAudioContext; +var audioContext //audio context to help us record + +var recordButton = document.getElementById("recordButton"); +var stopButton = document.getElementById("stopButton"); +var pauseButton = document.getElementById("pauseButton"); + +//add events to those 2 buttons +recordButton.addEventListener("click", startRecording); +stopButton.addEventListener("click", stopRecording); +pauseButton.addEventListener("click", pauseRecording); + +function startRecording() { + console.log("recordButton clicked"); + + /* + Simple constraints object, for more advanced audio features see + https://addpipe.com/blog/audio-constraints-getusermedia/ + */ + + var constraints = { audio: true, video:false } + + /* + Disable the record button until we get a success or fail from getUserMedia() + */ + + recordButton.disabled = true; + stopButton.disabled = false; + pauseButton.disabled = false + + /* + We're using the standard promise based getUserMedia() + https://developer.mozilla.org/en-US/docs/Web/API/MediaDevices/getUserMedia + */ + + navigator.mediaDevices.getUserMedia(constraints).then(function(stream) { + console.log("getUserMedia() success, stream created, initializing Recorder.js ..."); + + /* + create an audio context after getUserMedia is called + sampleRate might change after getUserMedia is called, like it does on macOS when recording through AirPods + the sampleRate defaults to the one set in your OS for your playback device + + */ + audioContext = new AudioContext(); + + //update the format + //document.getElementById("formats").innerHTML="Format: 1 channel pcm @ "+audioContext.sampleRate/1000+"kHz" + + /* assign to gumStream for later use */ + gumStream = stream; + + /* use the stream */ + input = audioContext.createMediaStreamSource(stream); + + /* + Create the Recorder object and configure to record mono sound (1 channel) + Recording 2 channels will double the file size + */ + rec = new Recorder(input,{numChannels:1}) + + //start the recording process + rec.record() + + console.log("Recording started"); + + }).catch(function(err) { + //enable the record button if getUserMedia() fails + recordButton.disabled = false; + stopButton.disabled = true; + pauseButton.disabled = true + }); +} + +function pauseRecording(){ + console.log("pauseButton clicked rec.recording=",rec.recording ); + if (rec.recording){ + //pause + rec.stop(); + pauseButton.innerHTML="Resume"; + }else{ + //resume + rec.record() + pauseButton.innerHTML="Pause"; + + } +} + +function stopRecording() { + console.log("stopButton clicked"); + + //disable the stop button, enable the record too allow for new recordings + stopButton.disabled = true; + recordButton.disabled = false; + pauseButton.disabled = true; + + //reset button just in case the recording is stopped while paused + pauseButton.innerHTML="Pause"; + + //tell the recorder to stop the recording + rec.stop(); + + //stop microphone access + gumStream.getAudioTracks()[0].stop(); + + //create the wav blob and pass it on to createDownloadLink + rec.exportWAV(createDownloadLink); +} + +function createDownloadLink(blob) { + console.log(blob); + var xhr=new XMLHttpRequest(); + xhr.onload=function(e) { + if(this.readyState === 4) { + console.log("Server returned: ",e.target.responseText); + //var r = JSON.parse(e.target.responseText); + document.getElementById("question").value = e.target.responseText; + } + }; + var fd=new FormData(); + fd.append("audio_data",blob, new Date().toISOString()); + xhr.open("POST","asr", true); + xhr.send(fd); +} diff --git a/nlp_demo_riva/client/js/myscript.js b/nlp_demo_riva/client/js/myscript.js new file mode 100755 index 00000000..6ee1f4cd --- /dev/null +++ b/nlp_demo_riva/client/js/myscript.js @@ -0,0 +1,127 @@ +function clicked() { + var xhttp = new XMLHttpRequest(); + xhttp.onreadystatechange = function() { + if (this.readyState == 4 && this.status == 200) { + console.log(this.responseText); + var jsonResponse = JSON.parse(this.responseText)[0]; + // + if (jsonResponse === ''){ + document.getElementById("context").innerHTML = 'Sorry, I do not know the answer. Please fine tune the BERT network'; + } + else{ + document.getElementById("context").innerHTML = 'Answer: '+ jsonResponse; + } + + function extra(){ + if (jsonResponse === ''){ + playTheText('Sorry, I do not know the answer. Please fine tune the BERT network'); + } + else{ + playTheText('The answer is '+jsonResponse); + } + } + + function say_question(){ + playTheText(question_doc, extra); + } + say_question(); + // playTheText('Question', say_question); + } + }; + + xhttp.open("POST", "infer", true); + xhttp.setRequestHeader("Content-Type", "application/json;charset=UTF-8"); + var para_doc = document.getElementById("para").value; + var question_doc = document.getElementById("question").value; + xhttp.send(JSON.stringify({ "para": para_doc, "question": question_doc })); +}; + + +var Sound = (function () { + var df = document.createDocumentFragment(); + return function Sound(src, callback) { + var snd = new Audio(src); + df.appendChild(snd); // keep in fragment until finished playing + snd.addEventListener('ended', function () {df.removeChild(snd); + if (callback != null){ + callback(); + } + }); + snd.play(); + return snd; + } +}()); +// then do it +// var snd = Sound("data:audio/wav;base64," + base64string); +// +function playTheText(inputs, callback){ + var xhttp = new XMLHttpRequest(); + xhttp.onreadystatechange = function() { + if (this.readyState == 4 && this.status == 200) { + console.log(this); + var response = this.response; + // then do it + var snd = Sound("data:audio/wav;base64," + response, callback); + } + }; + + xhttp.open("POST", "tacotron", true); + xhttp.setRequestHeader("Content-Type", "application/json;charset=UTF-8"); + xhttp.send(JSON.stringify({ "text": inputs})); +} + +function playIt() { + var inputs = document.getElementById("question").value; + playTheText(inputs); +}; + +function selected(){ + document.getElementById("question").value = document.getElementById("examples").value; +}; + +function newOption(text){ + opt = document.createElement('option'); + opt.value = text; + opt.innerText = text; + return opt; +}; + +function getText(){ + // read text from URL location + var request = new XMLHttpRequest(); + request.open('GET', 'doc', true); + request.send(null); + request.onreadystatechange = function () { + if (request.readyState === 4 && request.status === 200) { + var type = request.getResponseHeader('Content-Type'); + if (type.indexOf("text") !== 1) { + document.getElementById("para").value = request.responseText; + //return request.responseText; + } + } + } + + var request2 = new XMLHttpRequest(); + request2.open('GET', 'questions', true); + request2.send(null); + request2.onreadystatechange = function () { + if (request2.readyState === 4 && request2.status === 200) { + var type = request2.getResponseHeader('Content-Type'); + if (type.indexOf("text") !== 1) { + var jsonResponse = JSON.parse(this.responseText); + var question; + var selection = document.getElementById("examples"); + for (var id=0; id { + getText(); + //console.log('loaded'); +}); diff --git a/nlp_demo_riva/client/js/recorder.js b/nlp_demo_riva/client/js/recorder.js new file mode 100755 index 00000000..0fcb6b3c --- /dev/null +++ b/nlp_demo_riva/client/js/recorder.js @@ -0,0 +1,357 @@ +(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.Recorder = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o + + + + +Created by FontForge 20190801 at Mon Mar 23 10:45:51 2020 + By Robert Madole +Copyright (c) Font Awesome + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/nlp_demo_riva/client/webfonts/fa-brands-400.ttf b/nlp_demo_riva/client/webfonts/fa-brands-400.ttf new file mode 100644 index 00000000..948a2a6c Binary files /dev/null and b/nlp_demo_riva/client/webfonts/fa-brands-400.ttf differ diff --git a/nlp_demo_riva/client/webfonts/fa-brands-400.woff b/nlp_demo_riva/client/webfonts/fa-brands-400.woff new file mode 100644 index 00000000..2a89d521 Binary files /dev/null and b/nlp_demo_riva/client/webfonts/fa-brands-400.woff differ diff --git a/nlp_demo_riva/client/webfonts/fa-brands-400.woff2 b/nlp_demo_riva/client/webfonts/fa-brands-400.woff2 new file mode 100644 index 00000000..141a90a9 Binary files /dev/null and b/nlp_demo_riva/client/webfonts/fa-brands-400.woff2 differ diff --git a/nlp_demo_riva/client/webfonts/fa-regular-400.eot b/nlp_demo_riva/client/webfonts/fa-regular-400.eot new file mode 100644 index 00000000..38cf2517 Binary files /dev/null and b/nlp_demo_riva/client/webfonts/fa-regular-400.eot differ diff --git a/nlp_demo_riva/client/webfonts/fa-regular-400.svg b/nlp_demo_riva/client/webfonts/fa-regular-400.svg new file mode 100644 index 00000000..48634a9a --- /dev/null +++ b/nlp_demo_riva/client/webfonts/fa-regular-400.svg @@ -0,0 +1,803 @@ + + + + + +Created by FontForge 20190801 at Mon Mar 23 10:45:51 2020 + By Robert Madole +Copyright (c) Font Awesome + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/nlp_demo_riva/client/webfonts/fa-regular-400.ttf b/nlp_demo_riva/client/webfonts/fa-regular-400.ttf new file mode 100644 index 00000000..abe99e20 Binary files /dev/null and b/nlp_demo_riva/client/webfonts/fa-regular-400.ttf differ diff --git a/nlp_demo_riva/client/webfonts/fa-regular-400.woff b/nlp_demo_riva/client/webfonts/fa-regular-400.woff new file mode 100644 index 00000000..24de566a Binary files /dev/null and b/nlp_demo_riva/client/webfonts/fa-regular-400.woff differ diff --git a/nlp_demo_riva/client/webfonts/fa-regular-400.woff2 b/nlp_demo_riva/client/webfonts/fa-regular-400.woff2 new file mode 100644 index 00000000..7e0118e5 Binary files /dev/null and b/nlp_demo_riva/client/webfonts/fa-regular-400.woff2 differ diff --git a/nlp_demo_riva/client/webfonts/fa-solid-900.eot b/nlp_demo_riva/client/webfonts/fa-solid-900.eot new file mode 100644 index 00000000..d3b77c22 Binary files /dev/null and b/nlp_demo_riva/client/webfonts/fa-solid-900.eot differ diff --git a/nlp_demo_riva/client/webfonts/fa-solid-900.svg b/nlp_demo_riva/client/webfonts/fa-solid-900.svg new file mode 100644 index 00000000..7742838b --- /dev/null +++ b/nlp_demo_riva/client/webfonts/fa-solid-900.svg @@ -0,0 +1,4938 @@ + + + + + +Created by FontForge 20190801 at Mon Mar 23 10:45:51 2020 + By Robert Madole +Copyright (c) Font Awesome + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/nlp_demo_riva/client/webfonts/fa-solid-900.ttf b/nlp_demo_riva/client/webfonts/fa-solid-900.ttf new file mode 100644 index 00000000..5b979039 Binary files /dev/null and b/nlp_demo_riva/client/webfonts/fa-solid-900.ttf differ diff --git a/nlp_demo_riva/client/webfonts/fa-solid-900.woff b/nlp_demo_riva/client/webfonts/fa-solid-900.woff new file mode 100644 index 00000000..beec7917 Binary files /dev/null and b/nlp_demo_riva/client/webfonts/fa-solid-900.woff differ diff --git a/nlp_demo_riva/client/webfonts/fa-solid-900.woff2 b/nlp_demo_riva/client/webfonts/fa-solid-900.woff2 new file mode 100644 index 00000000..978a681a Binary files /dev/null and b/nlp_demo_riva/client/webfonts/fa-solid-900.woff2 differ diff --git a/nlp_demo_riva/docker/Dockerfile.riva b/nlp_demo_riva/docker/Dockerfile.riva new file mode 100755 index 00000000..d19ff74d --- /dev/null +++ b/nlp_demo_riva/docker/Dockerfile.riva @@ -0,0 +1,16 @@ +FROM nvcr.io/nvidia/riva/riva-speech-client:1.4.0-beta +# RUN apt-get update +RUN apt-get update && apt-get -y install git python3-dev build-essential locales-all +ENV LC_ALL=en_US.utf8 +RUN mkdir /workspace +WORKDIR /workspace +WORKDIR /home + +#RUN pip install tensorflow==1.13.1 +RUN pip install cherrypy pudb + +RUN mkdir /workspace/server + +RUN pip3 install inflect unidecode +COPY . /workspace/server +WORKDIR /workspace/server diff --git a/nlp_demo_riva/image.png b/nlp_demo_riva/image.png new file mode 100755 index 00000000..a4ef0fd2 Binary files /dev/null and b/nlp_demo_riva/image.png differ diff --git a/nlp_demo_riva/models_infer.py b/nlp_demo_riva/models_infer.py new file mode 100755 index 00000000..5e0718d8 --- /dev/null +++ b/nlp_demo_riva/models_infer.py @@ -0,0 +1,33 @@ +""" + //////////////////////////////////////////////////////////////////////////// + // + // Copyright (C) NVIDIA Corporation. All rights reserved. + // + // NVIDIA Sample Code + // + // Please refer to the NVIDIA end user license agreement (EULA) associated + // with this source code for terms and conditions that govern your use of + // this software. Any use, reproduction, disclosure, or distribution of + // this software and related documentation outside the terms of the EULA + // is strictly prohibited. + // + //////////////////////////////////////////////////////////////////////////// +""" +from asr_infer import asr_text +from tts_infer import get_wave +from qa_infer import get_answer + + +class Model(object): + + def __init__(self): + pass + + def qa_infer(self, paragraph_text, question): + return get_answer(paragraph_text, question) + + def asr_infer(self, wav_file): + return asr_text(wav_file) + + def tacotron_infer(self, text): + return get_wave(text) diff --git a/nlp_demo_riva/privkey.pem b/nlp_demo_riva/privkey.pem new file mode 100755 index 00000000..a97ca26c --- /dev/null +++ b/nlp_demo_riva/privkey.pem @@ -0,0 +1,27 @@ +-----BEGIN RSA PRIVATE KEY----- +MIIEowIBAAKCAQEAxUlwbpoVYqH24XV+pniyHZUyWiCBpp+IhATA0dt5VobmKPgM +gwGXDZx0iZd+fKf6SO8uo+N5iSuCbmnyNePQyxgtH8XAAJhQWLSXFdIDh1i+O/GC +Ocf433j46QJl823lQzmChzuuNMuWLZ4rTk4gtIB7n2DSycyxtphbMFJD2pWX35d/ +0nRSJE0+fcl9EAvWn4+m4fzB4tb/sSKlx79u7CPFeUSOp73Wklh63cWc+yQaBgk3 +gYCdvWrROQ+//Kmg6ka0RtNqdPgASZSJa3uvbt7Yvn+hmgpdBxBb2XodFoBiw5P+ +HsFy0G6Nat8tg0oVhDcP6Wqextv8i0OuCc2siwIDAQABAoIBACXqNjxbSm7ZN6we +u4dcvMZorPObOa9/C2pry27JYilZ5ZPMEAOBY7lO7yqePcXRNo2bwffnOK0++mMj +41OuA6t0av+nLn4ux4o0srCT2u/BA1Zb1K4sG00/X37QYi2FWkEwJUC+HH2y/pqn +wiTbaPenlZqMrhXwS9sOrr+7n6S7MsJc+aa4k0/2LOjnA6MG7Z/MXeXtzF4ccsdY +t/n0WmwISTNxmPNG2pHUytZ5GiJ5/hXEp9DJLt8e5WfrH46mPlX2kCyOANvEXYxS +zte9y2uwxRgXIlJwyE8Uf6oDlTwigSzfK3OWkwuKCLWBUFJKWhLosGXSPx4uLdod +kyocFdkCgYEA4NRqkL7oK90kn7mqT6pYAJpuAxsmifUxtqwxIUNZzZo/ZUwLSy2A +cVIfokZnyZiMq19W/vF74tdbo8GDvryjeWKpGmvbe911CwzVnTrSvthpnrBFQqBu +xz3HnnTl2a166HDpCN9eUYR/YOJd4sUvXHcHYQ8k3EOSQfLw0HAdpRcCgYEA4KN6 +5v4zd/SQ7vLfPhqg+yPX7Nx9WWgCUUFccZSW+Q6ud7gXfrA1RLdSgOwA0veDmnpU +sPt6xHILwJELb67slc/VkyANJLkvt/EbdhuhYBqhhT4XCW78TI5ieiVHyyuP8wdQ +ZrWpMxl24ehCFUYwv5IZhZ9BIHgVJWZQcPJNRK0CgYAy27ozfgv1CDRlsVE2bjk0 +AbsLFtQz9vRE91SxypOA7/iRSI9xdRyOBd7EDZsivlBr38hFKYk1ujOvqnHL7s4o +AkpwgJ+IuILmegPEam8L3tadoBA6zyHgDjievqDUCes4s3nzmNu0Iv3Rg8NrLeHV +z9MqgIt9DAgExRj2fbYnBwKBgC38SWSQFSkxP5oqzdiAywOeSs2KNX7f89l+b9Yw +fNdvUffgD683kzAF9zW9Gk4VrTMqZ7vzPyaH0jARgS3TuUrRyP7dSNODtWkKSnzb +GyX5TadhFoYv2iYx36bxisjkmgs+LA9akNCNHfERArYoMEKHPgJEn6ht7KZDU6RL +ddXhAoGBALsOsKl/cd+n3eSLuhpHKxX8FOXzcyZ6l+DgUAaJP+QZeLQD3Umooc8R +PgIev9+UFNpQTxpizEDTUpzklSXTB9X6UcnBlqGVR5/BOqKH2qmU4kuPDYT2FkRu +aIwlE0BGLuZohmkMo4br/jUMzJcA4oIb1NGrdBNXC8BjJljV3xtN +-----END RSA PRIVATE KEY----- diff --git a/nlp_demo_riva/qa_infer.py b/nlp_demo_riva/qa_infer.py new file mode 100644 index 00000000..de4fcc53 --- /dev/null +++ b/nlp_demo_riva/qa_infer.py @@ -0,0 +1,39 @@ +""" + //////////////////////////////////////////////////////////////////////////// + // + // Copyright (C) NVIDIA Corporation. All rights reserved. + // + // NVIDIA Sample Code + // + // Please refer to the NVIDIA end user license agreement (EULA) associated + // with this source code for terms and conditions that govern your use of + // this software. Any use, reproduction, disclosure, or distribution of + // this software and related documentation outside the terms of the EULA + // is strictly prohibited. + // + //////////////////////////////////////////////////////////////////////////// +""" +# NLP proto +import riva_api.riva_nlp_pb2 as rnlp +import riva_api.riva_nlp_pb2_grpc as rnlp_srv +import grpc + +channel = grpc.insecure_channel('riva:50051') +riva_nlp = rnlp_srv.RivaLanguageUnderstandingStub(channel) + + +def get_answer(paragraph_text, question_text): + + total = len(paragraph_text) + stride = 1024 + final_answer = '' + final_score = 0 + for i in range(0, total, stride): + req = rnlp.NaturalQueryRequest() + req.query = question_text + req.context = paragraph_text[i:] + resp = riva_nlp.NaturalQuery(req) + if resp.results[0].score > final_score and resp.results[0].answer: + final_answer = resp.results[0].answer + final_score = resp.results[0].score + return final_answer diff --git a/nlp_demo_riva/riva/asr_lm_tools/config_LM_tuning.sh b/nlp_demo_riva/riva/asr_lm_tools/config_LM_tuning.sh new file mode 100644 index 00000000..929ec5db --- /dev/null +++ b/nlp_demo_riva/riva/asr_lm_tools/config_LM_tuning.sh @@ -0,0 +1,34 @@ +# Copyright (c) 2021, NVIDIA CORPORATION. All rights reserved. +# +# NVIDIA CORPORATION and its licensors retain all intellectual property +# and proprietary rights in and to this software, related documentation +# and any modifications thereto. Any use, reproduction, disclosure or +# distribution of this software and related documentation without an express +# license agreement from NVIDIA CORPORATION is strictly prohibited. + +# Absolute path to directory which contains the audio files to use for tuning +# This folder will be mounted inside Docker container +audio_file_dir="/home/user1/wav/test/" + +# Absolute path to the ASR manifest json file containing the path to the audio files +# an the corresponding transcripts +# Each line of the .json file must look like: +#{"audio_filepath": "/home/user1/wav/test/1272-135031-0000.wav","text": "because you were sleeping instead of conquering the lovely rose princess has become a fiddle without a bow while poor shaggy sits there a cooing dove"} +# And example file is provided in the riva-api-client image under /work/wav/test/transcripts.json +audio_file_manifest="/home/user1/wav/test/transcripts.json" + +# Range of beam width values to consider +beam_width_start=128 +beam_width_end=512 +beam_width_incrementer=128 + +# Range of alpha values to consider +alpha_start=0. +alpha_end=3. +alpha_incrementer=0.5 + +# Range of beta values to consider +beta_start=-2.5 +beta_end=1.0 +beta_incrementer=0.5 + diff --git a/nlp_demo_riva/riva/asr_lm_tools/config_LM_tuning_flashlight_decoder.sh b/nlp_demo_riva/riva/asr_lm_tools/config_LM_tuning_flashlight_decoder.sh new file mode 100644 index 00000000..71293762 --- /dev/null +++ b/nlp_demo_riva/riva/asr_lm_tools/config_LM_tuning_flashlight_decoder.sh @@ -0,0 +1,44 @@ +# Copyright (c) 2021, NVIDIA CORPORATION. All rights reserved. +# +# NVIDIA CORPORATION and its licensors retain all intellectual property +# and proprietary rights in and to this software, related documentation +# and any modifications thereto. Any use, reproduction, disclosure or +# distribution of this software and related documentation without an express +# license agreement from NVIDIA CORPORATION is strictly prohibited. + +# Absolute path to directory which contains the audio files to use for tuning +# This folder will be mounted inside Docker container +audio_file_dir="/home/user1/wav/test/" + +# Absolute path to the ASR manifest json file containing the path to the audio files +# an the corresponding transcripts +# Each line of the .json file must look like: +#{"audio_filepath": "/home/user1/wav/test/1272-135031-0000.wav","text": "because you were sleeping instead of conquering the lovely rose princess has become a fiddle without a bow while poor shaggy sits there a cooing dove"} +# And example file is provided in the riva-api-client image under /work/wav/test/transcripts.json +audio_file_manifest="/home/user1/wav/test/transcripts.json" + +# Range of lm_weight values to consider +lm_weight_start=0. +lm_weight_end=1.0 +lm_weight_incrementer=0.1 + +# Range of word_insertion_score values to consider +word_insertion_score_start=-1.0 +word_insertion_score_end=1.0 +word_insertion_score_incrementer=0.25 + +# Range of beam_size values to consider +beam_size_start=16 +beam_size_end=64 +beam_size_incrementer=16 + +# Range of beam_size_token values to consider +beam_size_token_start=16 +beam_size_token_end=64 +beam_size_token_incrementer=16 + +# Range of beam_threshold values to consider +beam_threshold_start=10. +beam_threshold_end=30. +beam_threshold_incrementer=10. + diff --git a/nlp_demo_riva/riva/asr_lm_tools/config_LM_tuning_gpu_decoder.sh b/nlp_demo_riva/riva/asr_lm_tools/config_LM_tuning_gpu_decoder.sh new file mode 100644 index 00000000..61c91c21 --- /dev/null +++ b/nlp_demo_riva/riva/asr_lm_tools/config_LM_tuning_gpu_decoder.sh @@ -0,0 +1,40 @@ +# Copyright (c) 2021, NVIDIA CORPORATION. All rights reserved. +# +# NVIDIA CORPORATION and its licensors retain all intellectual property +# and proprietary rights in and to this software, related documentation +# and any modifications thereto. Any use, reproduction, disclosure or +# distribution of this software and related documentation without an express +# license agreement from NVIDIA CORPORATION is strictly prohibited. + +# Absolute path to directory which contains the audio files to use for tuning +# This folder will be mounted inside Docker container +audio_file_dir="/tuning_data/" + +# Absolute path to the ASR manifest json file containing the path to the audio files +# an the corresponding transcripts +# Each line of the .json file must look like: +#{"audio_filepath": "/home/user1/wav/test/1272-135031-0000.wav","text": "because you were sleeping instead of conquering the lovely rose princess has become a fiddle without a bow while poor shaggy sits there a cooing dove"} +# And example file is provided in the riva-api-client image under /work/wav/test/transcripts.json +# And example file is provided in the riva-api-client image under /work/wav/test/ +audio_file_manifest="/tuning_data/transcripts.json" + +# Range acoustic_scale values to consider +acoustic_scale_start=1.0 +acoustic_scale_end=3.0 +acoustic_scale_incrementer=0.25 + +# Range of word_insertion values to consider +word_insertion_start=4. +word_insertion_end=8. +word_insertion_incrementer=0.5 + +# Range of default_beam values to consider +default_beam_start=13 +default_beam_end=16 +default_beam_incrementer=1 + +# Range of lattice_beam values to consider +lattice_beam_start=3 +lattice_beam_end=7 +lattice_beam_incrementer=1 + diff --git a/nlp_demo_riva/riva/asr_lm_tools/modify_config_param.sh b/nlp_demo_riva/riva/asr_lm_tools/modify_config_param.sh new file mode 100644 index 00000000..3a1b1579 --- /dev/null +++ b/nlp_demo_riva/riva/asr_lm_tools/modify_config_param.sh @@ -0,0 +1,21 @@ +#!/bin/bash +# Copyright (c) 2021, NVIDIA CORPORATION. All rights reserved. +# +# NVIDIA CORPORATION and its licensors retain all intellectual property +# and proprietary rights in and to this software, related documentation +# and any modifications thereto. Any use, reproduction, disclosure or +# distribution of this software and related documentation without an express +# license agreement from NVIDIA CORPORATION is strictly prohibited. + +if [ $# -ne 3 ] +then + echo "Usage: modify_config_param.sh " +fi + +triton_config_file=$1 +name=$2 +value=$3 + +line_number=`grep \"$name\" -A 2 -n $triton_config_file | tail -n 1 | cut -d "-" -f 1` +cmd="sed -i '${line_number}s/.*/string_value:\"${value}\"/' ${triton_config_file}" +eval $cmd diff --git a/nlp_demo_riva/riva/asr_lm_tools/tune_LM.sh b/nlp_demo_riva/riva/asr_lm_tools/tune_LM.sh new file mode 100644 index 00000000..bfaa85d2 --- /dev/null +++ b/nlp_demo_riva/riva/asr_lm_tools/tune_LM.sh @@ -0,0 +1,237 @@ +#!/bin/bash +# Copyright (c) 2021, NVIDIA CORPORATION. All rights reserved. +# +# NVIDIA CORPORATION and its licensors retain all intellectual property +# and proprietary rights in and to this software, related documentation +# and any modifications thereto. Any use, reproduction, disclosure or +# distribution of this software and related documentation without an express +# license agreement from NVIDIA CORPORATION is strictly prohibited. + +# This script can be used to find optimal language model hyper-parameters (alpha, beta, beam_width for CPU decoder, and default_beam, lattice_beam, word_insertion_penalty and acoustic_scale for GPU decoder) +# It uses offline recognition without punctuation + +script_path="$( cd "$(dirname "$0")" >/dev/null 2>&1 ; pwd -P )" + +if [ "$#" -lt 3 ]; then + echo "Usage: $0 is absolute path to Riva config file (config.sh)" + echo " is absolute path to language model tuning config file (see config_LM_tuning.sh or config_LM_tuning_gpu_decoder.sh)" + echo " is the type of decoder being used. Can be cpu or gpu" + exit 1 +fi + +riva_config_file=${1} +lm_tuning_config_file=${2} +decoder_type=${3} + +# Creating new config file with only ASR service enabled +new_riva_config_file=$(mktemp /tmp/riva_config.XXXXXX) +echo "New config file: $new_riva_config_file" +cp $riva_config_file $new_riva_config_file + +#Disable all services except ASR +echo "service_enabled_asr=true" >> $new_riva_config_file +echo "service_enabled_nlp=false" >> $new_riva_config_file +echo "service_enabled_tts=false" >> $new_riva_config_file + +source $new_riva_config_file +source $lm_tuning_config_file + +if [ ! -d "$audio_file_dir" ]; then + echo "audio_file_dir $audio_file_dir does not exist. Please update ${lm_tuning_config_file}" + exit 1 +fi + +if [ ! -f "$audio_file_manifest" ]; then + echo "audio_file_manifest $audio_file_manifest does not exist. Please update ${lm_tuning_config_file}" + exit 1 +fi + +sed_path=$(echo "${audio_file_dir}" | sed 's/\//\\\//g') +update_manifest_cmd="sed 's/$sed_path/\/wav\//g' /wav/manifest.json > /wav/manifest.tmp.json" +mnt_args="-v ${audio_file_dir}:/wav/ -v $audio_file_manifest:/wav/manifest.json" + +#Launch Riva +riva_start_cmd="$script_path/../riva_start.sh ${new_riva_config_file}" + +client_cmd="$update_manifest_cmd; /usr/local/bin/riva_asr_client --word_time_offsets=false --riva_uri=localhost:50051 --automatic_punctuation=false --audio_file=/wav/manifest.tmp.json --output_filename=/wav/output.json; python3 /work/utils/calc_wer.py -test /wav/output.json -ref /wav/manifest.tmp.json" +riva_cmd="docker run --init --rm $mnt_args --net host --name ${riva_daemon_client} $image_client /bin/bash -c \"$client_cmd\"" + +echo "Riva command:" +echo $riva_cmd + +now=`date +%Y-%m-%d_%H:%M:%S` +tuning_results_filename="riva_lm_tuning_${now}.csv" + +# --------------- +# Start tuning +# --------------- + +#Start tuning LM model for CPU decoder +if [[ $decoder_type == "cpu" ]]; then + + triton_config_file=/data/models/ctc-decoder-cpu-streaming-offline/config.pbtxt + + if [[ ! -v beam_width_start || ! -v beam_width_end || ! -v beam_width_incrementer || \ + ! -v alpha_start || ! -v alpha_end || ! -v alpha_incrementer || \ + ! -v beta_start || ! -v beta_end || ! -v beta_incrementer ]]; then + echo "Make sure the following variables are defined in LM_tuning config file $lm_tuning_config_file:" + echo "" + echo "beam_width_start (current_value = $beam_width_start)" + echo "beam_width_end (current_value = $beam_width_end)" + echo "beam_width_incrementer (current_value = $beam_width_incrementer)" + echo "" + echo "alpha_start (current_value = $alpha_start)" + echo "alpha_end (current_value = $alpha_end)" + echo "alpha_incrementer (current_value = $alpha_incrementer)" + echo "" + echo "beta_start (current_value = $beta_start)" + echo "beta_end (current_value = $beta_end)" + echo "beta_incrementer (current_value = $beta_incrementer)" + echo "" + exit 1 + fi + + beam_width_arr=$(awk "BEGIN{for(i=$beam_width_start;i<=$beam_width_end;i+=$beam_width_incrementer)print i}") + alpha_arr=$(awk "BEGIN{for(i=$alpha_start;i<=$alpha_end;i+=$alpha_incrementer)print i}") + beta_arr=$(awk "BEGIN{for(i=$beta_start;i<=$beta_end;i+=$beta_incrementer)print i}") + + echo "beam, alpha, beta, wer" >> $tuning_results_filename + best_wer=100. + for beam_width in $beam_width_arr + do + for alpha in $alpha_arr + do + for beta in $beta_arr + do + echo "Terminating Triton and Riva server" + docker kill $riva_daemon_speech &> /dev/null + + # Modify the Triton config file + docker run --init --rm -v $script_path:/tmp/ -v $riva_model_loc:/data/ ubuntu:18.04 /bin/bash -c "/tmp/modify_config_param.sh ${triton_config_file} beam_search_width ${beam_width}; /tmp/modify_config_param.sh ${triton_config_file} language_model_alpha ${alpha}; /tmp/modify_config_param.sh ${triton_config_file} language_model_beta $beta" + + echo "Launching Triton and Riva server" + eval $riva_start_cmd + + echo "Running ASR with beam_width $beam_width, alpha $alpha, beta $beta" + echo "riva_cmd: $riva_cmd" + docker kill riva-asr-client &> /dev/null; eval $riva_cmd &> output_tmp + wer_string=$(cat output_tmp | grep -i "Total files" | tr -d $'\r') + wer=$(echo $wer_string | cut -d ":" -f 3) + echo "WER: $wer" + if [ $? -ne 0 ]; then + echo "Run failed." + else + if (( $(echo "$wer < $best_wer" |bc -l) )); then + echo "Updating best result" + best_wer=$wer + best_alpha=$alpha + best_beta=$beta + best_beam_width=$beam_width + fi + fi + echo "$beam_width, $alpha, $beta, $wer" >> $tuning_results_filename + done + done + done + + echo "Best values:" + echo "Alpha: $best_alpha" + echo "Beta: $best_beta" + echo "Beam wdith: $best_beam_width" + +#Start tuning LM model for GPU decoder +elif [[ $decoder_type == "gpu" ]]; then + + triton_decoder_config_file=/data/models/ctc-decoder-gpu-streaming-offline/config.pbtxt + triton_lattice_config_file=/data/models/lattice-post-processor/config.pbtxt + + if [[ ! -v acoustic_scale_start || ! -v acoustic_scale_end || ! -v acoustic_scale_incrementer || \ + ! -v word_insertion_start || ! -v word_insertion_end || ! -v word_insertion_incrementer || \ + ! -v default_beam_start || ! -v default_beam_end || ! -v default_beam_incrementer || \ + ! -v lattice_beam_start || ! -v lattice_beam_end || ! -v lattice_beam_incrementer ]]; then + echo "Make sure the following variables are defined in LM_tuning config file $lm_tuning_config_file:" + echo "" + echo "acoustic_scale_start (current_value = $acoustic_scale_start)" + echo "acoustic_scale_end (current_value = $acoustic_scale_end)" + echo "acoustic_scale_incrementer (current_value = $acoustic_scale_incrementer)" + echo "" + echo "word_insertion_start (current_value = $word_insertion_start)" + echo "word_insertion_end (current_value = $word_insertion_end)" + echo "word_insertion_incrementer (current_value = $word_insertion_incrementer)" + echo "" + echo "default_beam_start (current_value = $default_beam_start)" + echo "default_beam_end (current_value = $default_beam_end)" + echo "default_beam_incrementer (current_value = $default_beam_incrementer)" + echo "" + echo "lattice_beam_start (current_value = $lattice_beam_start)" + echo "lattice_beam_end (current_value = $lattice_beam_end)" + echo "lattice_beam_incrementer (current_value = $lattice_beam_incrementer)" + echo "" + exit 1 + fi + + acoustic_scale_arr=$(awk "BEGIN{for(i=$acoustic_scale_start;i<=$acoustic_scale_end;i+=$acoustic_scale_incrementer)print i}") + word_insertion_arr=$(awk "BEGIN{for(i=$word_insertion_start;i<=$word_insertion_end;i+=$word_insertion_incrementer)print i}") + default_beam_arr=$(awk "BEGIN{for(i=$default_beam_start;i<=$default_beam_end;i+=$default_beam_incrementer)print i}") + lattice_beam_arr=$(awk "BEGIN{for(i=$lattice_beam_start;i<=$lattice_beam_end;i+=$lattice_beam_incrementer)print i}") + + echo "default_beam, lattice_beam, word_insertion, acoustic_scale, wer" >> $tuning_results_filename + best_wer=100. + for default_beam in $default_beam_arr + do + for lattice_beam in $lattice_beam_arr + do + for word_insertion in $word_insertion_arr + do + for acoustic_scale in $acoustic_scale_arr + do + echo "Terminating Triton and Riva server" + docker kill $riva_daemon_speech &> /dev/null + + # Modify the Triton config file + docker run --init --rm -v $script_path:/tmp/ -v $riva_model_loc:/data/ ubuntu:18.04 /bin/bash -c "/tmp/modify_config_param.sh ${triton_decoder_config_file} default_beam ${default_beam}; /tmp/modify_config_param.sh ${triton_decoder_config_file} lattice_beam ${lattice_beam}; /tmp/modify_config_param.sh ${triton_lattice_config_file} lattice_beam ${lattice_beam}; /tmp/modify_config_param.sh ${triton_lattice_config_file} word_insertion_penalty ${word_insertion}; /tmp/modify_config_param.sh ${triton_decoder_config_file} acoustic_scale ${acoustic_scale}; " + + echo "Launching Triton and Riva server" + eval $riva_start_cmd + + echo "Running ASR with default_beam $default_beam, lattice_beam $lattice_beam, word_insertion $word_insertion, acoustic_scale $acoustic_scale" + echo "riva_cmd: $riva_cmd" + docker kill riva-asr-client &> /dev/null; eval $riva_cmd &> output_tmp + wer_string=$(cat output_tmp | grep -i "Total files" | tr -d $'\r') + wer=$(echo $wer_string | cut -d ":" -f 3) + echo "WER: $wer" + if [ $? -ne 0 ]; then + echo "Run failed." + else + if (( $(echo "$wer < $best_wer" |bc -l) )); then + echo "Updating best result" + best_wer=$wer + best_default_beam=$default_beam + best_lattice_beam=$lattice_beam + best_word_insertion=$word_insertion + best_acoustic_scale=$acoustic_scale + fi + fi + echo "$default_beam, $lattice_beam, $word_insertion, $acoustic_scale, $wer" >> $tuning_results_filename + done + done + done + done + + echo "Best values:" + echo "Default beam: $best_default_beam" + echo "Lattice beam: $best_lattice_beam" + echo "Word insertion: $best_word_insertion" + echo "Acoustic scale: $best_acoustic_scale" +else + echo "Invalid value for decoder_type. Must be cpu or gpu" +fi + +echo "WER: $best_wer" + +#Cleaning up +rm $new_riva_config_file + + diff --git a/nlp_demo_riva/riva/asr_lm_tools/tune_LM_flashlight.sh b/nlp_demo_riva/riva/asr_lm_tools/tune_LM_flashlight.sh new file mode 100644 index 00000000..b8ae6fd5 --- /dev/null +++ b/nlp_demo_riva/riva/asr_lm_tools/tune_LM_flashlight.sh @@ -0,0 +1,138 @@ +#!/bin/bash +# Copyright (c) 2021, NVIDIA CORPORATION. All rights reserved. +# +# NVIDIA CORPORATION and its licensors retain all intellectual property +# and proprietary rights in and to this software, related documentation +# and any modifications thereto. Any use, reproduction, disclosure or +# distribution of this software and related documentation without an express +# license agreement from NVIDIA CORPORATION is strictly prohibited. + +# This script can be used to find optimal language model hyper-parameters for flashlight decoder used with Citrinet) +# It uses offline recognition without punctuation + +script_path="$( cd "$(dirname "$0")" >/dev/null 2>&1 ; pwd -P )" + +if [ "$#" -lt 2 ]; then + echo "Usage: $0 " + echo " " + echo " where is absolute path to Riva config file (config.sh)" + echo " is absolute path to language model tuning config file (see config_LM_tuning_flashlight_decoder.sh)" + exit 1 +fi + +riva_config_file=${1} +lm_tuning_config_file=${2} + +# Creating new config file with only ASR service enabled +new_riva_config_file=$(mktemp /tmp/riva_config.XXXXXX) +echo "New config file: $new_riva_config_file" +cp $riva_config_file $new_riva_config_file + +#Disable all services except ASR +echo "service_enabled_asr=true" >> $new_riva_config_file +echo "service_enabled_nlp=false" >> $new_riva_config_file +echo "service_enabled_tts=false" >> $new_riva_config_file + +source $new_riva_config_file +source $lm_tuning_config_file + +if [ ! -d "$audio_file_dir" ]; then + echo "audio_file_dir $audio_file_dir does not exist. Please update ${lm_tuning_config_file}" + exit 1 +fi + +if [ ! -f "$audio_file_manifest" ]; then + echo "audio_file_manifest $audio_file_manifest does not exist. Please update ${lm_tuning_config_file}" + exit 1 +fi + +sed_path=$(echo "${audio_file_dir}" | sed 's/\//\\\//g') +update_manifest_cmd="sed 's/$sed_path/\/wav\//g' /wav/manifest.json > /wav/manifest.tmp.json" +mnt_args="-v ${audio_file_dir}:/wav/ -v $audio_file_manifest:/wav/manifest.json" + +#Launch Riva +riva_start_cmd="bash $script_path/../riva_start.sh ${new_riva_config_file}" + +client_cmd="$update_manifest_cmd; /usr/local/bin/riva_streaming_asr_client --num_parallel_requests=128 --chunk_duration_ms=1600 --model_name=citrinet-1024-asr-trt-ensemble-vad-streaming-offline --interim_results=false --word_time_offsets=false --riva_uri=localhost:50051 --automatic_punctuation=false --audio_file=/wav/manifest.tmp.json --output_filename=/wav/output.json; python3 /work/utils/calc_wer.py -test /wav/output.json -ref /wav/manifest.tmp.json" + +riva_cmd="docker run --init --rm $mnt_args --net host --name ${riva_daemon_client} $image_client /bin/bash -c \"$client_cmd\"" +echo "Riva command:" +echo $riva_cmd + +now=`date +%Y-%m-%d_%H:%M:%S` +tuning_results_filename="riva_lm_tuning_${now}.csv" + +# --------------- +# Start tuning +# --------------- + +#Use offline model to tune, faster +triton_config_file=/data/models/citrinet-1024-asr-trt-ensemble-vad-streaming-offline-ctc-decoder-cpu-streaming-offline/config.pbtxt + +lm_weight_arr=$(awk "BEGIN{for(i=$lm_weight_start;i<=$lm_weight_end;i+=$lm_weight_incrementer)print i}") +word_insertion_score_arr=$(awk "BEGIN{for(i=$word_insertion_score_start;i<=$word_insertion_score_end;i+=$word_insertion_score_incrementer)print i}") +beam_size_arr=$(awk "BEGIN{for(i=$beam_size_start;i<=$beam_size_end;i+=$beam_size_incrementer)print i}") +beam_size_token_arr=$(awk "BEGIN{for(i=$beam_size_token_start;i<=$beam_size_token_end;i+=$beam_size_token_incrementer)print i}") +beam_threshold_arr=$(awk "BEGIN{for(i=$beam_threshold_start;i<=$beam_threshold_end;i+=$beam_threshold_incrementer)print i}") + +echo "lm_weight, word_insertion_score, beam_size, beam_size_token, beam_threshold, wer" >> $tuning_results_filename +best_wer=100. + +for beam_size in $beam_size_arr +do +for beam_size_token in $beam_size_token_arr +do +for beam_threshold in $beam_threshold_arr +do +for lm_weight in $lm_weight_arr +do +for word_insertion_score in $word_insertion_score_arr +do + echo "Terminating Triton and Riva server" + docker kill $riva_daemon_speech &> /dev/null + + # Modify the Triton config file + docker run --init --rm -v $script_path:/tmp/ -v $riva_model_loc:/data/ ubuntu:18.04 /bin/bash -c "bash /tmp/modify_config_param.sh ${triton_config_file} lm_weight ${lm_weight}; bash /tmp/modify_config_param.sh ${triton_config_file} word_insertion_score $word_insertion_score; bash /tmp/modify_config_param.sh ${triton_config_file} beam_size $beam_size; bash /tmp/modify_config_param.sh ${triton_config_file} beam_size_token $beam_size_token; bash /tmp/modify_config_param.sh ${triton_config_file} beam_threshold $beam_threshold;" + + echo "Launching Triton and Riva server" + eval $riva_start_cmd + + echo "Running ASR with lm_weight $lm_weight, word_insertion_score $word_insertion_score, beam_size $beam_size, beam_size_token $beam_size_token, beam_threshold $beam_threshold" + echo "riva_cmd: $riva_cmd" + docker kill ${riva_daemon_client} &> /dev/null; eval $riva_cmd &> output_tmp + wer_string=$(cat output_tmp | grep -i "Total files" | tr -d $'\r') + wer=$(echo $wer_string | cut -d ":" -f 3) + echo "WER: $wer" + if [ $? -ne 0 ]; then + echo "Run failed." + else + if (( $(echo "$wer < $best_wer" |bc -l) )); then + echo "Updating best result" + best_wer=$wer + best_lm_weight=$lm_weight + best_word_insertion_score=$word_insertion_score + best_beam_size=$beam_size + best_beam_size_token=$beam_size_token + best_beam_threshold=$beam_threshold + fi + fi + echo "$lm_weight, $word_insertion_score, $beam_size, $beam_size_token, $beam_threshold, $wer" >> $tuning_results_filename +done +done +done +done +done + +echo "Best values:" +echo "lm_weight: $best_lm_weight" +echo "word_insertion_score: $best_word_insertion_score" +echo "beam_size: $best_beam_size" +echo "beam_size_token: $best_beam_size_token" +echo "beam_threshold: $best_beam_threshold" + +echo "WER: $best_wer" + +#Cleaning up +rm $new_riva_config_file + + diff --git a/nlp_demo_riva/riva/config.sh b/nlp_demo_riva/riva/config.sh new file mode 100644 index 00000000..b6d444b4 --- /dev/null +++ b/nlp_demo_riva/riva/config.sh @@ -0,0 +1,153 @@ +# Copyright (c) 2021, NVIDIA CORPORATION. All rights reserved. +# +# NVIDIA CORPORATION and its licensors retain all intellectual property +# and proprietary rights in and to this software, related documentation +# and any modifications thereto. Any use, reproduction, disclosure or +# distribution of this software and related documentation without an express +# license agreement from NVIDIA CORPORATION is strictly prohibited. + +# Enable or Disable Riva Services +service_enabled_asr=true +service_enabled_nlp=true +service_enabled_tts=true + +# Specify one or more GPUs to use +# specifying more than one GPU is currently an experimental feature, and may result in undefined behaviours. +gpus_to_use="device=0" + +# Specify the encryption key to use to deploy models +MODEL_DEPLOY_KEY="tlt_encode" + +# Locations to use for storing models artifacts +# +# If an absolute path is specified, the data will be written to that location +# Otherwise, a docker volume will be used (default). +# +# riva_init.sh will create a `rmir` and `models` directory in the volume or +# path specified. +# +# RMIR ($riva_model_loc/rmir) +# Riva uses an intermediate representation (RMIR) for models +# that are ready to deploy but not yet fully optimized for deployment. Pretrained +# versions can be obtained from NGC (by specifying NGC models below) and will be +# downloaded to $riva_model_loc/rmir by `riva_init.sh` +# +# Custom models produced by NeMo or TLT and prepared using riva-build +# may also be copied manually to this location $(riva_model_loc/rmir). +# +# Models ($riva_model_loc/models) +# During the riva_init process, the RMIR files in $riva_model_loc/rmir +# are inspected and optimized for deployment. The optimized versions are +# stored in $riva_model_loc/models. The riva server exclusively uses these +# optimized versions. +riva_model_loc="riva-model-repo" + +# The default RMIRs are downloaded from NGC by default in the above $riva_rmir_loc directory +# If you'd like to skip the download from NGC and use the existing RMIRs in the $riva_rmir_loc +# then set the below $use_existing_rmirs flag to true. You can also deploy your set of custom +# RMIRs by keeping them in the riva_rmir_loc dir and use this quickstart script with the +# below flag to deploy them all together. +use_existing_rmirs=false + +# Ports to expose for Riva services +riva_speech_api_port="50051" +riva_vision_api_port="60051" + +# NGC orgs +riva_ngc_org="nvidia" +riva_ngc_team="riva" +riva_ngc_image_version="1.4.0-beta" +riva_ngc_model_version="1.4.0-beta" + +# Pre-built models listed below will be downloaded from NGC. If models already exist in $riva-rmir +# then models can be commented out to skip download from NGC + +########## ASR MODELS ########## + +models_asr=( +### Punctuation model + "${riva_ngc_org}/${riva_ngc_team}/rmir_nlp_punctuation_bert_base:${riva_ngc_model_version}" + +### Citrinet-1024 Streaming w/ CPU decoder, best latency configuration + "${riva_ngc_org}/${riva_ngc_team}/rmir_asr_citrinet_1024_asrset1p7_streaming:${riva_ngc_model_version}" + +### Citrinet-1024 Streaming w/ CPU decoder, best throughput configuration +# "${riva_ngc_org}/${riva_ngc_team}/rmir_asr_citrinet_1024_asrset1p7_streaming_throughput:${riva_ngc_model_version}" + +### Citrinet-1024 Offline w/ CPU decoder, + "${riva_ngc_org}/${riva_ngc_team}/rmir_asr_citrinet_1024_asrset1p7_offline:${riva_ngc_model_version}" + +### Jasper Streaming w/ CPU decoder, best latency configuration +# "${riva_ngc_org}/${riva_ngc_team}/rmir_asr_jasper_english_streaming:${riva_ngc_model_version}" + +### Jasper Streaming w/ CPU decoder, best throughput configuration +# "${riva_ngc_org}/${riva_ngc_team}/rmir_asr_jasper_english_streaming_throughput:${riva_ngc_model_version}" + +### Jasper Offline w/ CPU decoder +# "${riva_ngc_org}/${riva_ngc_team}/rmir_asr_jasper_english_offline:${riva_ngc_model_version}" + +### Quarztnet Streaming w/ CPU decoder, best latency configuration +# "${riva_ngc_org}/${riva_ngc_team}/rmir_asr_quartznet_english_streaming:${riva_ngc_model_version}" + +### Quarztnet Streaming w/ CPU decoder, best throughput configuration +# "${riva_ngc_org}/${riva_ngc_team}/rmir_asr_quartznet_english_streaming_throughput:${riva_ngc_model_version}" + +### Quarztnet Offline w/ CPU decoder +# "${riva_ngc_org}/${riva_ngc_team}/rmir_asr_quartznet_english_offline:${riva_ngc_model_version}" + +### Jasper Streaming w/ GPU decoder, best latency configuration +# "${riva_ngc_org}/${riva_ngc_team}/rmir_asr_jasper_english_streaming_gpu_decoder:${riva_ngc_model_version}" + +### Jasper Streaming w/ GPU decoder, best throughput configuration +# "${riva_ngc_org}/${riva_ngc_team}/rmir_asr_jasper_english_streaming_throughput_gpu_decoder:${riva_ngc_model_version}" + +### Jasper Offline w/ GPU decoder +# "${riva_ngc_org}/${riva_ngc_team}/rmir_asr_jasper_english_offline_gpu_decoder:${riva_ngc_model_version}" +) + +########## NLP MODELS ########## + +models_nlp=( +### Bert base Punctuation model + "${riva_ngc_org}/${riva_ngc_team}/rmir_nlp_punctuation_bert_base:${riva_ngc_model_version}" + +### BERT base Named Entity Recognition model fine-tuned on GMB dataset with class labels LOC, PER, ORG etc. +# "${riva_ngc_org}/${riva_ngc_team}/rmir_nlp_named_entity_recognition_bert_base:${riva_ngc_model_version}" + +### BERT Base Intent Slot model fine-tuned on weather dataset. +# "${riva_ngc_org}/${riva_ngc_team}/rmir_nlp_intent_slot_bert_base:${riva_ngc_model_version}" + +### BERT Base Question Answering model fine-tuned on Squad v2. +# "${riva_ngc_org}/${riva_ngc_team}/rmir_nlp_question_answering_bert_base:${riva_ngc_model_version}" + +### Megatron345M Question Answering model fine-tuned on Squad v2. + "${riva_ngc_org}/${riva_ngc_team}/rmir_nlp_question_answering_megatron:${riva_ngc_model_version}" + +### Bert base Text Classification model fine-tuned on 4class (weather, meteorology, personality, nomatch) domain model. +# "${riva_ngc_org}/${riva_ngc_team}/rmir_nlp_text_classification_bert_base:${riva_ngc_model_version}" +) + +########## TTS MODELS ########## + +models_tts=( + "${riva_ngc_org}/${riva_ngc_team}/rmir_tts_fastpitch_hifigan_ljspeech:${riva_ngc_model_version}" +# "${riva_ngc_org}/${riva_ngc_team}/rmir_tts_tacotron_waveglow_ljspeech:${riva_ngc_model_version}" +) + +NGC_TARGET=${riva_ngc_org} +if [[ ! -z ${riva_ngc_team} ]]; then + NGC_TARGET="${NGC_TARGET}/${riva_ngc_team}" +else + team="\"\"" +fi + +# define docker images required to run Riva +image_client="nvcr.io/${NGC_TARGET}/riva-speech-client:${riva_ngc_image_version}" +image_speech_api="nvcr.io/${NGC_TARGET}/riva-speech:${riva_ngc_image_version}-server" + +# define docker images required to setup Riva +image_init_speech="nvcr.io/${NGC_TARGET}/riva-speech:${riva_ngc_image_version}-servicemaker" + +# daemon names +riva_daemon_speech="riva-speech" +riva_daemon_client="riva-client" diff --git a/nlp_demo_riva/riva/docker-compose.yml b/nlp_demo_riva/riva/docker-compose.yml new file mode 100644 index 00000000..af91598d --- /dev/null +++ b/nlp_demo_riva/riva/docker-compose.yml @@ -0,0 +1,27 @@ +version: "3.8" +services: + riva: + image: "nvcr.io/nvidia/riva/riva-speech:1.4.0-beta-server" + container_name: "speech" + shm_size: '1gb' + ipc: 'shareable' + deploy: + resources: + reservations: + devices: + - driver: nvidia + count: 1 + capabilities: [gpu] + volumes: + - riva-model-repo:/data + command: ["start-riva", "--riva-uri=0.0.0.0:50051", "--asr_service=true", "--tts_service=true", "--nlp_service=true"] + client: + image: client + ports: + - "8888:8888" + depends_on: + - "riva" + command: ["/usr/bin/python3", "webserver.py"] +volumes: + riva-model-repo: + external: true diff --git a/nlp_demo_riva/riva/examples/riva_streaming_asr_client.py b/nlp_demo_riva/riva/examples/riva_streaming_asr_client.py new file mode 100644 index 00000000..33f5f2fe --- /dev/null +++ b/nlp_demo_riva/riva/examples/riva_streaming_asr_client.py @@ -0,0 +1,170 @@ +import wave +import sys +import grpc +import time +import argparse + +import riva_api.riva_audio_pb2 as ra +import riva_api.riva_asr_pb2 as rasr +import riva_api.riva_asr_pb2_grpc as rasr_srv + + +def get_args(): + parser = argparse.ArgumentParser(description="Streaming transcription via Riva AI Services") + parser.add_argument("--num-clients", default=1, type=int, help="Number of client threads") + parser.add_argument("--num-iterations", default=1, type=int, help="Number of iterations over the file") + parser.add_argument( + "--input-file", required=True, type=str, help="Name of the WAV file with LINEAR_PCM encoding to transcribe" + ) + parser.add_argument( + "--simulate-realtime", default=False, action='store_true', help="Option to simulate realtime transcription" + ) + parser.add_argument( + "--word-time-offsets", default=False, action='store_true', help="Option to output word timestamps" + ) + parser.add_argument( + "--max-alternatives", + default=1, + type=int, + help="Maximum number of alternative transcripts to return (up to limit configured on server)", + ) + parser.add_argument( + "--automatic-punctuation", + default=False, + action='store_true', + help="Flag that controls if transcript should be automatically punctuated", + ) + parser.add_argument("--riva-uri", default="localhost:50051", type=str, help="URI to access Riva server") + parser.add_argument( + "--no-verbatim-transcripts", + default=False, + action='store_true', + help="If specified, text inverse normalization will be applied", + ) + + return parser.parse_args() + + +def print_to_file(responses, output_file, max_alternatives, word_time_offsets): + start_time = time.time() + with open(output_file, "w") as f: + for response in responses: + if not response.results: + continue + partial_transcript = "" + for result in response.results: + if result.is_final: + for index, alternative in enumerate(result.alternatives): + f.write( + "Time %.2fs: Transcript %d: %s\n" + % (time.time() - start_time, index, alternative.transcript) + ) + + if word_time_offsets: + f.write("Timestamps:\n") + f.write("%-40s %-16s %-16s\n" % ("Word", "Start (ms)", "End (ms)")) + for word_info in result.alternatives[0].words: + f.write( + "%-40s %-16.0f %-16.0f\n" % (word_info.word, word_info.start_time, word_info.end_time) + ) + else: + transcript = result.alternatives[0].transcript + partial_transcript += transcript + + f.write(">>>Time %.2fs: %s\n" % (time.time() - start_time, partial_transcript)) + + +def asr_client( + id, + output_file, + input_file, + num_iterations, + simulate_realtime, + riva_uri, + max_alternatives, + automatic_punctuation, + word_time_offsets, + verbatim_transcripts, +): + + CHUNK = 1600 + channel = grpc.insecure_channel(riva_uri) + wf = wave.open(input_file, 'rb') + + frames = wf.getnframes() + rate = wf.getframerate() + duration = frames / float(rate) + if id == 0: + print("File duration: %.2fs" % duration) + + client = rasr_srv.RivaSpeechRecognitionStub(channel) + config = rasr.RecognitionConfig( + encoding=ra.AudioEncoding.LINEAR_PCM, + sample_rate_hertz=wf.getframerate(), + language_code="en-US", + max_alternatives=max_alternatives, + enable_automatic_punctuation=automatic_punctuation, + enable_word_time_offsets=word_time_offsets, + verbatim_transcripts=verbatim_transcripts, + ) + + streaming_config = rasr.StreamingRecognitionConfig(config=config, interim_results=True) # read data + + def generator(w, s, num_iterations, output_file): + try: + for i in range(num_iterations): + w = wave.open(input_file, 'rb') + start_time = time.time() + yield rasr.StreamingRecognizeRequest(streaming_config=s) + num_requests = 0 + while 1: + d = w.readframes(CHUNK) + if len(d) <= 0: + break + num_requests += 1 + if simulate_realtime: + time_to_sleep = max(0.0, CHUNK / rate * num_requests - (time.time() - start_time)) + time.sleep(time_to_sleep) + yield rasr.StreamingRecognizeRequest(audio_content=d) + w.close() + except Exception as e: + print(e) + + responses = client.StreamingRecognize(generator(wf, streaming_config, num_iterations, output_file)) + print_to_file(responses, output_file, max_alternatives, word_time_offsets) + + +from threading import Thread + +parser = get_args() + +print("Number of clients:", parser.num_clients) +print("Number of iteration:", parser.num_iterations) +print("Input file:", parser.input_file) + +threads = [] +output_filenames = [] +for i in range(parser.num_clients): + output_filenames.append("output_%d.txt" % i) + t = Thread( + target=asr_client, + args=( + i, + output_filenames[-1], + parser.input_file, + parser.num_iterations, + parser.simulate_realtime, + parser.riva_uri, + parser.max_alternatives, + parser.automatic_punctuation, + parser.word_time_offsets, + not parser.no_verbatim_transcripts, + ), + ) + t.start() + threads.append(t) + +for i, t in enumerate(threads): + t.join() + +print(str(parser.num_clients), "threads done, output written to output_.txt") diff --git a/nlp_demo_riva/riva/examples/talk.py b/nlp_demo_riva/riva/examples/talk.py new file mode 100644 index 00000000..3af4f9e2 --- /dev/null +++ b/nlp_demo_riva/riva/examples/talk.py @@ -0,0 +1,96 @@ +# Copyright (c) 2020, NVIDIA CORPORATION. All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# * Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# * Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# * Neither the name of NVIDIA CORPORATION nor the names of its +# contributors may be used to endorse or promote products derived +# from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY +# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR +# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, +# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR +# PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY +# OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +#!/usr/bin/env python + +import time +import grpc + +import numpy as np +import argparse + +import riva_api.riva_audio_pb2 as ra +import riva_api.riva_tts_pb2 as rtts +import riva_api.riva_tts_pb2_grpc as rtts_srv +import wave + +import pyaudio + + +def get_args(): + parser = argparse.ArgumentParser(description="Streaming transcription via Riva AI Services") + parser.add_argument("--server", default="localhost:50051", type=str, help="URI to GRPC server endpoint") + parser.add_argument("--voice", type=str, help="voice name to use", default="ljspeech") + parser.add_argument("-o", "--output", default=None, type=str, help="Output file to write last utterance") + return parser.parse_args() + + +def main(): + args = get_args() + channel = grpc.insecure_channel(args.server) + tts_client = rtts_srv.RivaSpeechSynthesisStub(channel) + audio_handle = pyaudio.PyAudio() + + print("Example query:") + print( + " Hello, My name is Linda" + + ", and I am demonstrating speech synthesis with Riva {@EY2}.I. services, running on NVIDIA {@JH}{@IY1}_{@P}{@IY}_{@Y}{@UW0}s." + ) + req = rtts.SynthesizeSpeechRequest() + req.text = "Hello" + req.language_code = "en-US" + req.encoding = ra.AudioEncoding.LINEAR_PCM + req.sample_rate_hz = 22050 + req.voice_name = args.voice + + stream = audio_handle.open(format=pyaudio.paFloat32, channels=1, rate=22050, output=True) + while True: + print("Speak: ", end='') + req.text = str(input()) + if args.output: + wav = wave.open(args.output, 'wb') + wav.setnchannels(1) + wav.setsampwidth(2) + wav.setframerate(req.sample_rate_hz) + + print("Generating audio for request...") + print(f" > '{req.text}': ", end='') + start = time.time() + resp = tts_client.Synthesize(req) + stop = time.time() + print(f"Time to first audio: {(stop-start):.3f}s") + stream.write(resp.audio) + if args.output: + dt = np.float32 + f32_output = (np.frombuffer(resp.audio, dtype=np.float32) * 32767).astype(np.int16) + wav.writeframesraw(f32_output) + wav.close() + stream.stop_stream() + stream.close() + + +if __name__ == '__main__': + main() diff --git a/nlp_demo_riva/riva/examples/talk_stream.py b/nlp_demo_riva/riva/examples/talk_stream.py new file mode 100644 index 00000000..8ab50686 --- /dev/null +++ b/nlp_demo_riva/riva/examples/talk_stream.py @@ -0,0 +1,103 @@ +# Copyright (c) 2020, NVIDIA CORPORATION. All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# * Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# * Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# * Neither the name of NVIDIA CORPORATION nor the names of its +# contributors may be used to endorse or promote products derived +# from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY +# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR +# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, +# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR +# PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY +# OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +#!/usr/bin/env python + +import time +import grpc + +import numpy as np +import argparse + +import riva_api.riva_audio_pb2 as ra +import riva_api.riva_tts_pb2 as rtts +import riva_api.riva_tts_pb2_grpc as rtts_srv +import wave + +import pyaudio + + +def get_args(): + parser = argparse.ArgumentParser(description="Streaming transcription via Riva AI Services") + parser.add_argument("--server", default="localhost:50051", type=str, help="URI to GRPC server endpoint") + parser.add_argument("--voice", type=str, help="voice name to use", default="ljspeech") + parser.add_argument("-o", "--output", default=None, type=str, help="Output file to write last utterance") + return parser.parse_args() + + +def main(): + args = get_args() + channel = grpc.insecure_channel(args.server) + tts_client = rtts_srv.RivaSpeechSynthesisStub(channel) + audio_handle = pyaudio.PyAudio() + + print("Connecting...") + print("Example query:") + print( + " Hello, My name is Linda" + + ", and I am demonstrating streaming speech synthesis with Riva {@EY2}.I. services, running on NVIDIA {@JH}{@IY1}_{@P}{@IY}_{@Y}{@UW0}s." + ) + req = rtts.SynthesizeSpeechRequest() + req.text = "Hello" + req.language_code = "en-US" + req.encoding = ra.AudioEncoding.LINEAR_PCM + req.sample_rate_hz = 22050 + req.voice_name = args.voice + + stream = audio_handle.open(format=pyaudio.paFloat32, channels=1, rate=22050, output=True) + while True: + print("Speak: ", end='') + req.text = str(input()) + if args.output: + wav = wave.open(args.output, 'wb') + wav.setnchannels(1) + wav.setsampwidth(2) + wav.setframerate(req.sample_rate_hz) + + print("Generating audio for request...") + print(f" > '{req.text}': ", end='') + start = time.time() + responses = tts_client.SynthesizeOnline(req) + stop = time.time() + first = True + for resp in responses: + stop = time.time() + if first: + print(f"Time to first audio: {(stop-start):.3f}s") + first = False + stream.write(resp.audio) + if args.output: + dt = np.float32 + f32_output = (np.frombuffer(resp.audio, dtype=np.float32) * 32767).astype(np.int16) + wav.writeframesraw(f32_output) + if args.output: + wav.close() + stream.stop_stream() + stream.close() + + +if __name__ == '__main__': + main() diff --git a/nlp_demo_riva/riva/examples/transcribe_file.py b/nlp_demo_riva/riva/examples/transcribe_file.py new file mode 100644 index 00000000..e3b95fb8 --- /dev/null +++ b/nlp_demo_riva/riva/examples/transcribe_file.py @@ -0,0 +1,110 @@ +# Copyright (c) 2020, NVIDIA CORPORATION. All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# * Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# * Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# * Neither the name of NVIDIA CORPORATION nor the names of its +# contributors may be used to endorse or promote products derived +# from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY +# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR +# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, +# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR +# PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY +# OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +import argparse +import wave +import sys +import grpc +import time +import riva_api.riva_audio_pb2 as ra +import riva_api.riva_asr_pb2 as rasr +import riva_api.riva_asr_pb2_grpc as rasr_srv + + +def get_args(): + parser = argparse.ArgumentParser(description="Streaming transcription via Riva AI Services") + parser.add_argument("--server", default="localhost:50051", type=str, help="URI to GRPC server endpoint") + parser.add_argument("--audio-file", required=True, help="path to local file to stream") + parser.add_argument( + "--show-intermediate", action="store_true", help="show intermediate transcripts as they are available" + ) + return parser.parse_args() + + +def listen_print_loop(responses, show_intermediate=False): + num_chars_printed = 0 + idx = 0 + for response in responses: + idx += 1 + if not response.results: + continue + + partial_transcript = "" + for result in response.results: + if not result.alternatives: + continue + + transcript = result.alternatives[0].transcript + + if show_intermediate: + if not result.is_final: + partial_transcript += transcript + else: + overwrite_chars = ' ' * (num_chars_printed - len(transcript)) + print("## " + transcript + overwrite_chars + "\n") + num_chars_printed = 0 + + else: + if result.is_final: + sys.stdout.buffer.write(transcript.encode('utf-8')) + sys.stdout.flush() + print("\n") + + if show_intermediate and partial_transcript != "": + overwrite_chars = ' ' * (num_chars_printed - len(partial_transcript)) + sys.stdout.write(">> " + partial_transcript + overwrite_chars + '\r') + sys.stdout.flush() + num_chars_printed = len(partial_transcript) + 3 + + +CHUNK = 1024 +args = get_args() +wf = wave.open(args.audio_file, 'rb') + +channel = grpc.insecure_channel(args.server) +client = rasr_srv.RivaSpeechRecognitionStub(channel) +config = rasr.RecognitionConfig( + encoding=ra.AudioEncoding.LINEAR_PCM, + sample_rate_hertz=wf.getframerate(), + language_code="en-US", + max_alternatives=1, + enable_automatic_punctuation=True, +) +streaming_config = rasr.StreamingRecognitionConfig(config=config, interim_results=True) + +# read data + + +def generator(w, s): + yield rasr.StreamingRecognizeRequest(streaming_config=s) + d = w.readframes(CHUNK) + while len(d) > 0: + yield rasr.StreamingRecognizeRequest(audio_content=d) + d = w.readframes(CHUNK) + + +responses = client.StreamingRecognize(generator(wf, streaming_config)) +listen_print_loop(responses, show_intermediate=args.show_intermediate) diff --git a/nlp_demo_riva/riva/examples/transcribe_file_offline.py b/nlp_demo_riva/riva/examples/transcribe_file_offline.py new file mode 100644 index 00000000..63ae7721 --- /dev/null +++ b/nlp_demo_riva/riva/examples/transcribe_file_offline.py @@ -0,0 +1,63 @@ +# Copyright (c) 2020, NVIDIA CORPORATION. All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# * Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# * Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# * Neither the name of NVIDIA CORPORATION nor the names of its +# contributors may be used to endorse or promote products derived +# from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY +# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR +# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, +# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR +# PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY +# OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +import argparse +import grpc +import time +import riva_api.riva_audio_pb2 as ra +import riva_api.riva_asr_pb2 as rasr +import riva_api.riva_asr_pb2_grpc as rasr_srv +import wave + + +def get_args(): + parser = argparse.ArgumentParser(description="Streaming transcription via Riva AI Services") + parser.add_argument("--server", default="localhost:50051", type=str, help="URI to GRPC server endpoint") + parser.add_argument("--audio-file", required=True, help="path to local file to stream") + return parser.parse_args() + + +args = get_args() + +wf = wave.open(args.audio_file, 'rb') +with open(args.audio_file, 'rb') as fh: + data = fh.read() + +channel = grpc.insecure_channel(args.server) +client = rasr_srv.RivaSpeechRecognitionStub(channel) +config = rasr.RecognitionConfig( + encoding=ra.AudioEncoding.LINEAR_PCM, + sample_rate_hertz=wf.getframerate(), + language_code="en-US", + max_alternatives=1, + enable_automatic_punctuation=False, + audio_channel_count=1, +) + +request = rasr.RecognizeRequest(config=config, audio=data) + +response = client.Recognize(request) +print(response) diff --git a/nlp_demo_riva/riva/examples/transcribe_file_rt.py b/nlp_demo_riva/riva/examples/transcribe_file_rt.py new file mode 100644 index 00000000..63790ea3 --- /dev/null +++ b/nlp_demo_riva/riva/examples/transcribe_file_rt.py @@ -0,0 +1,132 @@ +# Copyright (c) 2020, NVIDIA CORPORATION. All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# * Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# * Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# * Neither the name of NVIDIA CORPORATION nor the names of its +# contributors may be used to endorse or promote products derived +# from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY +# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR +# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, +# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR +# PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY +# OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +import pyaudio +import argparse +import wave +import sys +import grpc +import riva_api.riva_audio_pb2 as ra +import riva_api.riva_asr_pb2 as rasr +import riva_api.riva_asr_pb2_grpc as rasr_srv + + +def get_args(): + parser = argparse.ArgumentParser(description="Streaming transcription via Riva AI Services") + parser.add_argument("--server", default="localhost:50051", type=str, help="URI to GRPC server endpoint") + parser.add_argument("--audio-file", required=True, help="path to local file to stream") + parser.add_argument("--output-device", type=int, default=None, help="output device to use") + parser.add_argument("--list-devices", action="store_true", help="list output devices indices") + return parser.parse_args() + + +def listen_print_loop(responses): + num_chars_printed = 0 + for response in responses: + if not response.results: + continue + + partial_transcript = "" + for result in response.results: + if not result.alternatives: + continue + + transcript = result.alternatives[0].transcript + + if not result.is_final: + partial_transcript += transcript + else: + overwrite_chars = ' ' * (num_chars_printed - len(transcript)) + print("## " + transcript + overwrite_chars + "\n") + num_chars_printed = 0 + + if partial_transcript != "": + overwrite_chars = ' ' * (num_chars_printed - len(partial_transcript)) + sys.stdout.write(">> " + partial_transcript + overwrite_chars + '\r') + sys.stdout.flush() + num_chars_printed = len(partial_transcript) + 3 + + +CHUNK = 1024 + +args = get_args() + +wf = wave.open(args.audio_file, 'rb') + +channel = grpc.insecure_channel(args.server) + +client = rasr_srv.RivaSpeechRecognitionStub(channel) +config = rasr.RecognitionConfig( + encoding=ra.AudioEncoding.LINEAR_PCM, + sample_rate_hertz=wf.getframerate(), + language_code="en-US", + max_alternatives=1, + enable_automatic_punctuation=True, +) +streaming_config = rasr.StreamingRecognitionConfig(config=config, interim_results=True) + +# instantiate PyAudio (1) +p = pyaudio.PyAudio() + +if args.list_devices: + for i in range(p.get_device_count()): + info = p.get_device_info_by_index(i) + if info['maxOutputChannels'] < 1: + continue + print(f"{info['index']}: {info['name']}") + sys.exit(0) + +# open stream (2) +stream = p.open( + output_device_index=args.output_device, + format=p.get_format_from_width(wf.getsampwidth()), + channels=wf.getnchannels(), + rate=wf.getframerate(), + output=True, +) + +# read data + + +def generator(w, s): + d = w.readframes(CHUNK) + yield rasr.StreamingRecognizeRequest(streaming_config=s) + while len(d) > 0: + yield rasr.StreamingRecognizeRequest(audio_content=d) + stream.write(d) + d = w.readframes(CHUNK) + return + + +responses = client.StreamingRecognize(generator(wf, streaming_config)) +listen_print_loop(responses) + +# stop stream (4) +stream.stop_stream() +stream.close() + +# close PyAudio (5) +p.terminate() diff --git a/nlp_demo_riva/riva/examples/transcribe_file_verbose.py b/nlp_demo_riva/riva/examples/transcribe_file_verbose.py new file mode 100644 index 00000000..0e0d24c3 --- /dev/null +++ b/nlp_demo_riva/riva/examples/transcribe_file_verbose.py @@ -0,0 +1,93 @@ +# Copyright (c) 2020, NVIDIA CORPORATION. All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# * Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# * Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# * Neither the name of NVIDIA CORPORATION nor the names of its +# contributors may be used to endorse or promote products derived +# from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY +# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR +# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, +# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR +# PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY +# OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +import argparse +import wave +import sys +import grpc +import time +import riva_api.riva_audio_pb2 as ra +import riva_api.riva_asr_pb2 as rasr +import riva_api.riva_asr_pb2_grpc as rasr_srv + + +def get_args(): + parser = argparse.ArgumentParser(description="Streaming transcription via Riva AI Services") + parser.add_argument("--server", default="localhost:50051", type=str, help="URI to GRPC server endpoint") + parser.add_argument("--audio-file", required=True, help="path to local file to stream") + return parser.parse_args() + + +def listen_print_loop(responses): + num_chars_printed = 0 + idx = 0 + for response in responses: + idx += 1 + if not response.results: + continue + + for result in response.results: + if not result.alternatives: + continue + + transcript = result.alternatives[0].transcript + + if result.is_final: + print(f"Final transcript: {transcript.encode('utf-8')}") + print(f"Confidence: {result.alternatives[0].confidence:9.4f}") + else: + print(f"Partial transcript: {transcript.encode('utf-8')}") + print(f"Stability: {result.stability:9.4f}") + + print("----") + + +CHUNK = 1024 +args = get_args() +wf = wave.open(args.audio_file, 'rb') + +channel = grpc.insecure_channel(args.server) +client = rasr_srv.RivaSpeechRecognitionStub(channel) +config = rasr.RecognitionConfig( + encoding=ra.AudioEncoding.LINEAR_PCM, + sample_rate_hertz=wf.getframerate(), + language_code="en-US", + max_alternatives=1, + enable_automatic_punctuation=True, +) +streaming_config = rasr.StreamingRecognitionConfig(config=config, interim_results=True) + +# read data +def generator(w, s): + yield rasr.StreamingRecognizeRequest(streaming_config=s) + d = w.readframes(CHUNK) + while len(d) > 0: + yield rasr.StreamingRecognizeRequest(audio_content=d) + d = w.readframes(CHUNK) + + +responses = client.StreamingRecognize(generator(wf, streaming_config)) +listen_print_loop(responses) diff --git a/nlp_demo_riva/riva/examples/transcribe_mic.py b/nlp_demo_riva/riva/examples/transcribe_mic.py new file mode 100644 index 00000000..f2ef15ba --- /dev/null +++ b/nlp_demo_riva/riva/examples/transcribe_mic.py @@ -0,0 +1,177 @@ +# Copyright (c) 2020, NVIDIA CORPORATION. All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# * Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# * Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# * Neither the name of NVIDIA CORPORATION nor the names of its +# contributors may be used to endorse or promote products derived +# from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY +# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR +# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, +# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR +# PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY +# OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +import sys +import grpc +import queue +import argparse + +import riva_api.riva_audio_pb2 as ra +import riva_api.riva_asr_pb2 as rasr +import riva_api.riva_asr_pb2_grpc as rasr_srv + +import pyaudio + +RATE = 16000 +CHUNK = int(RATE / 10) # 100ms + + +def get_args(): + parser = argparse.ArgumentParser(description="Streaming transcription via Riva AI Services") + parser.add_argument("--server", default="localhost:50051", type=str, help="URI to GRPC server endpoint") + parser.add_argument("--input-device", type=int, default=None, help="output device to use") + parser.add_argument("--list-devices", action="store_true", help="list output devices indices") + return parser.parse_args() + + +class MicrophoneStream(object): + """Opens a recording stream as a generator yielding the audio chunks.""" + + def __init__(self, rate, chunk, device=None): + self._rate = rate + self._chunk = chunk + self._device = device + + # Create a thread-safe buffer of audio data + self._buff = queue.Queue() + self.closed = True + + def __enter__(self): + self._audio_interface = pyaudio.PyAudio() + self._audio_stream = self._audio_interface.open( + format=pyaudio.paInt16, + input_device_index=self._device, + channels=1, + rate=self._rate, + input=True, + frames_per_buffer=self._chunk, + stream_callback=self._fill_buffer, + ) + + self.closed = False + + return self + + def __exit__(self, type, value, traceback): + self._audio_stream.stop_stream() + self._audio_stream.close() + self.closed = True + # Signal the generator to terminate so that the client's + # streaming_recognize method will not block the process termination. + self._buff.put(None) + self._audio_interface.terminate() + + def _fill_buffer(self, in_data, frame_count, time_info, status_flags): + """Continuously collect data from the audio stream, into the buffer.""" + self._buff.put(in_data) + return None, pyaudio.paContinue + + def generator(self): + while not self.closed: + chunk = self._buff.get() + if chunk is None: + return + data = [chunk] + + while True: + try: + chunk = self._buff.get(block=False) + if chunk is None: + return + data.append(chunk) + except queue.Empty: + break + + yield b''.join(data) + + +def listen_print_loop(responses): + num_chars_printed = 0 + for response in responses: + if not response.results: + continue + + partial_transcript = "" + for result in response.results: + if not result.alternatives: + continue + + transcript = result.alternatives[0].transcript + + if not result.is_final: + partial_transcript += transcript + else: + overwrite_chars = ' ' * (num_chars_printed - len(transcript)) + print("## " + transcript + overwrite_chars + "\n") + num_chars_printed = 0 + + if partial_transcript != "": + overwrite_chars = ' ' * (num_chars_printed - len(partial_transcript)) + sys.stdout.write(">> " + partial_transcript + overwrite_chars + '\r') + sys.stdout.flush() + num_chars_printed = len(partial_transcript) + 3 + + +def main(): + args = get_args() + + if args.list_devices: + p = pyaudio.PyAudio() + for i in range(p.get_device_count()): + info = p.get_device_info_by_index(i) + if info['maxInputChannels'] < 1: + continue + print(f"{info['index']}: {info['name']}") + sys.exit(0) + + channel = grpc.insecure_channel(args.server) + client = rasr_srv.RivaSpeechRecognitionStub(channel) + + config = rasr.RecognitionConfig( + encoding=ra.AudioEncoding.LINEAR_PCM, + sample_rate_hertz=RATE, + language_code="en-US", + max_alternatives=1, + enable_automatic_punctuation=True, + ) + streaming_config = rasr.StreamingRecognitionConfig(config=config, interim_results=True) + + with MicrophoneStream(RATE, CHUNK, device=args.input_device) as stream: + audio_generator = stream.generator() + requests = (rasr.StreamingRecognizeRequest(audio_content=content) for content in audio_generator) + + def build_generator(cfg, gen): + yield rasr.StreamingRecognizeRequest(streaming_config=cfg) + for x in gen: + yield x + + responses = client.StreamingRecognize(build_generator(streaming_config, requests)) + + listen_print_loop(responses) + + +if __name__ == '__main__': + main() diff --git a/nlp_demo_riva/riva/nb_demo_speech_api.ipynb b/nlp_demo_riva/riva/nb_demo_speech_api.ipynb new file mode 100644 index 00000000..cbc3e290 --- /dev/null +++ b/nlp_demo_riva/riva/nb_demo_speech_api.ipynb @@ -0,0 +1,697 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "# Copyright 2021 NVIDIA Corporation. All Rights Reserved.\n", + "#\n", + "# Licensed under the Apache License, Version 2.0 (the \"License\");\n", + "# you may not use this file except in compliance with the License.\n", + "# You may obtain a copy of the License at\n", + "#\n", + "# http://www.apache.org/licenses/LICENSE-2.0\n", + "#\n", + "# Unless required by applicable law or agreed to in writing, software\n", + "# distributed under the License is distributed on an \"AS IS\" BASIS,\n", + "# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n", + "# See the License for the specific language governing permissions and\n", + "# limitations under the License.\n", + "# ==============================================================================" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "\n", + "# Python API Examples\n", + "\n", + "This notebook walks through the basics of the Riva Speech and Language AI Services.\n", + "\n", + "## Overview\n", + "\n", + "NVIDIA Riva is a platform for building and deploying AI applications that fuse vision, speech and other sensors. It offers a complete workflow to build, train and deploy AI systems that can use visual cues such as gestures and gaze along with speech in context. With the Riva platform, you can:\n", + "\n", + "- Build speech and visual AI applications using pretrained NVIDIA Neural Modules ([NeMo](https://github.com/NVIDIA/NeMo)) available at NVIDIA GPU Cloud ([NGC](https://ngc.nvidia.com/catalog/models?orderBy=modifiedDESC&query=%20label%3A%22NeMo%2FPyTorch%22&quickFilter=models&filters=)).\n", + "\n", + "- Transfer learning: re-train your model on domain-specific data, with NVIDIA [NeMo](https://github.com/NVIDIA/NeMo). NeMo is a toolkit and platform that enables researchers to define and build new state-of-the-art speech and natural language processing models.\n", + "\n", + "- Optimize neural network performance and latency using NVIDIA TensorRT \n", + "\n", + "- Deploy AI applications with TensorRT Inference Server:\n", + " - Support multiple network formats: ONNX, TensorRT plans, PyTorch TorchScript models.\n", + " - Deployement on multiple platforms: from datacenter to edge servers, via Helm to K8s cluster, on NVIDIA Volta/Turing GPUs or Jetson Xavier platforms.\n", + "\n", + "See the below video for a demo of Riva capabilities." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from IPython.display import IFrame\n", + "\n", + "# Riva Youtube demo video\n", + "IFrame(\"https://www.youtube.com/embed/r264lBi1nMU?rel=0&controls=0&showinfo=0\", width=\"560\", height=\"315\", frameborder=\"0\", allowfullscreen=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For more detailed information on Riva, please refer to the [Riva developer documentation](https://developer.nvidia.com/).\n", + "\n", + "## Introduction the Riva Speech and Natural Languages services\n", + "\n", + "Riva offers a rich set of speech and natural language understanding services such as:\n", + "\n", + "- Automated speech recognition (ASR)\n", + "- Text-to-Speech synthesis (TTS)\n", + "- A collection of natural language understanding services such as named entity recognition (NER), punctuation, intent classification." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Learning objectives\n", + "\n", + "- Understand how interact with Riva Speech and Natural Languages APIs, services and use cases\n", + "\n", + "## Requirements and setup\n", + "\n", + "To execute this notebook, please follow the setup steps in [README](./README.md).\n", + "\n", + "We first generate some required libraries." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "import io\n", + "import librosa\n", + "from time import time\n", + "import numpy as np\n", + "import IPython.display as ipd\n", + "import grpc\n", + "import requests\n", + "\n", + "# NLP proto\n", + "import riva_api.riva_nlp_pb2 as rnlp\n", + "import riva_api.riva_nlp_pb2_grpc as rnlp_srv\n", + "\n", + "# ASR proto\n", + "import riva_api.riva_asr_pb2 as rasr\n", + "import riva_api.riva_asr_pb2_grpc as rasr_srv\n", + "\n", + "# TTS proto\n", + "import riva_api.riva_tts_pb2 as rtts\n", + "import riva_api.riva_tts_pb2_grpc as rtts_srv\n", + "import riva_api.riva_audio_pb2 as ra" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Create Riva clients and connect to Riva Speech API server\n", + "\n", + "The below URI assumes a local deployment of the Riva Speech API server on the default port. In case the server deployment is on a different host or via Helm chart on Kubernetes, the user should use an appropriate URI." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "channel = grpc.insecure_channel('localhost:50051')\n", + "\n", + "riva_asr = rasr_srv.RivaSpeechRecognitionStub(channel)\n", + "riva_nlp = rnlp_srv.RivaLanguageUnderstandingStub(channel)\n", + "riva_tts = rtts_srv.RivaSpeechSynthesisStub(channel)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Content\n", + "1. [Offline ASR Example](#1)\n", + "1. [Core NLP Service Examples](#2)\n", + "1. [TTS Service Example](#3)\n", + "1. [Riva NLP Service Examples](#4)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "\n", + "## 1. Offline ASR Example\n", + "\n", + "Riva Speech API supports `.wav` files in PCM format, `.alaw`, `.mulaw` and `.flac` formats with single channel in this release. " + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# This example uses a .wav file with LINEAR_PCM encoding.\n", + "# read in an audio file from local disk\n", + "path = \"/work/wav/sample.wav\"\n", + "audio, sr = librosa.core.load(path, sr=None)\n", + "with io.open(path, 'rb') as fh:\n", + " content = fh.read()\n", + "ipd.Audio(path)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ASR Transcript: What is natural language processing? \n", + "\n", + "\n", + "Full Response Message:\n", + "results {\n", + " alternatives {\n", + " transcript: \"What is natural language processing? \"\n", + " confidence: -8.908161163330078\n", + " }\n", + " channel_tag: 1\n", + " audio_processed: 6.400000095367432\n", + "}\n", + "\n" + ] + } + ], + "source": [ + "# Set up an offline/batch recognition request\n", + "req = rasr.RecognizeRequest()\n", + "req.audio = content # raw bytes\n", + "req.config.encoding = ra.AudioEncoding.LINEAR_PCM # Supports LINEAR_PCM, FLAC, MULAW and ALAW audio encodings\n", + "req.config.sample_rate_hertz = sr # Audio will be resampled if necessary\n", + "req.config.language_code = \"en-US\" # Ignored, will route to correct model in future release\n", + "req.config.max_alternatives = 1 # How many top-N hypotheses to return\n", + "req.config.enable_automatic_punctuation = True # Add punctuation when end of VAD detected\n", + "req.config.audio_channel_count = 1 # Mono channel\n", + "\n", + "response = riva_asr.Recognize(req)\n", + "asr_best_transcript = response.results[0].alternatives[0].transcript\n", + "print(\"ASR Transcript:\", asr_best_transcript)\n", + "\n", + "print(\"\\n\\nFull Response Message:\")\n", + "print(response)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "\n", + "## 2. Core NLP Service Examples\n", + "\n", + "All of the Core NLP Services support batched requests. The maximum batch size,\n", + "if any, of the underlying models is hidden from the end user and automatically\n", + "batched by the Riva and TRTIS servers.\n", + "\n", + "The Core NLP API provides three methods currently:\n", + "\n", + " 1. TransformText - map an input string to an output string\n", + " \n", + " 2. ClassifyText - return a single label for the input string\n", + " \n", + " 3. ClassifyTokens - return a label per input token" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "TransformText Output:\n", + " Add punctuation to this sentence.\n", + " Do you have any red Nvidia shirts?\n", + " I need one cpu, four gpus and lots of memory for my new computer. It's going to be very cool.\n" + ] + } + ], + "source": [ + "# Use the TextTransform API to run the punctuation model\n", + "req = rnlp.TextTransformRequest()\n", + "req.model.model_name = \"riva_punctuation\"\n", + "req.text.append(\"add punctuation to this sentence\")\n", + "req.text.append(\"do you have any red nvidia shirts\")\n", + "req.text.append(\"i need one cpu four gpus and lots of memory \"\n", + " \"for my new computer it's going to be very cool\")\n", + "\n", + "nlp_resp = riva_nlp.TransformText(req)\n", + "print(\"TransformText Output:\")\n", + "print(\"\\n\".join([f\" {x}\" for x in nlp_resp.text]))" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Named Entities:\n", + " jensen huang (PER)\n", + " nvidia corporation (ORG)\n", + " santa clara (LOC)\n", + " california (LOC)\n" + ] + } + ], + "source": [ + "# Use the TokenClassification API to run a Named Entity Recognition (NER) model\n", + "# Note: the model configuration of the NER model indicates that the labels are\n", + "# in IOB format. Riva, subsequently, knows to:\n", + "# a) ignore 'O' labels\n", + "# b) Remove B- and I- prefixes from labels\n", + "# c) Collapse sequences of B- I- ... I- tokens into a single token\n", + "\n", + "req = rnlp.TokenClassRequest()\n", + "req.model.model_name = \"riva_ner\" # If you have deployed a custom model with the domain_name \n", + " # parameter in ServiceMaker's `riva-build` command then you should use \n", + " # \"riva_ner_\" where \n", + " # is the name you provided to the domain_name parameter.\n", + "\n", + "req.text.append(\"Jensen Huang is the CEO of NVIDIA Corporation, \"\n", + " \"located in Santa Clara, California\")\n", + "resp = riva_nlp.ClassifyTokens(req)\n", + "\n", + "print(\"Named Entities:\")\n", + "for result in resp.results[0].results:\n", + " print(f\" {result.token} ({result.label[0].class_name})\")" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "results {\n", + " labels {\n", + " class_name: \"weather\"\n", + " score: 0.9975590109825134\n", + " }\n", + "}\n", + "results {\n", + " labels {\n", + " class_name: \"meteorology\"\n", + " score: 0.984375\n", + " }\n", + "}\n", + "results {\n", + " labels {\n", + " class_name: \"personality\"\n", + " score: 0.984375\n", + " }\n", + "}\n", + "\n" + ] + } + ], + "source": [ + "# Submit a TextClassRequest for text classification.\n", + "# Riva NLP comes with a default text_classification domain called \"domain_misty\" which consists of \n", + "# 4 classes: meteorology, personality, weather and nomatch\n", + "\n", + "request = rnlp.TextClassRequest()\n", + "request.model.model_name = \"riva_text_classification_domain\" # If you have deployed a custom model \n", + " # with the `--domain_name` parameter in ServiceMaker's `riva-build` command \n", + " # then you should use \"riva_text_classification_\"\n", + " # where is the name you provided to the \n", + " # domain_name parameter. In this case the domain_name is \"domain\"\n", + "request.text.append(\"Is it going to snow in Burlington, Vermont tomorrow night?\")\n", + "request.text.append(\"What causes rain?\")\n", + "request.text.append(\"What is your favorite season?\")\n", + "ct_response = riva_nlp.ClassifyText(request)\n", + "print(ct_response)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "\n", + "## 3. TTS Service Example\n", + "\n", + "Subsequent releases will include added features, including model registration to support multiple languages/voices with the same API. Support for resampling to alternative sampling rates will also be added." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "req = rtts.SynthesizeSpeechRequest()\n", + "req.text = \"Is it recognize speech or wreck a nice beach?\"\n", + "req.language_code = \"en-US\" # currently required to be \"en-US\"\n", + "req.encoding = ra.AudioEncoding.LINEAR_PCM # Supports LINEAR_PCM, FLAC, MULAW and ALAW audio encodings\n", + "req.sample_rate_hz = 22050 # ignored, audio returned will be 22.05KHz\n", + "req.voice_name = \"ljspeech\" # ignored\n", + "\n", + "resp = riva_tts.Synthesize(req)\n", + "audio_samples = np.frombuffer(resp.audio, dtype=np.float32)\n", + "ipd.Audio(audio_samples, rate=22050)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "\n", + "## 4. Riva NLP Service Examples\n", + "\n", + "The NLP Service contains higher-level/more application-specific NLP APIs. This\n", + "guide demonstrates how the AnalyzeIntent API can be used for queries across\n", + "both known and unknown domains." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "intent {\n", + " class_name: \"weather.humidity\"\n", + " score: 0.983601987361908\n", + "}\n", + "slots {\n", + " token: \"san francisco\"\n", + " label {\n", + " class_name: \"weatherplace\"\n", + " score: 0.9822959899902344\n", + " }\n", + "}\n", + "slots {\n", + " token: \"?\"\n", + " label {\n", + " class_name: \"weatherplace\"\n", + " score: 0.6474800109863281\n", + " }\n", + "}\n", + "domain_str: \"weather\"\n", + "domain {\n", + " class_name: \"weather\"\n", + " score: 1.0\n", + "}\n", + "\n" + ] + } + ], + "source": [ + "# The AnalyzeIntent API can be used to query a Intent Slot classifier. The API can leverage a\n", + "# text classification model to classify the domain of the input query and then route to the \n", + "# appropriate intent slot model.\n", + "\n", + "# Lets first see an example where the domain is known. This skips execution of the domain classifier\n", + "# and proceeds directly to the intent/slot model for the requested domain.\n", + "\n", + "req = rnlp.AnalyzeIntentRequest()\n", + "req.query = \"How is the humidity in San Francisco?\"\n", + "req.options.domain = \"weather\" # The is appended to \"riva_intent_\" to look for a \n", + " # model \"riva_intent_\". So in this e.g., the model \"riva_intent_weather\"\n", + " # needs to be preloaded in riva server. If you would like to deploy your \n", + " # custom Joint Intent and Slot model use the `--domain_name` parameter in \n", + " # ServiceMaker's `riva-build intent_slot` command.\n", + "\n", + "resp = riva_nlp.AnalyzeIntent(req)\n", + "print(resp)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "intent {\n", + " class_name: \"weather.rainfall\"\n", + " score: 0.9661880135536194\n", + "}\n", + "slots {\n", + " token: \"tomorrow\"\n", + " label {\n", + " class_name: \"weatherforecastdaily\"\n", + " score: 0.5325539708137512\n", + " }\n", + "}\n", + "slots {\n", + " token: \"?\"\n", + " label {\n", + " class_name: \"weatherplace\"\n", + " score: 0.6895459890365601\n", + " }\n", + "}\n", + "domain_str: \"weather\"\n", + "domain {\n", + " class_name: \"weather\"\n", + " score: 0.9975590109825134\n", + "}\n", + "\n" + ] + } + ], + "source": [ + "# Below is an example where the input domain is not provided.\n", + "\n", + "req = rnlp.AnalyzeIntentRequest()\n", + "req.query = \"Is it going to rain tomorrow?\"\n", + "\n", + " # The input query is first routed to the a text classification model called \"riva_text_classification_domain\"\n", + " # The output class label of \"riva_text_classification_domain\" is appended to \"riva_intent_\"\n", + " # to get the appropriate Intent Slot model to execute for the input query.\n", + " # Note: The model \"riva_text_classification_domain\" needs to be loaded into Riva server and have the appropriate\n", + " # class labels that would invoke the corresponding intent slot model.\n", + "\n", + "resp = riva_nlp.AnalyzeIntent(req)\n", + "print(resp)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[weather.cloudy]\tIs it currently cloudy in Tokyo?\n", + "[weather.rainfall]\tWhat is the annual rainfall in Pune?\n", + "[weather.humidity]\tWhat is the humidity going to be tomorrow?\n" + ] + } + ], + "source": [ + "# Some weather Intent queries\n", + "queries = [\n", + " \"Is it currently cloudy in Tokyo?\",\n", + " \"What is the annual rainfall in Pune?\",\n", + " \"What is the humidity going to be tomorrow?\"\n", + "]\n", + "for q in queries:\n", + " req = rnlp.AnalyzeIntentRequest()\n", + " req.query = q\n", + " start = time()\n", + " resp = riva_nlp.AnalyzeIntent(req)\n", + "\n", + " print(f\"[{resp.intent.class_name}]\\t{req.query}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Time to complete 10 synchronous requests: 0.05957150459289551\n", + "Time to complete 10 asynchronous requests: 0.020952463150024414\n", + "\n" + ] + } + ], + "source": [ + "# Demonstrate latency by calling repeatedly.\n", + "# NOTE: this is a synchronous API call, so request #N will not be sent until\n", + "# response #N-1 is returned. This means latency and throughput will be negatively\n", + "# impacted by long-distance & VPN connections\n", + "\n", + "req = rnlp.TextTransformRequest()\n", + "req.text.append(\"i need one cpu four gpus and lots of memory for my new computer it's going to be very cool\")\n", + "\n", + "iterations = 10\n", + "# Demonstrate synchronous performance\n", + "start_time = time()\n", + "for _ in range(iterations):\n", + " nlp_resp = riva_nlp.PunctuateText(req)\n", + "end_time = time()\n", + "print(f\"Time to complete {iterations} synchronous requests: {end_time-start_time}\")\n", + "\n", + "# Demonstrate async performance\n", + "start_time = time()\n", + "futures = []\n", + "for _ in range(iterations):\n", + " futures.append(riva_nlp.PunctuateText.future(req))\n", + "for f in futures:\n", + " f.result()\n", + "end_time = time()\n", + "print(f\"Time to complete {iterations} asynchronous requests: {end_time-start_time}\\n\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "\n", + "## 5. Go deeper into Riva capabilities\n", + "\n", + "Now that you have a basic introduction to the Riva APIs, you may like to try out:\n", + "\n", + "### 1. Sample apps:\n", + "\n", + "Riva comes with various sample apps as a demonstration for how to use the APIs to build interesting applications such as a [chatbot](https://docs.nvidia.com/deeplearning/riva/user-guide/docs/samples/weather.html), a domain specific speech recognition or [keyword (entity) recognition system](https://docs.nvidia.com/deeplearning/riva/user-guide/docs/samples/callcenter.html), or simply how Riva allows scaling out for handling massive amount of requests at the same time. ([SpeechSquad)](https://docs.nvidia.com/deeplearning/riva/user-guide/docs/samples/speechsquad.html) \n", + "Have a look at the Sample Application section in the [Riva developer documentation](https://developer.nvidia.com/) for all the sample apps.\n", + "\n", + "\n", + "### 2. Finetune your own domain specific Speech or NLP model and deploy into Riva.\n", + "\n", + "Train the latest state-of-the-art speech and natural language processing models on your own data using [NeMo](https://github.com/NVIDIA/NeMo) or [Transfer Learning ToolKit](https://developer.nvidia.com/transfer-learning-toolkit) and deploy them on Riva using the [Riva ServiceMaker tool](https://docs.nvidia.com/deeplearning/riva/user-guide/docs/model-servicemaker.html).\n", + "\n", + "\n", + "### 3. Further resources:\n", + "\n", + "Explore the details of each of the APIs and their functionalities in the [docs](https://docs.nvidia.com/deeplearning/jarvis/user-guide/docs/protobuf-api/protobuf-api-root.html)." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.6.9" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/nlp_demo_riva/riva/nemo2riva-1.4.0b0-py3-none-any.whl b/nlp_demo_riva/riva/nemo2riva-1.4.0b0-py3-none-any.whl new file mode 100644 index 00000000..8410cb93 Binary files /dev/null and b/nlp_demo_riva/riva/nemo2riva-1.4.0b0-py3-none-any.whl differ diff --git a/nlp_demo_riva/riva/protos/audio.proto b/nlp_demo_riva/riva/protos/audio.proto new file mode 100644 index 00000000..031188f4 --- /dev/null +++ b/nlp_demo_riva/riva/protos/audio.proto @@ -0,0 +1,40 @@ +// Copyright (c) 2021, NVIDIA CORPORATION. All rights reserved. +// +// NVIDIA CORPORATION and its licensors retain all intellectual property +// and proprietary rights in and to this software, related documentation +// and any modifications thereto. Any use, reproduction, disclosure or +// distribution of this software and related documentation without an express +// license agreement from NVIDIA CORPORATION is strictly prohibited. + + +syntax = "proto3"; + +package nvidia.jarvis; + +option cc_enable_arenas = true; + + +/* + * AudioEncoding specifies the encoding of the audio bytes in the encapsulating message. + */ +enum AudioEncoding { + // Not specified. + ENCODING_UNSPECIFIED = 0; + + // Uncompressed 16-bit signed little-endian samples (Linear PCM). + LINEAR_PCM = 1; + + // `FLAC` (Free Lossless Audio + // Codec) is the recommended encoding because it is + // lossless--therefore recognition is not compromised--and + // requires only about half the bandwidth of `LINEAR16`. `FLAC` stream + // encoding supports 16-bit and 24-bit samples, however, not all fields in + // `STREAMINFO` are supported. + FLAC = 2; + + // 8-bit samples that compand 14-bit audio samples using G.711 PCMU/mu-law. + MULAW = 3; + + // 8-bit samples that compand 13-bit audio samples using G.711 PCMU/a-law. + ALAW = 20; +} diff --git a/nlp_demo_riva/riva/protos/health.proto b/nlp_demo_riva/riva/protos/health.proto new file mode 100644 index 00000000..fb88c51f --- /dev/null +++ b/nlp_demo_riva/riva/protos/health.proto @@ -0,0 +1,39 @@ +// Copyright (c) 2021, NVIDIA CORPORATION. All rights reserved. +// +// NVIDIA CORPORATION and its licensors retain all intellectual property +// and proprietary rights in and to this software, related documentation +// and any modifications thereto. Any use, reproduction, disclosure or +// distribution of this software and related documentation without an express +// license agreement from NVIDIA CORPORATION is strictly prohibited. + + +// +//Based on gRPC health check protocol - more details found here: +//https://github.com/grpc/grpc/blob/master/doc/health-checking.md +// + +syntax = "proto3"; +option go_package = "nvidia.com/riva_speech"; + +package grpc.health.v1; + + +option cc_enable_arenas = true; + +service Health { + rpc Check(HealthCheckRequest) returns (HealthCheckResponse); + rpc Watch(HealthCheckRequest) returns (stream HealthCheckResponse); +} + +message HealthCheckRequest { + string service = 1; +} + +message HealthCheckResponse { + enum ServingStatus { + UNKNOWN = 0; + SERVING = 1; + NOT_SERVING = 2; + } + ServingStatus status = 1; +} diff --git a/nlp_demo_riva/riva/protos/jarvis_asr.proto b/nlp_demo_riva/riva/protos/jarvis_asr.proto new file mode 100644 index 00000000..f0435667 --- /dev/null +++ b/nlp_demo_riva/riva/protos/jarvis_asr.proto @@ -0,0 +1,276 @@ +// Copyright 2019 Google LLC. +// Copyright (c) 2021, NVIDIA CORPORATION. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +syntax = "proto3"; + +package nvidia.jarvis.asr; + +option cc_enable_arenas = true; +option go_package = "nvidia.com/jarvis_speech"; + +import "audio.proto"; + +/* + * The JarvisASR service provides two mechanisms for converting speech to text. + */ +service JarvisASR { + // Recognize expects a RecognizeRequest and returns a RecognizeResponse. This request will block + // until the audio is uploaded, processed, and a transcript is returned. + rpc Recognize(RecognizeRequest) returns (RecognizeResponse) {} + // StreamingRecognize is a non-blocking API call that allows audio data to be fed to the server in + // chunks as it becomes available. Depending on the configuration in the StreamingRecognizeRequest, + // intermediate results can be sent back to the client. Recognition ends when the stream is closed + // by the client. + rpc StreamingRecognize(stream StreamingRecognizeRequest) returns (stream StreamingRecognizeResponse) {} +} + + +/* + * RecognizeRequest is used for batch processing of a single audio recording. + */ +message RecognizeRequest { + // Provides information to recognizer that specifies how to process the request. + RecognitionConfig config = 1; + // The raw audio data to be processed. The audio bytes must be encoded as specified in + // `RecognitionConfig`. + bytes audio = 2; +} + + +/* + * A StreamingRecognizeRequest is used to configure and stream audio content to the + * Jarvis ASR Service. The first message sent must include only a StreamingRecognitionConfig. + * Subsequent messages sent in the stream must contain only raw bytes of the audio + * to be recognized. + */ +message StreamingRecognizeRequest { + // The streaming request, which is either a streaming config or audio content. + oneof streaming_request { + // Provides information to the recognizer that specifies how to process the + // request. The first `StreamingRecognizeRequest` message must contain a + // `streaming_config` message. + StreamingRecognitionConfig streaming_config = 1; + // The audio data to be recognized. Sequential chunks of audio data are sent + // in sequential `StreamingRecognizeRequest` messages. The first + // `StreamingRecognizeRequest` message must not contain `audio` data + // and all subsequent `StreamingRecognizeRequest` messages must contain + // `audio` data. The audio bytes must be encoded as specified in + // `RecognitionConfig`. + bytes audio_content = 2; + } +} + +// Provides information to the recognizer that specifies how to process the request +message RecognitionConfig { + // The encoding of the audio data sent in the request. + // + // All encodings support only 1 channel (mono) audio. + AudioEncoding encoding = 1; + + // Sample rate in Hertz of the audio data sent in all + // `RecognizeAudio` messages. + int32 sample_rate_hertz = 2; + + // Required. The language of the supplied audio as a + // [BCP-47](https://www.rfc-editor.org/rfc/bcp/bcp47.txt) language tag. + // Example: "en-US". + // Currently only en-US is supported + string language_code = 3; + + // Maximum number of recognition hypotheses to be returned. + // Specifically, the maximum number of `SpeechRecognizeAlternative` messages + // within each `SpeechRecognizeResult`. + // The server may return fewer than `max_alternatives`. + // If omitted, will return a maximum of one. + int32 max_alternatives = 4; + + // The number of channels in the input audio data. + // ONLY set this for MULTI-CHANNEL recognition. + // Valid values for LINEAR16 and FLAC are `1`-`8`. + // Valid values for OGG_OPUS are '1'-'254'. + // Valid value for MULAW, AMR, AMR_WB and SPEEX_WITH_HEADER_BYTE is only `1`. + // If `0` or omitted, defaults to one channel (mono). + // Note: We only recognize the first channel by default. + // To perform independent recognition on each channel set + // `enable_separate_recognition_per_channel` to 'true'. + int32 audio_channel_count = 7; + + // If `true`, the top result includes a list of words and + // the start and end time offsets (timestamps) for those words. If + // `false`, no word-level time offset information is returned. The default is + // `false`. + bool enable_word_time_offsets = 8; + + // If 'true', adds punctuation to recognition result hypotheses. + // The default 'false' value does not add punctuation to result hypotheses. + bool enable_automatic_punctuation = 11; + + // This needs to be set to `true` explicitly and `audio_channel_count` > 1 + // to get each channel recognized separately. The recognition result will + // contain a `channel_tag` field to state which channel that result belongs + // to. If this is not true, we will only recognize the first channel. The + // request is billed cumulatively for all channels recognized: + // `audio_channel_count` multiplied by the length of the audio. + bool enable_separate_recognition_per_channel = 12; + + // Which model to select for the given request. Valid choices: Jasper, Quartznet + string model = 13; + + // The verbatim_transcripts flag enables or disable inverse text normalization. + // 'true' returns exactly what was said, with no denormalization. + // 'false' applies inverse text normalization, also this is the default + bool verbatim_transcripts = 14; + + // Custom fields for passing request-level + // configuration options to plugins used in the + // model pipeline. + map custom_configuration = 24; + + +} + +// Provides information to the recognizer that specifies how to process the request +message StreamingRecognitionConfig { + // Provides information to the recognizer that specifies how to process the request + RecognitionConfig config = 1; + + // If `true`, interim results (tentative hypotheses) may be + // returned as they become available (these interim results are indicated with + // the `is_final=false` flag). + // If `false` or omitted, only `is_final=true` result(s) are returned. + bool interim_results = 2; +} + +// The only message returned to the client by the `Recognize` method. It +// contains the result as zero or more sequential `SpeechRecognitionResult` +// messages. +message RecognizeResponse { + // Sequential list of transcription results corresponding to + // sequential portions of audio. Currently only returns one transcript. + repeated SpeechRecognitionResult results = 1; +} + +// A speech recognition result corresponding to the latest transcript +message SpeechRecognitionResult { + + // May contain one or more recognition hypotheses (up to the + // maximum specified in `max_alternatives`). + // These alternatives are ordered in terms of accuracy, with the top (first) + // alternative being the most probable, as ranked by the recognizer. + repeated SpeechRecognitionAlternative alternatives = 1; + + // For multi-channel audio, this is the channel number corresponding to the + // recognized result for the audio from that channel. + // For audio_channel_count = N, its output values can range from '1' to 'N'. + int32 channel_tag = 2; + + // Length of audio processed so far in seconds + float audio_processed = 3; +} + +// Alternative hypotheses (a.k.a. n-best list). +message SpeechRecognitionAlternative { + // Transcript text representing the words that the user spoke. + string transcript = 1; + + // The non-normalized confidence estimate. A higher number + // indicates an estimated greater likelihood that the recognized words are + // correct. This field is set only for a non-streaming + // result or, of a streaming result where `is_final=true`. + // This field is not guaranteed to be accurate and users should not rely on it + // to be always provided. + float confidence = 2; + + // A list of word-specific information for each recognized word. Only populated + // if is_final=true + repeated WordInfo words = 3; +} + +// Word-specific information for recognized words. +message WordInfo { + // Time offset relative to the beginning of the audio in ms + // and corresponding to the start of the spoken word. + // This field is only set if `enable_word_time_offsets=true` and only + // in the top hypothesis. + int32 start_time = 1; + + // Time offset relative to the beginning of the audio in ms + // and corresponding to the end of the spoken word. + // This field is only set if `enable_word_time_offsets=true` and only + // in the top hypothesis. + int32 end_time = 2; + + // The word corresponding to this set of information. + string word = 3; +} + + +// `StreamingRecognizeResponse` is the only message returned to the client by +// `StreamingRecognize`. A series of zero or more `StreamingRecognizeResponse` +// messages are streamed back to the client. +// +// Here are few examples of `StreamingRecognizeResponse`s +// +// 1. results { alternatives { transcript: "tube" } stability: 0.01 } +// +// 2. results { alternatives { transcript: "to be a" } stability: 0.01 } +// +// 3. results { alternatives { transcript: "to be or not to be" +// confidence: 0.92 } +// alternatives { transcript: "to bee or not to bee" } +// is_final: true } +// + +message StreamingRecognizeResponse { + + // This repeated list contains the latest transcript(s) corresponding to + // audio currently being processed. + // Currently one result is returned, where each result can have multiple + // alternatives + repeated StreamingRecognitionResult results = 1; +} + +// A streaming speech recognition result corresponding to a portion of the audio +// that is currently being processed. +message StreamingRecognitionResult { + // May contain one or more recognition hypotheses (up to the + // maximum specified in `max_alternatives`). + // These alternatives are ordered in terms of accuracy, with the top (first) + // alternative being the most probable, as ranked by the recognizer. + repeated SpeechRecognitionAlternative alternatives = 1; + + // If `false`, this `StreamingRecognitionResult` represents an + // interim result that may change. If `true`, this is the final time the + // speech service will return this particular `StreamingRecognitionResult`, + // the recognizer will not return any further hypotheses for this portion of + // the transcript and corresponding audio. + bool is_final = 2; + + // An estimate of the likelihood that the recognizer will not + // change its guess about this interim result. Values range from 0.0 + // (completely unstable) to 1.0 (completely stable). + // This field is only provided for interim results (`is_final=false`). + // The default of 0.0 is a sentinel value indicating `stability` was not set. + float stability = 3; + + // For multi-channel audio, this is the channel number corresponding to the + // recognized result for the audio from that channel. + // For audio_channel_count = N, its output values can range from '1' to 'N'. + int32 channel_tag = 5; + + // Length of audio processed so far in seconds + float audio_processed = 6; +} diff --git a/nlp_demo_riva/riva/protos/jarvis_nlp.proto b/nlp_demo_riva/riva/protos/jarvis_nlp.proto new file mode 100644 index 00000000..0d7f2dad --- /dev/null +++ b/nlp_demo_riva/riva/protos/jarvis_nlp.proto @@ -0,0 +1,131 @@ +// Copyright (c) 2021, NVIDIA CORPORATION. All rights reserved. +// +// NVIDIA CORPORATION and its licensors retain all intellectual property +// and proprietary rights in and to this software, related documentation +// and any modifications thereto. Any use, reproduction, disclosure or +// distribution of this software and related documentation without an express +// license agreement from NVIDIA CORPORATION is strictly prohibited. + +syntax = "proto3"; + +package nvidia.jarvis.nlp; + +option cc_enable_arenas = true; +option go_package = "nvidia.com/jarvis_speech"; + +import "jarvis_nlp_core.proto"; + +// Jarvis NLP Services implement task-specific APIs for popular NLP tasks including +// intent recognition (as well as slot filling), and entity extraction. +service JarvisNLP { + // AnalyzeEntities accepts an input string and returns all named entities within + // the text, as well as a category and likelihood. + rpc AnalyzeEntities(AnalyzeEntitiesRequest) returns (TokenClassResponse) {} + + // AnalyzeIntent accepts an input string and returns the most likely + // intent as well as slots relevant to that intent. + // + // The model requires that a valid "domain" be passed in, and optionally + // supports including a previous intent classification result to provide + // context for the model. + rpc AnalyzeIntent(AnalyzeIntentRequest) returns (AnalyzeIntentResponse) {} + + // PunctuateText takes text with no- or limited- punctuation and returns + // the same text with corrected punctuation and capitalization. + rpc PunctuateText(TextTransformRequest) returns (TextTransformResponse) {} + + // NaturalQuery is a search function that enables querying one or more documents + // or contexts with a query that is written in natural language. + rpc NaturalQuery(NaturalQueryRequest) returns (NaturalQueryResponse) {} +} + +// AnalyzeIntentContext is reserved for future use when we may send context back in a +// a variety of different formats (including raw neural network hidden states) +message AnalyzeIntentContext { + // Reserved for future use +} + +// AnalyzeIntentOptions is an optional configuration message to be sent as part of +// an AnalyzeIntentRequest with query metadata +message AnalyzeIntentOptions { + // Optionally provide context from previous interactions to bias the model's prediction + oneof context { + string previous_intent = 1; + AnalyzeIntentContext vectors = 2; + } + // Optional domain field. Domain must be supported otherwise an error will be returned. + // If left blank, a domain detector will be run first and then the query routed to the + // appropriate intent classifier (if it exists) + string domain = 3; + + // Optional language field. Assumed to be "en-US" if not specified. + string lang = 4; +} + +// AnalyzeIntentRequest is the input message for the AnalyzeIntent service +message AnalyzeIntentRequest { + // The string to analyze for intent and slots + string query = 1; + // Optional configuration for the request, including providing context from previous turns + // and hardcoding a domain/language + AnalyzeIntentOptions options = 2; +} + +// AnalyzeIntentResponse is returned by the AnalyzeIntent service, and includes information +// related to the query's intent, (optionally) slot data, and its domain. +message AnalyzeIntentResponse { + // Intent classification result, including the label and score + Classification intent = 1; + // List of tokens explicitly marked as filling a slot relevant to the intent, where the + // tokens may not exactly match the input (based on the recombined values after tokenization) + repeated TokenClassValue slots = 2; + // Returns the inferred domain for the query if not hardcoded in the request. In the case where + // the domain was hardcoded in AnalyzeIntentRequest, the returned domain is an exact match to the + // request. In the case where no domain matches the query, intent and slots will be unset. + // + // DEPRECATED, use Classification domain field. + string domain_str = 3; + + // Returns the inferred domain for the query if not hardcoded in the request. In the case where + // the domain was hardcoded in AnalyzeIntentRequest, the returned domain is an exact match to the + // request. In the case where no domain matches the query, intent and slots will be unset. + Classification domain = 4; +} + +// AnalyzeEntitiesOptions is an optional configuration message to be sent as part of +// an AnalyzeEntitiesRequest with query metadata +message AnalyzeEntitiesOptions { + // Optional language field. Assumed to be "en-US" if not specified. + string lang = 4; +} + +// AnalyzeEntitiesRequest is the input message for the AnalyzeEntities service +message AnalyzeEntitiesRequest { + // The string to analyze for intent and slots + string query = 1; + // Optional configuration for the request, including providing context from previous turns + // and hardcoding a domain/language + AnalyzeEntitiesOptions options = 2; +} + +message NaturalQueryRequest { + // The natural language query + string query = 1; + + // Maximum number of answers to return for the query. Defaults to 1 if not set. + uint32 top_n = 2; + + // Context to search with the above query + string context = 3; +} + +message NaturalQueryResult { + // text which answers the query + string answer = 1; + // Score representing confidence in result + float score = 2; +} + +message NaturalQueryResponse { + repeated NaturalQueryResult results = 1; +} diff --git a/nlp_demo_riva/riva/protos/jarvis_nlp_core.proto b/nlp_demo_riva/riva/protos/jarvis_nlp_core.proto new file mode 100644 index 00000000..7415c6ce --- /dev/null +++ b/nlp_demo_riva/riva/protos/jarvis_nlp_core.proto @@ -0,0 +1,131 @@ +// Copyright (c) 2021, NVIDIA CORPORATION. All rights reserved. +// +// NVIDIA CORPORATION and its licensors retain all intellectual property +// and proprietary rights in and to this software, related documentation +// and any modifications thereto. Any use, reproduction, disclosure or +// distribution of this software and related documentation without an express +// license agreement from NVIDIA CORPORATION is strictly prohibited. + +syntax = "proto3"; + +package nvidia.jarvis.nlp; + +option cc_enable_arenas = true; +option go_package = "nvidia.com/jarvis_speech"; + +/* + * The Jarvis Core NLP Service provides generic NLP services for custom + * model use cases. The intent of this service is to allow users to design + * models for arbitrary use cases that conform simply with input and output types + * specified in the service. As an explicit example, the ClassifyText function + * could be used for sentiment classification, domain recognition, language + * identification, etc. + */ +service JarvisCoreNLP { + // ClassifyText takes as input an input/query string and parameters related + // to the requested model to use to evaluate the text. The service evaluates the + // text with the requested model, and returns one or more classifications. + rpc ClassifyText(TextClassRequest) returns (TextClassResponse) {} + + // ClassifyTokens takes as input either a string or list of tokens and parameters + // related to which model to use. The service evaluates the text with the requested + // model, performing additional tokenization if necessary, and returns one or more + // class labels per token. + rpc ClassifyTokens(TokenClassRequest) returns (TokenClassResponse) {} + + // TransformText takes an input/query string and parameters related to the + // requested model and returns another string. The behavior of the function + // is defined entirely by the underlying model and may be used for + // tasks like translation, adding punctuation, augment the input directly, etc. + rpc TransformText(TextTransformRequest) returns (TextTransformResponse) {} + +} + +// NLPModelParams is a metadata message that is included in every request message +// used by the Core NLP Service and is used to specify model characteristics/requirements +message NLPModelParams { + // Requested model to use. If unavailable, the request will return an error + string model_name = 1; +} + +// TextTransformRequest is a request type intended for services like TransformText +// which take an arbitrary text input +message TextTransformRequest { + // Each repeated text element is handled independently for handling multiple + // input strings with a single request + repeated string text = 1; + uint32 top_n = 2; // + NLPModelParams model = 3; +} + +// TextTransformResponse is returned by the TransformText method. Responses +// are returned in the same order as they were requested. +message TextTransformResponse { + repeated string text = 1; +} + +// TextClassRequest is the input message to the ClassifyText service. +message TextClassRequest { + // Each repeated text element is handled independently for handling multiple + // input strings with a single request + repeated string text = 1; + + // Return the top N classification results for each input. 0 or 1 will return top class, otherwise N. + // Note: Current disabled. + uint32 top_n = 2; + NLPModelParams model = 3; +} + +// Classification messages return a class name and corresponding score +message Classification { + string class_name = 1; + float score = 2; +} + +// Span of a particular result +message Span { + uint32 start = 1; + uint32 end = 2; +} + +// ClassificationResults contain zero or more Classification messages +// If the number of Classifications is > 1, top_n > 1 must have been +// specified. +message ClassificationResult { + repeated Classification labels = 1; +} + +// TextClassResponse is the return message from the ClassifyText service. +message TextClassResponse { + repeated ClassificationResult results = 1; +} + +// TokenClassRequest is the input message to the ClassifyText service. +message TokenClassRequest { + // Each repeated text element is handled independently for handling multiple + // input strings with a single request + repeated string text = 1; + + // Return the top N classification results for each input. 0 or 1 will return top class, otherwise N. + // Note: Current disabled. + uint32 top_n = 3; + NLPModelParams model = 4; +} + +// TokenClassValue is used to correlate an input token with its classification results +message TokenClassValue { + string token = 1; + repeated Classification label = 2; + repeated Span span = 3; +} + +// TokenClassSequence is used for returning a sequence of TokenClassValue objects +// in the original order of input tokens +message TokenClassSequence { + repeated TokenClassValue results = 1; +} + +// TokenClassResponse returns a single TokenClassSequence per input request +message TokenClassResponse { + repeated TokenClassSequence results = 1; +} diff --git a/nlp_demo_riva/riva/protos/jarvis_tts.proto b/nlp_demo_riva/riva/protos/jarvis_tts.proto new file mode 100644 index 00000000..8810dbb3 --- /dev/null +++ b/nlp_demo_riva/riva/protos/jarvis_tts.proto @@ -0,0 +1,46 @@ +// Copyright (c) 2021, NVIDIA CORPORATION. All rights reserved. +// +// NVIDIA CORPORATION and its licensors retain all intellectual property +// and proprietary rights in and to this software, related documentation +// and any modifications thereto. Any use, reproduction, disclosure or +// distribution of this software and related documentation without an express +// license agreement from NVIDIA CORPORATION is strictly prohibited. + + +syntax = "proto3"; + +package nvidia.jarvis.tts; + +option cc_enable_arenas = true; +option go_package = "nvidia.com/jarvis_speech"; + +import "audio.proto"; + +service JarvisTTS { + // Used to request speech-to-text from the service. Submit a request containing the + // desired text and configuration, and receive audio bytes in the requested format. + rpc Synthesize(SynthesizeSpeechRequest) returns (SynthesizeSpeechResponse) {} + + // Used to request speech-to-text returned via stream as it becomes available. + // Submit a SynthesizeSpeechRequest with desired text and configuration, + // and receive stream of bytes in the requested format. + rpc SynthesizeOnline(SynthesizeSpeechRequest) returns (stream SynthesizeSpeechResponse) {} +} + +message SynthesizeSpeechRequest { + string text = 1; + string language_code = 2; + // audio encoding params + AudioEncoding encoding = 3; + int32 sample_rate_hz = 4; + // voice params + string voice_name = 5; +} + +message SynthesizeSpeechResponse { + bytes audio = 1; +} + +/* + * + */ diff --git a/nlp_demo_riva/riva/protos/riva_asr.proto b/nlp_demo_riva/riva/protos/riva_asr.proto new file mode 100644 index 00000000..ddb69833 --- /dev/null +++ b/nlp_demo_riva/riva/protos/riva_asr.proto @@ -0,0 +1,276 @@ +// Copyright 2019 Google LLC. +// Copyright (c) 2021, NVIDIA CORPORATION. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +syntax = "proto3"; + +package nvidia.riva.asr; + +option cc_enable_arenas = true; +option go_package = "nvidia.com/riva_speech"; + +import "riva_audio.proto"; + +/* + * The RivaSpeechRecognition service provides two mechanisms for converting speech to text. + */ +service RivaSpeechRecognition { + // Recognize expects a RecognizeRequest and returns a RecognizeResponse. This request will block + // until the audio is uploaded, processed, and a transcript is returned. + rpc Recognize(RecognizeRequest) returns (RecognizeResponse) {} + // StreamingRecognize is a non-blocking API call that allows audio data to be fed to the server in + // chunks as it becomes available. Depending on the configuration in the StreamingRecognizeRequest, + // intermediate results can be sent back to the client. Recognition ends when the stream is closed + // by the client. + rpc StreamingRecognize(stream StreamingRecognizeRequest) returns (stream StreamingRecognizeResponse) {} +} + + +/* + * RecognizeRequest is used for batch processing of a single audio recording. + */ +message RecognizeRequest { + // Provides information to recognizer that specifies how to process the request. + RecognitionConfig config = 1; + // The raw audio data to be processed. The audio bytes must be encoded as specified in + // `RecognitionConfig`. + bytes audio = 2; +} + + +/* + * A StreamingRecognizeRequest is used to configure and stream audio content to the + * Riva ASR Service. The first message sent must include only a StreamingRecognitionConfig. + * Subsequent messages sent in the stream must contain only raw bytes of the audio + * to be recognized. + */ +message StreamingRecognizeRequest { + // The streaming request, which is either a streaming config or audio content. + oneof streaming_request { + // Provides information to the recognizer that specifies how to process the + // request. The first `StreamingRecognizeRequest` message must contain a + // `streaming_config` message. + StreamingRecognitionConfig streaming_config = 1; + // The audio data to be recognized. Sequential chunks of audio data are sent + // in sequential `StreamingRecognizeRequest` messages. The first + // `StreamingRecognizeRequest` message must not contain `audio` data + // and all subsequent `StreamingRecognizeRequest` messages must contain + // `audio` data. The audio bytes must be encoded as specified in + // `RecognitionConfig`. + bytes audio_content = 2; + } +} + +// Provides information to the recognizer that specifies how to process the request +message RecognitionConfig { + // The encoding of the audio data sent in the request. + // + // All encodings support only 1 channel (mono) audio. + AudioEncoding encoding = 1; + + // Sample rate in Hertz of the audio data sent in all + // `RecognizeAudio` messages. + int32 sample_rate_hertz = 2; + + // Required. The language of the supplied audio as a + // [BCP-47](https://www.rfc-editor.org/rfc/bcp/bcp47.txt) language tag. + // Example: "en-US". + // Currently only en-US is supported + string language_code = 3; + + // Maximum number of recognition hypotheses to be returned. + // Specifically, the maximum number of `SpeechRecognizeAlternative` messages + // within each `SpeechRecognizeResult`. + // The server may return fewer than `max_alternatives`. + // If omitted, will return a maximum of one. + int32 max_alternatives = 4; + + // The number of channels in the input audio data. + // ONLY set this for MULTI-CHANNEL recognition. + // Valid values for LINEAR16 and FLAC are `1`-`8`. + // Valid values for OGG_OPUS are '1'-'254'. + // Valid value for MULAW, AMR, AMR_WB and SPEEX_WITH_HEADER_BYTE is only `1`. + // If `0` or omitted, defaults to one channel (mono). + // Note: We only recognize the first channel by default. + // To perform independent recognition on each channel set + // `enable_separate_recognition_per_channel` to 'true'. + int32 audio_channel_count = 7; + + // If `true`, the top result includes a list of words and + // the start and end time offsets (timestamps) for those words. If + // `false`, no word-level time offset information is returned. The default is + // `false`. + bool enable_word_time_offsets = 8; + + // If 'true', adds punctuation to recognition result hypotheses. + // The default 'false' value does not add punctuation to result hypotheses. + bool enable_automatic_punctuation = 11; + + // This needs to be set to `true` explicitly and `audio_channel_count` > 1 + // to get each channel recognized separately. The recognition result will + // contain a `channel_tag` field to state which channel that result belongs + // to. If this is not true, we will only recognize the first channel. The + // request is billed cumulatively for all channels recognized: + // `audio_channel_count` multiplied by the length of the audio. + bool enable_separate_recognition_per_channel = 12; + + // Which model to select for the given request. Valid choices: Jasper, Quartznet + string model = 13; + + // The verbatim_transcripts flag enables or disable inverse text normalization. + // 'true' returns exactly what was said, with no denormalization. + // 'false' applies inverse text normalization, also this is the default + bool verbatim_transcripts = 14; + + // Custom fields for passing request-level + // configuration options to plugins used in the + // model pipeline. + map custom_configuration = 24; + + +} + +// Provides information to the recognizer that specifies how to process the request +message StreamingRecognitionConfig { + // Provides information to the recognizer that specifies how to process the request + RecognitionConfig config = 1; + + // If `true`, interim results (tentative hypotheses) may be + // returned as they become available (these interim results are indicated with + // the `is_final=false` flag). + // If `false` or omitted, only `is_final=true` result(s) are returned. + bool interim_results = 2; +} + +// The only message returned to the client by the `Recognize` method. It +// contains the result as zero or more sequential `SpeechRecognitionResult` +// messages. +message RecognizeResponse { + // Sequential list of transcription results corresponding to + // sequential portions of audio. Currently only returns one transcript. + repeated SpeechRecognitionResult results = 1; +} + +// A speech recognition result corresponding to the latest transcript +message SpeechRecognitionResult { + + // May contain one or more recognition hypotheses (up to the + // maximum specified in `max_alternatives`). + // These alternatives are ordered in terms of accuracy, with the top (first) + // alternative being the most probable, as ranked by the recognizer. + repeated SpeechRecognitionAlternative alternatives = 1; + + // For multi-channel audio, this is the channel number corresponding to the + // recognized result for the audio from that channel. + // For audio_channel_count = N, its output values can range from '1' to 'N'. + int32 channel_tag = 2; + + // Length of audio processed so far in seconds + float audio_processed = 3; +} + +// Alternative hypotheses (a.k.a. n-best list). +message SpeechRecognitionAlternative { + // Transcript text representing the words that the user spoke. + string transcript = 1; + + // The non-normalized confidence estimate. A higher number + // indicates an estimated greater likelihood that the recognized words are + // correct. This field is set only for a non-streaming + // result or, of a streaming result where `is_final=true`. + // This field is not guaranteed to be accurate and users should not rely on it + // to be always provided. + float confidence = 2; + + // A list of word-specific information for each recognized word. Only populated + // if is_final=true + repeated WordInfo words = 3; +} + +// Word-specific information for recognized words. +message WordInfo { + // Time offset relative to the beginning of the audio in ms + // and corresponding to the start of the spoken word. + // This field is only set if `enable_word_time_offsets=true` and only + // in the top hypothesis. + int32 start_time = 1; + + // Time offset relative to the beginning of the audio in ms + // and corresponding to the end of the spoken word. + // This field is only set if `enable_word_time_offsets=true` and only + // in the top hypothesis. + int32 end_time = 2; + + // The word corresponding to this set of information. + string word = 3; +} + + +// `StreamingRecognizeResponse` is the only message returned to the client by +// `StreamingRecognize`. A series of zero or more `StreamingRecognizeResponse` +// messages are streamed back to the client. +// +// Here are few examples of `StreamingRecognizeResponse`s +// +// 1. results { alternatives { transcript: "tube" } stability: 0.01 } +// +// 2. results { alternatives { transcript: "to be a" } stability: 0.01 } +// +// 3. results { alternatives { transcript: "to be or not to be" +// confidence: 0.92 } +// alternatives { transcript: "to bee or not to bee" } +// is_final: true } +// + +message StreamingRecognizeResponse { + + // This repeated list contains the latest transcript(s) corresponding to + // audio currently being processed. + // Currently one result is returned, where each result can have multiple + // alternatives + repeated StreamingRecognitionResult results = 1; +} + +// A streaming speech recognition result corresponding to a portion of the audio +// that is currently being processed. +message StreamingRecognitionResult { + // May contain one or more recognition hypotheses (up to the + // maximum specified in `max_alternatives`). + // These alternatives are ordered in terms of accuracy, with the top (first) + // alternative being the most probable, as ranked by the recognizer. + repeated SpeechRecognitionAlternative alternatives = 1; + + // If `false`, this `StreamingRecognitionResult` represents an + // interim result that may change. If `true`, this is the final time the + // speech service will return this particular `StreamingRecognitionResult`, + // the recognizer will not return any further hypotheses for this portion of + // the transcript and corresponding audio. + bool is_final = 2; + + // An estimate of the likelihood that the recognizer will not + // change its guess about this interim result. Values range from 0.0 + // (completely unstable) to 1.0 (completely stable). + // This field is only provided for interim results (`is_final=false`). + // The default of 0.0 is a sentinel value indicating `stability` was not set. + float stability = 3; + + // For multi-channel audio, this is the channel number corresponding to the + // recognized result for the audio from that channel. + // For audio_channel_count = N, its output values can range from '1' to 'N'. + int32 channel_tag = 5; + + // Length of audio processed so far in seconds + float audio_processed = 6; +} diff --git a/nlp_demo_riva/riva/protos/riva_audio.proto b/nlp_demo_riva/riva/protos/riva_audio.proto new file mode 100644 index 00000000..e69b24c5 --- /dev/null +++ b/nlp_demo_riva/riva/protos/riva_audio.proto @@ -0,0 +1,40 @@ +// Copyright (c) 2021, NVIDIA CORPORATION. All rights reserved. +// +// NVIDIA CORPORATION and its licensors retain all intellectual property +// and proprietary rights in and to this software, related documentation +// and any modifications thereto. Any use, reproduction, disclosure or +// distribution of this software and related documentation without an express +// license agreement from NVIDIA CORPORATION is strictly prohibited. + + +syntax = "proto3"; + +package nvidia.riva; + +option cc_enable_arenas = true; + + +/* + * AudioEncoding specifies the encoding of the audio bytes in the encapsulating message. + */ +enum AudioEncoding { + // Not specified. + ENCODING_UNSPECIFIED = 0; + + // Uncompressed 16-bit signed little-endian samples (Linear PCM). + LINEAR_PCM = 1; + + // `FLAC` (Free Lossless Audio + // Codec) is the recommended encoding because it is + // lossless--therefore recognition is not compromised--and + // requires only about half the bandwidth of `LINEAR16`. `FLAC` stream + // encoding supports 16-bit and 24-bit samples, however, not all fields in + // `STREAMINFO` are supported. + FLAC = 2; + + // 8-bit samples that compand 14-bit audio samples using G.711 PCMU/mu-law. + MULAW = 3; + + // 8-bit samples that compand 13-bit audio samples using G.711 PCMU/a-law. + ALAW = 20; +} diff --git a/nlp_demo_riva/riva/protos/riva_nlp.proto b/nlp_demo_riva/riva/protos/riva_nlp.proto new file mode 100644 index 00000000..9f35d9a0 --- /dev/null +++ b/nlp_demo_riva/riva/protos/riva_nlp.proto @@ -0,0 +1,244 @@ +// Copyright (c) 2021, NVIDIA CORPORATION. All rights reserved. +// +// NVIDIA CORPORATION and its licensors retain all intellectual property +// and proprietary rights in and to this software, related documentation +// and any modifications thereto. Any use, reproduction, disclosure or +// distribution of this software and related documentation without an express +// license agreement from NVIDIA CORPORATION is strictly prohibited. + +syntax = "proto3"; + +package nvidia.riva.nlp; + +option cc_enable_arenas = true; +option go_package = "nvidia.com/riva_speech"; + +/* Riva Natural Language Services implement generic and task-specific APIs. + * The generic APIs allows users to design + * models for arbitrary use cases that conform simply with input and output types + * specified in the service. As an explicit example, the ClassifyText function + * could be used for sentiment classification, domain recognition, language + * identification, etc. + * The task-specific APIs can be used for popular NLP tasks such as + * intent recognition (as well as slot filling), and entity extraction. + */ + +service RivaLanguageUnderstanding { + + // ClassifyText takes as input an input/query string and parameters related + // to the requested model to use to evaluate the text. The service evaluates the + // text with the requested model, and returns one or more classifications. + rpc ClassifyText(TextClassRequest) returns (TextClassResponse) {} + + // ClassifyTokens takes as input either a string or list of tokens and parameters + // related to which model to use. The service evaluates the text with the requested + // model, performing additional tokenization if necessary, and returns one or more + // class labels per token. + rpc ClassifyTokens(TokenClassRequest) returns (TokenClassResponse) {} + + // TransformText takes an input/query string and parameters related to the + // requested model and returns another string. The behavior of the function + // is defined entirely by the underlying model and may be used for + // tasks like translation, adding punctuation, augment the input directly, etc. + rpc TransformText(TextTransformRequest) returns (TextTransformResponse) {} + + // AnalyzeEntities accepts an input string and returns all named entities within + // the text, as well as a category and likelihood. + rpc AnalyzeEntities(AnalyzeEntitiesRequest) returns (TokenClassResponse) {} + + // AnalyzeIntent accepts an input string and returns the most likely + // intent as well as slots relevant to that intent. + // + // The model requires that a valid "domain" be passed in, and optionally + // supports including a previous intent classification result to provide + // context for the model. + rpc AnalyzeIntent(AnalyzeIntentRequest) returns (AnalyzeIntentResponse) {} + + // PunctuateText takes text with no- or limited- punctuation and returns + // the same text with corrected punctuation and capitalization. + rpc PunctuateText(TextTransformRequest) returns (TextTransformResponse) {} + + // NaturalQuery is a search function that enables querying one or more documents + // or contexts with a query that is written in natural language. + rpc NaturalQuery(NaturalQueryRequest) returns (NaturalQueryResponse) {} +} + +// NLPModelParams is a metadata message that is included in every request message +// used by the Core NLP Service and is used to specify model characteristics/requirements +message NLPModelParams { + // Requested model to use. If unavailable, the request will return an error + string model_name = 1; +} + +// TextTransformRequest is a request type intended for services like TransformText +// which take an arbitrary text input +message TextTransformRequest { + // Each repeated text element is handled independently for handling multiple + // input strings with a single request + repeated string text = 1; + uint32 top_n = 2; // + NLPModelParams model = 3; +} + +// TextTransformResponse is returned by the TransformText method. Responses +// are returned in the same order as they were requested. +message TextTransformResponse { + repeated string text = 1; +} + +// TextClassRequest is the input message to the ClassifyText service. +message TextClassRequest { + // Each repeated text element is handled independently for handling multiple + // input strings with a single request + repeated string text = 1; + + // Return the top N classification results for each input. 0 or 1 will return top class, otherwise N. + // Note: Current disabled. + uint32 top_n = 2; + NLPModelParams model = 3; +} + +// Classification messages return a class name and corresponding score +message Classification { + string class_name = 1; + float score = 2; +} + +// Span of a particular result +message Span { + uint32 start = 1; + uint32 end = 2; +} + +// ClassificationResults contain zero or more Classification messages +// If the number of Classifications is > 1, top_n > 1 must have been +// specified. +message ClassificationResult { + repeated Classification labels = 1; +} + +// TextClassResponse is the return message from the ClassifyText service. +message TextClassResponse { + repeated ClassificationResult results = 1; +} + +// TokenClassRequest is the input message to the ClassifyText service. +message TokenClassRequest { + // Each repeated text element is handled independently for handling multiple + // input strings with a single request + repeated string text = 1; + + // Return the top N classification results for each input. 0 or 1 will return top class, otherwise N. + // Note: Current disabled. + uint32 top_n = 3; + NLPModelParams model = 4; +} + +// TokenClassValue is used to correlate an input token with its classification results +message TokenClassValue { + string token = 1; + repeated Classification label = 2; + repeated Span span = 3; +} + +// TokenClassSequence is used for returning a sequence of TokenClassValue objects +// in the original order of input tokens +message TokenClassSequence { + repeated TokenClassValue results = 1; +} + +// TokenClassResponse returns a single TokenClassSequence per input request +message TokenClassResponse { + repeated TokenClassSequence results = 1; +} + +// AnalyzeIntentContext is reserved for future use when we may send context back in a +// a variety of different formats (including raw neural network hidden states) +message AnalyzeIntentContext { + // Reserved for future use +} + +// AnalyzeIntentOptions is an optional configuration message to be sent as part of +// an AnalyzeIntentRequest with query metadata +message AnalyzeIntentOptions { + // Optionally provide context from previous interactions to bias the model's prediction + oneof context { + string previous_intent = 1; + AnalyzeIntentContext vectors = 2; + } + // Optional domain field. Domain must be supported otherwise an error will be returned. + // If left blank, a domain detector will be run first and then the query routed to the + // appropriate intent classifier (if it exists) + string domain = 3; + + // Optional language field. Assumed to be "en-US" if not specified. + string lang = 4; +} + +// AnalyzeIntentRequest is the input message for the AnalyzeIntent service +message AnalyzeIntentRequest { + // The string to analyze for intent and slots + string query = 1; + // Optional configuration for the request, including providing context from previous turns + // and hardcoding a domain/language + AnalyzeIntentOptions options = 2; +} + +// AnalyzeIntentResponse is returned by the AnalyzeIntent service, and includes information +// related to the query's intent, (optionally) slot data, and its domain. +message AnalyzeIntentResponse { + // Intent classification result, including the label and score + Classification intent = 1; + // List of tokens explicitly marked as filling a slot relevant to the intent, where the + // tokens may not exactly match the input (based on the recombined values after tokenization) + repeated TokenClassValue slots = 2; + // Returns the inferred domain for the query if not hardcoded in the request. In the case where + // the domain was hardcoded in AnalyzeIntentRequest, the returned domain is an exact match to the + // request. In the case where no domain matches the query, intent and slots will be unset. + // + // DEPRECATED, use Classification domain field. + string domain_str = 3; + + // Returns the inferred domain for the query if not hardcoded in the request. In the case where + // the domain was hardcoded in AnalyzeIntentRequest, the returned domain is an exact match to the + // request. In the case where no domain matches the query, intent and slots will be unset. + Classification domain = 4; +} + +// AnalyzeEntitiesOptions is an optional configuration message to be sent as part of +// an AnalyzeEntitiesRequest with query metadata +message AnalyzeEntitiesOptions { + // Optional language field. Assumed to be "en-US" if not specified. + string lang = 4; +} + +// AnalyzeEntitiesRequest is the input message for the AnalyzeEntities service +message AnalyzeEntitiesRequest { + // The string to analyze for intent and slots + string query = 1; + // Optional configuration for the request, including providing context from previous turns + // and hardcoding a domain/language + AnalyzeEntitiesOptions options = 2; +} + +message NaturalQueryRequest { + // The natural language query + string query = 1; + + // Maximum number of answers to return for the query. Defaults to 1 if not set. + uint32 top_n = 2; + + // Context to search with the above query + string context = 3; +} + +message NaturalQueryResult { + // text which answers the query + string answer = 1; + // Score representing confidence in result + float score = 2; +} + +message NaturalQueryResponse { + repeated NaturalQueryResult results = 1; +} diff --git a/nlp_demo_riva/riva/protos/riva_tts.proto b/nlp_demo_riva/riva/protos/riva_tts.proto new file mode 100644 index 00000000..904585e2 --- /dev/null +++ b/nlp_demo_riva/riva/protos/riva_tts.proto @@ -0,0 +1,46 @@ +// Copyright (c) 2021, NVIDIA CORPORATION. All rights reserved. +// +// NVIDIA CORPORATION and its licensors retain all intellectual property +// and proprietary rights in and to this software, related documentation +// and any modifications thereto. Any use, reproduction, disclosure or +// distribution of this software and related documentation without an express +// license agreement from NVIDIA CORPORATION is strictly prohibited. + + +syntax = "proto3"; + +package nvidia.riva.tts; + +option cc_enable_arenas = true; +option go_package = "nvidia.com/riva_speech"; + +import "riva_audio.proto"; + +service RivaSpeechSynthesis { + // Used to request speech-to-text from the service. Submit a request containing the + // desired text and configuration, and receive audio bytes in the requested format. + rpc Synthesize(SynthesizeSpeechRequest) returns (SynthesizeSpeechResponse) {} + + // Used to request speech-to-text returned via stream as it becomes available. + // Submit a SynthesizeSpeechRequest with desired text and configuration, + // and receive stream of bytes in the requested format. + rpc SynthesizeOnline(SynthesizeSpeechRequest) returns (stream SynthesizeSpeechResponse) {} +} + +message SynthesizeSpeechRequest { + string text = 1; + string language_code = 2; + // audio encoding params + AudioEncoding encoding = 3; + int32 sample_rate_hz = 4; + // voice params + string voice_name = 5; +} + +message SynthesizeSpeechResponse { + bytes audio = 1; +} + +/* + * + */ diff --git a/nlp_demo_riva/riva/riva_api-1.4.0b0-py3-none-any.whl b/nlp_demo_riva/riva/riva_api-1.4.0b0-py3-none-any.whl new file mode 100644 index 00000000..2a5cea5f Binary files /dev/null and b/nlp_demo_riva/riva/riva_api-1.4.0b0-py3-none-any.whl differ diff --git a/nlp_demo_riva/riva/riva_clean.sh b/nlp_demo_riva/riva/riva_clean.sh new file mode 100644 index 00000000..d66fc7c2 --- /dev/null +++ b/nlp_demo_riva/riva/riva_clean.sh @@ -0,0 +1,67 @@ +#!/bin/bash +# Copyright (c) 2021, NVIDIA CORPORATION. All rights reserved. +# +# NVIDIA CORPORATION and its licensors retain all intellectual property +# and proprietary rights in and to this software, related documentation +# and any modifications thereto. Any use, reproduction, disclosure or +# distribution of this software and related documentation without an express +# license agreement from NVIDIA CORPORATION is strictly prohibited. + +check_docker_version() { + version_string=$(docker version --format '{{.Server.Version}}') + if [ $? -ne 0 ]; then + echo "Unable to run Docker. Please check that Docker is installed and functioning." + exit 1 + fi + maj_ver=$(echo $version_string | awk -F. '{print $1}') + min_ver=$(echo $version_string | awk -F. '{print $2}') + if [ "$maj_ver" -lt "19" ] || ([ "$maj_ver" -eq "19" ] && [ "$min_ver" -lt "03" ]); then + echo "Docker version insufficient. Please use Docker 19.03 or later" + exit 1; + fi +} + +delete_docker_volume() { + + # detect if docker volume or local filesystem was used to store models + if [[ "$(docker volume inspect --format '{{ .Name }}' $1)" == "$1" ]]; then + echo "Deleting docker volume..." + read -r -p "Found docker volume '$1'. Delete? [y/N] " response + if [[ "$response" =~ ^([yY][eE][sS]|[yY])$ ]] + then + docker volume rm $1 &> /dev/null + else + echo "Skipping..." + fi + else + echo "'$1' is not a Docker volume, or has already been deleted." + if [ -d $1 ]; then + echo "Local path '$1' exists. Delete manually, if desired, with:" + echo "rm -rf $1" + fi + fi + +} + +# BEGIN SCRIPT +check_docker_version + +# load config file +script_path="$( cd "$(dirname "$0")" >/dev/null 2>&1 ; pwd -P )" +if [ -z "$1" ]; then + config_path="${script_path}/config.sh" +else + config_path=$(readlink -f $1) +fi +if [[ ! -f $config_path ]]; then + echo 'Unable to load configuration file. Override path to file with -c argument.' + exit 1 +fi +source $config_path + +echo "Cleaning up local Riva installation." + +docker kill $riva_daemon_speech &> /dev/null +docker rm -f $riva_daemon_speech &> /dev/null + +delete_docker_volume $riva_model_loc diff --git a/nlp_demo_riva/riva/riva_init.sh b/nlp_demo_riva/riva/riva_init.sh new file mode 100644 index 00000000..c38fe5b0 --- /dev/null +++ b/nlp_demo_riva/riva/riva_init.sh @@ -0,0 +1,160 @@ +#!/bin/bash +# Copyright (c) 2021, NVIDIA CORPORATION. All rights reserved. +# +# NVIDIA CORPORATION and its licensors retain all intellectual property +# and proprietary rights in and to this software, related documentation +# and any modifications thereto. Any use, reproduction, disclosure or +# distribution of this software and related documentation without an express +# license agreement from NVIDIA CORPORATION is strictly prohibited. + +get_ngc_key_from_environment() { + # first check the global NGC_API_KEY environment variable + local ngc_key=$NGC_API_KEY + # if env variable was not set, and a ~/.ngc/config exists + # try to get it from there + if [ -z "$ngc_key" ] && [[ -f "$HOME/.ngc/config" ]] + then + ngc_key=$(cat $HOME/.ngc/config | grep ^apikey | awk '{print $3}') + fi + echo $ngc_key +} + +docker_pull() { + image_exists=$(docker images --filter=reference=$1 -q | wc -l) + if [[ $image_exists -eq 1 ]]; then + echo " > Image $1 exists. Skipping." + return + fi + attempts=3 + echo " > Pulling $1. This may take some time..." + for ((i = 1 ; i <= $attempts ; i++)); do + docker pull -q $1 &> /dev/null + if [ $? -ne 0 ]; then + echo " > Attempt $i out of $attempts failed" + if [ $i -eq $attempts ]; then + echo "Error occurred pulling '$1'." + docker pull $1 + echo "Exiting." + exit 1 + else + echo " > Trying again..." + continue + fi + else + break + fi + done +} + +check_docker_version() { + version_string=$(docker version --format '{{.Server.Version}}') + if [ $? -ne 0 ]; then + echo "Unable to run Docker. Please check that Docker is installed and functioning." + exit 1 + fi + maj_ver=$(echo $version_string | awk -F. '{print $1}') + min_ver=$(echo $version_string | awk -F. '{print $2}') + if [ "$maj_ver" -lt "19" ] || ([ "$maj_ver" -eq "19" ] && [ "$min_ver" -lt "03" ]); then + echo "Docker version insufficient. Please use Docker 19.03 or later" + exit 1; + fi +} + +# BEGIN SCRIPT +check_docker_version + +# load config file +script_path="$( cd "$(dirname "$0")" >/dev/null 2>&1 ; pwd -P )" +if [ -z "$1" ]; then + config_path="${script_path}/config.sh" +else + config_path=$(readlink -f $1) +fi + +if [[ ! -f $config_path ]]; then + echo 'Unable to load configuration file. Override path to file with -c argument.' + exit 1 +fi +source $config_path || exit 1 + +# automatically get NGC_API_KEY or request from user if necessary +NGC_API_KEY="$(get_ngc_key_from_environment)" +if [ -z "$NGC_API_KEY" ]; then + read -sp 'Please enter API key for ngc.nvidia.com: ' NGC_API_KEY + echo +fi + +# use the API key to run docker login for the NGC registry +# exit early if the key is invalid, because we won't be able to do anything +echo "Logging into NGC docker registry if necessary..." +echo $NGC_API_KEY | docker login -u '$oauthtoken' --password-stdin nvcr.io &> /dev/null +if [ $? -ne 0 ]; then + echo 'NGC API Key is invalid. Please check and try again.' + exit 1 +fi + +# pull all the requisite images we're going to need +echo "Pulling required docker images if necessary..." +echo "Note: This may take some time, depending on the speed of your Internet connection." +# pull the speech server if any of asr/nlp/tts services are requested +if [ "$service_enabled_asr" = true ] || [ "$service_enabled_nlp" = true ] || [ "$service_enabled_tts" = true ]; then + echo "> Pulling Riva Speech Server images." + docker_pull $image_speech_api + docker_pull $image_client + docker_pull $image_init_speech +fi + + +if [ "$use_existing_rmirs" = false ]; then + echo + echo "Downloading models (RMIRs) from NGC..." + echo "Note: this may take some time, depending on the speed of your Internet connection." + echo "To skip this process and use existing RMIRs set the location and corresponding flag in config.sh." + + # build up commands to download from NGC + if [ "$service_enabled_asr" = true ] || [ "$service_enabled_nlp" = true ] || [ "$service_enabled_tts" = true ]; then + gmr_speech_models="" + if [ "$service_enabled_asr" = true ]; then + for model in ${models_asr[@]}; do + gmr_speech_models+=" $model" + done + fi + if [ "$service_enabled_nlp" = true ]; then + for model in ${models_nlp[@]}; do + gmr_speech_models+=" $model" + done + fi + if [ "$service_enabled_tts" = true ]; then + for model in ${models_tts[@]}; do + gmr_speech_models+=" $model" + done + fi + + # download required images + docker run --init -it --rm --gpus '"'$gpus_to_use'"' \ + -v $riva_model_loc:/data \ + -e "NGC_CLI_API_KEY=$NGC_API_KEY" \ + -e "NGC_CLI_ORG=nvidia" \ + --name riva-service-maker \ + $image_init_speech download_ngc_models $gmr_speech_models + + if [ $? -ne 0 ]; then + echo "Error in downloading models." + exit 1 + fi + fi +fi + +# convert all rmirs +echo +echo "Converting RMIRs at $riva_model_loc/rmir to Riva Model repository." + +set -x +docker run --init -it --rm --gpus '"'$gpus_to_use'"' \ + -v $riva_model_loc:/data \ + -e "MODEL_DEPLOY_KEY=${MODEL_DEPLOY_KEY}" \ + --name riva-service-maker \ + $image_init_speech deploy_all_models /data/rmir /data/models + +echo +echo "Riva initialization complete. Run ./riva_start.sh to launch services." diff --git a/nlp_demo_riva/riva/riva_start.sh b/nlp_demo_riva/riva/riva_start.sh new file mode 100644 index 00000000..3a0f55e3 --- /dev/null +++ b/nlp_demo_riva/riva/riva_start.sh @@ -0,0 +1,85 @@ +#!/bin/bash +# Copyright (c) 2021, NVIDIA CORPORATION. All rights reserved. +# +# NVIDIA CORPORATION and its licensors retain all intellectual property +# and proprietary rights in and to this software, related documentation +# and any modifications thereto. Any use, reproduction, disclosure or +# distribution of this software and related documentation without an express +# license agreement from NVIDIA CORPORATION is strictly prohibited. + +check_docker_version() { + version_string=$(docker version --format '{{.Server.Version}}') + if [ $? -ne 0 ]; then + echo "Unable to run Docker. Please check that Docker is installed and functioning." + exit 1 + fi + maj_ver=$(echo $version_string | awk -F. '{print $1}') + min_ver=$(echo $version_string | awk -F. '{print $2}') + if [ "$maj_ver" -lt "19" ] || ([ "$maj_ver" -eq "19" ] && [ "$min_ver" -lt "03" ]); then + echo "Docker version insufficient. Please use Docker 19.03 or later" + exit 1; + fi +} + +block_until_server_alive() { + for i in {1..30} + do + docker exec $1 /bin/grpc_health_probe -addr=:$riva_speech_api_port 2> /dev/null + rc=$? + if [ $rc -ne 0 ]; then + echo "Waiting for Riva server to load all models...retrying in 10 seconds" + sleep 10 + else + echo "Riva server is ready..." + exit 0 + fi + done + echo "Health ready check failed." + echo "Check Riva logs with: docker logs $riva_daemon_speech" + exit 1 +} + +# BEGIN SCRIPT +check_docker_version + +# load config file +script_path="$( cd "$(dirname "$0")" >/dev/null 2>&1 ; pwd -P )" +if [ -z "$1" ]; then + config_path="${script_path}/config.sh" +else + config_path=$(readlink -f $1) +fi + +if [[ ! -f $config_path ]]; then + echo 'Unable to load configuration file. Override path to file with -c argument.' + exit 1 +fi +source $config_path + +# determine required LD_PRELOAD & model_repos based on desired services +ld_preload="" +if [ "$service_enabled_asr" = true ] || [ "$service_enabled_nlp" = true ] || [ "$service_enabled_tts" = true ]; then + model_repos+=" --model-repo=/data/models/" + # generate ld_preload based on what's deployed in /data/plugins... + ld_preload+=$(docker run --init -it --rm -v $riva_model_loc:/data --entrypoint "/bin/bash" $image_speech_api -c "find /data/plugins/*.so -type f ! -size 0 2>/dev/null" | sed 's/\r//g' | paste -sd ':' -) +fi + +# speech server is required +# check if it's already running first... +if [ $(docker ps -q -f "name=^/$riva_daemon_speech$" | wc -l) -eq 0 ]; then + echo "Starting Riva Speech Services. This may take several minutes depending on the number of models deployed." + docker rm $riva_daemon_speech &> /dev/null + docker run -d \ + --init \ + --gpus '"'$gpus_to_use'"' \ + -p 8000 -p 8001 -p 8002 -p $riva_speech_api_port:$riva_speech_api_port \ + -e "LD_PRELOAD=$ld_preload" \ + -v $riva_model_loc:/data \ + --ulimit memlock=-1 --ulimit stack=67108864 \ + --name $riva_daemon_speech $image_speech_api \ + start-riva --riva-uri=0.0.0.0:$riva_speech_api_port \ + --asr_service=$service_enabled_asr --tts_service=$service_enabled_tts --nlp_service=$service_enabled_nlp &> /dev/null +else + echo "Riva Speech already running. Skipping..." +fi +block_until_server_alive $riva_daemon_speech diff --git a/nlp_demo_riva/riva/riva_start_client.sh b/nlp_demo_riva/riva/riva_start_client.sh new file mode 100644 index 00000000..cd5513eb --- /dev/null +++ b/nlp_demo_riva/riva/riva_start_client.sh @@ -0,0 +1,73 @@ +#!/bin/bash +# Copyright (c) 2021, NVIDIA CORPORATION. All rights reserved. +# +# NVIDIA CORPORATION and its licensors retain all intellectual property +# and proprietary rights in and to this software, related documentation +# and any modifications thereto. Any use, reproduction, disclosure or +# distribution of this software and related documentation without an express +# license agreement from NVIDIA CORPORATION is strictly prohibited. + +get_ngc_key_from_environment() { + # first check the global NGC_API_KEY environment variable + local ngc_key=$NGC_API_KEY + # if env variable was not set, and a ~/.ngc/config exists + # try to get it from there + if [ -z "$ngc_key" ] && [[ -f "$HOME/.ngc/config" ]] + then + ngc_key=$(cat $HOME/.ngc/config | grep apikey | awk '{print $3}') + fi + echo $ngc_key +} + +docker_pull_and_login_quiet_exit_on_fail() { + image_exists=$(docker images --filter=reference=$1 -q | wc -l) + if [[ $image_exists -eq 1 ]]; then + echo " > Image $1 exists. Skipping pull." + return + fi + + # confirm we're logged in + # automatically get NGC_API_KEY or request from user if necessary + NGC_API_KEY="$(get_ngc_key_from_environment)" + if [ -z "$NGC_API_KEY" ]; then + read -sp 'Please enter API key for ngc.nvidia.com: ' NGC_API_KEY + echo + fi + + # use the API key to run docker login for the NGC registry + # exit early if the key is invalid, because we won't be able to do anything + echo "Logging into NGC docker registry if necessary..." + echo $NGC_API_KEY | docker login -u '$oauthtoken' --password-stdin nvcr.io &> /dev/null + if [ $? -ne 0 ]; then + echo 'NGC API Key is invalid. Please check and try again.' + exit 1 + fi + + echo " > Pulling $1. This may take some time..." + docker pull -q $1 &> /dev/null + if [ $? -ne 0 ]; then + echo "Error occurred pulling '$1'." + docker pull $1 + echo "Exiting." + exit 1 + fi +} + +script_path="$( cd "$(dirname "$0")" >/dev/null 2>&1 ; pwd -P )" +if [ -z "$1" ]; then + config_path="${script_path}/config.sh" +else + config_path=$(readlink -f $1) +fi + +source $config_path + +docker_pull_and_login_quiet_exit_on_fail ${image_client} + +docker run --init -it --privileged \ + -v /dev/bus/usb:/dev/bus/usb \ + -v /dev/snd:/dev/snd \ + -v $PWD:/result \ + --net=host --rm \ + --name ${riva_daemon_client} \ + ${image_client} diff --git a/nlp_demo_riva/riva/riva_stop.sh b/nlp_demo_riva/riva/riva_stop.sh new file mode 100644 index 00000000..4db15294 --- /dev/null +++ b/nlp_demo_riva/riva/riva_stop.sh @@ -0,0 +1,37 @@ +#!/bin/bash +# Copyright (c) 2021, NVIDIA CORPORATION. All rights reserved. +# +# NVIDIA CORPORATION and its licensors retain all intellectual property +# and proprietary rights in and to this software, related documentation +# and any modifications thereto. Any use, reproduction, disclosure or +# distribution of this software and related documentation without an express +# license agreement from NVIDIA CORPORATION is strictly prohibited. + +check_docker_version() { + version_string=$(docker version --format '{{.Server.Version}}') + if [ $? -ne 0 ]; then + echo "Unable to run Docker. Please check that Docker is installed and functioning." + exit 1 + fi + maj_ver=$(echo $version_string | awk -F. '{print $1}') + min_ver=$(echo $version_string | awk -F. '{print $2}') + if [ "$maj_ver" -lt "19" ] || ([ "$maj_ver" -eq "19" ] && [ "$min_ver" -lt "03" ]); then + echo "Docker version insufficient. Please use Docker 19.03 or later" + exit 1; + fi +} + +# BEGIN SCRIPT +check_docker_version + +# load config file +script_path="$( cd "$(dirname "$0")" >/dev/null 2>&1 ; pwd -P )" +config_path="${script_path}/config.sh" +if [[ ! -f $config_path ]]; then + echo 'Unable to load configuration file. Override path to file with -c argument.' + exit 1 +fi +source $config_path + +echo "Shutting down docker containers..." +docker kill $riva_daemon_speech &> /dev/null diff --git a/nlp_demo_riva/text/doc.txt b/nlp_demo_riva/text/doc.txt new file mode 100755 index 00000000..08f55bea --- /dev/null +++ b/nlp_demo_riva/text/doc.txt @@ -0,0 +1,21 @@ +A stock exchange is an exchange (or bourse) where stockbrokers and traders can buy and sell shares (equity stock), bonds, and other securities. Many large companies have their stocks listed on a stock exchange. This makes the stock more liquid and thus more attractive to many investors. The exchange may also act as a guarantor of settlement. These and other stocks may also be traded "over the counter" (OTC), that is, through a dealer. Some large companies will have their stock listed on more than one exchange in different countries, so as to attract international investors. + +Stock exchanges may also cover other types of securities, such as fixed-interest securities (bonds) or (less frequently) derivatives, which are more likely to be traded OTC. + +Trade in stock markets means the transfer (in exchange for money) of a stock or security from a seller to a buyer. This requires these two parties to agree on a price. Equities (stocks or shares) confer an ownership interest in a particular company. + +Participants in the stock market range from small individual stock investors to larger investors, who can be based anywhere in the world, and may include banks, insurance companies, pension funds and hedge funds. Their buy or sell orders may be executed on their behalf by a stock exchange trader. + +Some exchanges are physical locations where transactions are carried out on a trading floor, by a method known as open outcry. This method is used in some stock exchanges and commodities exchanges, and involves traders shouting bid and offer prices. The other type of stock exchange has a network of computers where trades are made electronically. An example of such an exchange is the NASDAQ. + +A potential buyer bids a specific price for a stock, and a potential seller asks a specific price for the same stock. Buying or selling at the Market means you will accept any ask price or bid price for the stock. When the bid and ask prices match, a sale takes place, on a first-come, first-served basis if there are multiple bidders at a given price. + +The purpose of a stock exchange is to facilitate the exchange of securities between buyers and sellers, thus providing a marketplace. The exchanges provide real-time trading information on the listed securities, facilitating price discovery. + +The New York Stock Exchange (NYSE) is a physical exchange, with a hybrid market for placing orders electronically from any location as well as on the trading floor. Orders executed on the trading floor enter by way of exchange members and flow down to a floor broker, who submits the order electronically to the floor trading post for the Designated market maker ("DMM") for that stock to trade the order. The DMM's job is to maintain a two-sided market, making orders to buy and sell the security when there are no other buyers or sellers. If a bid–ask spread exists, no trade immediately takes place – in this case the DMM may use their own resources (money or stock) to close the difference. Once a trade has been made, the details are reported on the "tape" and sent back to the brokerage firm, which then notifies the investor who placed the order. Computers play an important role, especially for program trading. + +The NASDAQ is an electronic exchange, where all of the trading is done over a computer network. The process is similar to the New York Stock Exchange. One or more NASDAQ market makers will always provide a bid and ask the price at which they will always purchase or sell 'their' stock. + +The Paris Bourse, now part of Euronext, is an order-driven, electronic stock exchange. It was automated in the late 1980s. Prior to the 1980s, it consisted of an open outcry exchange. Stockbrokers met on the trading floor of the Palais Brongniart. In 1986, the CATS trading system was introduced, and the order matching system was fully automated. + +People trading stock will prefer to trade on the most popular exchange since this gives the largest number of potential counter parties (buyers for a seller, sellers for a buyer) and probably the best price. However, there have always been alternatives such as brokers trying to bring parties together to trade outside the exchange. Some third markets that were popular are Instinet, and later Island and Archipelago (the latter two have since been acquired by Nasdaq and NYSE, respectively). One advantage is that this avoids the commissions of the exchange. However, it also has problems such as adverse selection. Financial regulators have probed dark pools. \ No newline at end of file diff --git a/nlp_demo_riva/text/questions.txt b/nlp_demo_riva/text/questions.txt new file mode 100644 index 00000000..e115a159 --- /dev/null +++ b/nlp_demo_riva/text/questions.txt @@ -0,0 +1,5 @@ +What is NASDAQ? +When did the stock exchange get automated? +What are traded in the stock exchange? +What is Paris Bourse? +Why do we need a stock exchange? diff --git a/nlp_demo_riva/tts_infer.py b/nlp_demo_riva/tts_infer.py new file mode 100644 index 00000000..249424f1 --- /dev/null +++ b/nlp_demo_riva/tts_infer.py @@ -0,0 +1,48 @@ +""" + //////////////////////////////////////////////////////////////////////////// + // + // Copyright (C) NVIDIA Corporation. All rights reserved. + // + // NVIDIA Sample Code + // + // Please refer to the NVIDIA end user license agreement (EULA) associated + // with this source code for terms and conditions that govern your use of + // this software. Any use, reproduction, disclosure, or distribution of + // this software and related documentation outside the terms of the EULA + // is strictly prohibited. + // + //////////////////////////////////////////////////////////////////////////// +""" +# TTS proto +import riva_api.riva_tts_pb2 as rtts +import riva_api.riva_tts_pb2_grpc as rtts_srv +import riva_api.riva_audio_pb2 as ra + +import grpc +import numpy as np +from wave_utils import add_header + +channel = grpc.insecure_channel('riva:50051') +riva_tts = rtts_srv.RivaSpeechSynthesisStub(channel) + + +def get_wave(text): + req = rtts.SynthesizeSpeechRequest() + req.text = text + # currently required to be "en-US" + req.language_code = "en-US" + # Supports LINEAR_PCM, FLAC, MULAW and ALAW audio encodings + req.encoding = ra.AudioEncoding.LINEAR_PCM + # ignored, audio returned will be 22.05KHz + req.sample_rate_hz = 22050 + # ignored + req.voice_name = "ljspeech" + + resp = riva_tts.Synthesize(req) + float32_data = np.frombuffer(resp.audio, dtype=np.float32) + print(float32_data.min(), float32_data.max()) + float32_data = float32_data / 1.414 + float32_data = float32_data * 32767 + int16_data = float32_data.astype(np.int16).tobytes() + wav = add_header(int16_data, 16, 1, 22050) + return wav diff --git a/nlp_demo_riva/wait_socket.py b/nlp_demo_riva/wait_socket.py new file mode 100644 index 00000000..618390c4 --- /dev/null +++ b/nlp_demo_riva/wait_socket.py @@ -0,0 +1,41 @@ +""" + //////////////////////////////////////////////////////////////////////////// + // + // Copyright (C) NVIDIA Corporation. All rights reserved. + // + // NVIDIA Sample Code + // + // Please refer to the NVIDIA end user license agreement (EULA) associated + // with this source code for terms and conditions that govern your use of + // this software. Any use, reproduction, disclosure, or distribution of + // this software and related documentation outside the terms of the EULA + // is strictly prohibited. + // + //////////////////////////////////////////////////////////////////////////// +""" +import time +import socket + + +def wait_for_port(port, host='localhost', timeout=5.0): + """Wait until a port starts accepting TCP connections. + Args: + port (int): Port number. + host (str): Host address on which the port should exist. + timeout (float): In seconds. How long to wait before raising errors. + Raises: + TimeoutError: The port isn't accepting connection after time + specified in `timeout`. + """ + start_time = time.perf_counter() + while True: + try: + with socket.create_connection((host, port), timeout=timeout): + break + except OSError as ex: + time.sleep(0.01) + if time.perf_counter() - start_time >= timeout: + raise TimeoutError( + 'Waited too long for the port {} on host {} to \ + start accepting ' + 'connections.'.format(port, host)) from ex diff --git a/nlp_demo_riva/wave_utils.py b/nlp_demo_riva/wave_utils.py new file mode 100644 index 00000000..62097a6a --- /dev/null +++ b/nlp_demo_riva/wave_utils.py @@ -0,0 +1,61 @@ +""" + //////////////////////////////////////////////////////////////////////////// + // + // Copyright (C) NVIDIA Corporation. All rights reserved. + // + // NVIDIA Sample Code + // + // Please refer to the NVIDIA end user license agreement (EULA) associated + // with this source code for terms and conditions that govern your use of + // this software. Any use, reproduction, disclosure, or distribution of + // this software and related documentation outside the terms of the EULA + // is strictly prohibited. + // + //////////////////////////////////////////////////////////////////////////// +""" + + +def get_data(data): + total = 0 + for i, num in enumerate(data): + total += num * 256**i + return total + + +def set_data(content, data): + length = len(content) + for i in range(length-1, -1, -1): + content[i] = data // (256**i) + data = data % (256**i) + return content + + +def examine_wav(content): + print('header type:', content[0:4]) + print('file size: %d' % get_data(content[4:8])) + print('file type header: %s' % content[8:12]) + print('file format chunk marker: %s' % content[12:16]) + print('format data length: %d, has to be 16' % get_data(content[16:20])) + print('Type of format %d, 1 for pcm' % get_data(content[20:22])) + print('Number of channels %d' % get_data(content[22:24])) + print('Sample rate: %d' % get_data(content[24:28])) + print('Byte rate: %d' % get_data(content[28:32])) + print('Byte Per Sample * Channels : %d' % get_data(content[32:34])) + print('Bits Per Sample: %d' % get_data(content[34:36])) + print('data chunk header: %s' % content[36:40]) + print('data chunk size: %d' % get_data(content[40:44])) + print(len(content), 'match', 44 + get_data(content[40:44])) + + +def add_header(newdata, bits_per_sample, channel, sr): + n = bytearray( + b'RIFF\xc4P\x05\x00WAVEfmt \x10\x00\x00\x00\x01\x00\x01\x00\x80>\x00\x00\x00}\x00\x00\x02\x00\x10\x00data\xa0P\x05\x00' # noqa + ) + n[22:24] = set_data(n[22:24], channel) + n[34:36] = set_data(n[34:36], bits_per_sample) + n[32:34] = set_data(n[32:34], bits_per_sample // 8 * channel) + n[24:28] = set_data(n[24:28], sr) + n[28:32] = set_data(n[28:32], sr * bits_per_sample * channel // 8) + n[40:44] = set_data(n[40:44], len(newdata)) + n[4:8] = set_data(n[4:8], 44 + len(newdata) - 8) + return n + newdata diff --git a/nlp_demo_riva/webserver.py b/nlp_demo_riva/webserver.py new file mode 100755 index 00000000..fe8e33c4 --- /dev/null +++ b/nlp_demo_riva/webserver.py @@ -0,0 +1,104 @@ +""" + //////////////////////////////////////////////////////////////////////////// + // + // Copyright (C) NVIDIA Corporation. All rights reserved. + // + // NVIDIA Sample Code + // + // Please refer to the NVIDIA end user license agreement (EULA) associated + // with this source code for terms and conditions that govern your use of + // this software. Any use, reproduction, disclosure, or distribution of + // this software and related documentation outside the terms of the EULA + // is strictly prohibited. + // + //////////////////////////////////////////////////////////////////////////// +""" +import cherrypy +import pathlib +import io +from base64 import b64encode +from models_infer import Model +from wait_socket import wait_for_port +wait_for_port(50051, "riva", 120) + + +m = Model() + + +WEB_ROOT = str(pathlib.Path(__file__).parent.absolute())+'/client' +print(WEB_ROOT) + + +def stop_clean(): + print('stopped') + + +def run_server(): + + cherrypy.config.update({ + 'server.socket_port': 8888, + # 'environment': 'production', + 'engine.autoreload.on': False, + # 'server.thread_pool': 1, + 'server.socket_host': '0.0.0.0', + 'tools.staticdir.on': True, + 'tools.staticdir.dir': WEB_ROOT, + 'tools.staticdir.index': 'index.html' + }) + + cherrypy.server.ssl_certificate = "cert.pem" + cherrypy.server.ssl_private_key = "privkey.pem" + + class HelloWorld(object): + + @cherrypy.expose + def doc(self): + p = pathlib.Path('text/doc.txt') + if p.exists(): + with io.open(str(p), 'r', encoding='utf-8') as f: + content = f.read() + return content + else: + return "" + + @cherrypy.expose + @cherrypy.tools.json_out() + def questions(self): + p = pathlib.Path('text/questions.txt') + if p.exists(): + with io.open(str(p), 'r', encoding='utf-8') as f: + content = f.readlines() + return content + else: + return [] + + @cherrypy.expose + @cherrypy.tools.json_out() + @cherrypy.tools.json_in() + def infer(self): + input_json = cherrypy.request.json + r = m.qa_infer(input_json['para'], input_json['question']) + return [r] + + @cherrypy.expose + def asr(self, audio_data): + inputs = audio_data + r = m.asr_infer(inputs.file) + return r + + @cherrypy.expose + @cherrypy.tools.json_in() + def tacotron(self): + input_json = cherrypy.request.json + r = m.tacotron_infer(input_json['text']) + print('input', input_json['text']) + cherrypy.response.headers[ + 'Content-Type'] = 'application/octet-stream' + return b64encode(r) + + cherrypy.engine.subscribe('stop', stop_clean) + cherrypy.quickstart(HelloWorld()) + + +if __name__ == '__main__': + run_server()