diff --git a/.bumpversion.cfg b/.bumpversion.cfg new file mode 100644 index 00000000..c835ed0f --- /dev/null +++ b/.bumpversion.cfg @@ -0,0 +1,20 @@ +[bumpversion] +current_version = 0.6.3 +commit = True +tag = True +parse = (?P\d+)(\.(?P\d+))(\.(?P\d+))((?P.)(?P\d+))? +serialize = + {major}.{minor}.{patch}{release}{build} + {major}.{minor}.{patch} + +[bumpversion:part:release] +optional_value = g +first_value = g +values = + a + b + g + +[bumpversion:file:ipyvolume/_version.py] + +[bumpversion:file:js/package.json] diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 00000000..973904dc --- /dev/null +++ b/.gitattributes @@ -0,0 +1,3 @@ +docs/* linguist-documentation +notebooks/* linguist-documentation +js/* linguist-vendored diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml new file mode 100644 index 00000000..baeafd75 --- /dev/null +++ b/.github/workflows/build.yml @@ -0,0 +1,243 @@ +name: Build + +on: + push: + branches: [ master ] + pull_request: + branches: '*' + +env: + PIP_DISABLE_PIP_VERSION_CHECK: 1 + +defaults: + run: + shell: bash -l {0} + +jobs: + lint: + runs-on: ubuntu-latest + steps: + + - name: Checkout + uses: actions/checkout@v2 + + - name: Install Conda environment with Micromamba + uses: mamba-org/provision-with-micromamba@main + with: + environment-file: environment-test.yml + environment-name: ipyvolume-test + extra-specs: | + python=3.9 + pytest=${{ matrix.pytest }} + + - name: Python PEP8 check + run: flake8 ipyvolume + + build: + runs-on: ubuntu-latest + steps: + + - name: Checkout + uses: actions/checkout@v2 + + - name: Install Conda environment with Micromamba + uses: mamba-org/provision-with-micromamba@main + with: + environment-file: environment-test.yml + environment-name: ipyvolume-test + extra-specs: | + python=${{ matrix.python-version }} + + - name: Install the package + run: | + pip install . + + - name: Test installation files + run: | + test -d $CONDA_PREFIX/share/jupyter/nbextensions/ipyvolume + test -f $CONDA_PREFIX/share/jupyter/nbextensions/ipyvolume/extension.js + test -f $CONDA_PREFIX/share/jupyter/nbextensions/ipyvolume/index.js + test -d $CONDA_PREFIX/share/jupyter/labextensions/ipyvolume + test -f $CONDA_PREFIX/share/jupyter/labextensions/ipyvolume/package.json + test -d $CONDA_PREFIX/share/jupyter/labextensions/ipyvolume/static + + + - name: Validate the nbextension + run: jupyter nbextension list 2>&1 | grep "ipyvolume/extension" + + - name: Validate the labextension + run: jupyter labextension list 2>&1 | grep ipyvolume + + # - name: JavaScript prettyfier + # run: | + # yarn install + # yarn run prettier --check . + # working-directory: js + + - name: Python tests + run: pytest ipyvolume + + - name: JavaScript tests + run: | + npm install + npm run test + working-directory: js + + - name: Build Python package + run: | + python setup.py sdist bdist_wheel + cd dist + sha256sum * | tee SHA256SUMS + + - name: Pack JavaScript package + run: | + yarn pack + mv ipyvolume*.tgz ../dist + working-directory: js + + - name: Upload builds + uses: actions/upload-artifact@v2 + with: + name: dist ${{ github.run_number }} + path: ./dist + + visual-regression-tests: + runs-on: ubuntu-latest + needs: [build] + + steps: + - name: Checkout + uses: actions/checkout@v2 + + - name: Install Conda environment with Micromamba + uses: mamba-org/provision-with-micromamba@main + with: + environment-file: environment-test.yml + environment-name: ipyvolume-test + extra-specs: | + python=3.9 + pytest=${{ matrix.pytest }} + + - uses: actions/download-artifact@v2 + with: + name: dist ${{ github.run_number }} + path: ./dist + + - name: Install the package + run: pip install -vv ipyvolume*.whl + working-directory: dist + + - name: Install Galata + run: yarn install + working-directory: ui-tests + + - name: Launch JupyterLab + run: yarn run start-jlab:detached + working-directory: ui-tests + + - name: Wait for JupyterLab + uses: ifaxity/wait-on-action@v1 + with: + resource: http-get://localhost:8999/api + timeout: 20000 + + - name: Run UI Tests + run: yarn run test + working-directory: ui-tests + + - name: Upload UI Test artifacts + if: always() + uses: actions/upload-artifact@v2 + with: + name: ui-test-output + path: ui-tests/test-output + + install: + runs-on: ${{ matrix.os }}-latest + needs: [build] + + strategy: + fail-fast: false + matrix: + os: [ubuntu, macos, windows] + python: ['3.6', '3.9'] + include: + - python: '3.6' + dist: 'ipyvolume*.tar.gz' + - python: '3.9' + dist: 'ipyvolume*.whl' + + steps: + + - name: Checkout + uses: actions/checkout@v2 + + - name: Install Conda environment with Micromamba + uses: mamba-org/provision-with-micromamba@main + with: + environment-file: environment-test.yml + environment-name: ipyvolume-test + extra-specs: | + python=${{ matrix.python-version }} + + - uses: actions/download-artifact@v2 + with: + name: dist ${{ github.run_number }} + path: ./dist + + - name: Install the package + run: | + cd dist + pip install -vv ${{ matrix.dist }} + + - name: Test installation files + run: | + test -d $CONDA_PREFIX/share/jupyter/nbextensions/ipyvolume + test -f $CONDA_PREFIX/share/jupyter/nbextensions/ipyvolume/extension.js + test -f $CONDA_PREFIX/share/jupyter/nbextensions/ipyvolume/index.js + test -d $CONDA_PREFIX/share/jupyter/labextensions/ipyvolume + test -f $CONDA_PREFIX/share/jupyter/labextensions/ipyvolume/package.json + test -d $CONDA_PREFIX/share/jupyter/labextensions/ipyvolume/static + + - name: Validate the nbextension + run: jupyter nbextension list 2>&1 | grep "ipyvolume/extension" + + - name: Validate the labextension + run: jupyter labextension list 2>&1 | grep ipyvolume + + JupyterLab2-build: + runs-on: ${{ matrix.os }}-latest + needs: [build] + + strategy: + fail-fast: false + matrix: + os: [ubuntu] + python: ['3.9'] + + steps: + + - name: Checkout + uses: actions/checkout@v2 + + - name: Install node + uses: actions/setup-node@v1 + with: + node-version: "14.x" + registry-url: "https://registry.npmjs.org" + + - name: Set up Python ${{ matrix.python-version }} + uses: actions/setup-python@v2 + with: + python-version: ${{ matrix.python-version }} + + - uses: actions/download-artifact@v2 + with: + name: dist ${{ github.run_number }} + path: ./dist + + - name: Install JupyterLab 2 + run: pip install jupyterlab==2 + + - name: Install the labextension + run: jupyter labextension install dist/ipyvolume*.tgz --debug diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml new file mode 100644 index 00000000..5694c5ca --- /dev/null +++ b/.github/workflows/release.yml @@ -0,0 +1,44 @@ +name: Publish Package + +# on: +# release: +# types: [published] +on: + push: + tags: + - '*' + +jobs: + deploy: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v2 + - name: Install node + uses: actions/setup-node@v1 + with: + node-version: '14.x' + registry-url: 'https://registry.npmjs.org' + - name: Install Python + uses: actions/setup-python@v2 + with: + python-version: '3.x' + - name: Install dependencies + run: | + python -m pip install --upgrade pip + pip install twine wheel jupyter-packaging "jupyterlab<4" + - name: Publish the Python package + env: + TWINE_USERNAME: __token__ + TWINE_PASSWORD: ${{ secrets.PYPI_API_TOKEN }} + run: | + python setup.py sdist bdist_wheel + twine upload --skip-existing dist/* + - name: Publish the NPM package + run: | + cd js + echo $PRE_RELEASE + if [[ $PRE_RELEASE == "true" ]]; then export TAG="next"; else export TAG="latest"; fi + npm publish --tag ${TAG} --access public + env: + NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }} + PRE_RELEASE: ${{ github.event.release.prerelease }} diff --git a/.gitignore b/.gitignore index f221f20e..4e713fdd 100644 --- a/.gitignore +++ b/.gitignore @@ -111,3 +111,5 @@ static/ # Visual Studio Code .vscode/ + +share/jupyter diff --git a/.releash.py b/.releash.py index 30bffe7a..bd8ac2a4 100644 --- a/.releash.py +++ b/.releash.py @@ -14,9 +14,9 @@ package_python.version_targets.append(VersionTarget(package_python, '{path}/ipyvolume/_version.py')) package_python.release_targets.append(gittag) -package_python.release_targets.append(ReleaseTargetSourceDist(package_python, universal_wheel=True)) +# package_python.release_targets.append(ReleaseTargetSourceDist(package_python, universal_wheel=True)) #core.release_targets.append(gitpush) -package_python.release_targets.append(ReleaseTargetCondaForge(package_python, '../feedstocks/ipyvolume-feedstock')) +# package_python.release_targets.append(ReleaseTargetCondaForge(package_python, '../feedstocks/ipyvolume-feedstock')) # js part @@ -31,7 +31,7 @@ package_js.version_targets.append(VersionTargetJson(package_js, '{path}/package.json')) package_js.release_targets.append(gittag) -package_js.release_targets.append(ReleaseTargetNpm(package_js)) +# package_js.release_targets.append(ReleaseTargetNpm(package_js)) #core.release_targets.append(gitpush) #package_python.release_targets.append(ReleaseTargetCondaForge(package_python, '../feedstocks/ipyvolume-feedstock')) diff --git a/.travis.yml b/.travis.yml deleted file mode 100644 index 8ef2d152..00000000 --- a/.travis.yml +++ /dev/null @@ -1,49 +0,0 @@ -language: c -os: - - linux - - osx -env: - matrix: - - PYTHON_VERSION=2.7 - - PYTHON_VERSION=3.5 - - PYTHON_VERSION=3.6 -# - PYTHON_VERSION=3.7 ipywidgets currently does not support 3.7 -# matrix: -# allow_failures: -# env: PYTHON_VERSION=3.6 - -addons: - chrome: stable - -before_install: - - if [[ $TRAVIS_OS_NAME == linux ]]; then sudo apt-get update; fi - - . $HOME/.nvm/nvm.sh - - nvm install stable - - nvm use stable - - if [[ $TRAVIS_OS_NAME == linux ]]; then wget https://repo.continuum.io/miniconda/Miniconda-latest-Linux-x86_64.sh -O miniconda.sh; fi - - if [[ $TRAVIS_OS_NAME == osx ]]; then wget https://repo.continuum.io/miniconda/Miniconda3-latest-MacOSX-x86_64.sh -O miniconda.sh; fi - - bash miniconda.sh -b -p $HOME/miniconda - - export PATH="$HOME/miniconda/bin:$PATH" - - hash -r - - conda config --set always_yes yes --set changeps1 no - - conda update -q conda - - conda info -a - - conda create -q -n test-environment python=$PYTHON_VERSION numpy scipy runipy - - source activate test-environment - - conda install -c conda-forge pytest==3.8.1 pytest-cov bokeh nodejs matplotlib scikit-image shapely flake8 - - pip install PyChromeDevTools - - pip install coveralls - -install: - - pip install -e . - -script: - - py.test --cov-report= --cov=ipyvolume ipyvolume - - npm run --prefix js install-test - - flake8 ipyvolume - - (cd js; ./node_modules/.bin/eslint src/selectors.js) - - (cd js; npm run test) -# - runipy examples/examples.ipynb - -after_success: - coveralls diff --git a/MANIFEST.in b/MANIFEST.in index 4b52db33..ae3b063f 100644 --- a/MANIFEST.in +++ b/MANIFEST.in @@ -1,5 +1,5 @@ -recursive-include ipyvolume/static *.* include LICENSE include README.rst include README.md -include ipyvolume.json \ No newline at end of file +include js/package.json +recursive-include ipyvolume/vue *.vue diff --git a/README.md b/README.md index 1f04eb05..fa8eb582 100644 --- a/README.md +++ b/README.md @@ -11,7 +11,7 @@ Try out in mybinder: [![Binder](http://mybinder.org/badge.svg)](https://beta.myb 3d plotting for Python in the Jupyter notebook based on IPython widgets using WebGL. -Ipyvolume currenty can +Ipyvolume currently can * Do (multi) volume rendering. * Create scatter plots (up to ~1 million glyphs). * Create quiver plots (like scatter, but with an arrow pointing in a particular direction). @@ -23,9 +23,9 @@ Ipyvolume currenty can * Animations / sequences, all scatter/quiver plot properties can be a list of arrays, which can represent time snapshots. * Stylable (although still basic) * Integrates with - * [ipywidgets](https://github.com/ipython/ipywidgets) for adding gui controls (sliders, button etc), see an [example at the documentation homepage](http://ipyvolume.readthedocs.io/en/latest/index.html#built-on-ipywidgets) - * [bokeh](//bokeh.pydata.org) by [linking the selection](http://ipyvolume.readthedocs.io/en/latest/bokeh.html) - * [bqplot](https://github.com/bloomberg/bqplot) by [linking the selection](http://ipyvolume.readthedocs.io/en/latest/bqplot.html) + * [ipywidgets](https://github.com/ipython/ipywidgets) for adding gui controls (sliders, button etc), see an [example at the documentation homepage](http://ipyvolume.readthedocs.io/en/latest/index.html#built-on-ipywidgets) + * [bokeh](//bokeh.pydata.org) by [linking the selection](http://ipyvolume.readthedocs.io/en/latest/bokeh.html) + * [bqplot](https://github.com/bloomberg/bqplot) by [linking the selection](http://ipyvolume.readthedocs.io/en/latest/bqplot.html) Ipyvolume will probably, but not yet: * Render labels in latex. @@ -53,6 +53,8 @@ Documentation is generated at readthedocs: [![Documentation](https://readthedocs # Installation +If you want to use Jupyter Lab, please use version 3.0. + ## Using pip *Advice: Make sure you use conda or virtualenv. If you are not a root user and want to use the `--user` argument for pip, you expose the installation to all python environments, which is a bad practice, make sure you know what you are doing.* @@ -67,25 +69,13 @@ $ pip install ipyvolume $ conda install -c conda-forge ipyvolume ``` -## For Jupyter lab users - -The Jupyter lab extension is not enabled by default (yet). - -``` -$ conda install -c conda-forge nodejs # or some other way to have a recent node -$ jupyter labextension install @jupyter-widgets/jupyterlab-manager -$ jupyter labextension install ipyvolume -$ jupyter labextension install jupyter-threejs - -``` - ## Pre-notebook 5.3 If you are still using an old notebook version, ipyvolume and its dependend extension (widgetsnbextension) need to be enabled manually. If unsure, check which extensions are enabled: ``` -$ jupyter nbextention list +$ jupyter nbextension list ``` If not enabled, enable them: @@ -112,19 +102,14 @@ $ jupyter nbextension enable --py --user widgetsnbextension ``` $ git clone https://github.com/maartenbreddels/ipyvolume.git $ cd ipyvolume -$ pip install -e . -$ jupyter nbextension install --py --symlink --sys-prefix ipyvolume +$ pip install -e . notebook jupyterlab +$ (cd js; npm run build) +$ jupyter nbextension install --py --overwrite --symlink --sys-prefix ipyvolume $ jupyter nbextension enable --py --sys-prefix ipyvolume +# for jupyterlab (>=3.0), symlink share/jupyter/labextensions/bqplot-image-gl +$ jupyter labextension develop . --overwrite ``` -For all cases make sure [ipywidgets is enabled](http://ipywidgets.readthedocs.io/en/latest/user_install.html) if you use Jupyter notebook version < 5.3 (using `--user` instead of `--sys-prefix` if doing a local install): - -``` -$ jupyter nbextension enable --py --sys-prefix widgetsnbextension -$ jupyter nbextension enable --py --sys-prefix pythreejs -$ jupyter nbextension enable --py --sys-prefix ipywebrtc -$ jupyter nbextension enable --py --sys-prefix ipyvolume -``` ## Developer workflow diff --git a/RELEASE.md b/RELEASE.md index 5b92c6c4..a51dd042 100644 --- a/RELEASE.md +++ b/RELEASE.md @@ -1,18 +1,28 @@ -- To release a new version of ipyvolume on PyPI: +# Using CI + + * Update ipyvolume/_version.py + * Update js/package.json + * Add and commit, e.g. `git add -u; git commit -m 'Update to version 0.6.0'` + * Tag: `git tag v0.6.0` + * Release using push: `git push upstream master v0.6.0` + +# Manual + +## To release a new version of ipyvolume on PyPI: Update _version.py (set release version, remove 'dev') git add and git commit -python setup.py sdist upload -python setup.py bdist_wheel upload -git tag -a X.X.X -m 'comment' + * `python setup.py sdist upload` +* `python setup.py bdist_wheel upload` +* `git tag -a X.X.X -m 'comment'` Update _version.py (add 'dev' and increment minor) -git add and git commit -git push -git push --tags + * git add and git commit + * `git push` + * `git push --tags` -- To release a new version of ipyvolume on NPM: +## To release a new version of ipyvolume on NPM: # nuke the `dist` and `node_modules` -git clean -fdx -npm install -npm publish + * git clean -fdx + * `npm install` + * `npm publish` diff --git a/docs/source/animation.ipynb b/docs/source/animation.ipynb deleted file mode 100644 index 16f4378c..00000000 --- a/docs/source/animation.ipynb +++ /dev/null @@ -1,7977 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Animation\n", - "All (or most of) the changes in scatter and quiver plots are (linearly) interpolated. On top top that, scatter plots and quiver plots can take a sequence of arrays (the first dimension), where only one array is visualized. Together this can make smooth animations with coarse timesteps. Lets see an example." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import ipyvolume as ipv\n", - "import numpy as np" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Basic animation" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "239444c89b374df38fa42aa7a59fbe16", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "VBox(children=(Figure(animation=200.0, camera=PerspectiveCamera(fov=46.0, position=(0.0, 0.0, 2.0), quaternion…" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# only x is a sequence of arrays\n", - "x = np.array([[-1, -0.8], [1, -0.1], [0., 0.5]])\n", - "y = np.array([0.0, 0.0])\n", - "z = np.array([0.0, 0.0])\n", - "ipv.figure()\n", - "s = ipv.scatter(x, y, z, marker='sphere', size=10)\n", - "ipv.xyzlim(-1, 1)\n", - "ipv.animation_control(s) # shows controls for animation controls\n", - "ipv.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "You can control which array to visualize, using the `scatter.sequence_index` property. Actually, the `pylab.animate_glyphs` is connecting the `Slider` and `Play` button to that property, but you can also set it from Python." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "s.sequence_index = 1" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Animating color and size\n", - "We now demonstrate that you can also animate color and size" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "x,y and z are of shape (25, 25)\n", - "and flattened of shape (625,)\n" - ] - } - ], - "source": [ - "# create 2d grids: x, y, and r \n", - "u = np.linspace(-10, 10, 25)\n", - "x, y = np.meshgrid(u, u)\n", - "r = np.sqrt(x**2+y**2)\n", - "print(\"x,y and z are of shape\", x.shape)\n", - "# and turn them into 1d\n", - "x = x.flatten()\n", - "y = y.flatten()\n", - "r = r.flatten()\n", - "print(\"and flattened of shape\", x.shape)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now we only animate the z component" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "z is of shape (15, 625)\n" - ] - } - ], - "source": [ - "# create a sequence of 15 time elements\n", - "time = np.linspace(0, np.pi*2, 15)\n", - "z = np.array([(np.cos(r + t) * np.exp(-r/5)) for t in time])\n", - "print(\"z is of shape\", z.shape)" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "2376e71f34ef4503bfccdefb9a67ccea", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "VBox(children=(Figure(animation=200.0, camera=PerspectiveCamera(fov=46.0, position=(0.0, 0.0, 2.0), quaternion…" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# draw the scatter plot, and add controls with animate_glyphs\n", - "ipv.figure()\n", - "s = ipv.scatter(x, z, y, marker=\"sphere\")\n", - "ipv.animation_control(s, interval=200)\n", - "ipv.ylim(-3,3)\n", - "ipv.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "color is of shape (15, 3, 625)\n" - ] - } - ], - "source": [ - "# Now also include, color, which containts rgb values\n", - "color = np.array([[np.cos(r + t), 1-np.abs(z[i]), 0.1+z[i]*0] for i, t in enumerate(time)])\n", - "size = (z+1)\n", - "print(\"color is of shape\", color.shape)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "color is of the wrong shape, the last dimension should contain the rgb value, i.e. the shape of should be (15, 2500, 3)" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [], - "source": [ - "color = np.transpose(color, (0, 2, 1)) # flip the last axes" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "dc41199297ca477eb7746db122b34869", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "VBox(children=(Figure(animation=200.0, camera=PerspectiveCamera(fov=46.0, position=(0.0, 0.0, 2.0), quaternion…" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "ipv.figure()\n", - "s = ipv.scatter(x, z, y, color=color, size=size, marker=\"sphere\")\n", - "ipv.animation_control(s, interval=200)\n", - "ipv.ylim(-3,3)\n", - "ipv.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Creating movie files\n", - "We now make a movie, with a 2 second duration, where we rotate the camera, and change the size of the scatter points. " - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "3e659ec033324585a78699bc32925032", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Output()" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "def set_view(figure, framenr, fraction):\n", - " ipv.view(fraction*360, (fraction - 0.5) * 180, distance=2 + fraction*2)\n", - " s.size = size * (2+0.5*np.sin(fraction * 6 * np.pi))\n", - "ipv.movie('wave.gif', set_view, fps=20, frames=40)" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# include the gif with base64 encoding\n", - "import IPython.display\n", - "import base64\n", - "with open('wave.gif', 'rb') as gif:\n", - " url = b\"data:image/gif;base64,\" +base64.b64encode(gif.read())\n", - "IPython.display.Image(url=url.decode('ascii'))" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "collapsed": true - }, - "source": [ - "## Animated quiver\n", - "Not only scatter plots can be animated, quiver as well, so the direction vector (vx, vy, vz) can also be animated, as shown in the example below, which is a (subsample of) a simulation of a small galaxy orbiting a host galaxy (not visible)." - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "shape of steam data (6, 200, 1250)\n" - ] - } - ], - "source": [ - "import ipyvolume.datasets\n", - "stream = ipyvolume.datasets.animated_stream.fetch()\n", - "print(\"shape of steam data\", stream.data.shape) # first dimension contains x, y, z, vx, vy, vz, then time, then particle" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "8dfd1ab1047f429184adb52dc5dbd182", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "VBox(children=(Figure(animation=200.0, camera=PerspectiveCamera(fov=46.0, position=(0.0, 0.0, 2.0), quaternion…" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "fig = ipv.figure()\n", - "# instead of doing x=stream.data[0], y=stream.data[1], ... vz=stream.data[5], use *stream.data\n", - "# limit to 50 timesteps to avoid having a huge notebook\n", - "q = ipv.quiver(*stream.data[:,0:50,:200], color=\"red\", size=7)\n", - "ipv.style.use(\"dark\") # looks better\n", - "ipv.animation_control(q, interval=200)\n", - "ipv.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [], - "source": [ - "# fig.animation = 0 # set to 0 for no interpolation" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "anaconda-cloud": {}, - "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.4" - }, - "widgets": { - "application/vnd.jupyter.widget-state+json": { - "state": { - "00a1968307f74adb9fddf3dc4f38828e": { - "model_module": "jupyter-threejs", - "model_module_version": "~1.0.0", - "model_name": "PerspectiveCameraModel", - "state": { - "_model_module_version": "~1.0.0", - "_view_module": null, - "_view_module_version": "", - "aspect": 0.8, - "fov": 46, - "matrix": [ - 1, - 0, - 0, - 0, - 0, - 1, - -6.123233995736766e-17, - 0, - 0, - 6.123233995736766e-17, - 1, - 0, - 0, - 1.2246467991473532e-16, - 2, - 1 - ], - "matrixWorld": [ - 1, - 0, - 0, - 0, - 0, - 1, - -6.123233995736766e-17, - 0, - 0, - 6.123233995736766e-17, - 1, - 0, - 0, - 1.2246467991473532e-16, - 2, - 1 - ], - "matrixWorldInverse": [ - 1, - 0, - 0, - 0, - 0, - 1, - 6.123233995736766e-17, - 0, - 0, - -6.123233995736766e-17, - 1, - 0, - 0, - 0, - -2, - 1 - ], - "position": [ - 0, - 1.2246467991473532e-16, - 2 - ], - "projectionMatrix": [ - 2.9448154572796907, - 0, - 0, - 0, - 0, - 2.3558523658237527, - 0, - 0, - 0, - 0, - -1.00010000500025, - -1, - 0, - 0, - -0.200010000500025, - 0 - ], - "quaternion": [ - -3.061616997868383e-17, - 0, - 0, - 1 - ], - "rotation": [ - -6.123233995736766e-17, - 0, - 0, - "XYZ" - ] - } - }, - "02d2b6a819fc411cbc78688746d21311": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.4.0", - "model_name": "LinkModel", - "state": { - "source": [ - "IPY_MODEL_ea561674d7254c89aacdac5c4bf4815a", - "value" - ], - "target": [ - "IPY_MODEL_ff6eb48719bb46c89367ccf844932fed", - "sequence_index" - ] - } - }, - "0b15901ef7b34307971333d2fde5913e": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.4.0", - "model_name": "SliderStyleModel", - "state": { - "description_width": "" - } - }, - "0b44784ed5904895a8c2cc1e5f71c18c": { - "buffers": [ - { - "data": "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", - "encoding": "base64", - "path": [ - "x", - 0, - "data" - ] - }, - { - "data": "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", - "encoding": "base64", - "path": [ - "y", - 0, - "data" - ] - }, - { - "data": "vT/UvF/9BDyClDw9TPebPUsyuD16Xa09zZWBPTmhBD0EQTq6s8z2vAFgVr0J4Ya92BuQvQnhhr0BYFa9s8z2vARBOro5oQQ9zZWBPXpdrT1LMrg9TPebPYKUPD1f/QQ8vT/UvF/9BDwHKEs9paOlPXaMuD2sbpY91AYSPakGVbwzSHu9W2fPval0BL4ouRW+xUIevtW/IL7FQh6+KLkVvql0BL5bZ8+9M0h7vakGVbzUBhI9rG6WPXaMuD2lo6U9ByhLPV/9BDyClDw9paOlPUBUtz1+KIY9BuBxPFv9Q73kF9i9KLkVvukaKr5u7yy+NjAmvjIwHr580xq+MjAevjYwJr5u7yy+6Roqvii5Fb7kF9i9W/1DvQbgcTx+KIY9QFS3PaWjpT2ClDw9TPebPXaMuD1+KIY9t9vqOwnhhr2pdAS++awovnHXKb7ylQ6+xzLKvSWccb2Pd/68KQ6tvI93/rwlnHG9xzLKvfKVDr5x1ym++awovql0BL4J4Ya9t9vqO34ohj12jLg9TPebPUsyuD2sbpY9BuBxPAnhhr0DxAu+1+wsvnzTGr6EXru9vW8yvPK1ij0MtwM+MFkpPsu1NT4wWSk+DLcDPvK1ij29bzK8hF67vXzTGr7X7Cy+A8QLvgnhhr0G4HE8rG6WPUsyuD16Xa091AYSPVv9Q72pdAS+1+wsvmYHE74lnHG9yeJkPTBZKT7r23o+jBOUPmtLnT45cJ8+a0udPowTlD7r23o+MFkpPsniZD0lnHG9ZgcTvtfsLL6pdAS+W/1DvdQGEj16Xa09zZWBPakGVbzkF9i9+awovnzTGr4lnHG9ZkejPSemWT42lJc+0GqiPt7Olj7Z9YU+ewJ9Ptn1hT7ezpY+0GqiPjaUlz4nplk+ZkejPSWccb180xq++awovuQX2L2pBlW8zZWBPTmhBD0zSHu9KLkVvnHXKb6EXru9yeJkPSemWT5rS50+qq+aPq5aWT6HdLk9Hc7Ju8BDLL0dzsm7h3S5Pa5aWT6qr5o+a0udPiemWT7J4mQ9hF67vXHXKb4ouRW+M0h7vTmhBD0EQTq6W2fPvekaKr7ylQ6+vW8yvDBZKT42lJc+qq+aPrOpLT7AQyy9HIR4vnKivb4Hw9K+cqK9vhyEeL7AQyy9s6ktPqqvmj42lJc+MFkpPr1vMrzylQ6+6Roqvltnz70EQTq6s8z2vKl0BL5u7yy+xzLKvfK1ij3r23o+0GqiPq5aWT7AQyy9bPynvq+YBb/Y4Ba/JWUYv9jgFr+vmAW/bPynvsBDLL2uWlk+0GqiPuvbej7ytYo9xzLKvW7vLL6pdAS+s8z2vAFgVr0ouRW+NjAmviWccb0MtwM+jBOUPt7Olj6HdLk9HIR4vq+YBb+D2ha/0TDuvs8Vvr7RMO6+g9oWv6+YBb8chHi+h3S5Pd7Olj6ME5Q+DLcDPiWccb02MCa+KLkVvgFgVr0J4Ya9xUIevjIwHr6Pd/68MFkpPmtLnT7Z9YU+Hc7Ju3Kivb7Y4Ba/0TDuvsDGNr20wHY+wMY2vdEw7r7Y4Ba/cqK9vh3OybvZ9YU+a0udPjBZKT6Pd/68MjAevsVCHr4J4Ya92BuQvdW/IL580xq+KQ6tvMu1NT45cJ8+ewJ9PsBDLL0Hw9K+JWUYv88Vvr60wHY+5aVmP7TAdj7PFb6+JWUYvwfD0r7AQyy9ewJ9Pjlwnz7LtTU+KQ6tvHzTGr7VvyC+2BuQvQnhhr3FQh6+MjAevo93/rwwWSk+a0udPtn1hT4dzsm7cqK9vtjgFr/RMO6+wMY2vbTAdj7Axja90TDuvtjgFr9yor2+Hc7Ju9n1hT5rS50+MFkpPo93/rwyMB6+xUIevgnhhr0BYFa9KLkVvjYwJr4lnHG9DLcDPowTlD7ezpY+h3S5PRyEeL6vmAW/g9oWv9Ew7r7PFb6+0TDuvoPaFr+vmAW/HIR4vod0uT3ezpY+jBOUPgy3Az4lnHG9NjAmvii5Fb4BYFa9s8z2vKl0BL5u7yy+xzLKvfK1ij3r23o+0GqiPq5aWT7AQyy9bPynvq+YBb/Y4Ba/JWUYv9jgFr+vmAW/bPynvsBDLL2uWlk+0GqiPuvbej7ytYo9xzLKvW7vLL6pdAS+s8z2vARBOrpbZ8+96RoqvvKVDr69bzK8MFkpPjaUlz6qr5o+s6ktPsBDLL0chHi+cqK9vgfD0r5yor2+HIR4vsBDLL2zqS0+qq+aPjaUlz4wWSk+vW8yvPKVDr7pGiq+W2fPvQRBOro5oQQ9M0h7vSi5Fb5x1ym+hF67vcniZD0nplk+a0udPqqvmj6uWlk+h3S5PR3OybvAQyy9Hc7Ju4d0uT2uWlk+qq+aPmtLnT4nplk+yeJkPYReu71x1ym+KLkVvjNIe705oQQ9zZWBPakGVbzkF9i9+awovnzTGr4lnHG9ZkejPSemWT42lJc+0GqiPt7Olj7Z9YU+ewJ9Ptn1hT7ezpY+0GqiPjaUlz4nplk+ZkejPSWccb180xq++awovuQX2L2pBlW8zZWBPXpdrT3UBhI9W/1Dval0BL7X7Cy+ZgcTviWccb3J4mQ9MFkpPuvbej6ME5Q+a0udPjlwnz5rS50+jBOUPuvbej4wWSk+yeJkPSWccb1mBxO+1+wsvql0BL5b/UO91AYSPXpdrT1LMrg9rG6WPQbgcTwJ4Ya9A8QLvtfsLL580xq+hF67vb1vMrzytYo9DLcDPjBZKT7LtTU+MFkpPgy3Az7ytYo9vW8yvIReu7180xq+1+wsvgPEC74J4Ya9BuBxPKxulj1LMrg9TPebPXaMuD1+KIY9t9vqOwnhhr2pdAS++awovnHXKb7ylQ6+xzLKvSWccb2Pd/68KQ6tvI93/rwlnHG9xzLKvfKVDr5x1ym++awovql0BL4J4Ya9t9vqO34ohj12jLg9TPebPYKUPD2lo6U9QFS3PX4ohj0G4HE8W/1DveQX2L0ouRW+6Roqvm7vLL42MCa+MjAevnzTGr4yMB6+NjAmvm7vLL7pGiq+KLkVvuQX2L1b/UO9BuBxPH4ohj1AVLc9paOlPYKUPD1f/QQ8ByhLPaWjpT12jLg9rG6WPdQGEj2pBlW8M0h7vVtnz72pdAS+KLkVvsVCHr7VvyC+xUIevii5Fb6pdAS+W2fPvTNIe72pBlW81AYSPaxulj12jLg9paOlPQcoSz1f/QQ8vT/UvF/9BDyClDw9TPebPUsyuD16Xa09zZWBPTmhBD0EQTq6s8z2vAFgVr0J4Ya92BuQvQnhhr0BYFa9s8z2vARBOro5oQQ9zZWBPXpdrT1LMrg9TPebPYKUPD1f/QQ8vT/UvA==", - "encoding": "base64", - "path": [ - "y", - 1, - "data" - ] - }, - { - "data": "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", - "encoding": "base64", - "path": [ - "y", - 2, - "data" - ] - }, - { - "data": "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", - "encoding": "base64", - "path": [ - "y", - 3, - "data" - ] - }, - { - "data": "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", - "encoding": "base64", - "path": [ - "y", - 4, - "data" - ] - }, - { - "data": "34Y8vXYjh73jtIi9A7w/vTscObzvcPs8mCWPPYimzD1X1PI95EsCPqOGBD4G+AM+u3EDPgb4Az6jhgQ+5EsCPlfU8j2Ipsw9mCWPPe9w+zw7HDm8A7w/veO0iL12I4e934Y8vXYjh73FcIa982IjvccTlzsH+mA9xpfHPdju+z1PUgQ+TFz1Pbe10D2+OKo9tjGOPUkLhD22MY49vjiqPbe10D1MXPU9T1IEPtju+z3Gl8c9B/pgPccTlzvzYiO9xXCGvXYjh73jtIi982IjvXxWJzwhF4k9x6rjPZ9iBD7IVPE9vjiqPcrwFj2ThRO8AoQ7vbkbjb3tG529uRuNvQKEO72ThRO8yvAWPb44qj3IVPE9n2IEPseq4z0hF4k9fFYnPPNiI73jtIi9A7w/vccTlzshF4k9lKbrPQb4Az63tdA9thMvPdvs+7xpYM29g7QdvqYUQb5DcVO+S/FYvkNxU76mFEG+g7Qdvmlgzb3b7Pu8thMvPbe10D0G+AM+lKbrPSEXiT3HE5c7A7w/vTscObwH+mA9x6rjPQb4Az44jsI9XJiUPO0bnb2yJiW+MxdevlsSdr5Ozna+bhpvvqAHa75uGm++Ts52vlsSdr4zF16+siYlvu0bnb1cmJQ8OI7CPQb4Az7HquM9B/pgPTscObzvcPs8xpfHPZ9iBD63tdA9XJiUPNhFvb2mFEG+xh90vm4ab761S0G+AjoGvjq6r70+Qo29OrqvvQI6Br61S0G+bhpvvsYfdL6mFEG+2EW9vVyYlDy3tdA9n2IEPsaXxz3vcPs8mCWPPdju+z3IVPE9thMvPe0bnb2mFEG+ZXR3vjv7Wb6oWe+9zUbUO2W07T2+WT8+zsxXPr5ZPz5ltO09zUbUO6hZ7707+1m+ZXR3vqYUQb7tG529thMvPchU8T3Y7vs9mCWPPYimzD1PUgQ+vjiqPdvs+7yyJiW+xh90vjv7Wb46uq+9Waa+PSUuhD6PC7w+axDWPnO13D5rENY+jwu8PiUuhD5Zpr49OrqvvTv7Wb7GH3S+siYlvtvs+7y+OKo9T1IEPoimzD1X1PI9TFz1PcrwFj1pYM29Mxdevm4ab76oWe+9Waa+Pf+4mz5ztdw+WzfnPrMS1D7zDsg+sxLUPls35z5ztdw+/7ibPlmmvj2oWe+9bhpvvjMXXr5pYM29yvAWPUxc9T1X1PI95EsCPre10D2ThRO8g7QdvlsSdr61S0G+zUbUOyUuhD5ztdw+ShrdPgptjz7Hxsg9cAOdPMfGyD0KbY8+ShrdPnO13D4lLoQ+zUbUO7VLQb5bEna+g7QdvpOFE7y3tdA95EsCPqOGBD6+OKo9AoQ7vaYUQb5Ozna+AjoGvmW07T2PC7w+WzfnPgptjz7gD469AZzIvoHOA78BnMi+4A+OvQptjz5bN+c+jwu8PmW07T0COga+Ts52vqYUQb4ChDu9vjiqPaOGBD4G+AM+tjGOPbkbjb1DcVO+bhpvvjq6r72+WT8+axDWPrMS1D7Hxsg9AZzIvg5RQr+DQFi/DlFCvwGcyL7Hxsg9sxLUPmsQ1j6+WT8+OrqvvW4ab75DcVO+uRuNvbYxjj0G+AM+u3EDPkkLhD3tG529S/FYvqAHa74+Qo29zsxXPnO13D7zDsg+cAOdPIHOA7+DQFi/B50fv4NAWL+BzgO/cAOdPPMOyD5ztdw+zsxXPj5Cjb2gB2u+S/FYvu0bnb1JC4Q9u3EDPgb4Az62MY49uRuNvUNxU75uGm++Orqvvb5ZPz5rENY+sxLUPsfGyD0BnMi+DlFCv4NAWL8OUUK/AZzIvsfGyD2zEtQ+axDWPr5ZPz46uq+9bhpvvkNxU765G429tjGOPQb4Az6jhgQ+vjiqPQKEO72mFEG+Ts52vgI6Br5ltO09jwu8Pls35z4KbY8+4A+OvQGcyL6BzgO/AZzIvuAPjr0KbY8+WzfnPo8LvD5ltO09AjoGvk7Odr6mFEG+AoQ7vb44qj2jhgQ+5EsCPre10D2ThRO8g7QdvlsSdr61S0G+zUbUOyUuhD5ztdw+ShrdPgptjz7Hxsg9cAOdPMfGyD0KbY8+ShrdPnO13D4lLoQ+zUbUO7VLQb5bEna+g7QdvpOFE7y3tdA95EsCPlfU8j1MXPU9yvAWPWlgzb0zF16+bhpvvqhZ771Zpr49/7ibPnO13D5bN+c+sxLUPvMOyD6zEtQ+WzfnPnO13D7/uJs+Waa+PahZ771uGm++Mxdevmlgzb3K8BY9TFz1PVfU8j2Ipsw9T1IEPr44qj3b7Pu8siYlvsYfdL47+1m+OrqvvVmmvj0lLoQ+jwu8PmsQ1j5ztdw+axDWPo8LvD4lLoQ+Waa+PTq6r707+1m+xh90vrImJb7b7Pu8vjiqPU9SBD6Ipsw9mCWPPdju+z3IVPE9thMvPe0bnb2mFEG+ZXR3vjv7Wb6oWe+9zUbUO2W07T2+WT8+zsxXPr5ZPz5ltO09zUbUO6hZ7707+1m+ZXR3vqYUQb7tG529thMvPchU8T3Y7vs9mCWPPe9w+zzGl8c9n2IEPre10D1cmJQ82EW9vaYUQb7GH3S+bhpvvrVLQb4COga+OrqvvT5Cjb06uq+9AjoGvrVLQb5uGm++xh90vqYUQb7YRb29XJiUPLe10D2fYgQ+xpfHPe9w+zw7HDm8B/pgPceq4z0G+AM+OI7CPVyYlDztG529siYlvjMXXr5bEna+Ts52vm4ab76gB2u+bhpvvk7Odr5bEna+MxdevrImJb7tG529XJiUPDiOwj0G+AM+x6rjPQf6YD07HDm8A7w/vccTlzshF4k9lKbrPQb4Az63tdA9thMvPdvs+7xpYM29g7QdvqYUQb5DcVO+S/FYvkNxU76mFEG+g7Qdvmlgzb3b7Pu8thMvPbe10D0G+AM+lKbrPSEXiT3HE5c7A7w/veO0iL3zYiO9fFYnPCEXiT3HquM9n2IEPshU8T2+OKo9yvAWPZOFE7wChDu9uRuNve0bnb25G429AoQ7vZOFE7zK8BY9vjiqPchU8T2fYgQ+x6rjPSEXiT18Vic882IjveO0iL12I4e9xXCGvfNiI73HE5c7B/pgPcaXxz3Y7vs9T1IEPkxc9T23tdA9vjiqPbYxjj1JC4Q9tjGOPb44qj23tdA9TFz1PU9SBD7Y7vs9xpfHPQf6YD3HE5c782IjvcVwhr12I4e934Y8vXYjh73jtIi9A7w/vTscObzvcPs8mCWPPYimzD1X1PI95EsCPqOGBD4G+AM+u3EDPgb4Az6jhgQ+5EsCPlfU8j2Ipsw9mCWPPe9w+zw7HDm8A7w/veO0iL12I4e934Y8vQ==", - "encoding": "base64", - "path": [ - "y", - 5, - "data" - ] - }, - { - "data": "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", - "encoding": "base64", - "path": [ - "y", - 6, - "data" - ] - }, - { - "data": "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", - "encoding": "base64", - "path": [ - "y", - 7, - "data" - ] - }, - { - "data": "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", - "encoding": "base64", - "path": [ - "y", - 8, - "data" - ] - }, - { - "data": "3gY+PQcTrjyyzIW8J5pivRPmrb0xV8m9oErBvZdknb1zOlW9chnZvLNYrLtlUws8HuZYPGVTCzyzWKy7chnZvHM6Vb2XZJ29oErBvTFXyb0T5q29J5pivbLMhbwHE6483gY+PQcTrjxw/Ka8RkiBvTvAvL2Mfsi9LNehvSb8Kr0NpHs7gmpEPdwGrD3WsN89Qj39PeVdAz5CPf091rDfPdwGrD2CakQ9DaR7Oyb8Kr0s16G9jH7IvTvAvL1GSIG9cPymvAcTrjyyzIW8RkiBvV2jwL1MK8O9R46DvYO2Hry2YVk91rDfPbhPGT7iCTE+KQ07PnqWPT5CyT0+epY9PikNOz7iCTE+uE8ZPtaw3z22YVk9g7YevEeOg71MK8O9XaPAvUZIgb2yzIW8J5pivTvAvL1MK8O9LBtvvWVTCzzcBqw9UDIVPjLbNz5MSTw+2UgrPttUEj530fs9YlzsPXfR+z3bVBI+2UgrPkxJPD4y2zc+UDIVPtwGrD1lUws8LBtvvUwrw707wLy9J5pivRPmrb2Mfsi9R46DvWVTCzwr8sA9pqgkPkLJPT4MLyc+2/vbPZygID0yAq+87797vVw5mr3vv3u9MgKvvJygID3b+9s9DC8nPkLJPT6mqCQ+K/LAPWVTCzxHjoO9jH7IvRPmrb0xV8m9LNehvYO2HrzcBqw9pqgkPmQlPT7bVBI+KLJNPe+/e72Z1SS+kWpsvju+ib7LuI++O76JvpFqbL6Z1SS+7797vSiyTT3bVBI+ZCU9PqaoJD7cBqw9g7YevCzXob0xV8m9oErBvSb8Kr22YVk9UDIVPkLJPT7bVBI+5+fjPMJG8b3B5Xm+tOSjvlVBsb40irC+XYauvjSKsL5VQbG+tOSjvsHleb7CRvG95+fjPNtUEj5CyT0+UDIVPrZhWT0m/Cq9oErBvZdknb0NpHs71rDfPTLbNz4MLyc+KLJNPcJG8b07vom+4uWvvruAp75ADYK+hTo4vhViGb6FOji+QA2CvruAp77i5a++O76JvsJG8b0osk09DC8nPjLbNz7WsN89DaR7O5dknb1zOlW9gmpEPbhPGT5MSTw+2/vbPe+/e73B5Xm+4uWvvnEinL4VYhm+YtsqPZ+BPj51dHM+n4E+PmLbKj0VYhm+cSKcvuLlr77B5Xm+7797vdv72z1MSTw+uE8ZPoJqRD1zOlW9chnZvNwGrD3iCTE+2UgrPpygID2Z1SS+tOSjvruAp74VYhm+ECwLPsBcyz6FtQs/IDYWP4W1Cz/AXMs+ECwLPhViGb67gKe+tOSjvpnVJL6coCA92UgrPuIJMT7cBqw9chnZvLNYrLvWsN89KQ07PttUEj4yAq+8kWpsvlVBsb5ADYK+YtsqPcBcyz6qwR4/MrwjP7uzGT8yvCM/qsEeP8Bcyz5i2yo9QA2CvlVBsb6Ramy+MgKvvNtUEj4pDTs+1rDfPbNYrLtlUws8Qj39PXqWPT530fs97797vTu+ib40irC+hTo4vp+BPj6FtQs/MrwjPxzOwz5INgo+HM7DPjK8Iz+FtQs/n4E+PoU6OL40irC+O76Jvu+/e7130fs9epY9PkI9/T1lUws8HuZYPOVdAz5CyT0+YlzsPVw5mr3LuI++XYauvhViGb51dHM+IDYWP7uzGT9INgo+B50fv0g2Cj67sxk/IDYWP3V0cz4VYhm+XYauvsu4j75cOZq9YlzsPULJPT7lXQM+HuZYPGVTCzxCPf09epY9PnfR+z3vv3u9O76JvjSKsL6FOji+n4E+PoW1Cz8yvCM/HM7DPkg2Cj4czsM+MrwjP4W1Cz+fgT4+hTo4vjSKsL47vom+7797vXfR+z16lj0+Qj39PWVTCzyzWKy71rDfPSkNOz7bVBI+MgKvvJFqbL5VQbG+QA2CvmLbKj3AXMs+qsEePzK8Iz+7sxk/MrwjP6rBHj/AXMs+YtsqPUANgr5VQbG+kWpsvjICr7zbVBI+KQ07Ptaw3z2zWKy7chnZvNwGrD3iCTE+2UgrPpygID2Z1SS+tOSjvruAp74VYhm+ECwLPsBcyz6FtQs/IDYWP4W1Cz/AXMs+ECwLPhViGb67gKe+tOSjvpnVJL6coCA92UgrPuIJMT7cBqw9chnZvHM6Vb2CakQ9uE8ZPkxJPD7b+9s97797vcHleb7i5a++cSKcvhViGb5i2yo9n4E+PnV0cz6fgT4+YtsqPRViGb5xIpy+4uWvvsHleb7vv3u92/vbPUxJPD64Txk+gmpEPXM6Vb2XZJ29DaR7O9aw3z0y2zc+DC8nPiiyTT3CRvG9O76JvuLlr767gKe+QA2CvoU6OL4VYhm+hTo4vkANgr67gKe+4uWvvju+ib7CRvG9KLJNPQwvJz4y2zc+1rDfPQ2kezuXZJ29oErBvSb8Kr22YVk9UDIVPkLJPT7bVBI+5+fjPMJG8b3B5Xm+tOSjvlVBsb40irC+XYauvjSKsL5VQbG+tOSjvsHleb7CRvG95+fjPNtUEj5CyT0+UDIVPrZhWT0m/Cq9oErBvTFXyb0s16G9g7YevNwGrD2mqCQ+ZCU9PttUEj4osk097797vZnVJL6Ramy+O76Jvsu4j747vom+kWpsvpnVJL7vv3u9KLJNPdtUEj5kJT0+pqgkPtwGrD2Dth68LNehvTFXyb0T5q29jH7IvUeOg71lUws8K/LAPaaoJD5CyT0+DC8nPtv72z2coCA9MgKvvO+/e71cOZq97797vTICr7ycoCA92/vbPQwvJz5CyT0+pqgkPivywD1lUws8R46DvYx+yL0T5q29J5pivTvAvL1MK8O9LBtvvWVTCzzcBqw9UDIVPjLbNz5MSTw+2UgrPttUEj530fs9YlzsPXfR+z3bVBI+2UgrPkxJPD4y2zc+UDIVPtwGrD1lUws8LBtvvUwrw707wLy9J5pivbLMhbxGSIG9XaPAvUwrw71HjoO9g7YevLZhWT3WsN89uE8ZPuIJMT4pDTs+epY9PkLJPT56lj0+KQ07PuIJMT64Txk+1rDfPbZhWT2Dth68R46DvUwrw71do8C9RkiBvbLMhbwHE648cPymvEZIgb07wLy9jH7IvSzXob0m/Cq9DaR7O4JqRD3cBqw91rDfPUI9/T3lXQM+Qj39Pdaw3z3cBqw9gmpEPQ2kezsm/Cq9LNehvYx+yL07wLy9RkiBvXD8prwHE6483gY+PQcTrjyyzIW8J5pivRPmrb0xV8m9oErBvZdknb1zOlW9chnZvLNYrLtlUws8HuZYPGVTCzyzWKy7chnZvHM6Vb2XZJ29oErBvTFXyb0T5q29J5pivbLMhbwHE6483gY+PQ==", - "encoding": "base64", - "path": [ - "y", - 9, - "data" - ] - }, - { - "data": "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", - "encoding": "base64", - "path": [ - "y", - 10, - "data" - ] - }, - { - "data": "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", - "encoding": "base64", - "path": [ - "y", - 11, - "data" - ] - }, - { - "data": "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", - "encoding": "base64", - "path": [ - "y", - 12, - "data" - ] - }, - { - "data": "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", - "encoding": "base64", - "path": [ - "y", - 13, - "data" - ] - }, - { - "data": "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", - "encoding": "base64", - "path": [ - "y", - 14, - "data" - ] - }, - { - "data": "AAAgwQAAIMEAACDBAAAgwQAAIMEAACDBAAAgwQAAIMEAACDBAAAgwQAAIMEAACDBAAAgwQAAIMEAACDBAAAgwQAAIMEAACDBAAAgwQAAIMEAACDBAAAgwQAAIMEAACDBAAAgwauqEsGrqhLBq6oSwauqEsGrqhLBq6oSwauqEsGrqhLBq6oSwauqEsGrqhLBq6oSwauqEsGrqhLBq6oSwauqEsGrqhLBq6oSwauqEsGrqhLBq6oSwauqEsGrqhLBq6oSwauqEsFVVQXBVVUFwVVVBcFVVQXBVVUFwVVVBcFVVQXBVVUFwVVVBcFVVQXBVVUFwVVVBcFVVQXBVVUFwVVVBcFVVQXBVVUFwVVVBcFVVQXBVVUFwVVVBcFVVQXBVVUFwVVVBcFVVQXBAADwwAAA8MAAAPDAAADwwAAA8MAAAPDAAADwwAAA8MAAAPDAAADwwAAA8MAAAPDAAADwwAAA8MAAAPDAAADwwAAA8MAAAPDAAADwwAAA8MAAAPDAAADwwAAA8MAAAPDAAADwwFVV1cBVVdXAVVXVwFVV1cBVVdXAVVXVwFVV1cBVVdXAVVXVwFVV1cBVVdXAVVXVwFVV1cBVVdXAVVXVwFVV1cBVVdXAVVXVwFVV1cBVVdXAVVXVwFVV1cBVVdXAVVXVwFVV1cCrqrrAq6q6wKuqusCrqrrAq6q6wKuqusCrqrrAq6q6wKuqusCrqrrAq6q6wKuqusCrqrrAq6q6wKuqusCrqrrAq6q6wKuqusCrqrrAq6q6wKuqusCrqrrAq6q6wKuqusCrqrrAAACgwAAAoMAAAKDAAACgwAAAoMAAAKDAAACgwAAAoMAAAKDAAACgwAAAoMAAAKDAAACgwAAAoMAAAKDAAACgwAAAoMAAAKDAAACgwAAAoMAAAKDAAACgwAAAoMAAAKDAAACgwFVVhcBVVYXAVVWFwFVVhcBVVYXAVVWFwFVVhcBVVYXAVVWFwFVVhcBVVYXAVVWFwFVVhcBVVYXAVVWFwFVVhcBVVYXAVVWFwFVVhcBVVYXAVVWFwFVVhcBVVYXAVVWFwFVVhcBVVVXAVVVVwFVVVcBVVVXAVVVVwFVVVcBVVVXAVVVVwFVVVcBVVVXAVVVVwFVVVcBVVVXAVVVVwFVVVcBVVVXAVVVVwFVVVcBVVVXAVVVVwFVVVcBVVVXAVVVVwFVVVcBVVVXAAAAgwAAAIMAAACDAAAAgwAAAIMAAACDAAAAgwAAAIMAAACDAAAAgwAAAIMAAACDAAAAgwAAAIMAAACDAAAAgwAAAIMAAACDAAAAgwAAAIMAAACDAAAAgwAAAIMAAACDAAAAgwFVV1b9VVdW/VVXVv1VV1b9VVdW/VVXVv1VV1b9VVdW/VVXVv1VV1b9VVdW/VVXVv1VV1b9VVdW/VVXVv1VV1b9VVdW/VVXVv1VV1b9VVdW/VVXVv1VV1b9VVdW/VVXVv1VV1b9VVVW/VVVVv1VVVb9VVVW/VVVVv1VVVb9VVVW/VVVVv1VVVb9VVVW/VVVVv1VVVb9VVVW/VVVVv1VVVb9VVVW/VVVVv1VVVb9VVVW/VVVVv1VVVb9VVVW/VVVVv1VVVb9VVVW/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFVVVT9VVVU/VVVVP1VVVT9VVVU/VVVVP1VVVT9VVVU/VVVVP1VVVT9VVVU/VVVVP1VVVT9VVVU/VVVVP1VVVT9VVVU/VVVVP1VVVT9VVVU/VVVVP1VVVT9VVVU/VVVVP1VVVT9VVdU/VVXVP1VV1T9VVdU/VVXVP1VV1T9VVdU/VVXVP1VV1T9VVdU/VVXVP1VV1T9VVdU/VVXVP1VV1T9VVdU/VVXVP1VV1T9VVdU/VVXVP1VV1T9VVdU/VVXVP1VV1T9VVdU/AAAgQAAAIEAAACBAAAAgQAAAIEAAACBAAAAgQAAAIEAAACBAAAAgQAAAIEAAACBAAAAgQAAAIEAAACBAAAAgQAAAIEAAACBAAAAgQAAAIEAAACBAAAAgQAAAIEAAACBAAAAgQFVVVUBVVVVAVVVVQFVVVUBVVVVAVVVVQFVVVUBVVVVAVVVVQFVVVUBVVVVAVVVVQFVVVUBVVVVAVVVVQFVVVUBVVVVAVVVVQFVVVUBVVVVAVVVVQFVVVUBVVVVAVVVVQFVVVUBVVYVAVVWFQFVVhUBVVYVAVVWFQFVVhUBVVYVAVVWFQFVVhUBVVYVAVVWFQFVVhUBVVYVAVVWFQFVVhUBVVYVAVVWFQFVVhUBVVYVAVVWFQFVVhUBVVYVAVVWFQFVVhUBVVYVAAACgQAAAoEAAAKBAAACgQAAAoEAAAKBAAACgQAAAoEAAAKBAAACgQAAAoEAAAKBAAACgQAAAoEAAAKBAAACgQAAAoEAAAKBAAACgQAAAoEAAAKBAAACgQAAAoEAAAKBAAACgQKuqukCrqrpAq6q6QKuqukCrqrpAq6q6QKuqukCrqrpAq6q6QKuqukCrqrpAq6q6QKuqukCrqrpAq6q6QKuqukCrqrpAq6q6QKuqukCrqrpAq6q6QKuqukCrqrpAq6q6QKuqukBVVdVAVVXVQFVV1UBVVdVAVVXVQFVV1UBVVdVAVVXVQFVV1UBVVdVAVVXVQFVV1UBVVdVAVVXVQFVV1UBVVdVAVVXVQFVV1UBVVdVAVVXVQFVV1UBVVdVAVVXVQFVV1UBVVdVAAADwQAAA8EAAAPBAAADwQAAA8EAAAPBAAADwQAAA8EAAAPBAAADwQAAA8EAAAPBAAADwQAAA8EAAAPBAAADwQAAA8EAAAPBAAADwQAAA8EAAAPBAAADwQAAA8EAAAPBAAADwQFVVBUFVVQVBVVUFQVVVBUFVVQVBVVUFQVVVBUFVVQVBVVUFQVVVBUFVVQVBVVUFQVVVBUFVVQVBVVUFQVVVBUFVVQVBVVUFQVVVBUFVVQVBVVUFQVVVBUFVVQVBVVUFQVVVBUGrqhJBq6oSQauqEkGrqhJBq6oSQauqEkGrqhJBq6oSQauqEkGrqhJBq6oSQauqEkGrqhJBq6oSQauqEkGrqhJBq6oSQauqEkGrqhJBq6oSQauqEkGrqhJBq6oSQauqEkGrqhJBAAAgQQAAIEEAACBBAAAgQQAAIEEAACBBAAAgQQAAIEEAACBBAAAgQQAAIEEAACBBAAAgQQAAIEEAACBBAAAgQQAAIEEAACBBAAAgQQAAIEEAACBBAAAgQQAAIEEAACBBAAAgQQ==", - "encoding": "base64", - "path": [ - "z", - 0, - "data" - ] - } - ], - "model_module": "ipyvolume", - "model_module_version": "^0.5.0-beta.1", - "model_name": "ScatterModel", - "state": { - "geo": "sphere", - "line_material": "IPY_MODEL_3681c5ad188d4b8e997027c2b67dd235", - "material": "IPY_MODEL_c44c743a4ccd48e3b3325e7349818580", - "selected": null, - "sequence_index": 14, - "size": 2, - "size_selected": 2.6, - "texture": null, - "visible": true, - "vx": null, - "vy": null, - "vz": null, - "x": [ - { - "dtype": "float32", - "shape": [ - 625 - ] - } - ], - "y": [ - { - "dtype": "float32", - "shape": [ - 625 - ] - }, - { - "dtype": "float32", - "shape": [ - 625 - ] - }, - { - "dtype": "float32", - "shape": [ - 625 - ] - }, - { - "dtype": "float32", - "shape": [ - 625 - ] - }, - { - "dtype": "float32", - "shape": [ - 625 - ] - }, - { - "dtype": "float32", - "shape": [ - 625 - ] - }, - { - "dtype": "float32", - "shape": [ - 625 - ] - }, - { - "dtype": "float32", - "shape": [ - 625 - ] - }, - { - "dtype": "float32", - "shape": [ - 625 - ] - }, - { - "dtype": "float32", - "shape": [ - 625 - ] - }, - { - "dtype": "float32", - "shape": [ - 625 - ] - }, - { - "dtype": "float32", - "shape": [ - 625 - ] - }, - { - "dtype": "float32", - "shape": [ - 625 - ] - }, - { - "dtype": "float32", - "shape": [ - 625 - ] - }, - { - "dtype": "float32", - "shape": [ - 625 - ] - } - ], - "z": [ - { - "dtype": "float32", - "shape": [ - 625 - ] - } - ] - } - }, - "0c447892c5bd4a61a4610427bae1810e": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.1.0", - "model_name": "LayoutModel", - "state": {} - }, - "0fa46a2814a34bd59ca3e501c5d8118a": { - "model_module": "jupyter-threejs", - "model_module_version": "~1.0.0", - "model_name": "ShaderMaterialModel", - "state": { - "_model_module_version": "~1.0.0", - "_view_module": null, - "_view_module_version": "" - } - }, - "15ae0e209e304a3b9bb24fe0fea70351": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.1.0", - "model_name": "LayoutModel", - "state": {} - }, - "15ae25305a5946e9a49f0e3dae821dc0": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.4.0", - "model_name": "LinkModel", - "state": { - "source": [ - "IPY_MODEL_cfb85996953142479439894fb4c96c1a", - "value" - ], - "target": [ - "IPY_MODEL_0b44784ed5904895a8c2cc1e5f71c18c", - "sequence_index" - ] - } - }, - "15d53645500840aea354c7a21d860250": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.1.0", - "model_name": "LayoutModel", - "state": {} - }, - "17d1334e9cb64d358df5ef35acb7a175": { - "model_module": "ipyvolume", - "model_module_version": "^0.5.0-beta.1", - "model_name": "FigureModel", - "state": { - "ambient_coefficient": 0.5, - "animation": 200, - "camera": "IPY_MODEL_6e3ec78da9aa467f8321c3c1d7083926", - "capture_fps": null, - "diffuse_coefficient": 0.8, - "height": 500, - "layout": "IPY_MODEL_15d53645500840aea354c7a21d860250", - "matrix_projection": [ - 2.9448154572796907, - 0, - 0, - 0, - 0, - 2.3558523658237527, - 0, - 0, - 0, - 0, - -1.00010000500025, - -1, - 0, - 0, - -0.200010000500025, - 0 - ], - "matrix_world": [ - 0.5, - 0, - 0, - 0, - 0, - 0.5, - 3.061616997868383e-17, - 0, - 0, - -3.061616997868383e-17, - 0.5, - 0, - 0, - 0, - -2, - 1 - ], - "meshes": [], - "scatters": [ - "IPY_MODEL_f864ec653a9b4f7fb057ccc1baba8ac9" - ], - "scene": "IPY_MODEL_9be9839fe9964a8e9d36c9f8e4b19fcb", - "specular_coefficient": 0.5, - "specular_exponent": 5, - "volumes": [], - "width": 400, - "xlim": [ - -1, - 1 - ], - "ylim": [ - -1, - 1 - ], - "zlim": [ - -1, - 1 - ] - } - }, - "183990fed4a245d18a801fe30c0a520d": { - "model_module": "jupyter-threejs", - "model_module_version": "~1.0.0", - "model_name": "ShaderMaterialModel", - "state": { - "_model_module_version": "~1.0.0", - "_view_module": null, - "_view_module_version": "" - } - }, - "197353e08a2a47d896802d935ab84101": { - "model_module": "jupyter-threejs", - "model_module_version": "~1.0.0", - "model_name": "SceneModel", - "state": { - "_model_module_version": "~1.0.0", - "_view_module": null, - "_view_module_version": "", - "background": null - } - }, - "1bd37a8733d045b9b28eedd3971c48d7": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.4.0", - "model_name": "LinkModel", - "state": { - "source": [ - "IPY_MODEL_992acf7dd9a44c028b851bd16b142ffc", - "value" - ], - "target": [ - "IPY_MODEL_cfb85996953142479439894fb4c96c1a", - "value" - ] - } - }, - "1d444769044f4665a87e8f1ed28e6616": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.4.0", - "model_name": "FloatSliderModel", - "state": { - "layout": "IPY_MODEL_f1e04a722ad847569876e85392fab858", - "max": 2, - "style": "IPY_MODEL_78ffb23f071a47deb5aaeae37489d992", - "value": 1 - } - }, - "1fd18b0a6b764e8c92a345f2744d9fab": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.1.0", - "model_name": "LayoutModel", - "state": {} - }, - "22f0f8cc309d4401b5cdc4e70e771051": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.1.0", - "model_name": "LayoutModel", - "state": {} - }, - "2376e71f34ef4503bfccdefb9a67ccea": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.4.0", - "model_name": "VBoxModel", - "state": { - "children": [ - "IPY_MODEL_d79017ea773b4b6f9d66a60a706b6668", - "IPY_MODEL_fd44c9c13f624c51a0b923236f832f36" - ], - "layout": "IPY_MODEL_2fe81ee960c446fa8178c16622124f21" - } - }, - "239444c89b374df38fa42aa7a59fbe16": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.4.0", - "model_name": "VBoxModel", - "state": { - "children": [ - "IPY_MODEL_cc7835a92f184cba990381766ff7a5d9", - "IPY_MODEL_622cfb5427804833b3eafe2cd064c9df" - ], - "layout": "IPY_MODEL_e492fbd963294c17a8e32f74283216e9" - } - }, - "240ca8a1bc594bc0ab8adc0c4f81b4d2": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.1.0", - "model_name": "LayoutModel", - "state": {} - }, - "245072663ea94bb096b2321d43813961": { - "model_module": "jupyter-threejs", - "model_module_version": "~1.0.0", - "model_name": "PerspectiveCameraModel", - "state": { - "_model_module_version": "~1.0.0", - "_view_module": null, - "_view_module_version": "", - "aspect": 0.8, - "fov": 46, - "matrix": [ - 1, - 0, - 0, - 0, - 0, - 1, - -6.123233995736766e-17, - 0, - 0, - 6.123233995736766e-17, - 1, - 0, - 0, - 1.2246467991473532e-16, - 2, - 1 - ], - "matrixWorld": [ - 1, - 0, - 0, - 0, - 0, - 1, - -6.123233995736766e-17, - 0, - 0, - 6.123233995736766e-17, - 1, - 0, - 0, - 1.2246467991473532e-16, - 2, - 1 - ], - "matrixWorldInverse": [ - 1, - 0, - 0, - 0, - 0, - 1, - 6.123233995736766e-17, - 0, - 0, - -6.123233995736766e-17, - 1, - 0, - 0, - 0, - -2, - 1 - ], - "position": [ - 0, - 1.2246467991473532e-16, - 2 - ], - "projectionMatrix": [ - 2.9448154572796907, - 0, - 0, - 0, - 0, - 2.3558523658237527, - 0, - 0, - 0, - 0, - -1.00010000500025, - -1, - 0, - 0, - -0.200010000500025, - 0 - ], - "quaternion": [ - -3.061616997868383e-17, - 0, - 0, - 1 - ], - "rotation": [ - -6.123233995736766e-17, - 0, - 0, - "XYZ" - ] - } - }, - "25277f48e0c34a6682c66c20e00a34e7": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.1.0", - "model_name": "LayoutModel", - "state": {} - }, - "2a90868385684f20b94ba826b2ed0853": { - "model_module": "ipyvolume", - "model_module_version": "^0.5.0-beta.1", - "model_name": "FigureModel", - "state": { - "ambient_coefficient": 0.5, - "animation": 200, - "camera": "IPY_MODEL_00a1968307f74adb9fddf3dc4f38828e", - "capture_fps": null, - "diffuse_coefficient": 0.8, - "height": 500, - "layout": "IPY_MODEL_bb6a8238f7ab431ca448bad38fcd6ebf", - "matrix_projection": [ - 2.9448154572796907, - 0, - 0, - 0, - 0, - 2.3558523658237527, - 0, - 0, - 0, - 0, - -1.00010000500025, - -1, - 0, - 0, - -0.200010000500025, - 0 - ], - "matrix_world": [ - 0.02678726034114551, - 0, - 0, - 0, - 0, - 0.03542447592596365, - 2.1691235527101927e-18, - 0, - 0, - -1.6486250790977329e-18, - 0.026924090770425724, - 0, - -0.024263206626966793, - -0.01759644420729889, - -1.9748047549075112, - 1 - ], - "meshes": [], - "scatters": [ - "IPY_MODEL_c54af9ae087647a0a8902750e345c6db" - ], - "scene": "IPY_MODEL_ca43709a8b204164a304b73735979e94", - "specular_coefficient": 0.5, - "specular_exponent": 5, - "style": { - "axes": { - "color": "white", - "label": { - "color": "white" - }, - "ticklabel": { - "color": "white" - }, - "visible": true - }, - "background-color": "#000001", - "box": { - "visible": true - } - }, - "volumes": [], - "width": 400, - "xlim": [ - -17.7598152, - 19.5713634 - ], - "ylim": [ - -13.6178036, - 14.6112661 - ], - "zlim": [ - -19.5065174, - 17.6349411 - ] - } - }, - "2c5d0c58a1b1495fb47908a36488c868": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.4.0", - "model_name": "FloatSliderModel", - "state": { - "layout": "IPY_MODEL_c4852057e7db42df8225fa43e52eed81", - "max": 49, - "style": "IPY_MODEL_fc3eca8b4090422bbff25ef37b9707c6", - "value": 17 - } - }, - "2fe81ee960c446fa8178c16622124f21": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.1.0", - "model_name": "LayoutModel", - "state": {} - }, - "3681c5ad188d4b8e997027c2b67dd235": { - "model_module": "jupyter-threejs", - "model_module_version": "~1.0.0", - "model_name": "ShaderMaterialModel", - "state": { - "_model_module_version": "~1.0.0", - "_view_module": null, - "_view_module_version": "" - } - }, - "3bd5bd6b326b48749588ca49278a6f8a": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.4.0", - "model_name": "SliderStyleModel", - "state": { - "description_width": "" - } - }, - "3d55f5ad3de442cabccb2f8b4c9658f9": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.4.0", - "model_name": "LinkModel", - "state": { - "source": [ - "IPY_MODEL_1d444769044f4665a87e8f1ed28e6616", - "value" - ], - "target": [ - "IPY_MODEL_6cbccad5b7db418eb20315cbbe3ea8be", - "sequence_index" - ] - } - }, - "3ddf7e481aec4de694577c019c98cfaf": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.1.0", - "model_name": "LayoutModel", - "state": {} - }, - "3e659ec033324585a78699bc32925032": { - "model_module": "@jupyter-widgets/output", - "model_module_version": "1.0.0", - "model_name": "OutputModel", - "state": { - "layout": "IPY_MODEL_884c07ef1ced4620b5cae4676ac3f5b5", - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": "convert -delay 5.0 -loop 0 /var/folders/4h/rklzvjwj08170p1nlsntfdkw0000gn/T/tmprcddbnx7/frame-*.png wave.gif\n" - } - ] - } - }, - "3e8cee824d0f4b68ad7f23b1717c261e": { - "model_module": "jupyter-threejs", - "model_module_version": "~1.0.0", - "model_name": "ShaderMaterialModel", - "state": { - "_model_module_version": "~1.0.0", - "_view_module": null, - "_view_module_version": "" - } - }, - "4163df1232f24aeb85117381a8944736": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.4.0", - "model_name": "DescriptionStyleModel", - "state": { - "description_width": "" - } - }, - "42dbcaf6de244359ae06cf249b1762fa": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.1.0", - "model_name": "LayoutModel", - "state": {} - }, - "4d7a6daf02e04c048401fe27f6e9411b": { - "model_module": "jupyter-threejs", - "model_module_version": "~1.0.0", - "model_name": "PerspectiveCameraModel", - "state": { - "_model_module_version": "~1.0.0", - "_view_module": null, - "_view_module_version": "", - "aspect": 0.8, - "fov": 46, - "matrix": [ - 1, - 0, - 0, - 0, - 0, - 1, - -6.123233995736766e-17, - 0, - 0, - 6.123233995736766e-17, - 1, - 0, - 0, - 1.2246467991473532e-16, - 2, - 1 - ], - "matrixWorld": [ - 1, - 0, - 0, - 0, - 0, - 1, - -6.123233995736766e-17, - 0, - 0, - 6.123233995736766e-17, - 1, - 0, - 0, - 1.2246467991473532e-16, - 2, - 1 - ], - "matrixWorldInverse": [ - 1, - 0, - 0, - 0, - 0, - 1, - 6.123233995736766e-17, - 0, - 0, - -6.123233995736766e-17, - 1, - 0, - 0, - 0, - -2, - 1 - ], - "position": [ - 0, - 1.2246467991473532e-16, - 2 - ], - "projectionMatrix": [ - 2.9448154572796907, - 0, - 0, - 0, - 0, - 2.3558523658237527, - 0, - 0, - 0, - 0, - -1.00010000500025, - -1, - 0, - 0, - -0.200010000500025, - 0 - ], - "quaternion": [ - -3.061616997868383e-17, - 0, - 0, - 1 - ], - "rotation": [ - -6.123233995736766e-17, - 0, - 0, - "XYZ" - ] - } - }, - "551355880ae0411d851959f2aa7992b0": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.1.0", - "model_name": "LayoutModel", - "state": {} - }, - "5a2ace988cc0485f8d31dd37b76a4365": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.1.0", - "model_name": "LayoutModel", - "state": {} - }, - "5b4887ec78ba48979450cc5618b18676": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.4.0", - "model_name": "LinkModel", - "state": { - "source": [ - "IPY_MODEL_e13c3dfe59994790b9a7b82c10c980a6", - "value" - ], - "target": [ - "IPY_MODEL_f864ec653a9b4f7fb057ccc1baba8ac9", - "sequence_index" - ] - } - }, - "622cfb5427804833b3eafe2cd064c9df": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.4.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_d4522e05191c44e59e373863e22cab61", - "IPY_MODEL_1d444769044f4665a87e8f1ed28e6616" - ], - "layout": "IPY_MODEL_706c95dc7c4447339433780af111bdea" - } - }, - "6b0dfc7b72df4df7bc5882fa15cb6440": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.4.0", - "model_name": "PlayModel", - "state": { - "interval": 200, - "layout": "IPY_MODEL_773829e529f94dc293c859db15bb5dd0", - "max": 2, - "style": "IPY_MODEL_edbdc0ff545b4bddb8d1bd00dd7ee5a7", - "value": 1 - } - }, - "6cbccad5b7db418eb20315cbbe3ea8be": { - "buffers": [ - { - "data": "AACAv83MTL8=", - "encoding": "base64", - "path": [ - "x", - 0, - "data" - ] - }, - { - "data": "AACAP83MzL0=", - "encoding": "base64", - "path": [ - "x", - 1, - "data" - ] - }, - { - "data": "AAAAAAAAAD8=", - "encoding": "base64", - "path": [ - "x", - 2, - "data" - ] - }, - { - "data": "AAAAAAAAAAA=", - "encoding": "base64", - "path": [ - "y", - 0, - "data" - ] - }, - { - "data": "AAAAAAAAAAA=", - "encoding": "base64", - "path": [ - "z", - 0, - "data" - ] - } - ], - "model_module": "ipyvolume", - "model_module_version": "^0.5.0-beta.1", - "model_name": "ScatterModel", - "state": { - "geo": "sphere", - "line_material": "IPY_MODEL_9401412e9014496d8a9b26f859ee9b9a", - "material": "IPY_MODEL_183990fed4a245d18a801fe30c0a520d", - "selected": null, - "sequence_index": 1, - "size": 10, - "size_selected": 2.6, - "texture": null, - "visible": true, - "vx": null, - "vy": null, - "vz": null, - "x": [ - { - "dtype": "float32", - "shape": [ - 2 - ] - }, - { - "dtype": "float32", - "shape": [ - 2 - ] - }, - { - "dtype": "float32", - "shape": [ - 2 - ] - } - ], - "y": [ - { - "dtype": "float32", - "shape": [ - 2 - ] - } - ], - "z": [ - { - "dtype": "float32", - "shape": [ - 2 - ] - } - ] - } - }, - "6d29285938e64814b00bb4c8dbfde5ee": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.4.0", - "model_name": "DescriptionStyleModel", - "state": { - "description_width": "" - } - }, - "6e3ec78da9aa467f8321c3c1d7083926": { - "model_module": "jupyter-threejs", - "model_module_version": "~1.0.0", - "model_name": "PerspectiveCameraModel", - "state": { - "_model_module_version": "~1.0.0", - "_view_module": null, - "_view_module_version": "", - "aspect": 0.8, - "fov": 46, - "matrix": [ - 1, - 0, - 0, - 0, - 0, - 1, - -6.123233995736766e-17, - 0, - 0, - 6.123233995736766e-17, - 1, - 0, - 0, - 1.2246467991473532e-16, - 2, - 1 - ], - "matrixWorld": [ - 1, - 0, - 0, - 0, - 0, - 1, - -6.123233995736766e-17, - 0, - 0, - 6.123233995736766e-17, - 1, - 0, - 0, - 1.2246467991473532e-16, - 2, - 1 - ], - "matrixWorldInverse": [ - 1, - 0, - 0, - 0, - 0, - 1, - 6.123233995736766e-17, - 0, - 0, - -6.123233995736766e-17, - 1, - 0, - 0, - 0, - -2, - 1 - ], - "position": [ - 0, - 1.2246467991473532e-16, - 2 - ], - "projectionMatrix": [ - 2.9448154572796907, - 0, - 0, - 0, - 0, - 2.3558523658237527, - 0, - 0, - 0, - 0, - -1.00010000500025, - -1, - 0, - 0, - -0.200010000500025, - 0 - ], - "quaternion": [ - -3.061616997868383e-17, - 0, - 0, - 1 - ], - "rotation": [ - -6.123233995736766e-17, - 0, - 0, - "XYZ" - ] - } - }, - "706c95dc7c4447339433780af111bdea": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.1.0", - "model_name": "LayoutModel", - "state": {} - }, - "7448e479d27248c19a6c873e2f5bb7c9": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.4.0", - "model_name": "LinkModel", - "state": { - "source": [ - "IPY_MODEL_6b0dfc7b72df4df7bc5882fa15cb6440", - "value" - ], - "target": [ - "IPY_MODEL_e13c3dfe59994790b9a7b82c10c980a6", - "value" - ] - } - }, - "75202cde091f4ea7889b666f63fc7bfb": { - "model_module": "jupyter-threejs", - "model_module_version": "~1.0.0", - "model_name": "ShaderMaterialModel", - "state": { - "_model_module_version": "~1.0.0", - "_view_module": null, - "_view_module_version": "" - } - }, - "75a153b2ab5b4400bf47853755764681": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.4.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_6b0dfc7b72df4df7bc5882fa15cb6440", - "IPY_MODEL_e13c3dfe59994790b9a7b82c10c980a6" - ], - "layout": "IPY_MODEL_82a162deabf6488c96e92705600a4066" - } - }, - "773829e529f94dc293c859db15bb5dd0": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.1.0", - "model_name": "LayoutModel", - "state": {} - }, - "782e95449c6e4d0cb991480d9f939f13": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.4.0", - "model_name": "LinkModel", - "state": { - "source": [ - "IPY_MODEL_85981af75a454270ad935917abaadf9c", - "value" - ], - "target": [ - "IPY_MODEL_2c5d0c58a1b1495fb47908a36488c868", - "value" - ] - } - }, - "78ffb23f071a47deb5aaeae37489d992": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.4.0", - "model_name": "SliderStyleModel", - "state": { - "description_width": "" - } - }, - "82a162deabf6488c96e92705600a4066": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.1.0", - "model_name": "LayoutModel", - "state": {} - }, - "85981af75a454270ad935917abaadf9c": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.4.0", - "model_name": "PlayModel", - "state": { - "interval": 200, - "layout": "IPY_MODEL_a62decff28d6453892e86db5124c6709", - "max": 49, - "style": "IPY_MODEL_6d29285938e64814b00bb4c8dbfde5ee", - "value": 17 - } - }, - "884c07ef1ced4620b5cae4676ac3f5b5": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.1.0", - "model_name": "LayoutModel", - "state": {} - }, - "89cdd81186ea4bc0bb2aef5a531a311d": { - "model_module": "jupyter-threejs", - "model_module_version": "~1.0.0", - "model_name": "SceneModel", - "state": { - "_model_module_version": "~1.0.0", - "_view_module": null, - "_view_module_version": "", - "background": null - } - }, - "8cd7b3c022054937a9d9fc5778faa430": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.1.0", - "model_name": "LayoutModel", - "state": {} - }, - "8d8e0d6a071745a7b0e3ef10616ac0bb": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.4.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_85981af75a454270ad935917abaadf9c", - "IPY_MODEL_2c5d0c58a1b1495fb47908a36488c868" - ], - "layout": "IPY_MODEL_c641231c68b14e8292677203201fa6b0" - } - }, - "8dbf31d0ae3648cbabe83f95f9b7e3b5": { - "model_module": "ipyvolume", - "model_module_version": "^0.5.0-beta.1", - "model_name": "FigureModel", - "state": { - "ambient_coefficient": 0.5, - "camera": "IPY_MODEL_cfb2da5a977640d4af4ec44890f9a747", - "capture_fps": null, - "diffuse_coefficient": 0.8, - "height": 500, - "layout": "IPY_MODEL_240ca8a1bc594bc0ab8adc0c4f81b4d2", - "matrix_projection": [ - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0 - ], - "matrix_world": [ - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0 - ], - "meshes": [], - "scatters": [], - "scene": "IPY_MODEL_89cdd81186ea4bc0bb2aef5a531a311d", - "specular_coefficient": 0.5, - "specular_exponent": 5, - "volumes": [], - "width": 400 - } - }, - "8dfd1ab1047f429184adb52dc5dbd182": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.4.0", - "model_name": "VBoxModel", - "state": { - "children": [ - "IPY_MODEL_2a90868385684f20b94ba826b2ed0853", - "IPY_MODEL_8d8e0d6a071745a7b0e3ef10616ac0bb" - ], - "layout": "IPY_MODEL_1fd18b0a6b764e8c92a345f2744d9fab" - } - }, - "8f267d3de871489e9d9f86652fb27317": { - "model_module": "jupyter-threejs", - "model_module_version": "~1.0.0", - "model_name": "ShaderMaterialModel", - "state": { - "_model_module_version": "~1.0.0", - "_view_module": null, - "_view_module_version": "" - } - }, - "9401412e9014496d8a9b26f859ee9b9a": { - "model_module": "jupyter-threejs", - "model_module_version": "~1.0.0", - "model_name": "ShaderMaterialModel", - "state": { - "_model_module_version": "~1.0.0", - "_view_module": null, - "_view_module_version": "" - } - }, - "9422aefc9f9d4beb922e66bc48c1dc2d": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.4.0", - "model_name": "VBoxModel", - "state": { - "children": [ - "IPY_MODEL_17d1334e9cb64d358df5ef35acb7a175", - "IPY_MODEL_75a153b2ab5b4400bf47853755764681" - ], - "layout": "IPY_MODEL_551355880ae0411d851959f2aa7992b0" - } - }, - "9909dfc27b8445c9b2c0b0e34b75bbad": { - "model_module": "jupyter-threejs", - "model_module_version": "~1.0.0", - "model_name": "SceneModel", - "state": { - "_model_module_version": "~1.0.0", - "_view_module": null, - "_view_module_version": "", - "background": null - } - }, - "992acf7dd9a44c028b851bd16b142ffc": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.4.0", - "model_name": "PlayModel", - "state": { - "interval": 200, - "layout": "IPY_MODEL_0c447892c5bd4a61a4610427bae1810e", - "max": 14, - "style": "IPY_MODEL_b4de25854e2d4a4981758a983b596d7d", - "value": 14 - } - }, - "9be9839fe9964a8e9d36c9f8e4b19fcb": { - "model_module": "jupyter-threejs", - "model_module_version": "~1.0.0", - "model_name": "SceneModel", - "state": { - "_model_module_version": "~1.0.0", - "_view_module": null, - "_view_module_version": "", - "background": null - } - }, - "a10382301480402aa1ddd69c44656e92": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.1.0", - "model_name": "LayoutModel", - "state": {} - }, - "a62decff28d6453892e86db5124c6709": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.1.0", - "model_name": "LayoutModel", - "state": {} - }, - "abf85081062f4e82888c09171f55ee72": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.1.0", - "model_name": "LayoutModel", - "state": {} - }, - "b05fab60e7a440729bd5414b8c187821": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.1.0", - "model_name": "LayoutModel", - "state": {} - }, - "b3b6951b0508438ba0077da1d5dc5634": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.4.0", - "model_name": "LinkModel", - "state": { - "source": [ - "IPY_MODEL_2c5d0c58a1b1495fb47908a36488c868", - "value" - ], - "target": [ - "IPY_MODEL_c54af9ae087647a0a8902750e345c6db", - "sequence_index" - ] - } - }, - "b4de25854e2d4a4981758a983b596d7d": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.4.0", - "model_name": "DescriptionStyleModel", - "state": { - "description_width": "" - } - }, - "bb6a8238f7ab431ca448bad38fcd6ebf": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.1.0", - "model_name": "LayoutModel", - "state": {} - }, - "bc48846669dd415cb70edde4dd74bf85": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.4.0", - "model_name": "LinkModel", - "state": { - "source": [ - "IPY_MODEL_d4522e05191c44e59e373863e22cab61", - "value" - ], - "target": [ - "IPY_MODEL_1d444769044f4665a87e8f1ed28e6616", - "value" - ] - } - }, - "bf169eb7e0d9407bbd19c23a12ca33fe": { - "model_module": "jupyter-threejs", - "model_module_version": "~1.0.0", - "model_name": "ShaderMaterialModel", - "state": { - "_model_module_version": "~1.0.0", - "_view_module": null, - "_view_module_version": "" - } - }, - "c0d781a560654bd5bcdddd6a44889c19": { - "model_module": "jupyter-threejs", - "model_module_version": "~1.0.0", - "model_name": "PerspectiveCameraModel", - "state": { - "_model_module_version": "~1.0.0", - "_view_module": null, - "_view_module_version": "", - "aspect": 0.8, - "fov": 46, - "matrix": [ - 1, - 0, - 0, - 0, - 0, - 1, - -6.123233995736766e-17, - 0, - 0, - 6.123233995736766e-17, - 1, - 0, - 0, - 1.2246467991473532e-16, - 2, - 1 - ], - "matrixWorld": [ - 1, - 0, - 0, - 0, - 0, - 1, - -6.123233995736766e-17, - 0, - 0, - 6.123233995736766e-17, - 1, - 0, - 0, - 1.2246467991473532e-16, - 2, - 1 - ], - "matrixWorldInverse": [ - -0.9987277295726381, - 0.014355444150423752, - -0.04834090820338506, - 0, - -0.04993747648021216, - -0.1482497564760616, - 0.9876883405951378, - 0, - 0.007012176942454733, - 0.9888457568943869, - 0.1487780173496581, - 0, - 1.734723475976808e-18, - 1.110223024625157e-16, - -3.9000000000000004, - 1 - ], - "position": [ - -0.048481141337516576, - 3.9378234682458557, - 0.3060978795529196 - ], - "projectionMatrix": [ - 2.9448154572796907, - 0, - 0, - 0, - 0, - 2.3558523658237527, - 0, - 0, - 0, - 0, - -1.00010000500025, - -1, - 0, - 0, - -0.200010000500025, - 0 - ], - "quaternion": [ - -0.013638269261214399, - 0.6522461107103127, - 0.7575875367570334, - -0.02121633392553267 - ], - "rotation": [ - -1.4212878018971877, - -0.04835975555170056, - -3.1272199119341355, - "XYZ" - ] - } - }, - "c44c743a4ccd48e3b3325e7349818580": { - "model_module": "jupyter-threejs", - "model_module_version": "~1.0.0", - "model_name": "ShaderMaterialModel", - "state": { - "_model_module_version": "~1.0.0", - "_view_module": null, - "_view_module_version": "" - } - }, - "c4852057e7db42df8225fa43e52eed81": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.1.0", - "model_name": "LayoutModel", - "state": {} - }, - "c54af9ae087647a0a8902750e345c6db": { - "buffers": [ - { - "data": "kJ+ov7loBMJLvVzBKK5pQO7x2T4bGlBClCPpwCqakcF28ha9gDnRQTbnq0GLDpTBNis7QaaLn8EIy47BTFzIQUyNnkEJaiFAvSsmQimUM0C5CAXATQCaQXrN9MFWy5BBRidrQZiFlMHcXx5Bn/4qQe9CMT/BaMg/fuGKQEzEfUHw9HbBkPHbvwyIxEHjgn5BUvDnwSTpC8J2VgZB0GGkwbkWWsA+z5zAAMX7QOsAAMH/TU5ACNluQA8tUUCFNS5B1CrnwUY+lsHWHUvBdji/QR+DjcDZNILACcInQM9tREE2sqhA/xXzwPeuV0Ha3JRB+tgUwTEQ9UAdgwRAnVBDwaAX8UCX5pJBUWmlwC3vHUG3SaTBh6bNQDdx4T2r+HdBEmtHQTR0j8FcKIK/LlENv6ZxAMBHdPLAGff7weLRe8GuaujB71ozwYhl78B0hM5BRkGQQVh6zMHdgcM/yhKOQbl8psBjABjCXQYSQaf2T8H+zCRAKX0OP46uF0C5MR/BkmAcwTylUUEMZQVAAn2lwTKEakHCAotBRah0QRoOZL+qiPxA8U6WQOUNk8D/riHC4WtnwP6hQ0GrV0HB7V3FQQP3vsCtV5DATLDZQY9Ng0HgA/rBCfmhwRbCvMCZ/nJB8vyWQTqIjsE/YQBCM6EBQtG1CcD80wVARgSCwFsfYkH/TZ9ANLmEQQwgT0HSIBe/zOIewFJAzEBVeaxBOUsCQfh9k0GwQATBL2inQU/2RsChEZvBpla6QcZsU8G4uKPAGEbuQKkn1sCNdYVBLZRlQDoT6b/x4IE/5bLpQNqR38Em3lhB0p/mwMbxvMBXpTJBMN0GwVxUM8GzJ+4/0wEPQrbtYMFCtNZAc2QTwG3O90FkJqlBruGaQG0aY0HlqQVCAcrQQQa0w0GKNJZBP81qQVFbqkCL1v7B0xNuQDW4TEGKG5FBXVyfQXqhs8Fx/1hC9AmDPxnIMkBPd8jAv0QSQRnj9sBVPRFBgdZDPwD2AsLjKlPByiqHv4l6vsHMJ0nBQJf+wDmOdz87THDBnrkMwcJWpcBJ5UZA6cmgQBfhjb8=", - "encoding": "base64", - "path": [ - "vx", - 0, - "data" - ] - }, - { - "data": "3CidwuuwwMKylKnC67OIwlQXYMLypsfBpLulwtASsMI8QIHCZGIJwpwpWsL/L7bCzmOKwmpSn8KUjaXCkv9FwmMIRsLmDXbCrKwjwhiDmcIWwlbCHLlFwoQWwMJ06VnCnEVYwjqbj8JB8ErCMqV9wqdcf8Jg/IPCQsyQwoO1icI774zCrri3wiRQPMJI6lvCws25wnKiwMKma3HCB/imwjlzsMLO3pjC44p/wtHGj8JmX33CkQF3woGAjsKE8W7CPKe+wiyyr8KQXafCrSQswi5TpcIq0qHC9n+Nwvy2VcJfHobCLmOowmtEUsIULWbCcLGDwv5dQ8JYtJLCwKqywvAdPsI4gFXCj8eFwiC6fcKav7/C+pl6wkSahMKCrEDC0YyQwtIOpMI3xJjCxY2XwpZki8IKH63CSLGxwurQw8Io2unCAESkwh8Lw8L2zQvCMM+NwiPgzcJ28G/CUwlIwpZakMLQmMTC731hwkClu8J4V3rCkWeqwg/ussL5CZHC0vF8wiJxksIsSbTCBt/JwvQtmsKePDTCyB0zwmb+e8Jcm3LCnqkmwh7bhsIu1NPCV2ODwrS8d8LPta7CnIVGwowXk8K+upXC80P6wbzIBsKu7r/CrGmwwqY7ssJsPFTCLMVRwsn2mMImVLLBuq4nwsqIjMIIlYjCumahwphxc8IJE3zC5urtwTDLisI/NY7ClHSBws7qhcJVqFjCuOF1wqbwlMIKG4vCfNruwYYzpsIcPqDCqtpGwvJgeMKF7p/CmKhnwggCjsIjbmrC6Aszwo67tMJKfozCXIFywsidrMKPTEfCSD2wwnYimcLDy6DCQgGlwlajbsLcc5XCZWAowqSGlMIOgWDC6s+RwmnfJ8KweyLCNfhDwhcFk8LOo7LBzvdywqReNMJG2SnC/is/wgYFecJuTajC4mJ7wsUHVMKioVTC7x0OwlRfwcLisOrB9m21wgkxlcJutHTCXpBtwiIpZcLqmZnCyOWCwgJCxsLEIKbC10WPwg/S18JjapLC7w2cwlKmhcKD8Z3CGuyOwqy5isJCfjnC6DSjwta2h8I=", - "encoding": "base64", - "path": [ - "vx", - 1, - "data" - ] - }, - { - "data": "rsEOw2ipCMNy6wvDX+YJw3KZ6sIMSNDCZ1QPw8axA8PUZfrC8Jblwusz+sIbkQjDR/EGw4pq3sK0Sw/DAosIw8aG4sI8eeXCBFH7wvCIGsNWhOTCmJXpwjSfEcPmQfnCZNnkwh566cIP/NfCqusKw7DD98LDwQPDhrMLw9waD8OGCvHCLNwcw3om58KS2fPCf/0Ow2qNEcNozPPCUk7pwg9SDcN9bArDmmMDwzLd88LEhfPCCjXdwguQDsNcG/PC7zIcw+yxAcMqAfvC2hsIwxxeFcO2JgvDheQPw6ZM/MLQJgrDpqQWw1aVCMOCEwPDjDvhwjD/3cIkwwvDkJEnw0pA38ICwQ3D+kXwwhJQEMOM4RDDmiUHw24O98KSLLvCitIbw/YLCMPc4QzDcGEIw/dXAcPuRSbD0DQJw38XIcPZ3CHDNOsTw4ypGcMUtMDCENEYw/IqDcOiJ9jCRIvfwugtA8MR5BLDKRPZwhQxI8Nnl/bCo3IXwxA8I8PAivXCz7fQwoobF8NBxiHDcBc9wwrjKMPyF+bClWn9wiI968Jt/PTCiZLXwpYQ18JukQ7DmN7pwqJu/MKmxRnDcAECw0IXA8MeewTDs4nAwv5CxsKGcQ3DSDwNwxpOGsN+o/bCSnnpwtp7/8LEztfCv3ziwg5MAcM61QHDhyMSw/mXEcOIogDD9QbLwr4WDMMDkwbDMHPywlRNBsOggwbDZo78wix5HsOvA/3C5n62woQWH8NqQOTCOvv4wiHBzcIk5AXDrWgDw0pH7cLUYQjDGGbcwmnAFMNz8AjDBC79wj8WEcM3WgDDZNAvw5LaCsNuWiXDdMQJw2pf0cIc/wrDtN7zwiLoCMP5BuPCr/0Jw6sr1cIeeerCSzfRwl4UFsPy6bXCCPMJw1A59MJ+ldzCblHQwlKc6cJI8gHDrJL1wjgS3sKKbu/CXRmawlReJsMGl8zCIF0Zw4HgEcN8Rt/CbODtwk/iysKBBBHDRfjpwnJJDMOEuAjDYRULw4hpD8PBbt7CRNgOwxEPBcMM9AzD0KL8wm4C+8KRdrLC9mMUwxy198I=", - "encoding": "base64", - "path": [ - "vx", - 2, - "data" - ] - }, - { - "data": "2fBAw8koM8NdhivD7Lo+wyZpPcNaOSnD6Ew9wxZmMsOlmjjDzYs7w7XVPsPKqTbDxnY9wxGfIMMxPkbDQLBVw6CNLMPk7x3DqO9FwxOETsPyJUHD5JJFw2AONMMddj7DIecnw4CtJcPUczXD3DxNwzArN8NcsDzDOrxEw1A/SsNm5SnD8CU9wwq/M8Pu+TfDyaY5wyx2O8OKgjHDfPocw4r7LMM4yUDD5nZHwzcwL8P+7i3D9KsTwzRdU8MqiCTDNzlWw94ZI8N6QyzDZXpUw3LsR8Om5DDDRlNFw3rJQcP4zD/DpM9NwwdUS8OAjkvD8IQrw7C8MMPAjDvD+l5Ywx49L8PP6E7Db54xwwI1TsOXzUHDiPZAw0/6LMNFdg7DUTJWw2tgLcPpwULD+oA5wwVEKMM+U1HD8Hotw9kbQMNaPkfD+ZtLww14MsPsdyfDepxWwwKPM8P0YSjD73wmwyhNM8N4LjzDNu0Ww1JuVsPo4jLDZXREww47TcOKaS3DAtsqw1CAW8NUQDvDfh5ew6FvUMMk8jrD8FdSw3d4JMPaEDHDArRDwwJlJsNaqjrDdusbw2w3NsOxbTrDw8VHw/QqL8MCIDbDeEEuw0btKMO0wCzDqa46w4gaRsPFvz3D1BMvw4yQKMMYdzTDNYwzw/R6KMPyHzbDYkZIw/DCSsNChT7DBPQ5w5KLQMPrTDjDjg0zwwAMQ8OcA1DDHXA8w5L+SMNomi/DIqUjw7dzSsNoqB3DTkpIw7CsG8OcOC7DKAxCw4M/LcM2CknDsolAwyj2MMMRfEPDerU7w+ApRsPmRUvDbHRew5ZZPcOvP0TD8FYuwwDjIMP06zfDRJ05w+LSRMMOuzPDnOhEw0lAI8NwNUPDKEsfw+ZlVcMAKyXD8ztGw7AbTcMKCC/D+TYhw9zxGsNZaSrDsH8sw2O4I8OGlDPD/scbw5PkYsPwlSPDhOAxw+5VQsOOpDHDFuElw9SmGsNg/EbD9KMcw1hzMsPohC7D1qZHw0dxK8OWshjDtCxKw1nkSMMwbkbDZQclwySNLMMw2iTDaws7w6Y7KcM=", - "encoding": "base64", - "path": [ - "vx", - 3, - "data" - ] - }, - { - "data": "H/9fw07pW8MoUVjDREdmw7QMeMPzv2PDoC9Yw7ReZMPOCGvDCrFyw7EXfsNGnl7D3rdqw+QrY8PJoHPDs854wxQwZMMiZUPDi5KAw6n8a8PmXXvD5z5+w5wXVsO4mnLDXppXww/5X8NWkG7DWO5xw+ZUa8Pu6mfDNpZuw9IyecM+VVrDlLhNw6eycMMDq23DRl5cw/ImXcPC2l/DOnxdwww8WsN6tXDDiHh2w7hdZsMGZF3DhV1Lw8jgisO8NU/Drm2DwwF0WMPk72XDlqV6w26WZ8OAplnDuN5tw9bzecNqe2TDotlzwwb6d8On5IbDDAhowwEobsNjG2DDg3V0w6BPa8MyvWzDMIBow7GQcMN6W27Diehoww2cV8OWcFHDMhWBw8j7TsNmqWvDI21hw8MDR8O6tm3DxRY/w25wXsPqHWLDgfxwwzOLT8N27GzDg/KBw6VGVcPU/13DzFdWw+hhVcN+4ljD88REwzuobMNf92vDuo5dw7LxYsM2zGXDJbVtwwKDg8Opy1PDMSF1ww6yX8ORSm7DgOt9wznhTsNgDF/DcSiCw0F0X8OgzmbDZvo7wwrEZsMKlVnDtJZ9w6BuWsMzdmbDQlVwwxifacPmLU/DElRew1SVYcMsXXjD6kpkwwj+RMMoaHLDdAxzw1ZyU8O6UmHDpaBqwwTTZMOlImvDEs5/w466acMfDWDDvlFow3ffcsPXcn7DAAJ5wzNAXsPSG1XDKBdlwzqsa8NqZFzDULOEw+4OZcP2SFzDguRrw8bHYMNGY3LDqsaAw/GBUsMSzGbD54Vyw53Ob8MAaXnDooF6w9sDYsPzglTDrGlXw7pyW8NCMV/DDWhtw4BJesMWY3HDG3V1w7ZhVcMe6YLDLDNXw7SwdsNVb2XDp/t3wxj4h8OvvWXD6Qpew1S/QsNfS0/D9DpUw+rVVsMUK2XDI99bw9K9hMPQZFrDQo9Ow6HVZcP2NXPD6jJZw4LzY8MknXDDCYFJw5geU8Okp1TDr7F3w6gvRcMGfUnDeDp7wzGihsPWmnbDLAtHw+hoXcMQJm7D3P5Yw+hqSsM=", - "encoding": "base64", - "path": [ - "vx", - 4, - "data" - ] - }, - { - "data": "CIhow3HFcMPyDXfD0NR5w8xEg8M+Q4jDUDZrw8IFgcOER4PD6g6Jw9gNkcMcGHPDjhGCw86IjMNus3XDVEV4w2h/h8Pvs23DxnWOw80bdcPbwoHDZtyIw07vaMNukYXDnJl5w1LBhMNgkIbDJLt5w7MngsOMV33DJgFsw7DhgsNudXbDteVjw0RLkMNmi4HDHTxnw6CmZsN4pXfD9h6Jw0Q3gsMUzIfD7liDwwTRg8NA2H/DMoFxw4rtk8NvfW3Dkr6Fw0ZLg8Ocf4bDW+5zwylSe8NT3nrDYv14w55iisMIbnfD0mF5wzRUfMOYdI7D4ASHw/8Ji8OFaXnDGwV8wx6Mi8Pu0WzDxqSDw2ChdcO363/DHFJ5w8pqc8OW1XzDGleGwzeycsOuZ3vDrMh7w1pZacOXBnXDwNlZw3/4ZsOfPmDDUmFxw1b/ccOHgo3DyMGGw5SsacPQuoHDCn94w3LPcsMDxFrDsBpqw0PQbMMr6ovDHiFgw8gRXcPal4XDQg6NwzgdgcPGQmvDCMh0w+FpYMM0mYTDN/B6w9C5cMNgFnvDqueFw3RvhMNA1XrDZhdlw8CLgsMy92zDT5WJw5KFd8MvGoHDNRqNw259jcOAKGnDMD9rwyB7Z8OnfonDzHOFw1shYcNKMY7DI7SSw+S6ccNw8nnDhKR9w2qGasOav3/D/LaPw1TqfMOE0XfDOmaCw7MMd8MgAojDzNGIwzQFa8PA22rD3GyKwwSPdcOgdYjDzLaRw+yFisPmCoLD2DR8w8YOgsNel37DcAiFwxAWeMP5GnPDUeSEw02Ed8ORcn/DE2h6w5vtasMoGWLDNN56wzIvhsM+5XzDIMSFw5IWh8NE3YnDL9aCw0j2ecO224vD5EKCwyB9eMPuCorDyGqHw0zNi8N3F4XD3u2Gw/jiZsMxd2bD/C9rw/kufcPmLYHDZniEw2mdb8P4IYLDy915w6B+dcPkH4vD6q12w3wNisOqQ3nDfwZpw3U5ZcP6nGvDdDKIw4LtcsPmIG/D0J51wxKYk8PwEXzDHgpvwzKnfsP2D4zDM6tzw+aAVcM=", - "encoding": "base64", - "path": [ - "vx", - 5, - "data" - ] - }, - { - "data": "B45bw/3gTcNSbGzDo9Jlw3SyXMOKOInDItpdw3zcWsPbLmfDlJ54w/XtccNPuWLD4tNrw8jagcP3XgbDeGFIwxziiMPAP17DJDt9w1hCV8NYg1XDRVpzw/BYSMPShn7DWSh+w9QkesMuIXLDtAZNw+KIa8NWJGbDH34Pw/GhVsMPcT/Doz5lw8yqjcMM9HHDVvtEwyjKPMNmmWzD9PGDw/y7eMPMRX3DL41nwwyha8MObX7D6Kxvw84SdMOPImXDlNAyw3AWecMG7XLDwp5Nw5CmU8P8P3fDEP9Nw8fZacN5LWfDklVRw+AzScPz5m7DzR55w1Y3bMMkU2rD9qpJw7g3gsNEqFTDSMJxw1J9SsP2EU3DWjRhw5zZb8MCBHzDOnpVwysjTsOI3mPD+Cdlw64KZcNmiEjD2ZpQw1RRUsPm/C3DVcQ9wwY8cMMku4PD+stXw6I0Z8MyjYDD4baBw+ylX8O00TTD8F1JwxyjSMPI0nTD+9ZVwwIDQ8O2l3PDDiJ4w5KBVsPwB2vDoA1Aw8HFSsOwSHTD5wFHwxPjbcP7r3nDCp1Tw4DXhMMT6jbDyYNZw1rTfMNcqF7D0cBvw47IZcPsg2bDJzCDw5CKi8O4akjDzxZUwyH+T8O4p2rDkyqHw4KuWsPh5ofDGTKPw3b4aMMYwG/D8r1Xwx6iXcNSjmfDIVd7w9/DYcNcY2nDLsJuw7OZW8Og/nzD2VFww4H3W8OlcWLD5VGJw6njSMNiqIbD5gh6w3hJf8NgmnrDBAZew7woe8OOEl7DdLdZw6TocsMAYGDDr+hrw2nbOMNC9k/D3AFHw86iPsMipWHDroF4w/bchcNKcG/DPFKAw7YBPcPDU2nDQpBVw8aZf8PPiHHDSI6Dw/4pUMNcyIbDW5tiw7meX8PxgIDD8o+Cw9COV8OCMU/D4JBmw7GmesO8SoDDQd+Fw2KsBsPu6oXDIQJ7w/YqZ8MYB3HDMihsw0xSgMNJW0vDLmFgw05aW8MlZ2DDoAKDw7y8cMN3GG/DfrnmwvgihsP+YxTDkJhqw4x2ZsNzYITDLINrw93EMsM=", - "encoding": "base64", - "path": [ - "vx", - 6, - "data" - ] - }, - { - "data": "Cu8OwxBrwMLcKx/DdrMNw6Gc9sK0vkbDYdcSw3oBv8K68wDDIfMKw0WIBcPhjgjDJn0FwwzeFMNmLKzBxZXnwvImR8NsMrbCBggYwyf//MI8oPPC1Uocwy4vqsLgmEfD2vdLw/r+G8OFeAnDehDowgzaDcN2ZgfDjBi4wS0i4cJ+1ELCRDEXwzJyMMNGbzPD7ujfwjDWm8KU1zHDIJkRw8jFE8O5AxPDugwGww92A8NqQTXDkuYpw+CLGcMsFyLDIs9xwlA4EcPKKA7DdLL7wqzXs8Jk9hXDGC36wg4v78J8dQ7DdcG8wiQC7ML7RxLDW30Xw6Zh1cLERA/DNOClwq3XGsOiGA3DEH8Pw3ba5MLabKXCQLALwySlMsNSYzDD1ITFwnTGaMLb1hXDBv0Iw8lDHcMKv87CR8S5wn/l/cJiD5vC9jXEwm4oHsPDmxnD4tzHwrS3E8Nc2C7DTMxqwzc678L4h9TCj7E6wkVD18JcXAXDcHUPw+qy8sKoZgnD+lgRw8myAcMaGh/DhkOdwnsy8cLH1BjDEzTownhBHMNYRE7DxIvlwm8OKcMiXDbCylW2wpYzO8N25RfDFKwTw+pCA8MufwjDKKoXw/b2KcNCu4PC2PgEwzYf/cKXpgzDt+NSwzg2z8L0sS7DlmAswxfzHcNqiDHDvRzGwmjnEMM1yQfDsNcRw/BS98L2tBnDU1oTw07ADMNoK0LDwHMVw6KlDsOaqAfDZikzwxYYsMJt3yPDALYTw6AZD8MsSg3DiHECwypxH8O0XPfCYLvkwgA6GsNE8RnDqskZw460ecKySO/CPrS2wkOppcI1/hbD0HIcw+4OMMPIxAvDMI4+w6AracJCjt3CHgjKwsbuQsPSBBHDmCkywxLIy8IA8inDtQfnwrxh2MLWIybDagENw472v8I+1MvC7Ag4w+qNKMOw/FbD1HRCwwWMAMIl00fDwSwZw3slMsPKRhHDrBclw68pFMMTFdXCEBoQw0ctFsO2whrDRBZSwyCLEMN4FSXDsYluwUrBQsNAEePBmlYbw5Ya+MLyljPDJo4ZwyCmS8I=", - "encoding": "base64", - "path": [ - "vx", - 7, - "data" - ] - }, - { - "data": "UP5vwvSOR8D5N3PCqvAkwoaE/8GwD6/C30Bhwl+KGcFfc/HBcCkhwnfV0ME0ey/CSl0Mwv6OA8LEwBZC+OnewfVbrcLUjoq/7pQzwoLJD8KJfCLCIURgwoV4BEF6ju/CDprUwtJRRsLGGBrCExDFwR2DGsJrix3CY9MyQurBkMFs2OBBfC9uwvIShsJ8lrTC9MSjwQOjhEFal6rC3k3gwY074cEqJxzC3n6NwSjY7cEJmKPCZ4N+wjnEX8IKeGTCJuUMQaKv58HRP7/BPFM9woLPDMBFTjDCLr4OwgqyocFRiyLCZu+4wOjA9MEsmzXCkNgtwlZkwMEyMyTCI4yeQGYcQMIcPVPCmVgSwmPyyMGwH2lAqFcmwoaHmcJuaZzCKb8DQJT1kEGKgFrCH2YjwvJfXMJ9kW3BfVTFQGQnHMJovbpBNuLzv45NM8KNWELCQL85QTYZXsLr8m3COdAuwxj/zMFCfyLBgOQAQsqcicHcNqjB4q9nwup0B8KYlMLBI1ULwpB248EbyTzCDgecQDrZAMLqkU7CYhwNwrCthcKE1wDDXMftwUjDg8KY/NdBEKavQKJRs8LYHT/CLGExwnqxJsKMOwrCaCwgwqBfeMK81bdBUQXxwRgKMsLH7iHCaMHfwmHcbMH6q5HCaDSKwhYHW8Lzu6DCYWcRwRRlWcIWogbC8kYTwrZi5MGm4i/C0KchwqbGHcLwGuTCXjo1wrNKUsImbxTCiKWHwhxiyj/Y61fCClIxwgAVr8FrSOrBJ9MlwqZ7RsKFXQnCri3lwfLbHMIgXVDCr+FXwiIymEFRDAjC5satPy7CmkDQHnLCFN1AwllQkcLc+APC65jDwuBBV0GeB+TBHsM/wLjfrsJkahTC64SQwuC8N8GfiHvCpuUywWBLk754r2XCICFfwi9MAEA+8yjAItHEwsxnhcLTlA/DoF+ewo9Q/0H6NbvCq+j6wSEFwMLY+yHCCDR1wmi84MFMzKzAtOZPwk5GZcLS/VHCe9YFw8a3UsI+LIzC8s0fQnr22MJObAtCyneNwllbCMIEgJ/Cds0ywqbTIUI=", - "encoding": "base64", - "path": [ - "vx", - 8, - "data" - ] - }, - { - "data": "nOGXQMZzWkK7hdZAzMSoQfSsjkGOPI7BJB/0QEWJIkIWMvNBEs28QS0pUEJEtJBBltzyQdT7L0KYUZZCngmmQTr+qsG0ujlCoGTMQeJtp0E6MxBBYgNNQbYjgkLCWT3Cc5GwwQpNm0EFAdBBujWoQYI5xkHv7tNBcmOuQkY3HUIEKJBC2E2CQeyJY0DUxT7B2FokQrCrmUJ/GerAAy5QQlOcSkLBEPxBC5A+QuhyCkIGHYDBjIgZQasVf0H8/ZBBDHlbQvEILUIoKENCOvmgQPgTR0L0MRJCLiAmQfYLPUKkgP9BkH81QnSsLUEM6t1BcujwQSj+3EH8YQVC3RpiQtQC1EGIHXdBXhsJQo7dpEEBE1xCDIfOQSRBG8DEmOPAYtZgQpJFbEJ9cC9BeH/GQSNBA0GgmSZC3n1vQhGVrkB/6qpCQgBeQpxpB0Kw49RBaBeHQj71UEGFf9BAHr+6wqDLuEHY9zFCmtyQQsA0BUKhbFNCCN17QB3SXEGOpixCXko/QtpmKkIsSAhC1lZ5QiTsmkGIKVNBCBT5QA+zOr+gnivCMDJLQYxeLUBiHotCbEFfQsBJdcEhxLpBuiDUQXxThkFdnQBCv/sAQhrFEUHskI5CKH7pQUbcZECfNNpBJkINwt0nCUK4i/bAHycnwOYIi0Gv2CTAQJozQpS1nUHa99hB0qEQQolOo0GYZOJBSsLhQdL+8EH4NiXCCrfdQcTlkEFnHXpBD3+Wv0FxZEIo3oxBiO7RQb5rTUIIYDxC7GyhQdKqrEG0uKxBHr9iQSJTH0Ls8cBBjQSWQY4IikLwDiVBXGdIQrxsc0LZzZNBlvvxQUCbncBnuRBCEXTbwaYOa0K4LbtBfvVOQrzuS8Fo3yFCfFVjPtoeNEKbrkRBOYlSQvHOQkIytylBobFiwLSaWEKPemZCBOIqwWV+nEAA5ILC6FZHwS4QmUK4/I7BuOU/QrrXT8E8dQBCou9BQVgFOULDylFCiq/pQO4ilkE20IpB8jBlwoiVmkGYTEPAUe2XQjnZJcJgwZVCSBOWv5JOVUH3N1LBGvAPQpp5sUI=", - "encoding": "base64", - "path": [ - "vx", - 9, - "data" - ] - }, - { - "data": "7sVZQnp6wUKEnWNCueWDQs5FaEL6r+FBZIJWQjKtlEIWL45CzL2LQmS0wUJQK4tCwAOYQqgrvUKyzMdC5hpJQiL8sUG22ZZC8uyPQshmc0I7xGlCkDFxQpTQzELa5fZAF18HQpXJgkIbIpJC+F40QmiThEL8PJRCeDnlQgiOn0KiOcdCWGCXQmg6WUJwVzFCQGWjQjKU6UIFxT9CLzDCQhAtsEL+wZ9CzB+pQvrBmkIeRNdB3iWGQohKikJOSIdCoJKrQlSvokLKh6lClltRQm76qkKcOrpCEgRDQgbXvEL42p5CLXyeQlSvJ0J26KJCNCykQli9fUIUf6JCftm4QkJvo0Lf/I5CBEamQngdOUJ2Z7ZCZA6TQoRBU0KkTxtCZFDIQjgBqEITD2hCvjSOQlI/XkJr/p9ChTa5Qla1LULU2fdC4v21QgoqqULHnZtCsdDXQlRNjEI8REFCfbCowbipXkJyKZpCUJ++QlRMiUJegrlCl21pQmIZKEIMnp5CCeHLQnRNrkJFpqhCtoLMQh2yX0K6JmJCG7UpQnLCQUJosp1BbiVHQp3xT0K6P8FCNOOrQuWNEEKUI41C/IaXQnHGcEJyWZJCONelQvBpcUL+4chCrZaAQtiLNkKGa5VCziSKQWcJgUJ0DxJCpuEzQn6OdkKa00xCm6eoQnBZnkJ0TolC0kKpQt02TUJ88IhCGBiTQuISmUK61FdBmDqcQsB1j0JaplBChaEwQlo0w0JKQ4RCGcyYQoaCvkJYLK9CYhqGQtifhUKYQ3xCRtxMQoaBrEI+oJtCMT6SQkS6zUIiekNCQLijQvaqzkJM8p9ClCOzQoxlJUIoWpxCgQa2QWQos0LcRGVCoHG0Qv1NKkKKX7dCdoFFQrTGrEJUEIFCyUK4QjVGlEKtR2pCZ58QQjaGrEL5KsVCKKFFQnN1SkKrGpjAEqTxQVjX1UJTyQdCgNOvQoI8PELSMqZCmkV5QvKcukIWV7NCjfdEQvTBmELvXoRCAFYTPoqqkEIusTZCagPJQj6FBEHk8spCsJJEQtbkW0L6BAFC+LKvQlQW5kI=", - "encoding": "base64", - "path": [ - "vx", - 10, - "data" - ] - }, - { - "data": "2KS3QmL5/kLfSr9CnvHJQnbSvkJO9nZC7NOsQiD+y0ICOsJCfE7TQvdJ7EKKu9NCyjTZQg6+9kIed+ZC9oyWQojlWELhErtCwrPNQvZjtkItbc5CBtC7QlwS/EImH0tC4KiTQtFmwUK9Bt1CnVKOQmJrvUJSHNRCpE4CQzip2UJupedCK2/lQp3ZukJsZqxCmqfZQhXODEN/6LBCFLXiQgJd1kKiReRCJnDWQj1j00KCp2JCtkPFQtaY20LCD8pCbPXXQlawxUJIcNFCLQe6Qnaq4EKIBfNCiZatQgYuAkMTR9hCOiHRQnp9m0J8FvVCFBLoQtx7uUKe79lCPr3tQv5C90IuzeNCdrjgQir2jEIsgu1CkizUQi5ItULAyo5C+scFQ6jrxUJQQ7lCC43QQrjcqUKBldVCmjjhQkYco0LdHxBDZMLhQobH5UKQQ+VC3CsHQyjU3kKET5pCieYDQqhnpEIA08FClHPVQr6Bu0IyU+5C4OPGQvpZh0LQdstCLgb7Qkdm0UISpORCS8MAQ+hnqkLeraxCNHuoQnPdpkL0yIJCFiqrQhVJsULEruJCAJHQQlJCkkIku8hCukzdQr65ukLqw8dCeCfvQr2FxULeQupCZU6wQrW5oUJmT9lCGINdQqfypkI1UIhCKvKhQmfisUKeYrRCqDblQqBV7UIsc8lCrOHnQhRcqUKWLL1CvFjQQpG90EJ/WGBC2OrgQmKE10JCM6pCPliaQq4n/kIns8dCOtrhQtAb9ULovtxCcBvNQtj/wULDEMJCymi2QmhZ2ULAjvJCEt7mQqkU/UL2k69CxXvNQhALBUPycfJCONT+QsIylUKCRc1CXrxwQi5T3kIqSLVCYCXwQlwHnEJGgvNCqL2qQkA06kJn789CMPnpQjgZtULCKL1CLnqKQuSH1UJ86fxCAEy3QhBzokK2QypCIFtxQlxRAUM1LoZCvj3PQtRXtkJIyedCrHS/QiXo9kJ51uVC0LigQhq83kLQUcFCzVgxQuBQ20J0gZtCBEjoQoBTPEJK8+xCDBWtQgj0skLPa4FCdvvlQihS+0I=", - "encoding": "base64", - "path": [ - "vx", - 11, - "data" - ] - }, - { - "data": "tAnwQlrVEUPaXfpCinUAQ/rW+0J9iq5CvijbQqZg90JgIedC4v0EQ2irAUM9HABDyO0CQ/zPBUOQe/BCctTQQvKKnUL+Z89Cb472QhC+6UIVnQhDtEnrQkiTCEM7BapC6ofMQsql60KcJwdDZ7/IQvcq5EKGz/tCj88DQ+7G/0LwBPBCHWwKQ1JW+EL8tupCLJf7QtDoE0PqAuxCN4H1QtSm5UI/RQlDdgDxQmqo9UJAg5xCYjrrQui9DEPXB/VCH6f7Qngd3kLhxeJC1vf8Qnl/AkNMSAVDUjboQqQ/G0PwKfVCPmf1Qmho2kJRPRpDMDYIQ3vX6kJmX/ZCis8HQ0/mGEN2sAlDQl0CQ+2VxUJ0GglDEoT8QiI640KYx75C67sbQ5Io00KutOlClg39Qlik0EJIUPlC5rLzQkzQ3EJAZhBDehj5Qr+YAEMm1AxDuPYVQ0pVC0MacMNCvNGUQjLIz0IBnddCoHbVQuL33UIxmgdDjisBQ34szUKWKOJCDLgJQ9AY6kJ1VgFD/sQOQw2U2EJq3tVCUifuQpbG2kLyt8ZC/zTtQgTE50K6F/BCwRzjQkllx0KzQe1COtEFQ0QT7UL6C+xCOKYQQ37x/kKOkfNCvBXTQjTB2kLK3QNDNGGnQtG1vkIW4LZCunDZQnqZ1ULlmOlC5MUHQ3ZjCUMswvlCbmYHQ5IO30LK5d9CwI74QgvD80LnebNCGOEGQ/h9A0Pk2N1CGqDLQktPEEMpRfZCVLIKQ6ZACkOJ7vJCTwX9Qm1F60K/Q/lC5tj5QjtV7kLwuRBDHKUQQ7RhC0OoK+1CCj3mQqfgFEOBUwpDRiEOQ5YwxkKQaOlCdG+xQgpx+kK7yuxCCFgMQzjhyEJGSQtDRvTgQufDCUOW7wVDvL4DQz48yULUGvRCj+HAQrTh60KocA1DT5zyQkcizkIYFaBCiEKlQkumD0MugrNCdETfQtvw9kLFLQdDWrbqQgwKDUO0RQJDKAnQQhSXBEPK9OZC8E2eQkAuB0O85sdCcprxQn1ynEKsRfpC9vnlQro96UJEPLFCBqwAQ0O77kI=", - "encoding": "base64", - "path": [ - "vx", - 12, - "data" - ] - }, - { - "data": "oTMMQ7sFDkNQ3RFDHM0TQ8b/E0PWxtVCwj76Qo+dB0M4BAFDOTQVQxBbBUPtxQxDNogPQ6YIBkMUrtJC4D4DQ97fw0JCgNVCeNgHQ/IDDUOXvBlDYJEFQ6gSAUMdZ+BCnBfzQiAhA0MAYxJDWjD4Qgl//EKwCwZD1PnSQlI2CUOMRcxCN3wRQ6SEE0OmlAtDBDQFQ3mrAEMYHwpD5gT7QhKd4kIy1BBD4sP8QuisAUM1UrxCCrcAQ3S+IkPXugZDEpMHQ0u28kJgJ+RC+18ZQ7yUB0PwQQZD6n8JQzy3JUOBcQBDiuYCQ1MgBUMEGilDU8QSQ+hoB0M+GvxCw44KQ7Y4IkO82w5DE78LQ3nz80IAXQxD2FYHQ4jY/kKO++FCeuQgQ0b/ykKgKwRD6uUIQyxt6UKEFAVDpcvqQh9mA0NGKOBC5Pn9QlzHA0MPgRxDoWEWQ4dqGkPQZ+BCwb3UQmyf70LLM91C/AewQiTP8UJNcw5DAGoVQ/ai/UIfrOpCefUNQ4ww+0IumgJDUA8NQ0mY+EJkPPFCn/QOQ6sxAEPIb/hCgt0RQ1wwB0Mw0txCxmDhQoTy7ELn6gBDktoSQ5beB0OSjAFDHiMeQ2iiE0MyPtdCe3DqQuanA0P52xBD3MjRQpkKz0IyM9lCcrIBQ57Y60J+qwVDudsPQ3qwCUN5pwtDwd8RQ+yjAkP4VfVCgBcIQ7utA0PCjehCZaUTQ5YdD0MEkgFDOtzvQl46DUPOMQpDekEaQyi+D0N2UfJCmgULQ0HxAkMwkgxDfmcWQxwa+EJ0exlD3hwfQ25ABkOYyQ5D5JDvQq46EEMZ3QlDOrINQ+P26UJ+WflCyPDcQkDd/0K1CwtDoFsTQ27Y5UId+BNDS1kEQzbrEEPRxRpDzAgJQ2Us10IiQA5DVj7sQlQ660K2WAhDCpUMQ0vG7EK/dttC8KbGQmj+DEMaIdNCnvTpQiPGEUO0GRFDHnsCQ/vHE0NifQZD6DXzQtLhDkOTs/xCXIrVQql2FUPxTuZCfqPHQvYNz0JAuN9C9PcHQ2QCCEPEp9RC2dsBQ7xzqEI=", - "encoding": "base64", - "path": [ - "vx", - 13, - "data" - ] - }, - { - "data": "OK4XQ+pQgEIMjRxDmvEYQ6H6F0Nk+PJCXpMFQzhx9kLH5QdDjBsZQ1wBAUMKvg9DNWcQQ06l/kIF+qxB2ogUQ+di4UI6xshCWo4NQ5L0GkM/tRNDAnoOQy7Yp0L+RgVDen0FQ4eRCUN/JBNDUMQLQ/2/A0OamgVDTipHQNj5BkMI6TJBIJUGQz2XIkP6lhlDCsgAQyIfSUKJkxVDKm/uQn/S6EJ1kwlDlJL6Qt59+EKlO9NCPk8FQ/VjLUOg3wpDTjP4QlK6AUM0T+9CJl8oQyYH2EJAufZCZY4XQ3JnEUPRQQFDRXztQl5eFUMGSShDZqQUQ837C0MCa/xCGD3XQntFHUOB8AVDhBsLQ15KCEOPtMpC2kYHQxZhBkMaDPpCdrICQ1SMk0K4yQtDEe0JQ5Zr9kLbOf9ChoKqQmxTEENPvxZBKgHuQjhp/0Jm8B5DhqkBQygbG0O2HvNC65QCQ3Ft/kJaOs9CAQ9OQZRD9EL+kglDLAYfQ2piDEMemPlCw+kJQ7R9/0IVQ/pCM6feQlLAAkNObQBD5WgcQ7/FC0P/WA1DliIiQ97eEkNNgFNCgla7QkT5AkPkfARDXfUWQ12HDkOfHAZDZHgdQ3HPHkPw6ClCbUH1Qjj5EkMHLxRDZODwQh6y00Kej/FCSi4QQ8Pc9kLk2Q5DjnPwQqqF/EJjUA9DtQcUQzAZDENU9P5CWh8MQ61FBkMgpghDdGcXQz/kDENskAtD5zMEQ9uupUK+whFDqmEfQxWrCUMmQt9CgxINQ7JyCUOOhRBDK1oeQy4P+0JAghlDNiYiQyvto0LMCiFDZMfnQmUbv0IMHf1COMkCQy40AUMBsQJDHRb9Qmq3x0K0bhNDziv9Qm3m9kLeiRRDsA4RQ0te9UIKySNDHgQCQ24/5kKKcRpD8OEFQ+wWvEK5DJpCkoUWQ0iC/0KQugRD5ArfQhvYp0I7N+hCtqv5Qla9HkM61xJDDIcIQ46WDkMMW/JCQt0EQwpFDEMQmAJDOmUAQ+bWFkOg1fhClJ89wVvm90IM4eFBBhAVQ8JOEEPsIe5CIA/vQjtfqME=", - "encoding": "base64", - "path": [ - "vx", - 14, - "data" - ] - }, - { - "data": "89YWQzLlisIEUxpDrwYJQ0IoBkNwEQND4QEGQ5GyZ0GelwRDmwEPQ/Dj5UIw+AVD5ET8QuIY3UIkYLzCg1UWQzCV9kJIb5BCpUIMQ4BUEkPosvdCBh8QQ8yUvcGsexRDu9cKQ1z3CEP0bQZDQsAPQ/4FAkNwnfdC3LPAwghM5kIkAtPCFMnnQhqkJUMXHx9DjNvQQrifdMKMiBhDdtfRQlP56kK2o/NCAL/mQmzu3kJcTeJCyH0DQ7AJKUPNrAZD4lipQaDKBUOqpO5CwkEXQ2j8WsHOUclCbksbQ/ftGULIA/lCTuIVQv6yG0NUPhtD0T0MQ2blrUJHsPJCtY2RwUQVDUPDLOVC6Nr2Qm5uCUOWeBHCnLT4QmgwB0NcQQND0R6AQY4EKML2xQtDrs7/QoCq90LCd7tC+CvQwcQ/EkNPdL7CphvAQiLg50I/swxDcAyLQqbPCUME0/tCD9oTQ1Wa6ULU8qlC/OTuwlYB20Je0ORCNPsSQ4ZGDENo1vhCMsb2QuaH80IAVedCdQxsQV2g8EIhegJDQU4ZQ8jHDUNgUhdDTLwYQ8nvFUN0H7PCHwKWQVzDCUMgZAFD1qYRQ+yH/kJ1fQBD/QwGQ7D5HkOkHMXC1/3vQtyVF0N2LA1DDOkCQzJruEKcYgBDQjEXQ+UF90L59BBDX8Xtv4op3EJUIwND0KMMQ/oOBUPkSPxCagcHQxDUAEOIHhdDhj4RQ+cb+UKKxAZDtVIKQ7euIcLMRRFDHCoZQ6jk5ULGB9hCDKIBQ2ZUCEOEeAZDNDwLQ0Ok9kLANBBD+mUaQ8xuRsJK8RpDvf7HQqtJC8Hk5dpCPGvYQrPQB0NCXQFD1UkJQ/gNHMLsc99CfNddQRhh/UIoAwxDldcUQ6NxCkEysBhDYA/LQiKG7UI+4hpDTMkMQ5r0M8GhlHLC7IMXQ7JuAkPgZRVDpjPvQqpZPsJW8fNCDA4CQyBxIkONigtDpqgHQ0Il8EJ16oVCwPYGQ02T8UKGSwBDl4wQQ0brBUP+Sf9C4kHFwkfSC0OHVMDCEj8XQ5IHAEOWr/5CYrzZQkyC9MI=", - "encoding": "base64", - "path": [ - "vx", - 15, - "data" - ] - }, - { - "data": "zy8AQ7uQ3sIAEAVDB+y+QihjuUJelwZDIIP2Qk0Rm8J6LtdCxYneQrnkqkJ8v81C3YODQvaek0L+xPjCYpf3QglDAUMd7CrCkqYCQ76P0kJq/p9CQAsJQ+rR0sJgWh1DUzwJQ6zW/0Jwa8VCsOn5QuwZ7kISY7xCytQAw6SlcUICXAXDXj+pQqyAEkMamRpD8noEQmB49MJ6+hFD1tuqQiTCw0JRI6dCKGCxQomwsUIGfelC7pL0QtpJEkNwefBCGLSqwrgF4kIqaL1C6LzMQiTRvMLu35RCJeXzQn3FkML868tCXnyewuA4BUOwMPtCA/jpQvA+gcL68sJC5y3NwjyM1kK7xqhC21miQkyZ4EIod8rCFu68QrKXAUN4IgJDUX+iwiiiCcMU0gJDQszEQhkL60LiYQHB6X/4wpAR/0J+HgvDxhc1QsA1rkLGBaZCJg9CwocEt0J4FflCRTweQ6XoLULGjFJC5EIXw70Zg0L8+V1CRizIQtnA4kKdlM1CfpO5QoE30ELzeKxC/LDBwrIrg0KJ+PtCQCvfQi71/ULh1hlDKG3TQtJoDUOwhAfDGZn6wuCQCkNcPe1CsjMAQ2YuI0JXLs5CTuGAQuGjD0PQzRDDhh/RQgDOAkNQyvBCJyIIQ1EQbkHoLQNDcL0TQ+MG60JwaQtDd2G1wg+MqkKU4bRCxjrwQnY7q0KcrupCeoDpQu2H4UKAQB9D/oP8QvJ1rEKwq7tCqrYIQ7sixsKykAZDthgEQzdZeEL1sbZCOFW+Qg3i+UKbVctCnCe+QjBfyEJkavZCQ4EFQ7JK3sK+IdpCLi18Quq6qcLGYadCxVmKQhLqB0Nm0NNC+FIOQxX26cI0ShXCmhzYws7y+EJhJu9C47AKQ9lPu8IqWsVCE9W5QYucz0KKgQZDeo/9QvLiAcOzzu7CgMgOQ1CN90LVZB9Dbq72Qt4jyMJqDPZC3BXaQtv0G0OC4fBCNMv9QkQeg0KUyJTC7N/sQj6ipUKi2+xCAiEbQ777p0KKAPdC9P/nwprZFkOUtP3CWugFQxLG60F0FgND+CKsQo4JF8M=", - "encoding": "base64", - "path": [ - "vx", - 16, - "data" - ] - }, - { - "data": "0n53QvKq6sJVHJ9Cj77PQKaC6kA6GwFDmOG6QklZysKRoshBxr4bQtg+qkGcQNtB0HiBwpUakcGqK/PCB+U3Qj0IAUOsORjDZIDbQvJ/4UCGcpC/YMnrQqRvB8OQbx5DHP79QqtY1kKPUnFBYsE8Qi5tvELQOWZBfhEBw5YQRMIckPzCHNs4QS9fjEJAXAhDSgS9wjN+DMOUSP5CEkxdQeB/vUG0gjXBio2ZQetLoUHsiudCNYbOQhhCw0LAT7ZCvs7awlvwuEHc8dBALjnmQGqB5sI5dnRA2jG9QbjQ5MJm4cxBEtLmwqTpE0L6aI1C0r6JQq4PzMLW+apB/vj3wjZNJkLS2W5BLFE4wS7uv0HwzOfChk2BQXu56ELqJutCtB/vwtTuEMO2fttCXOPPQf8Uy0IUhMXCKOwRwxgfMEIeYRDDHRJvwmYoTUD7QeTBrfr/wn4iMcGi+OZCtOwgQ6VjqMI511LC600Kw9J8UsJuUmDCDiBDQXTjskHmIN5BcogAQuEnhUIiLxrAXiwMw9JtgsKy0OFCq/h5QSy0kkK6dhND4xLrQHPW5EIUVAbDzL4ew0geBEPgaMNCGya5QpOgpcK7ruFBQABuwrGEzkKmIg7DgIF6Qj4mKUKa55xCegIHQ4yP0cJeIwBDG/X8Qs1Lz0Kyp/hCGF7mwlIPgEFS7/7AZMOdQjQxJMJ978NC+kCXQp+AoEKKqB9DPbSwQvC2GsCrR9/BWuz2QuIZ6cIkm9lC0G2wQhjJRcJglrJBTPEkQT4/wkLhnLJB/N4CQbEShUFUv6tCBMy8Qrxt+8JC8ytBaGPZwSHn78LMMgJBmlJKwXg9/kJqCsdB8kcMQ2px/sLYALXCLZwIwy+G50LfFqNCWjXLQibg9sJ+JrLB8D7dwtDG6UHNXJNCvHcNQmZlFMN+LQLDJsPzQo2yyULTbiFDRHrzQoTu4sLgsOxCpF3TQZnLCEO906dCsnfXQsrKRsIaDRPDLgpQQiL8tcBoxsRCS0YfQyQl08HSJdlC4B7bwl7iG0Mi2ffCCniWQnLMlcKElAFD+ShrQV6iDcM=", - "encoding": "base64", - "path": [ - "vx", - 17, - "data" - ] - }, - { - "data": "pxkuwl6+08I4qnPBzATOwlwf2sIu9dVC1s3HQSeyy8KwJ6jCiLN5wuACxMLl77LCdTkKw1q+68Kl4s/Cbl18wmZk7ULcxR/D4kGPQhAKysK27cPCGKOfQp01BsPznxRDuazQQuESiELKt8vCVCSQwv5QNULV/7DC+kbfwpBaAMPLTc3CEWqxwneeJ8KLZ8JCpMIaw54SBMP8+7RCBFagwo74lsLKHejCt2rLwtxko8J0VdlCvqOKQrLzREHg4RhCJtvawj4ItMIElcXC8yXnwlg74cJwPMbCoEW6ws7W+8JeSKjCyhPtwuZzosI8QqDBNL+4wc5K08LGtZ3Cmhnywl4hhMKYD63CHNXTwtZUkML+wt3C7g22wvi1uUL4PKZChiABwxim/sKoToxC85OuwgtWi0JE1APDuroHw0RGmcLkdPnCF1ETw+l318L2k87CuNQdw1BC6sI7m7xCYN4ZQz9C7cKUjibDLSXXwtZNAsO08wLD4Ju4wmGfmMLKC57CnUyPwnzcNsH1NdrCRE0Sw/qG/MLT1K1C4s/VwmQ9GsI0BwFDNADqwtRNWEIgC+fCzNIUw/Uu50INMnZCdT7ZQcMf98LwN67CHg8Cw3o9oEFoYO/CZLI6wlBJlMLoTS5A8MT5QhqD/8L+1elCqGyLQhMenELRlb9Ccq7lwvP3nsItm8jChsAWQIp038Ik33RCWp8jwR1UkUGIYxVD66GhQSYbwsJGpNDCoKGyQhQ84sL1ZWhCeHPzQHPpDsPyS5fCOt+7wj0TG0LEZMXC5EPewnIaucIQAL9BBj7lQRgF78JXX9zCGKUKwwpw/8IqOrTCnGTswkEx0EKmTrHCSRMAQxFI6sLMgcvCjqoGw1xaxEKYw3VBXHgHQRBw+MIxR8rCDGUlw7zkjsLPyCTCH32PwghLCMN+4O3C/8WnQrUpKUKcuhhD9NXgQprr28KGgNNCDPyuwrJ3yEKKjppByPCRQlQHDsORwx3DBGiTwvJh08IyOXpClvcaQzy06cKIk5VCfgi1wlQ8GEPjTdTC7Oz3wVKR2MIWOPJCSKClwqEn3cI=", - "encoding": "base64", - "path": [ - "vx", - 18, - "data" - ] - }, - { - "data": "3LXXwiUJoMLudLPCGD8fw4geGMMkLDpCTf6Rwnq9tMKyqQ/DgtL8wm8JJsObhhvDND8dwy4WF8OTnpbC7tf2wj02sELcsg3DomibQKJZHcNxuAPDGDkZQR6/4cLkqPNCcj11QtyBPMBhlifD9VYLwz0zKsIUGwfDDI6fwq7VHMMWRIPCFhUGw6FwxMIcWMZBgsMjwzxEzcI94tBBhkDswo4e+cIKKhbDrIEQww5gAsOQCLhCAFQdQclElcIrG1LCw4jEwgO1GMPgnQXDXfcvw6akwMJq/QPDNnccwzWl8cI+thLDO53Uwpc+EsNua9HCwlTqwhRzwcKW/wbDzkTQwrBuDsPFpAPDyNMQw/hZ8cL0kLrCFnMNw7icV0JYrYi/8Bjzws6HxMJQ3R4+ZqgRw1xL4EAmnAbDCnrawmyrDsNeaKXCzSwvw4a5FMMuZwjDZQwewxGfH8MPg0pCDQQFQ+wX8cKn7DHDkrN/wmpSE8P9rRzDWJ8XwxIi+sLboQjDX0wRw0nm3sLOpBLDwP8Dw2phCcMlmhtC2HApwzo63cLP4LhCTF4sw58iLMKFWqrCI//1wmRepkKAScO+R5eVwk+jAcNKTAvDlr0aw7ajlsISJafC4AMRw9JsCMMljZvC9rzHQixE8cLMBLlCHl0awuGMAUIrYDlC9MnIwjOh9sIa0QTDzEyywppMA8Mq3QbBRxDqwhZYo8LWfPVCzA+WwrROBcPGbv7CVj5HQWpxvMKkQAXCDuazwtA1LsNBuOnC/i8Pw6tGh8IGwCDDAo0gw2YwCMPYkIjCyqpuwqg4x8LirCrD1u0tw4ZE58Ly4PbCxu8bw2j6WkL6UxTD41nGQtBrwMKalsTCcWDrwiqQhULwW53CxLipwjGz2sKgcQXDG34qw8gm6sLr7ubCUrLSwpPD3MIlyLfCuPifQcJIncK42f9Cf/KzQoC9vsKRCaFCgFcTw/dyGkJV9ojCSsRBQS4XLcN+SxDD3FoDw5yJCcNEQa6/UC4KQ2TEFsPgWwlAeCRywgQIBkOwr5rCqEPEwvo/5cJ2RcxC5Nv8whL/csI=", - "encoding": "base64", - "path": [ - "vx", - 19, - "data" - ] - }, - { - "data": "GPoIw9MID8Ji9ALD9Y4pw979G8MT8ITCZksEwwhPicIC2yXD/SAbwz1SMsOZjC/DCX0Ww1gcFcOQ7AjCROcTw1SVBEHeieLC45mvwrKeKsMCMwzDrlywwixrlMLL5YVCuD2SwcdiucJSnzXDnGklw0Ac8cJvFxfDaLX0wc0oG8PNhT7BNuUTwy7l9sKl2JbCeIoVw6BbUMLj/4HCTPEJwynlEMNLqhbDDL8Xw592FMNI22dCFIuxwhYsAsOGtQXD7HOdwlRrK8P+2AbDr3Iyw0x1h8KQKwLDyPkzwy2JzcLo0ibDQs2lwlVaLcOfyBvDiHslwxIfn8ILBx/DtsCVwlBSMMMdcRTDSj8Ww/A5DsMIE33C3EUbwymQKsEoLsfCDUHHwnttb8Ju9J/CPJ0iw7IdvsLKdvHCIx6Lwi2eKsNw+V7BkfQmw73mF8PUEhHDkx0Lww+TI8Ohrx/CRge2Qn422sI4+hvDsZHdwHT6CsMWMhnDNPstw2LhD8Mocx3DGu0uw7YSJsOmTxTDdnTMwtPD/8J+pzbC4vwww6A2C8OIY9hBAGstw1bJ4MJZFSvCmpqtwsL4uEEC47XCFiIVwy6Z8MIUIhnDCNEZw2P2A8PAjwHCxEkswzB5IMOCHgTDCPg5Qv7zy8KuCS9CKAffwtayT8JEnxTCdRyTwgyWEMPT9gvDL3oTw9pgAMM0stfCREsowymVGsPyDItCDH4Nw479DsM4y/3CFEW0wmtBacJjlOvCzpYVw0qwKcOYdQvDmc4dwwhPEMOyOi7DPlckwzafFcMqUhDDypsAwxaYhMKsfzHD8cwlw03fqMLPywbDwgobwybeFsKutCfDmqQfQpmjg8JY6KvCZlaxwj7VL0HIURPDcg0Dw4b2osLbeA3DJFkZw7ccC8ONXxPDoO7iwkY/k8JI6zzCVMiPwuCgFMOFDJtCRhQkQp1cjMI5/v5BX24lww5fUMIOmAbDHdelwo0/KcNeyenCrKoWw8g1CcNAdsfCz37KQmQeFcOOkrTCwR6EwUjhsEIixw/CfOUAw6IU18LuZoJCVQkMw8SXJ0E=", - "encoding": "base64", - "path": [ - "vx", - 20, - "data" - ] - }, - { - "data": "Il4SwwAdG0Kx2BTDeHUew+5WEsOIDgPDlF0bw5VsCMKiOCXDiisiwwSLJMMQnSvDcfAAw7Z7AsObdLlB5zwZw9a/vsL+wJrCwskZw4INIMNolgrDl/oWw8j6zsGSBKzB7Bnswj4aGMMiUyvDr/4nw0xJIcMOOhbD7d8FQnbbB8OCAFJCqiQRw02PBMN3pAzDxtXzwv4AAEHLtgXDOJILw2SjEMO6zwbD/cQRw07oEsMoSFjBMQgnw8aQH8OkZTDDhotIwvQGI8OG/fjCwU4hw6BxtsFbm/PCX84vwxhjjcKuHCPDu8g9wkzyMMN3CDPDB0E1w3x/WMIWAx/DAMrvwbJbN8OO1xTDcaEJw6o4DcP66njB7lgXw6tbxMJB2BDD2J50wvn9GsFRTAnDJqAfw17oIsMVO73CwY5gwXH3LcOOYHZCbM0Lw+TsCMN77gvDAlrRwr7zFcP8kwXDKB+DQWaFscI1DPLCKypbQr4D68LeeQXDIGYow/tcDsMCpRvDCjsyw3xLNMPYagTDzr1gwk3W1MJ6svnClBoiwyU9EcMkvo7CdYocw4UEE8PBHY5BukAfwu8ymsK28h/D4Jo3w3/gycJerRbDjEAIwxLzHcOPwiNCkSQqwztNIsMASB/DYU1iwmR5l8I4VUzCiBkPw47fDsMzYAHDLJP0waCnFMMIbgTDsHstw7yF38ISVynDxDo2w6OvOMOcpqPBAjYuw0i7B8Ok9uDCqjoPw0CWn772+SLDZmIwwzQWEsOK+g/DVJQYw0qSLsO2FibD3kQZw1bmEMPpzjrDIJkpw+ciZsGBvSDDMCIKwwZlGsK0rgXDfLgHwzir6cIH0CHDKl5pwsjuusEeJ4PCWIk2wouLp8KUmzXDFr8Tww/PFsKyPwfDFcj1wgXdD8OQmxzD0OvdwqB6v8GrvJhBoQsPw0quJ8Nc1N/ASKJtwjuL98FUm3jC3Ocfw5xc/cK0GCrDirIbwyBCE8NZ8prCZDYWw+Wf/cJUhSvDuwX7QcHMBsPcoBHDeBgZQnygzcB04MRB+YQLw2Z2tcIfd7bAA9AIwyL5pkI=", - "encoding": "base64", - "path": [ - "vx", - 21, - "data" - ] - }, - { - "data": "sjsQw4QH9ULg2BfDPv0Hw/ykAMMOShjDSNMdw11Ln0GqChbDsNAbw1xKEMN7HhvDvCXBwgmCyMLwE7BC9q8Tw2QkDcPQvATC+vM4w13bB8Nt9f7CPCYywzMH6kH27rnCOlouwz4SMsM6ZhXDJEYbwwTsLMNiAQnDHAjKQgOjzsKbN/JCzioEw7oLBMMerivDt8emwuJak0I8DyvDGoH/wvZiAcN+t9TCUO0Dwy9fBsNsydvCOGBIw8ZZKsME0zvDIscHwWozDMMqi87CbHgIw6HgEkKWGNzCsHUaw9VNjcHuwhDDupC/QB64IsOG4TbDqwMyw4rrh8EjTw/Dks0jQo4FLsMDCwnD6nnfwsZw98JyYG5CZS8Iw30zJcOaTR3DFu5oQEagWkJ+VSbDZowSwwbPOcMw7V/CDElMQhMqHsO+zwFDlZjHwk5W2cILzfTCZp9WwpFX8sKXeC7DRpKWwqVZcsIPM5rCzmDxQochrsLAzcrCClwUw/jB+sJvJArDAJ0mwxQnLcOg/c3CoMNUQdydlcIVNCjDamEKwy8fC8Nu6Q7DqtoCw4KvHsPOCbtCPLa4QerqGMNy4z/Dhjs/w/KbkMIlfgvDfEvXwsmoJMM2GPJCffMaw2N8FcOSZybDGisJw98FJ8JeIwrDlkkYw47rPMNM/DXD/T/vQfoHC8Pa1tvCb84xw8qGrsJQuT3DYbUww8x6OsPorMPC2pA2w4JD5sKBmbrCRmohwzw1hkK4vzLDoro1w4K/2MIstgbDTnIGw/qIMsOUMxTDuzgGw/y4/sKzOkjDYUo6w+GhdkIoPgbD4NTDwvZgg0Gw2u7C8urPwlY+HMMK9wzDepr/wjh/G0J+FQzCWfufQcCtIcNWFT7DEGcUwwqC20HIg+zCMlqiwry1BsO/4BjDFA7LwpbPPEIES7pCk4g1wz3uJMN+iqTCTBwLw6QU/UFmAhTD3hsMw6u2KsOI6jTDrGY9w5cv4MLynrvBjHgKw1C41cJWv0fDgjKDwlY218J02STD0FXKQkiavcKAn8BCAWEKwyFYgsLyftHCBjfzwuBUFEM=", - "encoding": "base64", - "path": [ - "vx", - 22, - "data" - ] - }, - { - "data": "Zm0Gw05uM0NMkBDDUBLTwifcz8KaehnD/FcUw7X/q0LtGfnCQiYMw5xy78LNFgPDCiFRwrDEZ8IxIBtDvgQHw0CMGcPGsLtBjgY/w8U0y8KzodXCNXo2w40JuEIvIQfDVA5Bw89LNcNr1vDCaJcBw2ViJ8NzZOPCFLEiQ7zrZcKYbjZDssjdwhiH+cICRDTDYvIBwtRVC0N4qTfDCt/RwnuiysKH9YDCKCbhwvkc5MID5SDDnS5Lw/jOJ8PY9TPDP0pqQla51sLL3orCAnvVwhs30UKS0bHCKA/2wh0HgkKcE+fCx0SQQtQwBcPUGy3D2PMiw26cJkLv9ejCOKn0Qrh2GcMawuXC/JqSwsgztcJYEgtDtBHgwvG5RcMYxhnDqIGsQowk+EIGly3DlJT+wlxPN8OsxBa+vo/uQrpLAMPmKC1DqKE+wnoThcJcmbbC2CKeQZzXmcKWWDbDanQHw+ZcucHgdrnBVt46Q/kPP8Kpc1/C6qvxwiGKu8LEidjCeoQQw/GdGsMGL2vC662+Qq4K9sHoYzXD6wTYwsVk+sL8BzLDAKzFwvg4HMN1cChDzZPJQmgEOsP2YkPD7IQ2w6Kt/sHK/PTCgvaFwlnVHsNwTj5DlJUEwxgs+sKMvx/DHB0qw+MEWEBNsDDDHN0Uw/xcRsOoo0jDpBTJQoxB68ISmY/CaVMowwvjWsI+WDrDFPEfw2t7LMMgng7D1v8uwwSTpMKYhojCiGMhw2/OBUOcozDDICstwyI5YcK6G+TCClXUwgJVKMPAmPfCYC3awjw8xsKGokHDbCE5w0fgCUNS0cvCaks2wh7dn0LowrrChF9vwiL7J8Na+tvC4b8fwzpV5UKODl1BGdP9QpKXQ8OL3zXD0gMLwxAZzELSMrPCXy7Rwbns4cI2lAzDAXWrwoXgB0OIBSRDvFlBw1BnF8Na2gHD3AUpw7io1UI/azjD0yfdwvwlPcMiIS/D6NpCw1uHfcJXmlpCtTjuwiyol8IgwkbD/ZgAwxqMgcLzrSPDrLslQ/KfCcMUFChD1EsBw8xJ3MHG3CLD5s++wm1DOkM=", - "encoding": "base64", - "path": [ - "vx", - 23, - "data" - ] - }, - { - "data": "Kljtwq32J0OmMwHD1gaHwgkUj8J0ZhDD97sCwylsGUPc37TCFFfqwh7stcLifsrCmEAfQQoelT8eAD9Dx7/pwqXaFsO4XMJCxK01w8EiZsI8CpnCegEtw+d6HUNy/hrD4v89wzCjKsMGH6vC/Gu2wgRSF8Mcd6DC2o02Q48tMT+mmDNDkUaiwju638LqeS7D/U8AQnYiM0ObijPDFYyNwgiMbsJlUHvA57iwwu11rcIauS7DbEs9w0jkGsPgByDDypUNQ7RggsJjYJDBlZGQwq0CKENuzmDCcqCnwswRFUPA6ZjC7s4NQ6TiusKY5BjDJnMLw+ob7UJ6I6DCdn05Q5qz+MLJaaPCPE+cwfzLF8JQJTpD+7udwm98SsMdQg3DBQYfQwHUQEMlUybDQpLOwqTKJ8NkL4NCDto2QypHsMLu4yRDvy5eQQqIocAtSDPCqqHGQubNRsG9Ly7DNEEmwyMA/EHc3DFCwMFFQ0HXlUBJgwBBdX6uwutiMcKM3oTCZtPlwucD/sLaBuBAnGQmQxqc/UFUnTDD2uaNwgQ30sI6WDzDXKNxwm4rEMMKNlJDWJgzQ20vQMOb/DXDSRAjw9Qu1EGUa8nCfM4CwQrMD8O1Gk9DkvjRwu5ds8JC8g7DzJEwwwDdcEI4HjnDOSMJwyBUPMO480XD6nwpQ59YqMLh9EPB2TQVw4wc7cCUOirDXoIHwxh5FMMONCPDfGIcw2ZjC8K3Qe/BbAoXw1yuJkNSQiPDDKcaw8/7bEGMw6PCVA6IwjheFcMGILvCaZubwniNbsLigy3DaPYqw1y5OkOLl3/CrC2XQWjvDkPIp1nCHGWIP2YzJMMwUYzCIKEow3JSP0McYK5CrHpcQ5AjR8NydiLD3lb0wn4oLUMgUjbCU9ZFQmLEm8LgKPPC2rp6wqgWVEMkOTxDLfc6w/ImA8MmMRrDmJosw3C4LEMqdj3DCDmRwihJPcOS8R3DVKM3w1q1V0AqGRZD+Qq6wpyK9MFe7DXDsMIfw16MRD+OIRfDEtsuQ6BfGsNIX0dDUsnjwk6VBEKmmzfDYl9iwri6IUM=", - "encoding": "base64", - "path": [ - "vx", - 24, - "data" - ] - }, - { - "data": "0P/CwggR2kK2FNXCTtWgwS8S6sGq6ADDiknVwoLuKENCAj7CThavwswIZsL89oLCkqXBQr5vm0I65BZDlHm7wpUtDMN0FjFDyHYiw70Hn7/URAnCvGwaw779O0PUHSDDTpAuw1PkFsPyhDDCKlYmwiK3/8JR2A7CJygKQ0Spe0LgReVC9p0jwuT1usJyoB7DK5jLQpqMHEME5SPDJ4Swwe+sCT9+GKFCipFrwoSkTsLHWSrDnr8lw4HtBMPFhQPDlgdIQ1A0PMGvAndC4pL9wVw3LUOaGgXB++IRwo5MREMsZdnB0hM6Qx6ZNsJIZPfCCrjZwvtiQUMGFgTCThg8Q+9Pr8LQow/CRiVCQnTwHULEYyZDkjULwpU9PsOiQvXCYNI8Q/GfVENYDhXDuIyVwjKVEMODgANDuspGQ2QyGMIF489Ca46YQto8okLiVq1BA7gnQ6SYmULjZx3DarwwwwrK3UJpg+tCUv/7Qpwjm0L6r6FCFFs8wuZz7UFGNBnBCnuewhCht8IBk7hCAvhJQ/Zlz0JQRSHDAXHMweEjnsIOOTfDnjFgwQ0/+cJ2lStDoChrQ353N8O4Vx7DlY4Hw8cxw0K2UZTCceCZQvDq8cIm0RNDTrSQwhp4J8JYguvCaGcpw0IH+ULATTLDKMvtwgjyJ8MfWDbDWJA0Q/7zFMIzH4JCAuf0wsKhhEJ+XhLD2nvRwr3E6cJiLyjDvxwBw6UnAUKrPOlB8MoFw65wDEOs2w3D5QcAw4povkJWWw/C1i2PwY3b98I+s2PCZCwcwkYJrsBudg/DHJwSwwooL0MYx5TBIOysQpRVK0MP1CdAYhygQqEeF8M8tJzBKFAkw+SOUUOQkidD3mJrQzafOsPjqQbD8YDFwkBGQEM8pbNB9JgLQxzw08FAoMDCzx7twRglYUOzRw1DGCAow/Yh08JrZCLDo60jwyRMN0N0HjPDpDbOwahtMMOGFwTD1jAiw/KAr0JC+WBDjghuwiekFULyxRvD3tYqw3ByrkLIOgPDE7D0Qhb/HMMQ7RlDChW5wpkj40IguTfDgL2pPZHqqUI=", - "encoding": "base64", - "path": [ - "vx", - 25, - "data" - ] - }, - { - "data": "TCyNwvAERUIrmZjCZEwiQr5X3kE2FtnCje6YwrAl+kLyWM9A4ERLwlp4kMFhULPByFc1QzSPF0O7+bVC75CCwpjF+MIAsnVDCDMIw97VfUJcIshBzO4Aw05IGEOVORvDDTIXwzbS+MIcc8xAOlmlQV27xMLpvLBBapCgQkxW/kI8qG1CG1FmQSbNicJWvwbDL9MsQ+LS00IfhAvDjlw0Qisuo0IlQCFDMh22wWYezsBK5BzD3MAHw7glzMLi0r/CBts3Qx4+XEI+HxRDzDiQQQKY9kKGXHNC+HKqQWVLNkPyaBFCwPchQ2CBP0E6jKvC5HeOwjDEOkNwiuJBgGgJQ1esK8KopNRBj6HnQtSm7kJ8TdZCDMfEQYnAJ8Md68XCYDMlQ/7HD0PFXfjCksAkwmLx58IfLTZD7LcKQ0Cew0EYliZC+jgKQ7ITJUMayrhCw7NOQ2OlIEOvHQfDuMgtwy0GPUP27j9DzmaHQh/UGUOXRhVDYQXPPzZC3UIFO4VCWtsUwqIWSMJAvSpD2gI1QxGCL0PmAwvDv+b/QVm5OMIc6ifDIjMyQieSxMK+gsFCe6FLQzPhJcNwdf/CXA3KwnjSLkO6OyjC5gAjQ7z7tMLhhopCrg8HwpAYskFZfqnCwU4aw3AlPkPcHSPDOh+9wmJEDcMvMx7DKSMEQ0Z1x0G/TApDJJGxwiYXF0Mr9unC4DqHwqC+ncIe0iLDeRq8wh6q0kIy8dlCxQnewhSBs0JPsOPCgKW7wlZaKENuoNlB60REQj5uucJI2EHBD9UiQd4VhkI4etLCkvXiwrzV7EKQlBdC+1cbQ4BQEUMw5KBC+V8cQ5alA8OYATlCcrkXw0HmFkNlWz9DArw5Q0s9JcPIacfCMeqIwiC1EEN1dNdCrAZZQ9CqMUKlSIDCyf6iQRhaIkNpdqRCIPgLw1BnlcIMbh/DAu0Tw3KCDUP6lyDD90sDQtaoGcO+tcXCcp8Fw0TJJkMemW1D6yyCwaqs60IVmPbC/IMpw2AWJEOAe9PCMJ+UQrocF8OCBbJC/keBwjdzN0M60SzDjmyeQpZhskE=", - "encoding": "base64", - "path": [ - "vx", - 26, - "data" - ] - }, - { - "data": "9ucSwo9hAsDuQRTC4YzbQhH1wkLuUKfCDAgewpc4m0KmtYhCPRKqwNIV8EGe/vZBvHJpQ2LXTEP4zCpCKgvzwUEw0cKY72NDykjQwgvm/0L4H7xCXKPCwshgzkKs5A7DKbbzwvRHuMJn9ohCfEC3QhtJfMKJaKxCgfH3QfYHOUPdY0xBoDCrQnZyEcIK787CokpiQ65wW0L8UdfCqOTrQruMIUMkHlVDjvS3QXeITkLMLwrDlDLJwpqwdcJOflXCx2T/QpPv90Jim09DDoKdQln0lEIIYwdDpp+oQgS6AUOkKttCLx7PQqLGlEJKHBnCIQDMwXSzAUPEosVCQoiOQgiRPEGcYcJCcYctQ1a8NkM3xkZC1GG9Qs2LCsPShIzCqPPXQvo3nEKIirnCQGeLv+NspcJA3jhDMHaZQkN/uUJcIzbBFxFBQ1hSW0O9UBlDHDNFQyByWEMUFdnCzWIhw8XEVEOsknZDtBigQfzzU0OCjEZD/WdnQmwPNEPI3xFDRdNJQXccVb+U+lVDKJnoQtncU0NrEd/C4VzLQhvfgsAUDRHDhN3hQq6cgcLidBpCi0/tQt84DsNiLrfCG1Vtwuj9WUOxkCjACO5dQyTMTcL/gCxBJXdPQRZ+vUJI4i3CUMAFwzRrREMnlw7Dgh9+ws8A3MI/Lf/CKpCkQgB5uUKOyjtDjIM/wogAVEO6n6XC+tG3wT7iCMLg8BXDH7xLwggmLEPqfzRDFOqlwtZXK0Iw857CxNNNwgK5WkNcQ75Coo32Qqx/XcJAJDJC7C6RQtnODEPARm3CStOPwgYEYkKgSsxCMEtXQ/VEzUJrBx5D7wVUQxIM1sKKEe5Cti4FwwwGskJrHRVDPB7cQmNACsMxyWbCkN3twZjirkKcKDlDXkR6QxTA60J867nBX0C8QtianUKvcvVBtNvPwvZzFsJ3KhTDVG7/wlVBq0Lx9QjD1sPDQqD69MI8v2nCynzGwjRIX0OgtTdDIyAnQvTFO0OYWqvCAucfw9CTTkOiT5bCPHn/QXhVC8OBExZCJq7jwVv+QUPMWxvD4IEhQ0fN1ME=", - "encoding": "base64", - "path": [ - "vx", - 27, - "data" - ] - }, - { - "data": "YwvTQC92RMIxrVxBpFE2Q9TBJUNKGFfCbwfCQJtCDkK8TwNDoh8/QnK5sUIGIrpC48VcQyz6SkPIS7o+/EJUQR4EosLSXA5DjgyFwqhhOkOayyJDVZltwt7rWUKYtfjCokSuwtgxWMIA6gdDVCUjQ6i1qcFkxBZD7URVwY7TUEOy3e7B3FYfQ2AP90BsuIDCprxXQ9A+nEDm9IjC6RU5QzjHWkOwg01DjFmoQsrw50Ioq+fCqspxwpwQDMFCiTnAgoSKQr6WO0NslUlDDB8PQ/l38kGbu0RDGgISQ3Mvi0LasDVDjElXQhKtB0NIu6dB+rz2QfpnnkJbMytDQMeGQWSbl0KkbSVDVgxHQ853S0MIhTk/blkkQ16H0MKiqA7CPH5GQj4I4kGGhFvCAWRAQq5HMsID7gdDDsPSQQDmHkPqRmjCtG5XQ9DlT0PbcT5DOPIOQ4R9WkP0zJvCvpkNw5S+KEMxglFDmvq2wZwrVEMft0pDa37qQnZvUkPEJlVDdDWGQvvRUEIawj9DtFw3Qku4MEPmvJ7CXIorQ6efQ0I0eefCTJEzQ56WtcE88RLB5hlUQuhN48L8v0jC+E0Uwf7tOEPUiD5C3B1gQ+nDub+WVRTCZLmQQvaSIUNPWsxAJlrZwiDPBUOG++vCf3jAwbM6lcI4ebbCRoISQiAhIENMmztDT/zYP5KXTEO2ky7CNxT+QcRhjEEW6wLDvLvYP2R6TkOKrFBDAOVDwoDZzL/oPhjCWUdXP9g/WkPcZx9DUu9BQ4ClKMGUdt9CnlkLQ9atSUNIUKHA+rmpwZw1oEBZKShDpv5cQ4IRY0IUjlRDNC5SQ4j3msJ5OjtDhEPbwtCjGkIaE8BCwE3rQYYA1sIKpPbAjn6kQfdZFUIOdl5Doa9WQyjhNEP2PPFBlPQtQ7FRekF2r4fBU+5wwke8+0DoCgLDLuTPwtZHFkKC4drCU4YjQwCZpsI50yHB1vFswuSSZEMK0cVCMKTtQqCLU0MOnyvCchEQw4YOQkNcBRzCFuwBwcab9cJisuTA6DCdQYUWGUPbXAXDyDpeQxBphsI=", - "encoding": "base64", - "path": [ - "vx", - 28, - "data" - ] - }, - { - "data": "ckd4QqK4vMJpMo9CLG9yQ6rhV0PBP4zBV9lnQp4shcBn6jxDcpbQQv4QGUNGHB9D9fMfQ9EyEUNHDB3Ct4OIQqrDVMLB0pRCqRO2wVj9XENGgFdDNmNhwYIrwkDj4cfCxsA6wtWrE8FMKUtD4E5gQwa72kFyYk1DssNcwjDIK0Mzh47CcjFbQ9TZjEKX137B3KYSQ1xZNcLWC6nByENdQ3MKXkPqHRNDYmAbQxJpNEMJvLTC0v9pwbflZUJahFhCFlKmQU7jZENq1hFDbGpMQ7JdP8GmsVVDCbxHQ8qQgUFsHWtDyKEhQZJ9PkPwt65C1jXDQorCDEKSyWdDZvD0wfwnDEN3x1lDeN4qQwqtLkNMey/CjlRaQ2jTgsLku9lAnw0bwB5EYsGjyyPBKLjPQjLm5L4F75hCUnGPwWwqVkOGNMfCEsAqQ/wAD0OMWT9DIMOHQo5NKENE2yrCB4bmwqbNzUKX+OpCCF6Awt7jHENNSBxDssgwQ32YPEPQ1m5DoEb1Qo7c1UJgS/NCaHkwwbL43EKUECnCMUBkQ66M2kKYI6DCbmpjQxf070GCSU7C0vWiP27AoMJ0/kDA2FhOQjqM+kJ/EtxCY7UxQ9p7c0LYgZ3C/+MQQwalUkOBtmtCJEuewjFUoUL+ULPCjNfbQWQXC8Ju1kPC9jftwDVqV0OGTAxDhA9oQq+6FkNUZ8o/2kvGQqL0j0LIYdTCVuF9QtogN0OSFjdDX2zuwE5YNsJOokJB2qeBQuiwIEO26U9DeOhtQ85qMkIcRTRDNahJQ+jQXkMONFtC15ARQipwIsLipF9DpMgUQ6ivDkFIZVND+HUUQ1jnKcINSWlDyFSiwh6YxMAdAktCUDEVwoSUj8LcokhCQDGfQi74EMEW70xDHukHQ7QSV0M+PshCmoJaQyTwDcLmvH3C4MIAwY5ChELPDtPCPnaZwoPaw8CSlJzCtGxaQyoFDsJePSlCwDJOwQg3MUPmQb5BzO9EQ3KUL0Ni6bVAhtH1wp4qCkMo6FJAOmpBwmKny8IgLELC3yChQryyvEI7QdfCBvhdQzTfysI=", - "encoding": "base64", - "path": [ - "vx", - 29, - "data" - ] - }, - { - "data": "3uIJQ6srE8MU4A9D6pRpQ6myX0M6ux5CwiP8QsiUVMIasmZDNkYtQ3moZUMZ62lDYUOEQosSYUKZZ67C0EUPQ5OTOsGU6zdBzXkgQisnQUParV1Dlz1bQoxPXcK0i3XCoEBIQdjTVkJhz4BDmL93Q6ihtEJ2j2JD5orSwmTowkKAS/bCHvVrQ2ZkH0Ot0nJCBrqMQkeR2sL/jkBCHrpCQ2z6HkOAmVVCSktrQxuTaEPYHVvCZldNQhyOCkPA+/dCSC8AwtHIT0PrZnJCckBzQwojgcJu8ShDncZoQyhEMcLPn2pD+DQfwtY6ZkOIxCNDgO0xQ6qPdcH63nFDKPqmwotiUkOEdGRD2/WwQnkYw0JCb7/C/jRnQ0ZINsH4AZNCwqB0wtxMdcJwAkFChEovQ4jGdkLWfYZBtHeIwpgSb0OY5grDYeGnQqykS0IydxJDP3TgwCC1i0KADQZBjOOTwkbSEUJWpyBCb1Powv9NiULCn41CenBoQ6QE5UJ8Xz9Dom47QxpmLUMQJRJCRHmKwjQ1MkK2ujJBfx5wQ4qfO0Owp9TBNoNcQ7ZqykKIO8fCHshSwnPAAcLmQ2lCsnUEQ7W2fEI2CT5DSpyzQr52DEMS6vbCLLtoQxaFYUOE2PVCkdkPwkwn40FDv0XCSn/eQvF8rUEw80ZB1rx6wrHnZUPzfHJCbCcAQxvtjkKqtYFCiBQ4Q5bKC0MaV4fCRhMKQ3+8z0JyTOZCtl9qQjLvysLZJaxCa5ERQ9YZdUI71VhDfCFRQ663+0KaQXdD+gpwQ04uMUNJV/xC+g/VQtpot8IwSWdDypOGQqxqWMJJhRJDhhFdQopnHUE/r1lD1LIawviOaMKAoLQ7GMbVwoY6tcFcaPNCrDIdQ7wpgcLScglDWn0WQp5dR0PYHT1D6AZAQ7zxscLjVPPCMnmDQmblH0M0jITC3RUYwgWyZMIlagrCao5mQ5IbFEKmRNZClMpWQgCDmkL4TD/ChKKAQ3buuEIiH4pCS8Szwt5CRkKYlHFCu1TLwikli8Jez8PCeDMfQ+ZgAUKYO47CPBMZQxfSAsM=", - "encoding": "base64", - "path": [ - "vx", - 30, - "data" - ] - }, - { - "data": "1CVFQzyKIcOo9UFDOp0kQ8irPkNcrMJCX9E0Q9iKwMLX+V5DJ+lZQ/vUgkPiUYNDxAGDQK3pYj9EGf/ChbxKQ8Ck+EGUCADCgMu8QqQQ9ELsTC9DBgbrQlBt28JUearBYBGNQlHe1UJqpXNDnDlSQ9yqDkPSLkJDBA4Qw5oPNkI0DiPD1i1LQ2ruWEPlPwRDzmCZQUimIcP9WtRCPFsFQx03rULJjuHAKIyAQxGIYEM7WKvBgEDbQuiZQUPQUTFDEsGRwsrgCENwtGpAhKNYQ0Yk3sJi/NNCXqpXQ+izt8JI3zdDJAegwjxBXUN2R1VDUmtnQ+SQY8LCf0BDjAH3wsfDdUNePT1DqAX2QdagE0K7QAjDxOFFQyzADUK25gZDErvUwrzoxMJUfsJCx1ZiQ/xe50KUxMzBfjnYwszRT0OkAwfDegnwQeYvBMEidKlClp5kwl6/jT9erG1Cy7X9wYqVEMHoyP3Arm8gw+CkTkGi8WNB0qtpQ9PVUkKB7edCQDRjQ8/WWkM/LJfByDrbwhp3ur+cZGxCymtFQ+i0aUOi6NlBniIqQxR1H0OMSgjDNC+5wtCVYUFaBtpCXkNCQ7ibjUFSgnFDqmjIQdRRRkN0vBbDfAiKQwwQREMI4SlDrmbYQFSxGMES1TDBbvQ0Q75YkkI8jZBCKiPgwgiGOkO2AsNAgbg1Q+ZLkUG0T+5CMH5yQ4A8QEOCv+HB6Iw/Q15aNEKd4F5CJuH2QiY+FMOOoBNDnCpMQ9qej78wXi5D7hoIQ+acP0O0vYBDqANbQ7gP1EIyKzNDXJofQz3EAcNccTdDt+d4QRe83sJW95xCkintv+Cza0KtUBdDVgKAQFnLycJcjyLC5MIbw9JdvUFGOjBDXKNUQ+Vw3sLRXZVCbg+6wZA8FEM2tXNDylwNQ3SV/sIC0yfDwJ35QgnhaUP9ycnB3R4/v5J2xcKQCtpAB1M7Q/nIyUL+pB1DgPPcQrjfJEFojcDCakl3Q+IFBELKmPRCEtdhwoJLHsH29t1C0GsYw+zDEsIiOgrDzG5TQ3zpRcEIxBLCOM+qQp0E68I=", - "encoding": "base64", - "path": [ - "vx", - 31, - "data" - ] - }, - { - "data": "7sdqQ1Q4vsL3DFxDHEPGQiJ/C0OsCiFDVLJdQzJgEcPWlzVDpHZpQ+7QakMCQW9DytdCwlppNcI4NCTDIpdyQ6faqkKo+I/CL80UQxoxZEIyMNZCjPMxQ1rrKMPVt+ZBBc4DQ/6LH0MKMTpDbnkPQ15MP0P08wZDNmkdw9rZOr/wTgjDCCsVQ/b+a0O9zURDpgXTwe/eNcPsYyFDAKmQQmmjy0EqS2bCKnNhQypnM0M69ohBjuQnQ4AUY0P+sFtDX4DiwjaDgUK0lTnC1BwcQ8xpIsOneEFC0mMlQyYdCsNmleVCXYjywiqDL0MgxW9DqoKAQ7joysJQMflCYiQdw7LTdENIY/xCvFCFwd9fhsH2ISXDfKIPQxy2pkKweURDO6UTw6xjB8NkURFDNCl4Q4sXK0MVQ4HCKnYSwwQNEENR2p3CfANswYIabMKOwstB+X3HwpJ1XsKae+tCinuiQaqBSsLoT0XCGCocw1RoBcJUyAXCYqI8QwWTAsCAskJClEptQ3pgbUMY9IXCUFwOwwyxL8JMR9pCeLEEQ4PqZ0NE47hCwiXUQs7wT0PATyLDTAMCw9qui0Jg2x5DLi9yQ2zezsFMAnxDHVr3wTtAakPK7QLDGUiBQ4/MDEO8NUtD5uBsQnP7N8KieQhCxuVpQ1RG/UJ8mgZDJuwnw6lX7UKq4yfCN7NeQ/ge6cFG/y1DtLKGQz8eaEMWy6VBAnZkQ6gtlMAsO6NAgDM8Q8BdI8OStUtDRZZzQxQkT8IEatVCP4CGQnj9dEPY3VxDdwMnQ3w1J0Iy4lxDUM1KQ8LBHcNtYu9Cs93owWPOLMNS8a1BDaNEwob930JqMJdCEIhjQrjaEcNR5KXCxnpBwwYFlUI4IVxD2JtrQ4WRH8PicpZB1rSTwpjMoUI5i4BD9P60QmTSHsM5liDDjoMyQyLQikNWQM9BZDovQpKmDMOiA11Cqmz3Qnl6IENOE0hDfRAmQ2xYMcJkngnD1KVIQ6rLisFeVS9DZml9wTQAdMLEjSNDYx42wxiPhUBXNynDFp1lQ7pWWsKOfz9AwZbiQdhUOsI=", - "encoding": "base64", - "path": [ - "vx", - 32, - "data" - ] - }, - { - "data": "EF1pQ8YIJ8J8yFRDpEg4QvDPpkJLGl9D6JFjQ0JFM8MocvRCzH9TQ5z0K0OwkjRD/Ge+wj7nqsL2dgTD9f1yQ4iWE0OAd9zCxHJHQ8zYskBcCT9ClBRkQ5NnS8PG9qlC1CBAQy48TkOw2e1CMAqhQv42YUP8O51CgOzRwq48LcJiG5jC0Dy3QvYmWkPczXJD1ieJwgDBCcNkiU9DkEudQdW82sG1C8rCIhQpQxBb8kJ1n3dC5rZdQ6haZ0OiyW1D9CMZw/JnEEF0KrjCiIm6Qkx9McMsUoS/tVTIQmjJMcPaw1lCZjIhwy3+2kJGWmtDR+5yQwTaGMOyDYVCS3UXwwDdTkOWU4VC6VxlwgMVg8IAlOvCnCitQureA0N5InJDBOcrw/ZzJcMguDtDRUZhQ6t9XkNka8rCWHgiwzrSmELK/sjB+JJWwgXaz8KQm8jB/qUGw/LyzsIX3jJDhGSlQnh+tMIkrq3CiBq1wrdLk8Kpx5XCRYT4QoKgT8KGmufABaBPQxbkUkOkUNvC/WQewxR6qcKK1x9DPz6OQsRoPUMrJh9DHC5MQjIhZkM4ZNrCpq4iwwzTA0Ms7ktDjp6CQxTiisIInFtDu6uhwnQUa0OKQjjCghNHQ+ymlEL771NDNgH2QrC9pcJyerBCR7Z3Q42MNEPA2kFD/MBAwzzEckJTuarCiGltQ2IBksKFzF9DsZB5Q/QXcUPfc6FCXRVtQ6KhQsInTyDChtdvQ+Z55MLuj3JDqIJ6Q043vMI6Yj9C/EU7QRq9hEMSph9DSMPTQouBLcGyKXFDJWRjQ1JzAsMi0oRC8DmLwj4bRsO8Qd3BD8izwswrJ0PZpYNBqwHrQrJlPMNygQHDLI9BwwsG/0KYDXJDlKRWQ544OMNPKwLC8NDpwp2ysEECqmVDtx40QkBOIsPMH8bCdiRcQ7iDhEOwRKRC/KfBQpDWLcMKjtlC2TiKQjqsUUMcQWBD4GtXQ7DNtMKL2CnDTnkLQ95leMKrI19DDHYJQpY508JYL1NDa8L9wjzFYkIAL+7C3u9RQ7amv8LMMUdCpKyywYpBUUA=", - "encoding": "base64", - "path": [ - "vx", - 33, - "data" - ] - }, - { - "data": "SkpIQ/rU9r9BfDJDtLUTPnqYCEIek4BDSPhBQ5zv/cJaHIZCvNwiQ9E22EIYAelCVD8Iw1aY8MKnIJbCKwxRQ72jU0PmdhPDTKdtQ/yDFcKDg07Ay/h9QyLVIsNyUQ5DDkxzQ+rHa0PsTH5CzDPcQdNqY0PD+PRBhZ9SwjgJp8IizvDBVlgkQp2wNEOEkoBD62fZwhWil8JaQWpDwIvbwbTslMIGsgnDBDDZQj+/jELFVd5Cgi+CQ7Y3UEM6gltDQOwyw61kE8I2CwbD2ogrQnHP8sKiNDTCuPkvQrfKKsPpT25AonYWwyP3SkI3IkpDKshEQ/wNUcNVzIZB+byYwhOoEUPURIRBFta5wlIu3MJuDmTC1toUQpg2M0ORH3VDXhwDwyxd38JG/1ZD84wtQyZBfkM5ZAbD7rvQwuyMrkHyK4xB4LKwwrIWD8PA0InCpvwdwyLjDsMOUWxDUM8RQwLjAMO0evPCCl4ewv7t2sIoEd7COneMQooZxMLb6V7CQGEVQ8auFEOYPxLD7DLxwvLZ+cLsnU5D9JykQZZXB0MoX1pDgIeeQJAyWEOwbzHC6Acew8rBQUOO8mpDeipyQ2qo5cKcyCZDG2X7wiDVS0NC27Q/mnf/Qgpph0GODT9Dkos9Q7Az9MJ8sBND0/ddQzvAZUMunnJDC04Iw8i+PUFeSvjCPLNZQymB5cJXHn5DNv1DQ+JHT0NDOg9DqO9UQyR/scLRKqPCOcR/QwgUfMJPGHlD4xhfQ6UFAcPgHNG/GwoPwva/cUMGyL9C+i9XQgbgX8LS/GVDOwZhQ8iueMLsPapBHt/WwtAlHcO7cZDCfOn5wvFkWUPecwHCX5oyQ5IdEsMivzbDdDytwh4+NUMhi2dDCtIlQ9ZmAMMKo6HCIKgYw8uy6cFpPjRDjyAfQEw8gcKbXjbCLoRvQ87XVUM43wpD2AEbQ1cTCMOnYyVDWui3Qc6Bb0NWFltD0L53QxQnAcNm7jPDNBueQmDPzcKoqXxDQ4LDQgglD8PYympDLLOVwoaG/ULIhnTCjQMoQ/apCMNKpdBCfP+JwsM5C0I=", - "encoding": "base64", - "path": [ - "vx", - 34, - "data" - ] - }, - { - "data": "YbMXQ8IX+UE8tgBDxCImwiJTG8Efh25D4nMKQ0blmcJObZlBZFXXQqEwZUJYnnxCbM8pw322E8PnnALCQmYeQ7bqgENUvzPDKlN5Q+PwlMKC2UHC+/9zQ+ywwMLeGEJD9kuGQ665aUMGroJBpeaTwRu0QENHMTzB7EIrwTxk88J6g/lA1raNwMjIBkNs+mxD/qsSw0XhdMGsQmdD6baNwm5B6sIkWCPD5C5mQspRzkHLOyRD+NiEQ8N2JUOOwyhDPjriwp4umMLUvCjDXIQ5PgJfisLqLavCl19GwDwazsLBzSHCdpK1wm357z8aARVDncoFQyY9H8M0C9rB+fvKwWC0nkKkgNjB/oL2won6FMOngHzBiYfVwFGWXEOWW05DJwCKwsRcUMI7F1dD6h/lQg/tckOuMxvD2IRFwk73wcFrwk5CyEruwtEiK8OcidXC5m0bw8YaKsM28odDmm9KQ2sYJcNe/RjD0fDBP7hyDMMOqQzD1vbFQZsUDMOSrcXCjxeuQqeir0LmCijDVsQrwi7fIsOoIG5DiqG2wQoXsEJbHYFDAGgNwlOKLkOmkqvAukaJwrOhd0MET2xD1sJAQ+pqI8NCg9tCDkIkw+b0GEPZd/VBZeaFQpab/sHmJRJDbql4Q6j3JMO/hFBDlXUuQx9OgkMP9IVD0F6gwuj69sEMSRrDZGAqQ4geGsN+WHRDgf3/QsIOD0PNpEhDTYIjQzBs+sL8o/DCcG1lQz6OjcFEFVxD1PcrQ9NeGsMKIjLChcKbwipVPENe9CpCGPcMQSBHv8J09DpDL1JCQwC3gcGYHZXBhFQOw+ZZvsJkW+LCjOQXw0YXdUPPu5TClPdmQ+SipcJw7zXD7fSiwHPWZkO5BT5DIrXgQnhZj8K4Sf3CtkQxw8jblcLgD/RCNFobwo6HG8DwkHa95OhjQ55CFUNNoz1D97VWQ6xKnMILal1DLoKLwcCMcUNGEjdDXLx3Q10aH8Nfgd3CUvDWQYCoC8NlRnND/7glQyFoJ8MQvFZDsHf0wU5BSUMeiqTBWyzqQnj+LMNbTSJDhhDiwsQPX0I=", - "encoding": "base64", - "path": [ - "vx", - 35, - "data" - ] - }, - { - "data": "m5PKQsUfcULYPJ5CBWChwoJ2RsJSyjpD5OGtQnPfC8I3WbrBolNuQoHjZUHR94hBMkM4w7crGsOakvc/RinTQiEof0PU6gzDa2NhQ4ah1cLkz7LCO85KQxyQ9cFqG2RD+1J8Q6qBRUP12crBCI9twnvIBkMuc0fCIgrGQTaIG8OVRCVCwl05wsnDq0JjCUBD2CUxw9ZtJUI4+UVDwu3ewoqQGsMImRzDZpJWQbm7aMGsX1lDXs5kQxz+3EJGzMpCtPBdwhJB3MKUsynDQGsVwr7RvsGMnPbC3LQuwh5dQcIeV5/C79kzwva3H8LAbKpCgCyJQvnBycJOHofCY6ceQYcAvkG6DoPCPFwQw1ywLcOrbIFBqiE6wmREdUMAkRRD/jWpwefCa8GAPDhD1VGCQuJBPkNu6PLCcKP9wKATgMLQPJ1CToQPw/beHMMkoQnDgx+7wvxwKcOg24JDNYZxQ9z2LMNFlSPDOREVQsUfIcPGyxzD1rpvwU4yLcMXDQnD4zERQk6DGUIonAHDl9T0QGYcLcNQRG1DNLR0wjZzN0JYxYRDVBuPwjtY70KAbrVBjGGIwQGSikMYVEdDE2j+QpoDT8P0tnJCnu48w1TbvUJmKktCg0+HQcjMk8KabLZCKGCLQ7L6I8O0ZoJDhfTrQroCfEMWrIBDFCb3wfWUisIqQxvD+6baQhEbN8PewEJD9cV+QsCQo0Jq7HBDjnTHQjf4GsOcCRvDcpUyQ9hzv0FVfidDmDXZQu3SH8Nx46TCp93nwqR49UKFzknA2H/6wQxLAsOtiPNCI7QNQ+XkiEFWVlzC+dMmw7yQ+cG83BXDanEbw2xWaEOZWN7C0KeAQ8yHGMKYjevC2koZQjm+g0P4pQBDVs2CQtjCxsHDgyjDlgktwyn85sLEzIRCHHWgwq577kGidiNC95A6Q/PMp0JAWF9DXjeDQ0BBDMJeZIRDjoRXwsuaVkOAdPtCkplSQ34zLMOes0rBiq2ewcgRJ8OiIz9DdPthQ36sGMNqkyFDyl8cQVZygUNkJzxBoKKLQk/EH8OynFtDSDsaw9M3iUI=", - "encoding": "base64", - "path": [ - "vx", - 36, - "data" - ] - }, - { - "data": "e59iQhKkrEK86glCeZTswki5rMK4ugFDDNUqQhP+RUAM/3XCfJ+IQdpru8Gopr7BpCAEwx6Is8LROwFCvjduQvBlVEPEB2jCfFwtQz76BcNm7vzCbCwQQ7559EFf0mhDgEpJQ0ZXC0OXTnzCgozAwsAmoEJu5KjCvP9fQtc1KsMfjZBCPPOqwhTLIEJqggVDKTIjw8t9vELKgA9DoJgUw+ygNMNIcpHCrNbRwfp2T8JCa4BDNhUkQ+GGT0KxMixCTJeQwTSrCsMFELTC21eOwqD+jUG4jxzDyCiewscosMD+M+XCWhn+wAtCmMKaaNNBUshbQcapXcJcINLC43QUQhSmvMH4WcfCOKMJw18UGMP9EixCbmemwojDbUO6QrtCVTeIQQghV0GeYQNDAZi5Qa6j90K4fXjCoYbOQc6uxMKUusBCAo4Tw/g8i8KuLB3DUmuuwUTwxsJCglRDOGR7Q9h5s8KONJ/CrsaLQjfHC8PoQwTDugVKwpANMMNmNSjDKhHKwMyMUsBguEbCsPMjQiYr18KM1UdD5DG/wsuA5EC5mG5D9NvQwl5/ikIS2zJCiHxyQaYqhUPSLAdD9Ml1QmpRLMN4yY9Biq8pw2q3K0Is8YBC8OHSwWAi3MKYtipC02ODQ2ARx8KeSY1D3uR8Qt47SkPubVVDYoZpQRyS0MIohLvC40BaQv6ZEcMoZ/9CRIQmQT48/kEqUXtD5pYdQmL8H8MJuTDD3qHtQpbOfkJpH9FCgBlCQuju2cJK3ufC3oAVww7DdULazi/C/7qHwl+6HcOaW15C44agQrxPLULiHLLCKLIFwyby+kGj5C/D9fKlwnVIOkN6qg7DlHB1Q9le+L+o0IvC0vaCQqFYgUP8IoJCOj65QQKVgUGQQUXDu5Crwqy6FcOabYpBZjz1wnmuR0JxOp5CrkL6QmCQ40EQfWVDiAuHQ6CkIr2xlodD2K6uwl+HJUMU94pCpe0UQ+b2CsNGGQ9Cyu16wmCsGcNTgvJCOOGDQzDkkcIeY9pCfoJCQuyoikPkVB5CisLaQbjescIAd4RDlhQ7w9I3kEI=", - "encoding": "base64", - "path": [ - "vx", - 37, - "data" - ] - }, - { - "data": "xCSCQdh600L9UMjADFMaw6A78MLAT6NCdAJpQJEdH0J4DsDCnJqpwcDEZsJbX3TCXdUmwgS3nMFsMHFCL2eUQYqVG0MjWnjBtjXbQq0sGMMeSx7Dm7ugQtKjrkIQI1FDduEFQ6JookISkMPCvHsBw5aDCUKWjufC8KunQnZsAcM+tclCRi/0wuDdAsDY8olCBK29wtfQBkOfA6NCJk8xw39kKMND2pvAhjp7wv/XrcL+MIBDSP26QkxjOb8E95bAGr8rQaD6HcPWG+vBSBXMwqp9Z0KSdTDDONHbwgzT8kH8CxHDpcDCQcjD1sKOsMPBascEwsdmfME/9QvDg3NsQpQngcLOkwHD4m2Owq5vqMJW4IRC0+vpwrNyQUMmrj1CrCVEQlLdEkLgv55CaAlbwRCLi0Im8JLBpL1aQiYz/8IKE75CaCi9wm/eFMEGeRnDskvSQWaKicGg4hNDMFRmQzGqFcLoJ6HBPQHHQkCvPcJOQmnCepelwqu058LH+zXDnvArwihvHcKh8Zg/+qV/QoByU8JIygxD7OT8wnxY6sG6iDxD+toFwzrZxUFC+HlCEm8ZQuj5XEMHEpVCtwLQQP9Q2cLoJ6PB+LenwqxGW8CS7Y5Cbv+BwpUMDMMy1lQ+YoNWQ0wLXcIuUoFDlDNzQWo5BUPsPBZDYbNqQqbVB8MlAw3CloP4QDIhicJFOY5CCVMNwtocJcGE8GZDKNkywZawxMIfIhDDfb+AQtQRzUJw/T9CtZ9MwGrTwMGmMhDDbuYtw0IsJkFV06HC7A7LwnjgJ8OFPaQ/WLbSQUolgUIg5PHCNDGBwoKjuELJ0x/D1OFEwTwFAkOgYiXDw5VMQ+gZ70EYnvHBBMKlQnOzVEPGykRBEEh8wQYkWEIRhS/Dmv6JP7TpLMMkWtnBmvIlw2Qie0I0zOVCkKBrQqLqmsEG9E9D6N9nQ8QT9EE/wWdD3mrswikVzkInMa1BlLekQqb2OcK0TXxCrILNwuIYksIkgIBCrXKFQyeDLcHaeYFCyPmvQlorgEOkL4FCMtA7wW4dJcKOyYpDuGwyw159akI=", - "encoding": "base64", - "path": [ - "vx", - 38, - "data" - ] - }, - { - "data": "I3OowRh/vEIMki/C6lA5w8YmFsPE7B5Cjlz9wXc2mkKuwf3C8LZgwpTLssIKBr/C6nM1QfUjp0E/Ta1CCM2Wwe40z0LyGU1Bi6FaQsL6EcMJqDLD4vTMQZDQAUOYECdDFIqPQiZEA0LoyQHDXywew65em8CMMQ/DrNbUQuzljML8Q+dCFoobw8CLJ8L+NSNBgYEZwrl9F0MCTeBBXoEvw332scKSEwtCClvCwiDy78JApVVDILcSQqRLP8LaKDPCvLcLQuwtGMOOAitBOAgCw1psxELirRHDFv0Hw6nddkJW0SjDhfJXQomcBcN1jonC7BuUwkEOq0HQuyrDI0CZQl6XyMKCChrDNC9mwTAS3sGmxqxCX0cTw2i5AEPcdt5ANNCYQgBFY0L2RwpCmL87wmUAykGMm2pBxHCfQpwEF8PDpYVCIP0GwnOi6UEu283C8whpQsQNB0JbmrJCxlU7QwricsCrPlVBVuLmQi/kl0CfJITAz4fgwqo3U8JCSQvDYgaWwshGjsKWGw1CCMqdQlRQS8FOKKxCCvoYw2mXgMIeLf5CHA4ew6kgdcFcoZdCweVfQsT6HkOCdM5BoEkhwsfbZcIpsV7C1OuWwSppNcJLKIVCrGbIwuAsIsOYIRXCaOgZQyZxpMHa8UxDE5vgwUSqlEI0EqNCdpXOQmwIIsNUiepAOLwDwoiAqcGCq8ZBoOyWwoRrOsJiBD5DyhNZwmiqGMIBFIPC1P2NQZiOBkOQhs29/LNBwp3j5EHdXiPDhtolw6lwBsKQVuXCqlUEwzyc+MLMbS/CElWiwdbkoULwHxbDWc9qwdonDUOwP6LCpO7aQaxCo0KeNCTDfCQWQ/rWbUIcVrRAeCS4QqZZEUMeyQDCGFVRwtJEtEIbvczCvFU5Qs7nKsNGY4jCKCVMwzsHi0JWhQZDvo52QDWwd8LERCdDZ74sQw6saUJAPihDueURwzQqH0JCIZzBjSPiQVeqf0Gz251CICgMwzRbksHy+o5BcHZvQz618UH00s9BO0AAQw8tVkNYNK5CZIBBwoxMwcAyrnhDntHKwtYQx0E=", - "encoding": "base64", - "path": [ - "vx", - 39, - "data" - ] - }, - { - "data": "uYJgwhqpMEKMzJ3C/u05w/LPLcNv9/E/TUmAwofc6UL5ERnDSc+wwlwG7sIw0v7C9nUzQst4OkI9HdpCy19WwrQqbkIjDglCrHIIQXPGncLYHyTD0OimwZ4BGkMeb+hCeG2kQVoKB8Fwbx7Dqscyw9gfHcKA5SPDjcbaQrIUp8HwA7xC1gU3w4r4n8LJUiLCZA1qQDDOCENv7I3BBLfdwqRAysFe8W9CTLEBw9JoFsOOpRlDctcbwT7is8JEuJ3CTBlhQnR/ncLn2yBCeP4Zwyr9CEN6AYzCndYbwy4Ks0JbXjLDKBSkQqV8GcOgcdbCYZ/bwtFbaUI9gj7DOkevQkUTA8NeEinDukWzQY7edUEsWcNCvusrw057kUKqd+zBo4jFQss8lEKSvI3A+NaawsANTcEGACRCbAnHQlBeJcN2I4NB7l8NQYzfX0JtUArC9omeQnoLhEIYwCRCEG4EQ76UrEH5hQ9C81/MQsznCELUr/9BsY8Kw/zFhMDKzVzCCSXOwmynxsKLkG5CqCCrQjZxnEH4eiJCGA0sw23oxMIwj3xCoMIqw4WST8LyHKBCyvCJQqhrvUJoMGjBPIuhwgoOZ8G2QLHCKuHFQVcmp8KMywpCQ3oEw4L0K8OtC43CrsW7QtwZF0EW4g1DdKGHwgze2EFPabtBiDsSQ6goL8PDcR5CCXmJwlKgQ0EgPmbBfQbewvmwnMI8pApDgFu2wrDlVkBNNoLBsMm7wRvNBEPqnyfCgomwwhU8cULfYSDDRmmpwtKykMJqKBHDPicfw2B6J8IuP6PCTL9ywlrKsUKEKi3D4ZyrQRyvJ0OOA7/BsBdQQpxtHkKSPLnC/4W6Qoznr0LQHiBCpuC1QmJbqkLbWIzCkVOuwmFk+EK0TSzCsvePQj7s5cI40dTCtXJAw168iEKvw+VCrlQowtQVycLs6OhC0pLmQub+qELC6NVC1nQnwxZ9X8F8MF3CsXWDwZyfVkJJjqxC8wwuw95hjUHAyKjBF2ZCQwxAa0ISmQvBBHAVQ6fXI0Ovoc5CHk6mwv79tUHP2EJDKCEkwrBrpME=", - "encoding": "base64", - "path": [ - "vx", - 40, - "data" - ] - }, - { - "data": "4uOywnD0lcBRvN7CQPXYwh6QN8PzygTCepO8wsTXFUPCkivDKf7rwkJVEsNQURzDMtyGQgpRfkK8D9ZCOYqswr0KpUFAnE1CYz34wQbQW8HUN7PCenR0wqBCGkN1b4hCnGu4wWQvMcIEozTDZ64zw4jdi8JyPinDjWWbQoBimEHnsupB5rVDw8Q86cLu6KnCxDISQlRplkKeeGXCEHNDwqhFj0H47ZdCvuUfw7xbL8PvTctCiz5DwsIk/sIwnNfCLtaWQsi/AMGeOHxCqoUpw7r5FUMe9JXBhEUlw/kS4UI0ExfDkqrXQsgrI8OM1wvDZK8Mw3ibwkIw/ivDwpmfQt5dHMM4iSPDfpw9QvrfRELwHZhCGEc4w65U1UE05nzCeg7eQt5yrEKgJRvCNDHTwu0OOcJm0XlCuRDNQpqQIcMnVhbCEogaQj6AlUJeJGVBmHS2Qrh/rELQEgK9PtaTQmD4KEKSU1BCUyMHQqjQU0JAdGNCwbQfw1zFB0Ii94E/rnH+wqDy98IhjplC8IueQkv1O0I+PuI/Lqotw3j3A8P6CfRAndQXwwwlq8J0NmdCUkeYQgBFIkJ0iELCOIznwvRCvkFcNu/CSgZfQpWi7MJSzXjBrnYhwwUiH8OWp8fCaGUsQlAxFEL/x6xCJlHRwmJfRcFwesfBLl4jQ/NFEsOJY4FCUJfIwi7MGEJoCELCWUAOw/Ra1MJsN6hCeu/0wnpCB0KAc4lB2OFywrtwqEJsb53CaWX2wt2NnkKmxc3CFNWfwdyc1cKyFCvDee0xww6OF0GFDOLCcgy/wtM7kUJ03S/DyFBEQohwJEPoB3JBAlmHQh5CDEDErn3Bi7svQtL55UKSuZVCEPCIQpMXE0KnQ83CBPPwwjDRC0NI/wFAJIOsQr/0L8LL4Q3Ddef6wsPESELU4z1Cgm+hwiDMB8PSMIdCqDOIQn9910IOWGZCCBYsw0ajb8LE/KzCiP9YwpnamUIVk6lCLK1Iw52/LkKxklrCfHwNQ/5WnUJT+iHCSLzvQmVX3kJuCLZC4IvowiiuPkJRhwVDwd8JQG7SYMI=", - "encoding": "base64", - "path": [ - "vx", - 41, - "data" - ] - }, - { - "data": "lkbywjgEIMLEswzDMC48wjrjIMMK24TCzjb0wgibA0Osgi7DKF0Qw2aeKcO0+zPDDHSkQnZ1k0IwHXZCbDnqwtDRbMEpRYJCft6CwvbM00Eg/NLBgoPAwrGP30I3kshBmO5zwnSdl8LieznDAPAAw+6lwsK6rgfD4D2RQf7jTkITUgPCNs4pw9x0F8MMQvfCsmR8Qthd28E+f7fC0E9ZwBqhQ0JYIKhCe0I5w863OMNcTmtClIqkwqRrHsPUvAPDhLi2QuPSAkK4xqBCkhshw9bo2kKNs4VBDtYZw5Xv8UI4AYvCfXHrQpAuGcO+zCXDxewlwyn0DEOeYLrCNk0YQrYiLsMXoeDCZgqBQqAKmEIYL9ZButgmw7wwQcGyYr3CWNa9Qh1snEIoiIrC0W4DwzZcmMICmp5Cff6SQghl6sKAtJvCloVvQpZ2rEKcgkFC0ea6QkpOwUKEmRHC9vCuQdW7bkIypH1CgCk1wszGgUKMk5NC1iYpw7TzgEL0OBhCPqISw3ogEMOBzqxCjTo5Qh7zjUK7xgDCasEBw+kMJMM3zyDC3mCYwmHv6MIC7wlB2veLQsEnrcCSwJvCCHoRw8L+bEJxYBTD6nmcQoQRFcNt4UnCruE4wwiu08LM3/nCxfp1v4jMfkJrcR9CNKAKw/HeOMJV9oPCJwz5QuQZiMK57aZCyFn/wkBfbUJ2U53CUHAowwwOAsPQjgtCs+QTw7lgZEIWAShCU5i9wub+X0EMV97CMu8Yw/ZssULDdAPCFLyjQdI+CcPzJjzDls4vw0C9J0L4TQrDcOj5wq9V3kFaG+vC/PWMQiYD40JU/i5CIEmYQrqS/sG0E+FBEuteP0Tk+ULGE+BClEpfwWTnbMD24QHDM7AXw4wR3kK1bhdCrrO3Qrbv+UDFsy3DUkuSwjGr78BMotjBOAfiwkJdJ8Mmm7xBaTLdQcZP6EI1L4BBOhn8wihAxsLIvuLCakGtwjREtELO0ItCCEpPw7XLfELc06fCwNerQsMVtUKrF4zCQSQjQh+BbEL/FCBCKEITw5/Pi0Lscp9C5zkNQg01j8I=", - "encoding": "base64", - "path": [ - "vx", - 42, - "data" - ] - }, - { - "data": "hsEWw8B1fMIs/STDggnKwCV/tMJsy8TCuMUSw14lg0L+8w/DuIolwxQ0NsPBCj/DV6GzQvgumULl7WZAzN8Rw4xlP8IS35VCgg+/whfNT0LQLIdBOIv9wuCqoUCCgGPBd8G8wjIPz8K2ogrDiCZQwgjz8sIY1YbCWNARwkDrnEJTv4fCMkzBwmzgNsMUiBzDdL+oQo4j08Jkd/LC+gj4QVZsj0IvWKVCYilEwzxwFMMFUrBB7iPewkP3NcOP2xXDbI67Qo57ZULQ67VCKDG5woNv90FQGSxCoFTIwgoEtkI4cPDA5iaqQnM8z8Io6DbDti03w9VLLEMGZgPCvrwEwfRhM8POzx7CDA+WQsI4wEIGuEnBrx7HwpAVNcJLYfjChFk+QmKMAkIagsDCpBwaw5VMzsJWCLNCkBMvQcylDcJ4a7vCTLOUQvyUr0LmApBCEM2iQl5+wEIgV4rCyIrAwXtUlEIt5opCrmicwgZYjkKfJ6dCHCsSw6JTsUIzeH5C6Noewxy6HMOKl6dCE4yUwOgRt0JTfXnCmZczwpqrPsOj4aPCdE13wTAEEMNYp+3BMEoOQmTNNcIc5c3C/h8pw3hsukI5jC3DgRW7QvsJLsN6Sn7CPKRCwxQP2sGevRDDqusgwia8tEIG9wu/Qccow+i6l8LhPsrC6q8VQjk6QME4n7xC7jIWwxwVmUIr7dLCBwc7w5X6FMPyaBLBLCUmwxpalULYb3RCnwP8whEhP8ItTAvDWiIww7aesUKYB3FBjCU/QoQZI8OshTfDluHywpH4fUJF3RzDHHsUw+fhdsHYbUnCoN2rQrMzFUFw5oJC2T6ZQh8DfcI2/VtCQlAWwoaXpkJg4hdDAPamwtgSGsLQgBfDSDsyw8IBH0IcTIZCICixQoziMkLK10bDKqwBwmkrbsJrfJfCSTULw5xLQcN4zoPBMFMDwWZzpEKqK6HBqV9bwlcPBMNKmgfDTp/kwt2hvEJFGsBBAHsfw3iAmkLS+NrC5voGQv8tuEJpj8PCupzkwa9VPEECmBnBTh4uw1PxskKG5glCUl93QjrJicI=", - "encoding": "base64", - "path": [ - "vx", - 43, - "data" - ] - }, - { - "data": "MH0ww1Lkj8IdTTPDHui7QUyx58HmXAHDZ3Ylw0tzWkC2IZbCdEQwww5SHsNanibDtDewQuDwh0LgjRzCg0orw2p/nsI47JhCYErzwkRkiEIowz1CzG8Ywyw4vsJtgUnCvIP3wjz+/sJijXPCGLHUP/alDcMlDmfBZNGPwpVXxkKhxJ/Ccv0TwjjUTcOoijbDWmnHQh41BMPSgRHDfI9nQm6Mr0J6cYBC/kYfw/x8oMLpFinBxoIHw8qKQcNGzx/Dvu5RQvyxkEJIEq5CjirFwUKCE8KolHxCE17MwVpVCELq8/5BwlLXQfjs6MHXqDrD8dA6w56WAkOAifRAGjMWwsUCIcMWHTBB7jGcQpBK1kIugxrCWXASwhsilMIiQRfDBtVlwPW7e8G3WO/Cd/Aqw3SD/sJ6qqhCZJo1wqwVqkHkSLPCit2jQoCPh0LMxa5CwE4xQhgxnkLEJcbCsRCCwuTwp0J9VoRC+hOswnwDjkLRqalCxuuXwkKd00KAKaJCdMAdw1ovGcPOzFlCoQtCwvTT0kKQ07LCrK0QQS7uQsMq1OzCJKqzQZBJJsPGekfChpWTwWDDocKU+PfC5HU4w0ro+0Kglj7Ddq7JQpW5PMMcJ3jC5jEiw2qO4EF7ixzD/8SXwvY/6EL8NBLCBQRAw4gEzMJ8BgPDmAUbwiJpxEFvsrJCmOIlw+QGskLm/QDDvkc/w1QHIMPMTETC4BUuw1NhrEKMFJdCuvgZwzkKp8J+SiLDbYQ9wy/kmEK41jtCqK+FQnNINsPFR/zCxH1DwgrUmkJI2ybDZZ8kw9S6K8KuF+DAVCO5QqQersKo5aJC6KR/QootucLHnI9CcN2QwjxJnEGUcxlDEmDKwiUbisJ69yXD9Fo/w7gy3cF0C7ZCmq+RQoJfjkLE1FDDo+HGP04xl8Kk9LzCJa4ew7peT8N611TCVjYjwn726EG6jVHCBgLhwHhuHsMg6RfDBGUJw2BZr0KIm17ClIOQwuygqUIiWgPDKjdMwSj+kkKqV/fCMv2Awsu0/MG0WCzCdrU+w1h8zkKGuJrAQkWmQk6aXsI=", - "encoding": "base64", - "path": [ - "vx", - 44, - "data" - ] - }, - { - "data": "DvVAw/xEi8IGKyzDopg6QhRuVEH87h7D1swpwyjXLMKmJ4jBsGAjwyATk8K3XLTCDJWJQgBDCEJynXrCKJM9w7Dn2sLkT1FCdocPw9T3mkJg2opCxAUswzbJAcMSqqfCzAAVw14JE8OQ//DAtPwVQt6iG8PnS7VBidypwjT53ELS25/CPHK3QPFYTsPOz0bDznbQQn6JBcNmSSPDq9edQl4ewUJWXkRBuNOPwtPu5cGSsSDCJCobww6ZOcMoGhzDeyz/QE41oELW/URCL36CQXRUksK2X5xCOkbMQQbgecFkTGdCIhGowSThwEFo4yjDbpskw5RuXkLXKRJCCvdVwkhqx8KGHjNC1kyKQn7bx0KktFvCwmnzQLY0xsKq1S3DO2sowpWNMMIEwwrDuPktwyjZE8NMy1dCRNqWwnTVYUIWeZDC852fQj6ol0Fm6b1CiwzwwB5u9kHZzvzCB07LwjPNmkKcFCxCB0KkwgntcEJSQY9CbJKXwYSe3kKE8bZC5tgAw0Z23cItqShAAtaPwgbJwUKmGePCdLooQkxyD8OUxhXD6fw9QqQwMsNaOWbC6lJOwoPe4MLKbQzDRVg6w47QFEPSfDnD+PO+QpXhNsNIlU3C3AF4wr/hgEKokRrDJC7ZwkJQ7EIAd4rCtr5Hw1XC+cL0qBvDvOqawlNsRkIgYWlCtScqw5fntkI7mxTDjKAkw6KsG8NvDKvCrkElw4L1r0KUxqlCBgcxwwRuxMJw3THDyBY6w+K7JkJA24hCjg2fQg5UPcMc6TLCk0YJv01HqUKZTCTDBkEqw3y5Z8L8z7RBNFmmQjcD/8KVULZC9ma9QVvq78LAk6JC9H7Qwvqm18EV5bZC28TAwlo0wMIazCnDjxclw2YejcLlC9pCBg4BQpz5skJOADfD4X/6QcphkcI+m8LC6I8pw5ShPsMA/a3CvvyNwub3TcEANaPCrVjHQVT9MMMWTx/D9iobw8BAfELu6MvCdrpnwWRfoEJurRTDI3BbwjZ5y0H04hLDbMyiwr7dj8Ica3XCPA00w1zjtkKyNh/CLMfFQizzDsI=", - "encoding": "base64", - "path": [ - "vx", - 45, - "data" - ] - }, - { - "data": "0Hg5w8fJXcITlPrCYjmCQnJILEJ86TjDOEoJw3iCi8J228RBiVzYwvE6dMGywNvBpuloQXDKksEUpY/Czyo+w9SQCsMkgyjAdBIgw9BsoEJyb6lCdHw2w9yjB8MxXOXCghApw889IMNcUd5BOE54QjzTHcMo8UNCMMSpwnBz0kKYTozC2IUUQpqkH8PTY0fD98SxQjSt6sKinSvDjKO8QuZSvEIEADbCBB6IwTQxAkHnE4fCmHUow8KeE8Ne7P3CIDGWwcQJokKuJaPAgnMpQvyrs8L6uq9Cil1pQuThS8IEOpZCtrxYwhzTakKEdOzCQd3CwggmbsDe1GdC2vRtwg4qn8Gg8oZCZH8bQrT3g0Lb7XXCtLYbQiMk8cJIPznDdlOHwhxGYsJshxfDiU8Nw7K/IsPkXchANlmmwhBZnEI8hiXCc8Z+QnZbDMLsgrpCYONewrvc98FQ6RbDLgsGw8/L7UEo3+PAKtyJwpRDs0FggA9C2IuZQZztukIGibtCaMpkwgjlJcLDCS/CgxucwqSTTkJRhAbDlBB+Qi10p8J4Xy/DjhGBQkNqJ8PgKF/CFjZ/woxRDMNcjhbDMTEkw1AECkPCwvzCnA17Qs1jCsNvPA3Ct/swQCmLr0Kli//CIowKw4gViEIdesbCgIErw2UcEMNMHi7DY5G+wkw5hkLIjxlBnkcZw7Y+eEICSCLDUsmjwgoc68KSe+3CckUAw9C9iUJyQ6xC7HU+w8a1xcJKwDTDzwIZw47AN8HRhKRCz9WrQtDSKsOxdQJBC/X+QZxXqELMhA3DW4Ufw/8zesKOSDBCpmdCQixTC8OzMrVCHpT6wR7uEMMoAKhC1CEFwyMbXcJ51flBQDqfwvUB8MKy6BvD9rnJwnb9scKANetCbH0nwhRpyEIK987CMv9oQizkbMLA/67C7OEnw1ld1MJmq+vCCZ3GwsaOLMK6kdjCC3k9Qlf9OMNAfBfDPpYlw2yJL0FIrtvCGtjAQZIgOUKiCB/DypK6wmrR4MFeiiTDdI+uwiCl28LEsYbCwpfvwpBiK0Ky3Y7CsUPTQq0GDsE=", - "encoding": "base64", - "path": [ - "vx", - 46, - "data" - ] - }, - { - "data": "XNIBw5whsMFc/oHCTyWfQqQZgULct0bD2+SRwpRPqMI4GlhCTnA+wjYxnkFApG1BDtk7whSUbsJ6EZDCPC8Vw2j+JcOgtx7CgpYow0yzlUJjLLtCli0xwyZW+cLMhg7D1Bo1w66oIsM22lBCWMmdQrynBsNElodCVvuUwlyCmUIo9D/CthpzQjg5qMLghC3DbHAtQjh5psJBeyTDPrbMQlTwiEL87JzCNN+MQRb8DULgRbrCho0rwxAUmMLcel/CIJ8Nwly3kkKCISnCMcVuQtb3vMI27rJCm0aeQu5rk8In8atC5iONwnQ4oULyYx7C5KtIwbKdKsJUtpNCMW5iwlPzDUKswKRClNa8wKJnVUHpCW3C8lp2Qo4gCsO8pyTDLSWgwrEtasKIfxnDEA5/wtTZJcMStwjC7SafwnGgtUIhoQFBL9/uQeT0hsJQpJpCxyOqwo/+nMIcXCvDFa0hwx8LRMEOlVbCbg8xwob+IMKOwUrByKU0QgQiREJpZ6ZC3iGjQOVZIUF/NonC+OOMwhpTkMBoNxfDIHqaQkjGF8KATkHDWKaXQhR15MKTGT7CwF18wigcJMOkSRbD6qbKwhrvkEKhnEnCVc2yQKqRg8KEulvBMl4cQvM4y0IOlYvC4lQlw+ahOkFQtf3C0Le3wk5THsPkDjjDQt3IwhC4nUKvoQrClIrFwjUV9UDguyTDW29YvxVAM8I6exTDWYFTwkAb0kEa2IRCXrM1w2TYqsJA1B/DAg+cwtbogcIO3bJCEpunQs4xzcLRGilCTvhZQuQLj0KkCqzC2tH1wlwLaMJgFnBCddZ1wUSnBMNUpYRCBkeMwtblJcM61pxCKpMew8QKicKA/nrBkO5TwoaYDMPZuN/C5Jo7wkjFu8LjddFCO3vKwjUFzEKKXAjCwjimQgS8GMLUi3nC5CUSwyz7f8EuNBHDmOr7wtX9e8InhwTDRsh9QsBOMcN05+jCpPYjw8ytQ8LO68PCHJ1NQr6fy8B6PhzDUFgAw/V2gMKwhCfDeB+nwj5lEcNqRILCV7xqwmu2rj5spMjC/ji2QqLI30E=", - "encoding": "base64", - "path": [ - "vx", - 47, - "data" - ] - }, - { - "data": "hb2DwnRSTEI7xIPBkR6zQpTSn0JAainD+buuwebjscKibpVCkVWov2POKkKACzBCpUSkwoAqmcJ+en/CUQeZwugyPcO701rCjC4jwxrQX0Iv7bxCxD4PwyoUxsK0HSbDBFMyw6B7EMNWyYpCXRizQkwijsLQg6FCp4VQwgCbn0Fwkfm/LjGdQqi988FNRtnC7uLBwRwiu8FuJAPDB9XAQug6lEGGd67ClY8lQv5MYUIuVerC65Ebw18hIsE471lBnCQ2wkIhTEJwZnTCrECOQgpLsMLaI5FCYBe3QoKOpcLQdLZCgEGYwnYfu0KCQbtBxO4rQgKNhMJFD6pCVJA5wvyFjkJgIrZCLEI+wuSnEMIO/kDC1NabQg6ZFsN98LPCDr+fwmZxWMLSNwfD5PEAwYoLDMNIoW3CajyGwrjvwEKKBKpClratwXA7nsIJoBJCJNK8wkZNx8LuMTjDqP42w/nVBMKQIo7CuPHrP4BXmcJCg13CiKd8Qg+69MCVW0JC3WU2QvwuL0J+AJjCnHhWwugYL8KY1CDDVYmqQphhPMDob0fDfomkQgq6TcLyIgPClVBcwrdXNsMAWALDnJhmwZyXgcDs5BDAjI9AwsAWDMFtRnpB8Lt1Qhhc10KYDW3BpFU7w2463sGu6xfDsu/KwSb1I8MIdTTDCkC8wtC1qkJGX33CBLbkwcIF7sGKZg7D0KlAQk7NQkEavC3DabiFQUawtME2yEhBXpH6wuGsTMJEdcPCQl6nwCguwsKyy7JCxheCQpwVc8EILoJCnO6MQhiyBUJqVfXAzHZjwqQ5N8LfWY9CEt+Pwqzj2cKYAYdBkSGmwtA+MsNen2tCDvAyw7LAkcI+EETCqSJqwYzyHMMnJgfCdvzQwD6nr8IbIXZCrsrywro0tEKCXU5BIefTQvAiYsFyHxfBTJa5wt38BUJ/oCfDOLcWw4P/j8JI3BnDeECVQla3EcOAEE/CyjEMw0wvuMKQIZTC3IaOQsxGM8IelvnCJNMfw2bEoMJh5wLDDpeGwtstMsN24lrCnD9lwUUc2sEIbv3CboA3QtExoEI=", - "encoding": "base64", - "path": [ - "vx", - 48, - "data" - ] - }, - { - "data": "G+eWwaO+8EJiRKJBD4q4QpJhtEIEpr/CMDRnQeywpMJYZrFCLhcBQnWUaUJEMIFCbFW4wtzmmMKUADHC0Gq4wVIJR8PI8mbCFt0Dw+RRjUFCpqNCTteDwqp0XMIYeDbDQnwRwwh0sMKqOaJCqhi9QkVCQMHwELFC6C0lwQiqOcKe0tZCtvC2QuyQ+0Boy5jBtvuWwoZjp0KT2XfCv9GGQtryD8Iu2aDC1uJpQvJmkEI8cwvDCknMwsf2G0KsyGtCUlRIwi8Uo0CwpYbCtNubQoC/hcLCfNlBULzCQhY9osK4OLVC//SRwhLyxkK2mIdCOpybQpXAocKjpLZCngjhwUppu0JMC7xCHOKNwgwajMKWEcTBACCyQuQ2G8N5nevBfHqKwpKDLsIYI6jCwvDYQZbfgsIQPY7CyoExwniqv0LY4xZDeEmLwmqBl8KMxGrBlpmuwh4kx8JahjPDBptCw+HWLcIqr4zCMe7eQtLUqMK8l53CG7eWQgA0V8JaTbPAhN2NQvYgg0JQQYzCsJD5wXKphMLEhRzD/JSwQghYxkFnnTnDqZinQiSDY8Dy3QzBNMAnwppzP8OA9JDC0Yo2Qkw8YMI0S+tBoOmdws/KAULc0GpC4CaXQurD1ELdw9lBTTFIw0jsR8IRhS3DNrWVQfb/F8NnahnDc9SQworSq0JaX5rCnKa8QYjLRMIkZJDCCd+bQnQZRkL2FUDD5+p9Ql6IX8JHSgbChQYrwn4x0UHuKpbBCM82Qrp7z8JAvJ5CZ0KxQWu5GUIQvKBCdqKiQgK7tMER8E5Cgu2SQPSVxcFC0J5CQKe+wkISfcKplQPCeHydwrQjKcMcHUlB8iQ+wyRGi8JnMIzCO/3vQciXJsM0Ke9BKHPBQU58icJJlARADNPlwsw8WUKklzZCEkj6QjomU0GwB9dCr/lBwai1fELvyzXDemosww0LkcJarirDQuOiQhr1ocKq46JAQAmZwutI18Io8R/C8B2rQqDJfMJBR0zCUL46w8NvosJbIo7CK1vLwQaFTsPmbAHC2z6SQQ2bNMIScRbDEw1Pwaax80I=", - "encoding": "base64", - "path": [ - "vx", - 49, - "data" - ] - }, - { - "data": "oWaeQvYko0I4K5NCCTl/QpUWlEJ1dIxCoj3PQmHFU0IAv6lCbvmZQiiZhkKKmkJC1DP1QTqqhEJbKEtCTIpMQjDOeUJGxLNC1hJrQoKzQkK7eYJC/JqPQiAZikLGrltCPoS3QuyRvEIJE5lCPZE2QqVUtULwzIVCCweGQqUwBEIgWV1CLr09QnSAi0LBcZRC/eabQhSDhkIwfGpCsWiBQpCOl0IcFG1CTl5AQjRGgULs9ihC/YKmQt9IgUI9GG1CJK+2QcItbkI/cZxC08uOQvUzjkLWM4VCAMiUQuz0MkJLqqZCmcagQmvMlkLQmztCEgovQtCkPEJrXI5C2wmLQth+7UEa8ZNCOHxCQpzpckLwmUBCDxqAQibltUI8dohCbvZMQoUsiEJeNMhBPMxgQmWjgELKIJhCMYCJQufIgkKbIGNCpqwxQqNZgEKj3bNCd71pQlMLc0JOG55Cw+iOQiIswEJhU5NCB0yfQu5CvELEGOZC0C8ZQu8XlEJoMh9CmBuBQg4DPULiDIxCD2uaQm7Kl0IG33VCEKFsQtw9eEIFA6FC/8N4QmgdSUIgd3ZCfmmvQqEG0UJ6p5JCtEqFQpKliUKpWahCYLaCQkCxEELZ1pdC5qmpQoGZAkJn2YdC4/CNQtKsokKryIdCLTm3QghIoUL9JMRCfAlqQh1gVEJ0EiFC6myFQqAMwEKQXGZCNCs4Qu574kFHrINCYO64QmZur0LXUshCo4yjQr3Jc0KM4YNC1ZqCQg/4k0JwGG1CRv6cQvBIkUJTap9C8bmFQlRxWEL091dC9sqMQQKC8UEicKpCEDslQlBkl0JKdoFCX53AQsveFULwGaRCRwYaQp9noELZnlJCmzCvQrKMokKTbWhC+q5ZQnXZRELpyWBCajfKQulpnEKSHqxCZM+JQu7kbUIJdmlCBLuBQn3nskJv44tCl0GVQuQCekLWdp9C9H9ZQuAOy0KNvLBC/oyKQv5UYkKHE+FC5uatQhIOr0JiL4xCjTuFQr7AgUJWZVRCurZkQpHGX0JevEtCwHqtQmIvtkKeBo1C6I1hQo6sT0I=", - "encoding": "base64", - "path": [ - "vy", - 0, - "data" - ] - }, - { - "data": "lJGyQltZXULCkj9CePmlQqTrMELq/JJCPtCTQrwkyEFebolC6J9QQvwmO0I0DqxB+N9EQjK9DEJQgl1CFFpKQng0V0IpYqFCUqGBQtojWkKb9YhC82lLQuhlqEJY7IlC9N6UQgy+mULUxklC8sOKQgzccULkIK1CNqCNQic/l0FxT0dC3v4LQkCvYELinoRC2k/AQubdq0Iep1hCNORPQqGsaEJga3ZC6oSJQtB8iUI2VSxCpHS+QiT3g0IkrTJCH+QBQjinjULQVJBC7jODQqxoV0JSkalCaAOPQsjaQUJ7CaxCKHmAQuerg0LOD2tCA/AlQqAiJELsBr5CQJBWQuMVVUEivINC845sQgg5qUJenZtBlgOSQrqfs0LG4lNCMH0fQg/aU0Im0ipCJu0UQh8ih0JGFHxCHiSIQlaoM0I5vUhCBkRZQuJkmUI6wohCGq9HQvAiPkK+XL9CUbaKQiLWkEJjEaxCdL2RQojkn0Lez75CeAS5QTCaoEKw62lCbclzQrRIJkL405xCZHmWQprWp0LAuBRChJuHQq4VjEIQtn9C5NdoQhmcsUH9iRBCNOmkQtIopkJCZolC/GuzQk7TrUKA+E5CFVaSQjh7sUEUlkJCQmTQQrI5C0K4yyNCcttpQgfifULyfKZCsjqJQgyuoELGBJpCc9BvQrjGVELYunxCBgxwQryX3kLMI4BCog5xQvGvK0IcdIlCSCCDQuyIq0JcKMNCcqyFQqXsD0JBSaBCnpCgQgLIYUK8vptCpuWGQvSdwEJgVcNCeJtCQk71gUIwF4pCKrIfQtMDLUI0crdCnCnSQbqWsEJsGJRC3q2mQtL1vEGRzHJCoA31Qd/OeELmFg9CPeiFQvjXhEICcJdCHFVaQhe3aEJACmVCSm/YQvLwf0KOetBCc655Qq2/JULxIoZCSFFnQiXEhkLmlKRCVX6MQkY7ikLHFIBC9m1MQlonyUL1s6tCnNZaQm0HO0ISqdlC5wnGQlCCfUIG2K5C6n9jQk1WgkJOnSZCMKFzQmSfLELgYFJC1rKcQjKJhUKYaJRCAEgjQpROO0I=", - "encoding": "base64", - "path": [ - "vy", - 1, - "data" - ] - }, - { - "data": "AiaJQsJiCkIiFx1B1rXOQqqM70EuQ4JCNoYmQgDOMEFDrQhCTNaeQSinDEIylsVBbuZxQh5Fy0FSNVNC6K1yQiiuL0KRiXpCOhB7QvEcjkIQvXtCvoSyQay5tUISY55CAodZQn7BLUI9GhVBJDy1QtQbxUFmpZdC8HeCQsk/+0GnpS1CTDNdQk/4IkLggkdCwN6/QqptrULgRUlCGhBCQlfSJkJAuGxCRDqpQpMGjULQSShCnrbAQgKgeEKFfL5BAkMXQjbJikKsdjdCqQlUQuZRD0LrSZtCu6ZUQt5lh0JPNEhC0mgpQtWjLELujYVCROtuQs4rTULuZZpCNrnCQalMCEJyVUBCOHGeQgXPzkLeKZpBCoKGQngmnUI+VN5BebsvQuVB/UFL/V1CSU4mQs9OgUIgU/xB/IlsQp43sEEwoUpCvABtQuRHlEJaBg1CQLM8QvppLEKJPK1CPil5QowWLUIMG55CwnBhQiATU0LAEnhCUFA7QqS9hEI2K6NCDNJmQggXJEJ2N4RCMk1kQj31gkJxUWxBc8WMQmCviUIqqypCcddtQvYj9ECWjt9BX7OEQhD1Z0Jq/FhCJWm7QoLlxUKUtRdBXv6XQqwZJ0KKTa1Bh8y/Qv7/XUJxWdpB0C0wQvY0MELqWZ9CNps3QmdmhUIq0kdCuG1rQr+2iELqIKtCCrRTQpRLpEIoIn5C3muhQl9BTUKYioZC2HwTQqGTSEIw75hCbuYVQpBniUEXPqNCChusQiraGkLEaJ5CZH4qQv5+zEKX86JCOfkuQtyOkULwzJdCcu1SQiXsPUJwr2lCESfoQSkxt0INIY5CFiU5Qqy5FULFtQ1CYQQdQi4fOEK2eLBBHmc0QsKiTkJMapZCmZRSQty7gUJIinNCd1CkQiJHOELmEbpCI51KQhIlkUFSr4JC6HZLQqAeJ0KcPaxC6phKQtfdgkLMLk9CQF6GQmWrgEIgfENCU0z+QdCoLEKUj5FC2CbMQgKcHkKCrtFCiNcpQlc0ckJuGxRCbC1iQkzVzkF1Q0BCFIJmQnp8D0IILIZCvtREQrZlGkI=", - "encoding": "base64", - "path": [ - "vy", - 2, - "data" - ] - }, - { - "data": "6E4RQvw+sEGMyxZA9FeHQtZ7OUJHXUdCVQAEQbpyxkGNKdNBZTiKQero30HT++xB5KBxQka6NUIm7CRCeI91QhAfAELO6AhCGHJLQmakk0JI4yNCADE3vxhPl0Jucp5C2af4QVaXTUGuXwRBdCySQhpzUsDaMQVCckFEQtatI0KYXwRC0ZRwQlq9wkFS+ZtBas6RQsZBiEL3uVxCUptJQpk7KEKt50xCfka9Qs4xTUJqYxdCpttvQsC0TEL7yIpAzIoCQpSpM0L30e1BUW8ZQtSRzkEwxw5Cb+YAQoyffkL2sZlBPnKJQX7P+EEeIoVCrjmBQjb4LELgv91BpTcRQSC1JUIIfwxC4aeTQsJ0fUJgicBBonwaQjbJbEID5EFBxtgjQkbaNECco3BCfk9BQihGYELWg0FB8DkqQsZY20G0MSNCilZnQq6yJ0JM+3xAGOYcQsjoFkIm2kZC3+JJQhisiEAOEmVC5MXwQTzmZ0H8n79BAB9pQqqhGUJIBotCLrs4Qq8aK0LQfglC/pTrQXf620GlE9dBiUtAQkticEJJYZVBQplGQijqx0EcprdBvnwWQhLB5kGdE/RBfZ+LQqr3sUIJzmNBPppyQrNlN0IEjsZA6zp+QitufEK76aFB5BbZQeR+rkGSnV9CaM69Qdad9EFUSJhBT4JfQlBNZkLaiahC19IrQjDvNkLNV1RC/H6aQkioWUIRoF5CIuKOQJT4PEH7byxCUGOxQfz94kEQUD9Cbm6UQmwTA0ISNipCqtAFQnYcZUJGxxFC0Fg/QoabTULUfpdCZEBnQqzrKkKkFoZB1mAvQv5po0L0uCNCQM0aQRsUPkK0bhRCDYYhQsZvyUE6b/ZB1PiSQf4xDUI1GldCQI85Qu6EgEKgm1NC6N1JQnjP50Hq+G5CR2kGQkT4gMAWSU9CHiQfQrbISUFGY55Cm4IJQoS5RUKwcRZCnPRjQsS+EUKO1rBBkBvNQDCCRULtuA1CKsqgQsogs0FREqxCrTTLQX7jL0JUoRxC3P8nQihZnEDQYgxC4mi7QS0HB8GTpStCR0xxQgqM20E=", - "encoding": "base64", - "path": [ - "vy", - 3, - "data" - ] - }, - { - "data": "Zg/EwHkk0UB5kt9AosCoQaX/MEK2vspBatQcwSnvqUFlp8VB3uNPQXE0s0Hig9VBZHg7QtX4OULOymtBVtjTQe4ybEE+eHHBok7UQcrwIUJuKypBAg8kv4bWD0K07WhCvJ4gQC5dsL+0fEBBPnGUQVrdTEDwwQbB56mJQeZFJ0Jm1EVBixQQQjrBRECEvNfAsvEAQrJe+kHktglCUq/0QTT56kFCnAlC9ms8Qlm1h0FDb+BB1Aw7QSy810Fy5OdAAvpjQZnMt0CZ5ppBThSJQXZ6rEF48bY+vOEXQT/bCUKYkkRBBEC4wPzMdkHzLjRCdYcXQsCBpUFFmUbBDuI2QAI7FELw4qNBof3fQZQCIEHYQXxBfkbKQL7G9UHvYutA7F2tQUNlBsGlKlpCLo1DQr7+4UHeREdAWclpQW8isUFu8qNBA2MzQlsUOT/aYYLBRIKUQRxww0GajkJBer4CQmxJHsKmyrVBdEJVwMDtr8HIk83BChNFQvU4gkA9x4BBc6KeQTp2KUJ1uHxAVCOlQAbDUz9JX8RBZJUIQaKlIUKYbebAjKKWQQQHyEEghedAcuwuwSCAu8BMZCxBHALMQX6fE0LIpalBAT/kQWHVCkLqm9O/Hj6SQSfCQEJtc21B8m6sQNfYdcDccKJBWMIHwGg6+r7lemLBrFrkQfYscUH2mwBCvqa6QYTJEL8ue61BBDQcQuTaWELzWfpBZJGzwcpkZUA7oqfAkZSeQJmszUEDat1AmjkNQqwSwEHCGndA2hfJQYaozUCSMDrBosAHQiDz+EBW/klCPghoQpc00UGUyxfABFj+QVegS0LU+JxASPSAQJFnM0J0dgRCSDr/QcPE1MDZ8NlBpJt/wS62ZEG8HiNBCin8QXQ0D0LGdPVBqZv1QJZsWEH0A51Bjg4gQch+JsFiAbZBgFe3QTdymcFwgm1CWuR1QUknbkG+PItBEnZlQeKQH0E4Qo9AuqtIQGtHHkKMsDbBFG0NQhLMxkDK+jBChf+wQIHYdUGGWvNBmPoeQYCaLMHEsgJBVso0warn4MEcvlVB2VkVQoiiSUE=", - "encoding": "base64", - "path": [ - "vy", - 4, - "data" - ] - }, - { - "data": "pN8JwgJhlMH2uC7A6F8HwgSK8MAgA1nBZhx9wcSmP8BIjahACstqP2oLNkGbm4xBkq0JQPSqrkDPrRXCxDDjwQEdScHCvYXCqLNWwVBNLsFZcK3BfnpjwXiDrMEu3KtBBof/wYp5KMEe411Am3oswtkYrsC1+NbBrg4QwkQHrkEb4N3B9PTGwTyJ4MFBKuTB3+i9wRqjt8FK2BNA0nBpwf4kTcEumDw/AwRVwSIN+MGUzg1Bj8XnwTDrosHOpxTB5JW1wfqX/8E5S+6/kulswQDXScFkfeDBmBShwVLokMHY/lo/hK6awbxbFsFO9jrBgG2JwdXEtsFcYrfBpNqQwfIuiUH+wjPBcBIKwqk6QsJnsAXBlIW9wYzw7MAgdkjBdGKIwUiZCMKwc+hBrJ8vPjDoOcHfZ2DBEC3Jwe4OD0HEtTnBSqVWQR7JCsJeoxPCptOWwThSBj9/f/rBHkYHQXqCPMKyDMjBcrE7woh3McKz51LCGgVSwBqi8cGk0DnCEc62wVgQQEESSbPBenHRwQ4Zr8GmxgdB1MQDwqgMI0DgfgnCGOXewZREOkE13tjBWp9XwpbyLMKti2rBYKMNwq4htME8mTRBpuurwRR/o0Ayl6nBXooYwljotUDHI+1ACGe4wWFYqsHXlvnBWLkIwvKsz8HkHjfCMZapwdCTDMKtG93B/dgwwZjUe8J+KIbB1DGnwTizyUGhfqK/yJXpwepnisCcBIfCb+aeweEXnD92HRXCPH/UwUYLEcGir/jByNrHwERMRcLspy/CZChZwQpIEMLDqgTB4qrPQVBp4MB4YmjBsP2mP3CnF8DkpeXBn3alwAYnlEGwzHLADKc3QRpAZMISvfLAnLdYwiQ7Y8H4OQvCcA/TPndMrsFP/BfB0P9LwsYJZcHeTAPC48zLwVxfzcFGsrzB6Fwvvvr5R8LEFOBBkIldwVKAGsI0CETBiqcTwpNsmMFSyYjAQOlmwWS5esAqdYPCNMuowcIVLsHYi6rAtd6SwViWvcFdTqpAIHtVwil51cG62yTCyrPuwUMUFsLIYKrBJISawShd8sA=", - "encoding": "base64", - "path": [ - "vy", - 5, - "data" - ] - }, - { - "data": "BnxrwjSLWsKRab3BKOPFwih2osIiHZLCu7oYwi66UMKMsWjCHGacwarjKsK1ZJjBOleVwugAj8IUOsbCwBaqwiAvXcK86N7CsMOCwp6kmcK63GbC6KETwsJ2vsKCILbBsJOQwul+A8JZMmnBIn7JwtR32cG89DDCmkq/wqqUBMJCfLbCoDWswuD6h8Lyd1TCNJC6wn0NtMIMYxLCGlqkwv4GksLppX7CIu6hwiTEqsKZPczBogyQwvInhsJAJBfCJMx9wooIicLafFPCVj9lwn7mjcIbAl/CbIQ/wlx/qMLF5TzC8nlfwspFN8LQkIzCPLu2wsGsscKi8hzC/VpPwnD/C8I+QnPCdlfTwnzev8JFWT7CUsVgwrRcYcIXmDfCIMp+wsJyscKmt7jBMliPwtfZZcK27gbCABGfwlaHBsLr02HCCwIdwvRBeMKuEHnC3BB4wuSCSsLoNKXCFiCvwa6bhsJPNbbC0PXhwiOXfMLa1ovCe9ecwtDRacI2v7TCHgqIwiCRIsL8SFDCXKdtwuxDTMIyy9rB6AN9wu55YcKkgnnCJGaKwjJrp8G4GJ/ChIHFwoFPoMKAXT3CFFjFwgSdvcKapujBn2C0wsdVUsLXk3fCxsPFwtjJeMJkI5TBq7xqwqb2d8JUg7zC70lrwnU9ZsLQMJjCVp6owlEvkcK23cTCB0lsws5UzMJzP3jCWFW/wv6rKMKi+BbClDFBwkwWCcLMTcTChGJGwlp5P8KCeo3CJwq3wgShgMJaPnfC8FeFwm+Mv8JK84PCifWSwkorj8KyqHLC1/4wwpxvUsKvhhLCDqIowrYAjcKeKnzCY7oKwsCeNMJ0KpXCAAmuweA/3sLDgovCPIauwu5CVcLwwZDC8B9ewtSarML+B5TCLmDmwsJ3W8KQVs3Cf4SnwoPeZMIwoqTCynLpwYstpcJUiEXBvEtlwiitpsICE13CyaSRwqiIRsKSiBfCim0mwvbijsKuYrjCkBy0wsfkD8I+Kn7CShAzwrByksLInxvCCHzkwt6SRcKi+L/CzExqwiGda8IennTCZ/exwvL9QsI=", - "encoding": "base64", - "path": [ - "vy", - 6, - "data" - ] - }, - { - "data": "MAWnwmYpqMKia4LC91IEw4NY+cKUNQTDs8qRwsqyuMJG+uzC0KSTwlC8wMJJYa7C7TAFw/Z9/MIkwtvCLEXWwsApw8JTjgPDrPfXwv+6EMNyEcHCoB1twswnGMOnwILCwJrcwgE6lMIGx5DCjDfcwtpAhcJq0KHC9JnnwtaYvsJit/HCGRrqwgabp8JYTZDChBgdwwggDcPE6ZXCxy3pwsLr2cKSV/zCZNENwz+7ycKCCY/CVCPbwtQtwMLN04fCok2bwvCxosLDONPCWjnMwsoG5cJTvK3CQiGswplK+sKWieLCkEO/wvyYvcK20djCDrr3wqB+9cIb9aPCKpyewqjiwMJcQNjC6A32wmfh0MJ6mZvCULu3wrDX2cKkCJzCcme5wtyJ68L0c53CAQEGwyvpzMIRZHzCEmz7wqQExsJUv87CciXNwvKvncKM+ZDCzhawwuJR3sK7xuzCDXBcwgp3ncL1JQjDnvwNw4fMjsJEYZ3CgUsBw1KYuMK8lLzCvrvDwuS3ssK/tLLCE7SYwvzUs8I8MqPCxuOuwqw89MK+WqvCJD+/wh42qcJZC8rCMi35wlJJ1sIzvKDCiEQDwx9mGMOSNcXCJJMEw/pv2MJY6b7COiIIwyy3AcO4lIXCjPq1wsSx2MLgnPnCzo6Ywu78rcLas8TCIB79wsrLusIo3AvDnL/Jwo2m18IsndLC7v4Lw9LhxMK3YIvCCKeEwsjZu8JqnNjCDnOEwt5nvsJlp7PCfkP/wjms0sJ4erXCBL3lwmzV3MK2J43CBPzpwoRqpMKSqsvC9hbDwojPqMK8sKvC4q/AwtPoAMMfQbjCjvu6wjK/38ItBPTCALdmwtKQ7MIIdN3CRza+wp5+wMKwScLCz3ftwnQK/8K4av3ClGL8wlHNs8Ig+hPDyIH9wtalqMJ3qvTC3iVywny0zMKUll3C4h/KwmNxv8L7Z8nCOOCpwig8mcIlpKTCsGaKwr5c+MLI38TCZksXwyJqp8Igk/PCKPaFwlaX18JVnLrCkPLmwiNAhMJssNLCl86iwuB6icLbZbrCxtXrwvz6w8I=", - "encoding": "base64", - "path": [ - "vy", - 7, - "data" - ] - }, - { - "data": "AZPAwqbjrsJcd8TCBCncwt5B18J0IwfDG5LUwrxyv8KFTf7CGNnMwny99sKudOzC4owDwyo8A8MWGsHCYPzIwmSy2sJaUd/CpCDwwgTUEMPm7OLCfluPwjJYFsNYX7zCYVP6wpMayMICMtHC1v29wiWkyMLWmt7CDGHSwiqeAsMUVNbCaMW/wqJqqML4j5zCrvcVw8pgDMP0wsXCX13ZwiBk2MJbdgbDoxUXw17HqsKgLM/C1hTtwswWz8JwNafCTEqRwqAztcL2ygDDSNXuwjnC5MIMm83CHPvawrA+68JMdgPDPMvJwhZY7cIl6+zC/W/twvS+5MLwEevCqJWkwsjW7ML6kujClnjTwtZ8ucL2vKHCWn3dwrrRCcPmd8PC6US4wsoPzsLkstzCInYBw74E9cLGObPCd/3ywoYe+cIseOLCSpMCw6VsvsKFMYHCsvi6wjfb+sJ2d9/CY0qiwtx7icKCBAPD1PzrwnQfhcK1FYbCREzywszazMI1Gp3CYWvRwv+E5MLameLC0eKvwogLzcLgCt3CerPHwlp4FMO4G77CV2rMwqFM2sLQsLTCH9/XwvQU38LujsHCL8sBwyxZEcMYKQXD2L7zwnVQ7sIpR7XCUqUCwxDTFMNKz7zC4NbLwhqF3cK46/XC7XupwmxTwcJqPsrCqGL0wlhjvcKaw+jCBbzmwuC9ssK5W/zCP1wEw9Rk/cLXvrDCDuGUwkpZAsOEIrLC2JuiwluB1cIepLzCSvUAw5Qd3MI2YMzCF/7hwr2mv8JXoqDCAJXewjvXscK2fu7CdJLywvD6rcI/qOvCeLUCw279DsPe3sLC2s/wwlZABcNEptjCaPqewpwnyMKcTt3C8MGWwhJM5sLHicnCaiwGw2Iq8sI4HPnCxovcwh7i3MLUagLDuEXzwjvpoMJIoOvCspSmwqCyqcLO47DCSt3jwkZ1ssK8lerCDii3wmgCt8KVMtTC+IekwqwJ+8LAdKrCBJAYwzbH7sL6gBfDpLqbwvnNwsL20P3C2LPDwn4QjsKY/rbCUCipwmDcaMLfns3C9JbKwpF3zMI=", - "encoding": "base64", - "path": [ - "vy", - 8, - "data" - ] - }, - { - "data": "zC/JwubNmsKALNPCuH+owqoYnMIEHu/CoYrmwp3nqsK+0szCe1HawglcAMNWHgPDsCjAws6h3MJmNpfCXNenwhzazcJZIKvCUtbhwvs338J2pdXCCBSTwoTu+MLRadPCwlnqwhLw0cId2OPC/ICTwhYr2MIAv/XCOoanwqCiBMN61aXCED6MwvZHnsLCQpPCyub1wlAe6MIQc8/CdIurwoLXt8Iy1ebCKXnqwor4mMKkftrCYJ3SwrXUwcLoNqnCud91wifIyMJsbufCvU7Xwm78wcIQ+dfCpM3nwlhsr8KOatHCVv60woVH6MKfFd3CpfHBwkx8t8IjsvvCGsGVwp6M6MKW4cTCDhKVwjqgl8LyJpPC0mTbwkJnC8OKnMTCnEmswuzdoMKSTO3CHN/Kwpgb+sI8PrrCnGPGwgh5+8L5qsTCdpT4wsBl0MJQ9nzCu3SzwsWR4MIzx8XCmHW9wpsTZsKnF9nCO0CswoaSfsJlkZjCmD6rwiC0v8K03J3CXNrFwlQA7sJnCOHCkuWmwkSvwcLLkuTCQMjIwpF5BcPrSLTCDmfEwp/V28K1F4/CIPekwnL2ycLSFMnCvinewnSk58LOXAHDRcTHwsT03cJ4uZPCvnjLwq6l8sIA78zC2KvAwqATwsKw4NrC1jmkwj5ZzsIG2bPCrrvGwmySwMI6bKrCGvPdwjircsJaBOjC9k3TwnQdBcNEBLvCPhqWwtkR+8IOm3DCie2jwtwFxMJdGrLCUgbjwlrqw8Jgn9LCmCG5whbfncK+3bXCTpuvwvnLx8LeoebCXMv0wjyum8I3IvbCNKn6wusB/8I2NcfCLj/vwjyt/8IVnKLCPQeqwmb5lsKkWbvCJMhNwtbx4cKYXbrC+gfzwhaKxMKZNdPCS/KowhbX3cKMmtbC8uDNwvzQhMIvLr/CUpC0wmIIccKuAdTCZP/UwhWLlMJz4+LCG6zKwq66uMJI6ODCgP2nwppS0MLUGIXCoI74wtc9/8KazxfDhoacwnQJncIa1QjDoMmSwqDsh8KLPY3C3UOxwoIecMI6T8TC3EGYwkYMrsI=", - "encoding": "base64", - "path": [ - "vy", - 9, - "data" - ] - }, - { - "data": "D3G3wh2nbsKnBcnCpn96wpexgsKUDMvCKFDSwi6sisJ89pTChOzSwjQA1cKskvnCrBeFwgm/nsKEm0bCcZKKwgzntsLq82nC/GvEwii/nsKidq3CBOKKwqLgssLAc9PCCLDJwmr6xMICXOHCX51zwtQuzMJGdMzCUqtewkuy38IE8VXCjAeBwnJBi8KbgYDCGom3wpYGo8LwHcTCDl2DwnRbmsLo7K/C3AqqwvqPicI87svC8mWmwlu1p8I+M6PC4HtAwky4ysJUF7HCavKswnFvkcIMqMTCmDjKwsRXgcJGNI/CnoySwt+ivcLAa7zCkNOOwjaKdsJTIMfCGH11wiAHzcJZApvCXDZLwr6FgMIgOHHCq2K2wlYO/8JrYLHCdkKMwraSW8KYeOfCqP2RwrFg08LK66nCqx2OwkgiysLqqY/CtjvPwh3YxsLxzHHCXAuUwvabrcJ+HanCTcG+wqB7ScJT7aTCjvBMwmRSZcKO/JnCxJh2wsCbqsIk3qLCQ06wwoam6MJVcL3CRPaJwuYspsKke9TCccq9wuSz1sKQn5zC6L6uwrRrycK62ULC7LVcwpGtq8K5Xc3CmHCswpQ8q8ImJ73CYACXwrYEv8LOpVDC/c2NwqgxrsLiVMrCwiiqwspom8LeTrrCBWqUwp76usIOkpXCvsOPwprPtcIgiGLChiTCwmq5ScKyacTC6xSYwmLQ+MKcW7TCptmOwlCVusKxQTPCCJCXwrRQnMKyQ57C7hu3wrK8nsJS+rbCHOKQwtXBgsLsDb3CiTOLwsBoycIIX8zCCpjgwiSEeMK0KsnCaqLPwuh0xcLlULfCwDrIwuAV48KK/IbCrsCkwswGPsKCJ3nCzaYHwrC2zcIunaPCaP3Mwpy+jsIjwajClnJnwniCvcKqgKXCRlKfwkitRMIapoXCxA6swoItSMIiktrCsU68wkqaVsLYUsjCkv3HwkbRqMJOj9fC1mGiwjjKncKeGEDCLlu7wtbezcJi9/fC0imRwkLPh8JiEfLChr8uwuixdcL/NjXC6HmkwhdxcsL2WrDC/CKFwj6MfMI=", - "encoding": "base64", - "path": [ - "vy", - 10, - "data" - ] - }, - { - "data": "DNuXwunnCsJgta7CCdw2whYKc8I4YKTCosKuwvBkPcLS8zzCD6m6wrIDlcK27rfC9k4nwkliN8K2qpHB9jxxwopvm8IELfXBiJugwmzePcJxl3TC7tR1wnG7PcKcpcbCNRujwqcrq8IrtsbCLBNmwoVtscJ/sYrChqukwS5FpsJuCpXBjaluwpmyYsJ4tVLCNthpwmbKGcKA7K3Cl1BWwmW4dcJMPGLCY/dcwhL7acJmXLTCei+BwqQhhsJ6tZXCcHoDwizUpsKugmzCcCV7wnbWLMLs95LCdF6Tws4FGcIZMTXCejxKwu69hMJmjpDCRvFCwpCGAMLk0H3CZccmwhJPoMLq1GfC6vUfwhbRb8LqpSHCNoh+wsby1MIZVpbCMuA4wghO1MGlcNHC7BUywmTUqcIqW4nCa/YawqpDjsJ9CxHCLy2awvqjocIaYFHCE31Owm6ObcJjd4rCGAmxwpwBKMKQNVzCOpNJwRSoPcI2mYLCWJc4wkqiksIW0JTCDo+Mwii3xMKYyojCDj0/wp7WfsKa3rjCFrOawr5kosKu/H/Cbj+NwmbUq8Iwpa7BdVTTwSxzisKw5LXCOhFtws6IWsLEgHLC5M5DwiL0l8ISJ9DBUsYywhtjYcKf5rrCdRaPwj+qW8LEEJjCsVF8wuB8nMKnzWrCzlchwuU/lMKxXBjC2N2bwtBtNcIOEZ7Cnq5DwiKgt8I8eaTCvnp9wrZNbMIIWxrCHOGDwmJ5RcJYDITC94SEwkxAZMKwVonCipZjwr9JTsKkM7fCtEBqwuTWpsI8e6LCOhu7wkS1H8JgUIbC2PuZwnOTcMIAYJPCEJKEwoE4v8LEn3HC3NeWwnIFhsFQ8xzCILR0waxxrcLsqYXCcDihwtDVIcLA8XDCEKwBwsprkMICUmXC7Cdewl0M6sGKYgHCjHSZwizDHMJeJdHCNr+fwhpL4cG/A6jCQqqfwiJXkMKWVbjC9F+QwjwIUMIRgeHBvot8wrNdjsJT47rCItt/whh0VsL48cfCAVTywGxkVMLKTHLBc5yLwqloT8JVn5fC3qtuworA/8E=", - "encoding": "base64", - "path": [ - "vy", - 11, - "data" - ] - }, - { - "data": "hcJcwhIs075SOYfCRrj+wT4fT8LS7nbC2/KDwgS7jsEboODBzxCNwrJyLcIU7GnCPMeOwXL8jMEQ/q5BBH1Jwq30ecLwe72/Ea5ywlyedcEgfArC7K5KwnBVSkDQVbHCDAl0wpGticIVKoXCDg89wsTHjcJMZAXCsRPIQV4KSMLIm8ZBpsdQwrQCIsIFWh7CbFa3we4Yc0ECFpDCYrAZwj4CLsKuqaDByzTVwdACNcL5mJjCZKc5wgSYPcIEAHnCkaM4wTULUsKDvdrBvUkUwrZizcDcHS3CNDEzwvHcs8Dc8+rB9EqrwVqwGsI6/i7CrOfjwZi84L/IstPB+oxswWQDPcJ8GxjCza7iwRygRMJD3EbBKNEHwts0p8KC7mzCAcxkwSzEwkBAe67CGpGbwfDFf8KfoDTCuuCEv4sDKMI4dyJBOrA7wvhgRMK3wRzCFJm9wf6+9sGPNlTCMCabwqb76MFbq9LBv5ICQsQTCcK5QTfC2+v7weiVUMLEWnbCZVdCwiWdh8K9ZRDCDyqhwXcRHsJJDJfC3DlLwqlCVsJYDELCRF4/wutVhsKfJzRBbCqcQCPoT8KUDJHCVqgDwjS8qsFeePXBrM+gwTRlVcKQm81AMga0waIS2sGr4ZzCeAhjwvjn58GQwmnC/Z5FwlZNdcJYEyjCu9QGwDR+PcLi7evBkBBfwnbM/cHE2mvC3bTIwXgEfMKwiY7CwopMwq+GxsHmyNnBblFWwgx0HcHGjknCt7QbwqFL/8FLuibCp68tws7+EcK87IvCNJ0zwnTaTsLszVLC2smFwoJjF8E0IA/Cty08wggXIsHyizfCVTrswR0Gl8IXIE7CJVqDwhegk0FyBFzB0r7bQMC8icInvkPCEhFhwo7oYcCuawLCiejiwEQcN8KijfbBjCD4wcEUscBmsiJB/pOAwgju18Fah73CxN2AwpAmrkCIuIXCDqM+wp5DZcLiAIzC7CdrwhlGwMEkNLjA79UAwpwmGMKbVoXCPF9WwlDMDMJee5rC9y4eQopOLsJO9bZBl6JTwkRtEMJKZHjC3DhAwngWDEE=", - "encoding": "base64", - "path": [ - "vy", - 12, - "data" - ] - }, - { - "data": "GMrswZhhS0IO8SbCTAWdwRSFDMLtwx/CLCsnwvSUukHKamfBMi8Vws5AQMH5t7jBt1wDQRKqiEBuUZ5CJlT8wa6BN8IbivFBnlsewoJuUEGccQnBSlMWwoIPhkIFZpXCFzMfwsmARcKq3ufBmGPfwWWOR8KSvMdA+vSzQrLRRMF8xapCVKYjwq6GpcHUfMjBhG5+QZfoqUJgYFfCnIGfwYACs8GeZ4NBhozVP0B168F17nPCW0TewSa5xsHIgzPCXH+ZQUwEesFQZ3BArPUCwXiQK0KQJy/BoIBZwSSKEkJU5pDB2LCJQfJiH8FuXTvBFgL9wPTyC0Jajf9AJRK4QUVvB8Fwy5DBaHROwYgh4MH1PORBnPeawFhHcMJyryTC9AvmQdgsOkKy6YLCb+nCwLXNKMII41vBWl82QrZlKsHyGZJCaL1RwepkJsEysaLBY2omQRJcOr8AuA/CNLp/wm1XJcHU1pBAsGq2QoBzjMG6uJ3B4qB1wab2vsH4PhPCtkS/wa6cF8JwP8u9OoV/Qfu5IsHCtmHClkiZwaVjucEH0ADCgkSTwczmM8KpFmBCgmokQonoCMKn1E7CsNf8wCj8gUHuEi7AtiQ8QSzH3cE8s0hCuQWzvyiSFEDSkVzC8hkkwoiEhT+NQyHCiPEEwhYFLcL0tcXBtq8/QkoFYcGmMYrBQMb5wUvCPcEBaxfC7FwjwNBFDMJxvGfCIboMwnrszkDqeSfBNxocwhZXPUI+7gHC9I4qwQzYccCgQjbB4pHBwQb2nsGxtQLCh3/WwRhyQMHnP9jBrugVwkyPCUIEGlzAIgddwf6IYkJwa0fBNHJEQFomVsIuywzCXBVXwpDFe0JkfJZB4EwJQjycSMKUFOXBusbowdQPLkJHY+a+eNmeQTvkbcHdmSXAfYuNwHefxEHuj4VCQpJDwhSaV8H4S6LCnt8/woyEWEIK1EPC66f0wMQsIcKjiTLChQMrwud6s0ByRqVBVCa1PfLqKsBQ2CLCKKwnwsMGQsFgSlPCAiXeQpMnBMJ8UplCGa/8wbhsUsFeez3CAuT+wYjig0I=", - "encoding": "base64", - "path": [ - "vy", - 13, - "data" - ] - }, - { - "data": "E1buPx4ZC0NlGxvBI61iwEPrkb/ns4LBsRVnwejqskJmKaxAyv7NP3I/p0HdWoFBvmYbQrCyyEFgIjBD2kESwGBq3cG0jIZCUvaGwWQP/UEqQIFB7mmywY6XGUN8+WbCWNuOwcVd28E9oC5BGqGovu1Pz8GQYQ5CnAY3Qzxw/EGENjdD6PlWwcDXc0DTNxDB+sNvQgobMUPC8wLCKs+oP+6w/UDW+xVCkjz0QRU9QME2QjHCLtgFwaqmnz9qN8DBgJiIQjhO1UHSxtlBdPW7QdyB7UKSfsBBGn+1QVzWvkKEKADAgjWTQhgptEFAvo1B9gBnQdj6q0IGpO9BhLSkQlqDykHgdAxBKZvcQNyh9j9UAMRC/rWkQVJPDsJB2KXBCm20QmpO0EJ4XyHCVIMrQfAamcE6MuRBDhrbQnIUyEF2zBpDhh3MQbTI9EHA/MRAeNdSQkvM/EHg5IzB/I1Awh62hUEothpCzNw0Qxf5gUBG5FhB717uP6xWKkFxYcdAMD6IQFrV4sB3AfpBhOaCQhzI0UH++gzCIDeZQRb9N0EQznHBAkyXQZhRmcG0CwBDgoyuQsiwfcFlQ+jB+dWHQZrzdUK2s8tB2AhBQrwimz++Ve1CVUmmQfiiCEL19M/Bp4XCwY7wGkJEiKvBIHdjwbamv8EU39jA1C71QgIJrEGudaBAsN6CwPwTc0Hu7nTBH9+kQTofxsAIwCnCrvZ6wakp6EF+ckpBjFaxwW++CkOKlkPBOWCQQYMm4UFosaxBMt4hQGphrr9Huh1B3+CQP5SWAkIR6Im/mRznwIo10kLMpfdBCua/QcnYFUOQwrZB0MMBQlrV68F38QDAKIwfwtjyAEPgVoFCrGuOQmo79MGclb3A3V3mP8CC3EKgvRdCPphIQpSjpEFwIOFBOiLUQXTQhkJSRBdDv5L1wVKSzD8ge4DCOLXywTZ0B0M6UfHBocsGQtagqcG0wYTB72fFwdypGEK2JlZCQPELQr3KEEJd+WTBConowVM7h0GSbdHBElBdQ6aqq8GWMydDtL+bwOTsn0EIJP3BgJmjwAwxFUM=", - "encoding": "base64", - "path": [ - "vy", - 14, - "data" - ] - }, - { - "data": "ApckQmEqM0PKZudBGKDxQc50P0KUKx1BFKmJQXC4SUP8MghCOh84QvrcYkIManZChnWZQuWHREJ4glNDIlIaQpUC7sA6SOlCakr9QMN8UUJUgTRCQoaUwITTakPB7hbC6gqlQARcKcDa+WFCo0YWQlvuyD9fTmlCtrpIQ2D7qEJdaFJDfJcLQihWC0JYbgtBThvhQkKNW0MCxgzBo0DvQVwVQ0JjaHRCIvR1QnporEEUw9DBzi9DQXkw+kHA/Wc9VnggQ8JXkUKXu15CzbheQk6YWEMKmXRC+9yHQjDXKkM3IPFBQZEoQ/VldEJG8j9CWqkdQqqiMEMvjUlCTp8lQy7qaUKbdDRCOhQCQiJZKUIoMzJDUDc7QsZ0G8Ed1zBAN38lQy7nREPgJjvBAFMTQgQyvUD4I7JCv4RFQ8zrhkKk3zJD0IaOQqzFjEJ+cC1CiC/TQhjrh0IS6hNAHsDywdCYaUKn6ZVCEIlhQ7oOCEJ04GBCpEG1QbzfWEIcKVxCllEUQrrm0kF3jnJCjJkFQxStlEL9QzrB+j6FQgAWU0LmoTVAD093QvwHMEFGnD5DRhobQ8FiWECWtIbAO5YrQiaL8kLkfWJCdPq2QgVPCEK4Fi9D5iw2QhDyikLEK/1A89bMwBjFuELm876/1KsGQcxZRsD4tz5By1BbQyMlZULkvh9C593SQTscVUKiTBRBpp42Qpxjx0FJosXBIuHvQAxFR0IwyTZCCF8iwDNITEOsTixBHQJAQjmdgkIltVpCDaUiQoZknEFcr2pCAPMtQm+Pk0Iue9JBir3GQbJCLkMIFHVCGtqJQiF3YUN7mG5CQFlxQnJcM8AYtjtCYDm/wZIhVkMEexBDJHrvQjCXG8FOVpxB6JEXQmbmSENguapCZoGrQjFOcELaP3lCxtCCQrZCCkNKzVBD9C8fweT9lUEIaTDCdHszwQvyQkPc4CLB6OaGQvis5r1AYGtBaICQwMJjlkJGIMNCfVmUQm+/j0KNZFZBzdRvwcupV0JeDGNAQIpYQ9a+CsGPZkhDqojqQdLnj0JD8GvBRi4kQnpZL0M=", - "encoding": "base64", - "path": [ - "vy", - 15, - "data" - ] - }, - { - "data": "kKW1Qg2EEkMZd5ZC4MGkQoh+0UJYuh5C8FFcQoY8TUO4TqNCaCHFQvRwwkLfzehCRi74QvZEpkL+PipDoyS4Qk95eUEBiD1DXIMNQvo8q0Ka/KlC/eB9QfOrX0NYUmTBTaXtQchszUHmn95CmjG2QqziBkK9NbBCbQMhQ1SeFkNzyiJD6wq/QpxhlUKu2+JB5GgxQ7gsO0NQbZJBYi2mQnmkykKw47tCLrfDQu/qoEKlAr3A3W4JQj0ogkKJO99Be7MwQ9Kw5EK02MBCZrq7QmJNTENOM8hCSNXjQtilMUPGYK5C1w5OQ1M7z0IskqBCJYKHQkDwXENgqqJC/BQmQ+Y8vEKworpCuLWJQlFBxELg+CNDN7enQmoLkEFJFvRBXtUrQwnsQ0O1cKpBoMGTQvheB0IHpStDTppJQ8qw6kK00BNDtAEAQ1Q72kJ8WbxCPk0ZQ2sf3EIcnMNBlx8nwVoPBkPJyOtCnHIsQ/TfoULY0d9CfFiLQmRK30JMMeJCyJCYQuYBgUIVp8ZC/jMgQ97HEENiwXBBoiLmQq3r0EJIf65BtcnTQpRxO0KZzyBDhus7Q6qKvkGtL7tBEeiMQiQVTUNtI71CGG8MQ0ySj0LunxRD+A2VQlCC1kJUvj5CorlRQeyYO0Pmxp9B3OEPQvLgnkHFtfxBOwdOQ3zMwkL5mLRCHqF0Qmfo3ULC1hJC7AyTQqp5bkKgzI3AYksLQiPSpEKqJcJCvgCmQQX1NEOirhRCWzGgQvzf2kL9kL9C3lDCQoSqLkLOU+dCCQW/Qj4j20L0pV5C9DtuQvhvIUOoObxCkM/5QuTwV0O1ksdCTOW0Qjzf2kGErtlCZMStwFRWO0M+FldDHmzqQp4DS0EtPEFC1AGjQgtBR0OwTBBDwLH9QlIF2UIEWcpCnNPvQhYFGkPwIS5DSdpWQZ10G0IglqPB56IeQSSmKkMgOzdBcFLJQggyuEHoBklC6BaRQVZL60JaewlD+lzwQg43zUIWCy1CutL8PtpQykLAghZCFcYiQ3vDs0BCDSBDlMWUQhHeHUNwhmhAiEnIQmDmDkM=", - "encoding": "base64", - "path": [ - "vy", - 16, - "data" - ] - }, - { - "data": "ZlUWQ3buyUIgvwFDkicWQ57gJUN0FJZCmS/MQiAnIEOXdBlD0n8fQ9jDEEOofzRD0o0eQ63rCkMauOpCmHsZQwCFKkJ+RDRDb4WEQkfnAkMmJRFDjuIfQrZHJEM9EFZBf19hQv6QakI85DBDxt8hQ3SykEJd5QBDuCLXQjBwUkMEjNBCQV0rQ3Ox+kJaeEhC5AJUQyiq/EKsk0RC4MIdQ7dSJkPruQhDB2QPQ56mGkOebYdBqp1qQrSxykJcRXJC6NEPQ40TG0NCHxhDKmEKQyi5GUMasxlDHBscQ5bVDkNMIiND994pQ7ZlE0OkWOJC+NfGQrSBLUOOiQNDkHsDQwh6A0MYrBxDHhr+QnQOKkOcsfpCWowNQ0TJQELeF4FCw+MLQ25SEkPPf29C8AH9QqrWg0LKFj9DYqoYQwXcH0OpJ8FCsG8+Q+zTGkM81Q5DgXYWQ+A2GEM120ZCKq09QTaFMUNCQTZDGgnXQh7MEkNE6SVDHXIJQ6r+NEMm4zFDSMD2Qtzh20KwABhD+mQJQ2RQTEN8ZzdCZJIcQzo/K0MmAihCldEVQ592tEI6yOVCCjUSQ6p7N0Iz3FpC6PHGQmujXENQug5DYFYmQyZo5ULreNFCLNDbQmyyEEM8n71CdCgLQmQmYENjKi5CTeGMQg7kNkInxFFCqxcaQ6RbFkOQpRlDcl7KQlYiK0M3WIhCjxvRQofNxkIWOZdBFLOFQlo6CUOaKB9DlrBEQqJDBEOlrodCNKPjQgwFGkMEFBhDQhIoQw4bkEL+vC5DiPobQwzmFUMREa5Cr97BQuyW+EKuTglDxFk/Q54RJEP8zhhDipAHQ1I0eUKE8TBD1tCBQQDFCEMkvjNDizSxQoo6FUJeo6FCa5AHQ34HGEOy3DxD9tQNQ3alKUMQ4Q9D/g5IQ/eY8UJoqe5CFCYfQt2AfUIysepAymYHQrRAAUOihw1CTbsKQwYfQUKlBrZCoucvQtRMG0OmIPFCmvgtQyTBE0NHbphCFGyNQdLLFkOW/JtCRrzNQs7mrkFkL9xCsPMEQ0weM0OUw79BVdUsQzuiuUI=", - "encoding": "base64", - "path": [ - "vy", - 17, - "data" - ] - }, - { - "data": "+mA9Q/obSEKlXDJDWNFDQ7TzPUNOee1C2qggQ+yW10K6PT9DqINFQxipNEOHElVDl20LQwb4IUP4v3VCmp46Q51hl0LAjARDAkfKQvL8FEND/DhDtwaJQm1yt0JyEDlCwDqrQh3zwkLq7VJDYlo/Q81H70J3ohxDiR5DQgLLSkM0rCpCTj5YQyYbHEMEVJNCklEwQ8B/XEJLS6hCmIpEQ96pNkNa0BJD66ApQ8CDTkPC2y1C0CarQhwCBkOmNcZC3OLRQpgMHkMPbiZDoDwjQ9SZwEJlSjBDStUmQwIZx0Ldc0lDQHHxQp4SJENwgAtDtJ0BQ6yy9EKIPiZDknGyQlJEHEPLdTpDeq8hQ9gkPUNUTqFCzwE0Qzkdo0JeR9hChcfCQn60u0Lwk9JCdK4oQwbJz0KqYyFDQN6+QmMIJkOGbQ5CWGtDQxSrJEOEUBJDGDHxQjy4F0OS0p5CFvATQvSEF0N2ajVDrZQoQoDLGUO5eiZDpBc1Q20EQUNeQThDiHwmQ6xCJEOVECZDHEnHQumvM0OPbqRCEoMnQyIxYEP26H1CUTwkQyqgDUNidIRCxoTEQpz2i0L+w7VCTn/+QmrgLkOc9yhDzPEQQ8bpHUOU02NCkHMTQzMCFkMHxRNDtsZtQjCNMkOC/ItCpLLiQiU6l0IE+5RCjnLAQpDcLEO2ayxD+a0QQ9oaIkNGNtJCEq8GQ+TsEEOM+TdCuuXNQgexJkP7nR1De9GpQuY5lULNK85ChvgPQ5jIGEOIni5DPaRBQ89G0kKLDUVD0L0/Q6ijGEM7Au5CHrwGQyYNoEIuTB9DNtVLQ9yHwEKwCitDFrUfQzebz0L48TxDMJcoQsc+q0IyMgVDRBBoQjDegUKaSehCH9ZCQ8xtw0Lpzi1D+V/jQnbkNkPTZSlD7DhQQ5JLpELC7m1CXtKKQg6fu0JLiiBCfi93Qh6WpkLkIXpC/u8WQ5OvlkJMlghDIr+TQl6OEkN4rrBCDktAQzT8IUNyZ+JCJMkTQoj7GUNG3f5Cwo8hQvDPIkIA1GZCDLYzQ1gAF0NdwDtCFItHQ6ghDUI=", - "encoding": "base64", - "path": [ - "vy", - 18, - "data" - ] - }, - { - "data": "du01Q8gy5MCJ3zlDAKA1Q/LNHEOzbi1DaDZIQ3xHT0Jwuy9DCBE9Q9opJkMagTpDQDTPQizQC0Ma/Q5A0e4uQ78i7EJ6GK1CVOAKQzi6EENlYClDZCfKQiYLZ0HD8KpCeOLqQhnrDUO19zVD3mwoQxryKkOemBhDP51xwQ5pHUMUdbfB/Bc1Q4BpFEOVgMBCOlH3QkFptcGBR/RCxHAuQ6z9EUP+1vVCMiMYQzrJQkN8xJZCREblQhwpEEN65AtDDJ5/QieTAkPZAwhDZM4bQ/j4DEKGVBZDwtoPQ5yCU0KeWy1DJFSHQqZ+EkN/sQ1D8BoHQ01gj0KEwCNDyDYrQgp4EkO+Uh9DAPMZQ65gFkPj7/tBbhMoQw097ULf5CJD375GQiGuJEJW0hxDFsMmQ3ApFUNUg+pC5VQQQsnJC0P01wbCar0aQ0XrA0PcKvtC12+iQrIC4UKKHuZC/KGCQhN45kLVPwRDoq3EweIsAEMG5AdDdBozQ+xuGUOGfBFDp1goQ1FdQkMqVgdD4VVgQnTMBUPpS/tCwEoKQ0OZUkM2Y6tCJswPQ0rQNkNypHJBCJBMQmKhwEIAggRD8JwNQxoM9UIw5xtDlJPXQrovLUManr1AF1IOQ+b0AUPC9DFDaw+wQvQz/ELUeMhCarEWQ06h3UKprcFCkKANQtgnGUOOjxNDuKkoQ6xVAUOc4xND9IQLQ1hGNkNU25pCaFcDQ5ObG0PcCwJDUrQAQwuDHUEzEwpDDMQXQ/mu7kKxOBZDR2ofQ5fOBUNSviFDbzMqQ5A//EI4eA9DicwgQ/Mn90G9GBpDvA4dQ4oPn0F85w9DPzYJQzlUGUMmWBZD2I+TQlzXCEJCMKtCpx7XQTARwUJmIA9D0GBOQ7aJIkLgEwhDfKubQtWSFEMEgRpDst0pQ5zvJ0KEcpbAsO/KQhhr7UKcrJ1C3zO/QqyEB0JoVrxC+HIOQ2C6zEJE0CtDBDPYQtii3UJYOllCnHQaQ/9dCUNM6xlDPZ5qQvCZ90LilztDJrPSwSKPe0Lg2RVAXZsxQ5fT4kLJ4pJCRrUiQ9rb58E=", - "encoding": "base64", - "path": [ - "vy", - 19, - "data" - ] - }, - { - "data": "CtEbQ+44lcK08yZDNgwKQyId60K4cVNDp9E/Qy3jEsGM0QpDhBQfQ+kbCkOezAxDYJmCQtI80EJIuXvCAn8TQ1y9K0NtSCtCbkMlQ6++9EJIFwRDpSj6Qga/g8IacAJDTA4UQ/zCK0MQrgVDYp0AQ/AGPENjFwNDfYGtwn+DzELwrL/CeXoEQwA6AEMOqNVCNZGMQkIx0cI9dRdDhWkBQxlH0kLuxLVC2oX4QtfNFEOqm+ZCfkEKQyLSBEOMMBpDtPSgQbDb00JgRMRCWpICQxrr98GCduVCFsziQqaGLEAS9/1CiDIuQcDo6EKCrPhCt83rQgF7oEHKfAhD75YJwUOl7kIO0/BCZZX2Qs6a1UKlVL/BzlEFQ3R2HkMCnTlDeEhHwDrWUsFleT1DWOAPQwYGOkP8Q4dCxlrPwcOL00Iqkt7CwlzMQjQHt0KGdsFC97oWQnTcmUIubRpDQuDAQrzymELwZqVCsL66wkGnvUICUL1CdM4ZQ/iY1ULI5cxC8BkRQy8MMkNfKb1C/hoDQeXgqEIHUyxDRz/XQqC1K0OQv9NCCt3lQt7xNkPFVyHCXlWCQPyV9kJJnShDDRgBQ45zjEIs0AFDrDeFQoV4HUP810nCISjnQvnpzUK1VjBD5DvxQkQAk0JrdgZDHgkVQ41XFkO8YuZC1o3vwWQ79UJ8+tpCwOYgQ0CStUKwLTFDzv3rQjrhMkNiquBCfl0FQw6t9EI3acBC6C0aQ+UggcI0LRNDuEcGQ1gQnUJJ9+xC04zjQuAWA0MAMepCv68CQ+g5z0KAKg9DcjkgQ8bkwsEsoANDgUXJQlCpgMJKhN1CopDJQv42SUPWN9NC97ffQrTBmsHqSxJCd06zwOuHBEN5Ig9Drv4zQ4mZocEKz7dCTZwpQoT62EIpkPtC+jH9QlKqzb626JfCAMP/QozI20Jd5/VC6YIJQ0jBo8HwewNDhzX0QuB09EIZQy9D7AYLQ7HHjEIPd51BoAveQnTF00KsYjhDziClQnb9q0JGD11DwgLKwg3GsEJipmrCql0aQ7ppkEJAzdBCFn/nQvjcx8I=", - "encoding": "base64", - "path": [ - "vy", - 20, - "data" - ] - }, - { - "data": "Ucj4QifbHMP3DAlDe4m3QhsQokKGdkFDNn8hQ6ZInsI0KMBC50L0Quwc0EJfkL1CrWfZQU+afkLwLQfDTW/oQqPwQUMcUDm+kFYhQ0BlrkKYqrJCVyT3QqZZBsNQcylDz70cQ5OrKEPut65CPBWpQl5YLEOSkchCeaMcwzaZNEJk7yLDrFOtQqpI0EI8n8RC8yqRQf6oKMMsPBlDjQupQg4cgkKe7llCgEa8Qj7J0EKRvSVDOrYGQ/Sl3ULHiw1DtsfiwYi4l0K6kmtCCpnBQkj41MIwJ51CAs6jQi34UsLeaqBCLIhPwnIRp0IsT8RCFNK5QroBDMJgC8JCnvuHwsawr0IWIaNC/x2jQrbSdUJ0JLTCnFa5QiTrOkO9jCdDD+l7wuwYkMJXQT1DcCzkQpB0M0P0nGFBdNa5wnickEJW1yjDJvU/QnrXRUIgm4dCjckMwY7THUKI+yNDVmX9QgxqDkL/4w5CyKEXw04ta0KWbkdCdOLfQlH8bkIB0XdCqajkQlc3DkMATktCYgY0wpAPB0J1/TxDfmKaQpO2AENq4eRCHBClQvamH0M64dDCSEwzwiCiDEO8oyxDMg/OQj5QjkGUc8pCOWTJQXn+AEN4gObCSQuwQk1rkUIE0BpDHAcUQ/MkoUFw1SVD/MsAQ4eYJkNQ4edCvpzPwr7FrUIOToFC8isIQ2nfRUKs9SdDOES0Qo+DFUPa5w5D4mLsQqxon0Ky3G9CRpQQQ3IZFMPrzQRDTr3UQts1EUJ6TqZCCkKPQlLy3UJZbp9CZHK3QlAGlEIcx/ZCdHkMQwAAs8I0A8RCx140QtwoDcMIr5RCFfZwQvHETkPrk4VCEJgRQ7w0nMLbF3zB4TQkwjCwJUMQr/lC68gOQ0zCr8Ky4DRCm7f/QBwtjEKykr1C1LanQsp9PMJEMxjD41cDQ0Sls0K6GSRDxX00QwE9psIU2ilD0pW7QhEz9ELgoxtD+8wOQ2hV8kFIs4HBnjyVQkb5jEIOrDBDWmPTQnL/OUKyO05DNEksw0pl3kI+TAHD2RT5QlXd3EFdwApDlG6LQqh0GsM=", - "encoding": "base64", - "path": [ - "vy", - 21, - "data" - ] - }, - { - "data": "6G+3Qg7xVcOOyM1CpKk7Qm4ZNkLi5B1D7nX5QqhDIcOM9lNCIuWmQr5nikKAaVNCDhc0weuUnUF3E0TDbOWoQrNGLUPwVjHC2D8KQyzaO0J8TzhCuHLXQrKtOcPcqjBDfgoJQ5bUEUNuNjRCQsUfQtQQDkMEdXpCgYNMw34MS8E87VDD4tYsQpApnUK3xKFCMsEFwjF4TsOGsgdDCCcfQpMGxUGCEGVBXnWAQmDCeEL4ckVDcfTgQjZaqEIqy+dClG+qwryNJkI1GYFBtAZ1Qpb8M8OOoyZCjB5EQqRD6sKw7RBCo+v5wm4OSkIB3olCQo+EQt3vwsIEbFdCgjMMw+t6YELO7ixCrFQJQtXTUUGYkCjDJSxLQouCN0M8cglDzBYGwyLUBsPqkCZDDOelQqhnFUMQfDHCKJoZw7xPIEJsmT7DrYTDwFjdr0CkcgFCHhprwqgZD78Yrg9DUu8MQ3WaAsFmRCDBA5tBw+yso0EmLxdApG2GQjRLNkGGr7pB6BajQr2FzEKPsodAqn/UwsQSmMEg+C1DJqo1Qty+rEJGEc9CsIdFQh4+/0K8hyfDmPTEwv4QA0OrYxdDspOTQtIDEcJE1ZBCeK93wajhwEICdijDqGlzQjX0IkIoL/dCWvQOQ6oHEMLMhyRDaGzOQn3sFkNbbMZCLPcyw/mMQEK/yWpBzBDSQiKN6EBSSgtD3lR5QiBj4ELdGxRDRD2+QiYyBELAscRBY//zQpjAUsPnTtlCOpaXQtdz2sBqLzVCisMBQpTFrELOvjdCJ5ZYQnSQIEJq/7xCNJ/dQjnYIcN2m3BCjJwRwUmSRcNSowpCvmeIQQ4JNUMeOv9BVukTQxJBEsOiBJXCKOekwjLfJkPUHcVClMzOQm2eIcPvW6m/+qLRwfJG/EE2R4BCF6onQrfJzMIcsE7Dw1jqQib7iELEYzBDxk81Q/+DHsPSVS5DFoZwQgpK1kISkPlCRN77Qv7SHcGQu1vC4PAlQgJo8UEr0RBDJIzoQkv9IUBC1ClDWnZiw0w+30IE/j/DAjm5Qgo/p8FcYR5DNEvHQdl2NMM=", - "encoding": "base64", - "path": [ - "vy", - 22, - "data" - ] - }, - { - "data": "HHlrQm6NScOo1oVCgWlZQMARGkGQAPFCHNSsQubGZcMy3C5BiikzQoYyD0J8cGxBDhpPwvwG5MEA+mLDls9TQptXDkPWcLjCAN/XQhi0kUDHKThAjM2sQusyVcPsoiFDlhvWQtCU5kIIEMBAxAliwEEy1kJEzaJB5K9Rw0K7j8LYp0vDSFShPyqLUEJSlHJCvrirwt+SScN499lCcKGvwFfQicHqbPHBvlMKQsYeqkF3bDlDXQCqQhYcXkJtYatCHBQew8/PokCG9fnBqsjJQRjYZsOkRdg/OehpQc76OcNeTZnARX1AwzxXg0FLIBxCLPEeQoqmLcN9aSJB0OBFwxpFx0GohJlAyMuKwZ7jG8JiZFvDHxILQbx7HENGHdJCrEFCw5LMOsOePgVDcH5PQkrs40I4m9zCysBDw9T44EB6XiDD3CxywsgNJsLoYSnBxqjhwhK0K8LkpeZCPG4EQ749ZML2qWHCMSFFw/wDrsEC7ELCTvPHQaq5HcJarHbBEss9QjLKd0JovjnCYiofwzBZmMIWWRBDZMRNQdgDNULee6ZCgLx4QSZ0uUICG03DrAsXw3ql1kK11e5CjBc0Qt6avMK63C5CRodnwqQ5e0IuvjvD5GMJQu4a70AC6a9CaHLwQojpxMJt1AtDbFKYQrTB9EIS7JdCtv5nw7SO7EBGvyPC3t2PQjIsGMKssdNCSJ0OQv/Hk0IibgZD8q+JQmf5iMGSPmnBgve/QsivY8M/96JC2vk0QjSMTcJe8K1AUm2rwEYCdUI2zFxBLK2KQf9+PUB0iHtCZieaQny7TsNSqKNBbtJ8wq9SYMMk6v7AoSXswcz7EEPB2wjAEJEDQ1WPTsPiVRLDupcCw4RfD0NwRItCNPV/Qh6rV8NEDj/Ctl51wh27AsGn2QhCnPPUvjRhHMP36VXD3UW8Qt8lPkIKsSRD4uQbQwDdW8PkjBZDhnmzQbnnqUImMbNC0FLJQsCFS8LcC8bC9EgaQTXlbMFkMNVCJXTXQqLJOcKePwBDgMRmw/Ibw0L+IV7DHT5vQlarmMJgWhNDP56fwa4YHcM=", - "encoding": "base64", - "path": [ - "vy", - 23, - "data" - ] - }, - { - "data": "q1rPQW7s6cKeQO9B1r0ewt5x3sHzfKhC1qY/QpIvd8P44/DBcl7SQBQ+UkAgCabBhYLAwrxTpsLsVzPD8G6tQZ0C3UJ6kQ/DpgSYQtaUHsKgmiTCuD99QiBTQMOIbQhDgcuXQhcCpUJ+DfjBvigxwsTfjUKOFMTBYxwMw/i9AMPYZMzCHlwhwm4DxkFqhB9CaSgJwxIg+8JEhJ1C8rdQwrxgdsLQwqHCVG6XQNiVmsHwVRxDyElmQo5dz0FWpFhCToRdw4OKBcJlM6vCUGk2wd6NXsP+UynC/tWowR7yWcM8Gy/Ccflmw07sncGqXBRBSudZQfK2ccMokAbCwklNw8iutsBs6gnCGXSVwjF/wMLQW0jDrAkHwoZM8EKWRpFCDJZRw14BUsOyrr9C6UCnQVBKnULygSnDuSRHw8be28HhAJPC0AvfwmsZu8LIR2/CKNYZwyWlsMIg0KxCqtLgQqYa6cIMmtHCZvq/wuQUjcI6tdHCy056wTxjvMLSqV3CftBQQVQerUEPgM/CC/80w1G/C8O63txCIOemwVwznUDU5nJC1gGfwf+iY0LMgDLDNJo4w7CIoUJEY6lC+reMQdkrHsPISm5BWUfPwvGv50Gg/AvD5jsGQcpD2cEdsUhC0hK8Qnh2I8NpANxCIHlCQkzmtkJ15k9CBVdiw12NC8IQDtHCXqUZQr0BtcJPwpBCstogQQEwEUJ7TOFCbvUkQghkkMJScXXC5HWKQt64JcPDnVZCkCB3QcxdxMKonRHCmN0uwqbMEUJk84zBneWcwUQ+F8ICnflBzEQoQk4KQsNWk6fBHj7nwtY1RMMAoFnC7O2iwmQ51kJ+fBXCCVfZQg6UY8PH/l/DYrISw+iS4EKifSBCQALHQc9OXMMCrcHCSiTFwjK7R8IEEplASmkzwpQwM8OC1AjDOiyHQnJY2EGM1gxDrCr6QqlBZcNZ2e5CUKaVwdQKcEJ8G1RCFDOSQgUeu8IQrgnDEfeuwRqYg8LcjYlCdLS1QmifzMKS9axCkIL9wvWln0KAqSzDJCzSQaZqEcNUAPdCEmqFwkLni8I=", - "encoding": "base64", - "path": [ - "vy", - 24, - "data" - ] - }, - { - "data": "/3TtwCP8bsHb6gDB4yynwqQEiMJsZkVCCoEXQdAGI8MOZY3Clxf7wZYr6cFPxVvClB8Ow/ioC8N8annC5kwbwQwQn0KzITfD4qAxQn2HrMIMCa3CwuYeQnbmqMLUXdZCNkA4QsGcRULSK4bC7EKmwlS4CkK7o43CfsPHwfUwLMPsDjpBRlKlws5Qe8CGRppBCucvw+aCZ0BkvD1CXu3KwsZk28K0aAfDFNPPwY5UcsKJNfhCALH7QTEwicDHtrJBNi1dwzlrlMJSyRTDfPFEwshs8cKxObjCthFpwpi4N8PsX6TCx4NFwxsgZcLXqqDBlfpBwSr5dcOoB5zCXjMPwzcVD8J8g5bChrIEw6JcG8OBEerCBhGbwkWzpEKKIiJCBiIjw/b1FMPYnGRC0hclwc1yMkKI7k3DXJz0wqKafcJN8gxCBGYWw1glE8M45OXCPvknw0vPBMPFEWpCDwuwQqPeOMNRExLD1DnGQTC1/8LwLBnD0QRfwijfF8M3vsLCdv6owRz7isEh9R3DEDgbwxznQMPn8JdCEH9iwveCDcJjXBpC8J1qwhZ/pUHm/qbC/GAow50kXELEJ0hC7m4HweQwVMMQ82fBAU8WwywFn8BGHTLC1KeLwb5YfcLi9zJBbo+IQlr1WcPyl6FCmz2lQWigdEL1iuhB2Ef7wqg5ncJ2QiTDIIWeQP7mGcMO+h9CTbBrwa5eJb4I/q9CwnBPQT6EBMN+Vu3CrnQpQvZSSsJu3M5BAhFYwVi/CMOaBaHCpheowjZjQEE280PCbqdmwhiSpsJdmbw+WMrfQLhF8MJCfoHCpkQcwx7YtsKQGdXC8t4Gwyqni0Jz0pTCgcynQpwmG8OKOYHD3IPfwmWAoUJrcitBXvNjwYiADMP8SRbDFlwBwxZzvcJoX8TBT1W7wgj3CcMgb4bBMqIfQlby10A3d99CjA+9QnwFIcPsjrBCS758wsBmCUJS04FBbnE1QnqBBMM3xxHDAk1Xwn3D+8LCwQNClTmPQvImG8M58zZCAJUOwWCvdkIGmn/CnCsFwTCoUsNYLMJCCuDqwmkmBEI=", - "encoding": "base64", - "path": [ - "vy", - 25, - "data" - ] - }, - { - "data": "rHsmwqZzXUJ40TzCZgcBwzAB4cJKmXZBpIvpwby9NsLC497C//yKwv1necIONbHCR+Elw8anMMPmerhBpqMmwpj8RULgJDfDauJaQdqpAcM/pQTDOOJ/QfGBFUJE05hCYHaPQWWkhEHQWs7CQEzzwmFXuL/58OzC6BJVQpAZRMMuc4dC2JL9wlXhCcIOkYC/TOs/w9yEqUIG035Bxq0Xw307HMMeKSjD9JhpwtY6z8KjxbhC0hzZQO38C8LmyRfBqz8Sw4qZ6MJSlz/D18Cywop61cA+uhPDrhfCwlbAzsL4l/PC3Dq7wlZtv8J8rUPC0KMWwjJUEMMT+PbCmhtUwtW1gsKMcevCTfstw5xDPsNOCa3BVrT2wnRaN0JkMAhBLBOgwo4gBcJqMJJBkmEpwgNtPkFn5kXDOEt2wI5nycIAhsdCP2gtw0LeL8MEVx7D4NAQw9UoGsOsLP5BBWN5QgggX8Mz7irDNjGUQlT9LcOosTPDFJTAwlKvPcOUOQvDsDpdwk9GXcIIcjbD3diswgZGV8NJUShCOHu/wob2mMIYGYxB2FHOwl2kf8H3zOZAFhChwnDM9kHCdIJBohIFwpAUacNiLTTCNgEuw/KHHMI4OQZCCAEvwsKAysKmOeXBcp4uQpoFa8NvN1VCeQEAwfZ2AEJW9PJAqEkjweya9cLG1ELDquDiwXuISsMepgxB0QMcwlzADcKo+XlCVqx8wQZSM8PWmTHDhrN1QVbNI0JExua/hqwmwnRwGsN2+PvCsLL9wqycQ8ESx6HCEOXDwji9A8M4TOrB7qncwZcL1cFHpt/CgvMyw3Se2UEMmR/DfGEpwwFmBkLWkOPC4PhqQhcqNcKq9DzDrJhmwtxpSkIUC5PBZs9XwpOl1cGw5z/DGMEIw9xyDMNo5ljC/GYWw5IvacLo+mtClqJAQWNzW8H27KBCr4yCQoY3gMKGpWpCnkLdwjihDEEdyaLBGmaQQQA+F8MJ+tjCAu2twqbEMcNiBD6/6npQQkCdMcNuccJABBZMQmJ2L0LTi6FBkC8ywihoY8MKTY5CkB8owzAhrkI=", - "encoding": "base64", - "path": [ - "vy", - 26, - "data" - ] - }, - { - "data": "0IqawphWxkKS2a/Ccu0nw6OYG8P2Q5HBUzaJwp+R4EEulRPDtkbYwvKhwsIwTvTCjxkUw9zRL8Mf/YpCam+VwmFUoEFk0s3CPf6AwZX+IMNOCijDE0L8wLiev0LTGjRCd5IKwfVzfsHZSwrDPAQaw45rFsLk7x7DKi/AQqJAOcOw9sNCrOEnw51eh8L2PajBFsggwxVc+kL1aXfBRNk6w57HM8MiQiDD/GK7wvCjE8Msd3dCBBSFwbhGhMKLXCXCpGVrwqLuFMPL8TbDx8UCw2CJYUKE1TzDFawDw0SHe8HefBvD5JhqQBRmAcN2EprCJZd8wno1IcIAcyLDX6zKQS/QvMLYhBnD+iM7w9R6OMMYsjRC6kQjwzxgNUHPOr/ByTsJQfG4AkKyraPBzreXwsCGnsFexwDDAPZ2QrQLBcPlhAND1eYow3hAHsNS2DHDdjqrws7wC8PY1LxAYRQSQhTGOMO0kBfDrn3BQhFvOsM6fCrDaZgGwxevPcORcCXDvJ2zwhQuucKu4BvDPK81wO7/KcNgJg9BIBMHw3bD7sKi7xzATPUTw8KGVcIjEGZCGDkCQfwwAkE674LBVLFjwjZ2L8PGBJvCt9kcw3WDk8LSrpZC00+OwpZMBcMumorC6oGgQTgsFcNbkNtBpjgXwpYiiEBuO0jButxZQqclHcOU2TLDK4R2wujiRsMG1avB/x18wk6bi8I7TBNC4hw0wkRcRMO8CE3D0EVBwZQeu0JykevBhSmKwjTxC8MYWyDDO9ggw3BeEsINjePCVnwLwzQ6JsO0WGbC+FV1wiJ0MUJVoRvD/q8kw0iguEKnAD7Dj2Enw74t3b/8SxLDTEUGQmhLxUF4J6fC5eGJwAKosEFKjTzCjem9wmyTPELqkkTDeGPWwgyyKsOuYKnCj49Sw9DNTEEvn8hCbMl6wTAjC8JICkFClPMUQujhf0F9AvVBLzsZw7zYgsHoXmLCVhkMwfZyCsN8WT3CIeLzwjZ+Q8PcEwLCePEDQq8PG8OPjwPCnE+sQi/L00HAE4ZCVmSmwmxQKcMmUjlCS0tDw1lZ4kI=", - "encoding": "base64", - "path": [ - "vy", - 27, - "data" - ] - }, - { - "data": "vhjmwlDF/EJyLALDieY9w34zN8NPF1DCIYvawhnQlEKABizDgEkQw4RXBcOk3xfDaaizwl468sLMq8NC8u/awlBNFcF7dU3B8Ic0wiZjLMOClTbDLjEAwgm390K8+1NB5gUIwn/QQMJl+iTDzlUrw+NPlMJAQDjD2sfvQhIa7cKAe+JCZBo/wzZe0cIecSPC35uLwlceDkOXtDrCEulAwyKHI8ML9tPCvikFwyAqN8PpnwFCch8cwqrWwsJGupLCjnwaQTcMJMMz7evCfvskw6p3vEL6c0PDnuEbwzBTT0IDfSzDrFJtQkXGGMNSs8/CeiuxwkimrEHFXTnDPl6UQnn98ML1my3D2LUZw1RYA8Moc7FC6Oo5wy46qcGOWWXCXByOQg7hh0JZJGzC/hTfwiLlS8KSW/PBVDW+QoKsGcN9Lw1DofzjwkcFt8KYLiXDmmEkwbhvscIQxJvBFgQuQTPUzMIwiWnCiC3SQhSdDsPQeOfCMCAlw44xDcMwdSLDIoXywpgh+8IA0KPCDYNzQsAyj8LuzrzB3nkjw+ZyIsO5TKvBcJ4zwxDVt8I4569CIrlZQqnKVcGjeUDCk7iewjs4hsJGxuHCsiHIwtvk2cJISMZCLOvIwibWF8OBXtvCYrgywCi4DsJ/3TdAOruKwpLGtcEsLvvB/KG6QqGwLsMNf+LCsde9wvgDBsNyp0zC7NKtwh6gzcKKCjJBhoeVwmoYIsPYjTHDNIAhwv4q+kJgDGXC/ha/woAlq8IE7y7Ddp8tw+KTdcIeng/D2CMswx4tLcNniKjCOsG7wjgjsUJ46zrDptSjwpWM/0KcTjHDlezgwq4fEsKK8yHDdhwFQbpgg0L7DoXAkJciQnEvocAyEZfCIbIJw7q9s0IkPBfDRdlFwu7lLsP+bejC9pFww0KZWkIaYvVCrHEswhjpY8J/b3hB7NAgQb76hUJcG3ZACD82w5S+I8Lft7jC5bgMwri/r8JfBkxBGGMbw9xTHMOm4XrCALdkQWPGucKaXY/CbO3WQjShFUF0ecBCHJf6wmZ0qMKIhbRBFqcvw0ju8kI=", - "encoding": "base64", - "path": [ - "vy", - 28, - "data" - ] - }, - { - "data": "1PYZw9nxCUPb3SbDn4MuwwkCNcME0K3CAicTw/zi00IKvTHDoIMswwOkI8MQHivDAliuwerKGsJ7UeRCoDoRw9W7HMKcpQ5CEe+SwoiMFMNQXyTDVsdiwkOPBUNA9ZfBZWppwiQFocJfxC7DDrsiw8hQ3MJyITfDuDUBQ5TXSMGQ1+ZCY482w+99EsO04XHC+VfSQeQNDEO+VpvCP84Zw0TQz8J4iAHCNnsow3QfSMNA0GhAtlRywipO/cJmOc/CBCtgQrihE8O9dxHC4tI2w6x+6kLKrxjDciQjw+gFv0LFvCDD7Oa8QuhiIMMIFfrCCGTfwjyrekJGADHD3njUQi6MCcO2aCfDGMqYwogfT8KY1etCfIkzw8JKT8LfHLnCNtLdQoqesUIDBMLCWnsRwyX7o8KvLy5CVHTfQiygGsOhKgFDPFhOweVQKsF0ivHCYcJkQvsKqMEz9zLCrgRpwfwuvMFXJ9BBEPTKQnQLisLIiAvCWv41w+GqesKcDuvCXwgSw4B+F8McVUxAXCrEQkSdcUE+al/C6q8owwn4RcOu7B3CzDY1w6j/AsO4INRCNECgQhaoB8JWCp7CygbIwgIuf0H67BTDwB34wUp1DsP0V9xCtqsAw0qyFcM/og/D0P7Jwf5bx0EzU6bBA8/OwkaWRMK+n0TCzkbqQmInJcNgf8vBK8f6wnR0WcJZLKHC2srawk6GAsPo1WrBuIDOwuRQpcJcrOLCsiWMwiRpDEOYxarCvifvwiimJsEEyh/DRNcSw1jIrcKKtyHD6ms5w9Y2CsN03tXCv9/0wlyX6UJMTD7DmnLQQXyyD0MCrejC/7/2wbZ3jsIU9hPDQteJwf2tuELaBjtCgu2MQmer+MF3mczC8uYvw7wx50IUx5rCjXUbQaoEEcOitxLDwI9Lw5DwoUJVvAFD/kyMwmrUocJLoo3Bvr2FwWsnzELbqbDBbgo4w02JgcLysffCxIt1wmR+lcGQ3VRCcl0rw3YToMJ+ybbCSHmBwBDIhsFiH9zCSGfrQuLL9sCeKuNCxj8nw0irrsBUzsq+2LrSwpg94UI=", - "encoding": "base64", - "path": [ - "vy", - 29, - "data" - ] - }, - { - "data": "NKg+wxxs50LZxEHDQPSlwoC/BMMIKATD8742w+RiAUOQRBLDTkU8wxZQM8PCTibDeqc6Qqz5L0JSaOxCnt4zw/CzmsLdaIdCtP3Uwhj1gcIAS7bC0EevwhKq90L8rm3CDuitwtKN68L+vQ3DBiTOwqpmE8MzIQLD4wLsQroWmULjKrhCr2r2wvMIOsNjR6fCkCGpQhbz00KK5+LCqi50woK2QMGywzdCwDw4w/onLMNzSPrB8HCrwjhfE8PWuQPDhFzBQlL2k8KOQjVCDCIdw2JNAEP9i4LCXCAIw5CaAEONucfCUPrvQpRqCMNyiAfDt0T/wg/Kw0J6IdfCiDMAQ75FC8OSQuPCUmfXQaZEM0LRLAhD4kL7wu3vrcLxDwrDxU8KQyQ+ykIp5wjDBIowwyiO7MIALbxCSJ3lQmxl5sIzHYpC/kaWQhEPekLi/yjC4WTNQt4TXUK+PJjChTs2wr/RHEI6lolCUiSVQvFUUkE6B1FCLpclw4gkDUKqxerBOGchw3YuKMP5G49CRunyQlsMkEKzWr7CKLH7wh4YWMN6nHHCYF7/wt3IKcMkCeJC+hHAQihUaMLIQeDCAijqwgprjUI4qTPDXnwyQlSuKMPyAdFC9sASwwIn4ML+rSvDLr5SwsLZhkIII0TCxpwRw1JXosJlj4rCkDcBQ45UzMJasnxCfuIXw9oXz0GBPuXCfSr7wuKuGcO1rzrCM9T/wpLKqEHRb9fBx4nawivQBENt0+vC/NIIwyvegUIMNL3CKl9ywv2f58JedBjD1l0aw2DtX8JzQfjCcE0RwzIWBUN1sATDGpytQlC+CkPO1ajBms1AQvUH5MIndJ/CeJNFwr7v3kJ32LRCgoG5QkTZd8Jqp/zCtkVMw9YmAUM8qFJBnMBtQvYUkMKB2iXDgtPWwvFlxkLa191C7oDIwniP3MIfC23CvVpGwpaCAUO68lTCV1QAwwtNuMIG/RfDoj+5wrCeX0K0iqJCNKERw2iZX0GFAfLCHQLSwYJGd0JQ0hfDMC7eQl4X58FPne1Cee5Iw6a0Z0Kmz97Bb0mtwDKBgUI=", - "encoding": "base64", - "path": [ - "vy", - 30, - "data" - ] - }, - { - "data": "suBHw/Rmu0Aq6T7DMAF7Pc7umMKczCfDvt1Cw+WhBUOEdLbC+ccuw6x1GMNzX/jCetGdQrQlokL1VMlC8GM+w9KJ3cJiOqVC10cAw9TsbUG8NX/BiFrbwjSVuUK83brC0gLZwh3zDcP5EZnC5AsGwtTDKMO+JnDCV3KVQmCH3UJzi3NB/CxuwqLaPMPracPCM4HVQrPU9kFUIAfDK9iGQRM+SULWL6VCSF8Zw2Qt2sIeU3DCkyjNwg5KEsMR0Q/DPlLwQugYpz8wmKlCPLPBwrpV7EIJ7K9AhkCrwr6tDEP6EBHCGHD/QvzkrsLR3v7CKrr4wtIE60LdUAnCeakBQ6ke7MK+7EXC+zaYQn4LvELnwAFDEJSAwj5N38JrwynDEg0PQzgHyEJkgyHDIyA2w47FDsMIu+pCsGbJQmL4YsKVSlrCYjjSQkw3vEJ2qM9B7AHxQkpvtULq5szCIYuNwkwmlEJAvKhC233eQFxMWUK5vrZCL8vbwmP3rUKsFBZCdtMYw6LnH8OkospCxjr5QqjBxULJ4PjC5MSHwuINO8MMY5jCOvyAwobJOsOMWchCPg/FQu4dmsI+HwXD5Y7uwl/5wkK1kDLDdiimQlipKcNkN4xCE0MDw+iTd8KpGTLDZrmWwo2bskJuo4/CmKEmw1Q208IGaKfCrqDwQjx64MFWgc9CQukfw+hihkKaFgnDlJrzwr6XHsOfkpLC0mYHw6AokEKK/vVBOnsLw4PopULEaAjDKGQHwznVvUJcya3B3BBlQV3dAcOaxNvC2F/AwqKyWkEaBf7C5iIXw3K2/UKHsnLCAgHVQoik1kL6IylCnnmkQsY6EsNApBfBZZGZwkpH50KACOhCKNzGQgofrcIVaQfDhvREwxrz9ELasIZCg9OfQt1bXsBMlxnDPI4CwuYazUKu0S9CLG/qwuqy9MJ2CLzCfBWawuyPCkN2J53CVLJkwmJ12cIUBSPDBhDjwiJ+sEIXU7lCNsy5wg8he0INkQrDcFMxwjAdxULy8jLDRw2LQhjFOsLxvcpCO4pGw9kHu0KsM0jCzt5WQqNSPMI=", - "encoding": "base64", - "path": [ - "vy", - 31, - "data" - ] - }, - { - "data": "Jlcxw0mJ+MLEiR7DqFVIQgTCpMFie0LDYqMyw0Vj2EIBIt3BZLECwyC5tcLgeWbC/Q3EQu5JzkKGS+VBkAYswzBgEsPlWbRChLwOwwbGgUJOGj5C8b/3wqQtqUFtHADDmM34woZvHcNMzfzAYhPrQdr+L8PgQBJBRitKwp4V/kJ0XxTD0KNUvhLlHsMAnsvCUPLnQqgw1cLYnxLDIiKKQv7grkKpdtBCkKzCwk55GMJOUrPCbrniwn2j/MKYgwzDGRcGQwvRV0JdhNtC4on2waGshEKGClxCOCbRwYKQBkOCXKZBxFPsQrt808HuV8zCUbTKwjZ7/0LOcc9BrZDMQuZSmML9J0xB2nzRQhL59UKiaY5CNgakwOJlA8NcvzvDaVz3QiXmo0JfvS/DB5MbwzpVH8OLTABDaBxpQi8tk0DApiHD1vDqQrrt3ULgSJhCB/z4QijW2UIG6/3CWnG/wgLTx0LWY7RCpE8hw8pZpELw++JCh60Swq5S60KiKZxC8oHqwkZT8MIHHulCeqraQp645EJsuBTDsM0twVZR6cLUO7PC4nWCwNE5NcPqPShC2g+yQv4hvsI0gRLDIOnUwjO540Ir7Q7DrPrTQvo2EcO5NDzCTFCrwoGt+MD+KCPD9ujEwtcxzkIAGb3Calgjw8PI+8LorrrCgA6PQprsEUKzuP1ChjUVw3D3v0I4phfD8Oe/wuFsDsP4tcjCZWb9wlFAzUL6QY5CRUofw7cae8JypQ7DQrrmwid/2ULCbDBCUAF4QmkkAMOemFHCEFYGwi7scUIAxujCyMwNw9oLpkJMH1ZANKHgQr1M2EEGlqJCCAjLQt5vLMMXRjVCXAXTwnJEzEIJAgVDri6zQvxJ2sKboQLDITEWwxIsp0LgF8tC1GqzQgwOY0JUZ+PCeqW4QVw2sUKIWebCTF/5wpwE4MJo8ADDciTTws7T/kJO7c/CCh0BQfid6MKtIx7DYQ//wpqO0EKqTbxCTkoWwilzvELGTxPDRNB5wq6A7kJxl0LDgNWswsdygsLBhL5BfsQgw/BC7kJypJDCJoGxQnJzIsM=", - "encoding": "base64", - "path": [ - "vy", - 32, - "data" - ] - }, - { - "data": "j2v8wqkyE8M5I8/C5e+bQlRb2kFVqkfDAFT+wp6V58HwgfNBfhWGwlwt18EAmdFA5bDVQnJm40IWwwTDWST5woa2McPW87NCzhgSw1UiuUJdUKlCSDj7wvsQ3sLZGR7D4fMCw/MLH8PoYi1CljeKQmLdH8NWr2JCJa8hw0ZDAkO6lDXDgm84QgD04MLKkLnCMkPlQqhtN8O6vA/DPN3IQmjQ2UJwqONCHisnwp4YrUGUl+/CIlvlwlAvtcKsgOfCWuECQzTUpULnaPVCCqSiQVxtuMIbMbBCG+LfQQwGuEIc0WhCanCFQsAv+EFSgHzC6pR5wlnc7kKRXHtC+oWmwE8ByMEAvmFCzT7vQjOnCEOI3aXCqhImQgLmEMPyiTHDtuNWQmehREHsQC7DF6zLwqUyIcOK1ftCDPV/ws/iS0JGDTjDcIvrQmCC5kJfKNlCMi7jQh+P40IuDxHDqv/swnbb60IgRK9C+tFKwzZcyUJeuvVChE/UQUpWBUPo0shCRjF0wuQeVMIjzOxCen1zQriR7kJ6KyXDAQP/QfWRGsJKGcHCwnUbQvgdEsPEyObCl7xeQuKx2sJuFxTDgL2YwveS8UJquLLC4D7qQmoOxcKCBhfDvsgMwkYQI0K00PfCDJ7wwqRE2UKuiOnCnwsDwxiNC8N4RL/COl+ownpsk0InMwdDnPLmwmxs5kImUBjD1ppWwrABxMIMw/zCghrHwsQ570LyvchCKvgew+xmGMM0lALDES2bwpPS3EL+8KVCajSxQlKT0MLA+50//MCbQStmskIknbLCbBblwpgaScJh7zJCDEXWQl7PzcIsRdNCbeTaQmztO8MJjZhCugoEw/ATBkKovwhDcx4fQtDs/sLuw9fCwIugwhwHQcICivRCuxW1Qk55vELnI3vC1Zd7QoDXxkGiOC7DfJTuwtwqn8I4Mx7Dwi0Gw4ybd0Ka9/3CuJ1IQgPK4MJS7QPDPMMCw0Lg2ELopqNC3LMjQYhw40IFtA3DggOhwpoU/EJWJDzDvOwmwy80qcLu1gTDfHnOwib8BkPAor3CeBnbQmTZMcM=", - "encoding": "base64", - "path": [ - "vy", - 33, - "data" - ] - }, - { - "data": "MjmFwhawCcMUjSbC0sy7Qu3OdkJSZyTDSNdlwmhbCMPJL4xCz/4OwDXdoUFkD1JCjr/RQuJC4EIT7ijDtj6GwtovQ8NvtptCeLoEw2ot1kLajtNCd9/bwtBbPMOG4jHDfk31wv20C8OoUpJCNvO3QllZ5cKpAq5C/Ksxw1QZ8kIiwyPDoKeaQj4ogcKYzozCuI3LQgr1P8PEefTCPsnsQupY7UJCLNxCi/+IQFaTckL0xBPDxEnKwsozPMKuFo3CbZ+NQipIxUKqHfNCaoxUQpCdIsOuCtxCsqF/Qjs6BsJoQqRC0BO0wo39iULSHpTB4XaZwX2a80FEQqxCSOLywuJNu0Hs1KhCX7P0QtQiB0MItAfDsjmSQpJuFcNKVAPDaCapwpI1GMMSTRbDpq8swtz2CMPN985CiiA0w+QnnUJVcSbD1xLWQlbP0EL8eP9C9JujQh6U0UJcMBbDSCsFw2hx/EJ4i5VCbsoxw/0L3ULwcu9CSXuBQlIdB0Pamt1C1Mypv0DkjUEA+8xCe+5QwoC23EK0LSjDxQtyQig6sEFkbLvCNqmJQrFCssLVoh7DcApjwqr+58IaIAPDnS8LwhbA50IykhPC80LpQohPLcJaUB3DgKXrQG4Uk0JG2YXCoKMGw1Acy0IVyAbDyEKnwrBxDcMsKK/CQtQgw+zIvUIw7fxCDqKAwrod+UJIpgHDgrIfwXjsB8Jv4xDDsEprwlxj+UKKDPFCkJUCw9laJcPU5MPCUJD6wRytx0Ime9FCVKLNQowggMIOjCdC9jNcQkBT1EIYLD3CwMuNwhpbB8Pn6pBCfqSzQv6GK8OauO1CMpjSQgiKN8NLzLtCwEwWw8ywA8MICcxClH+CwvoPC8PhqYjCFn81wVqeHMOigANDq5SiQkQ46UKCAm7Bg+y5QjjY2sKMGynDbA/EwrJiKMKmvDDDTmwew1oQtMICrxDDigObQtvivcJenajCfBbrwlJYykLplCVChhE5QvFv9EKtV+LCYl/DwuLK6EKUVRHDXDEkw9AI0MKmRSLD8E8xwvLaCEOKx+jC9MruQgAIHMM=", - "encoding": "base64", - "path": [ - "vy", - 34, - "data" - ] - }, - { - "data": "Evw3wUzE38IpuINBRijLQuRrrUJsMcPC7DoIQVK/E8OFN79CLsNBQpR0RkLiDZ9CiN+uQk7IuEJLox3Dolpdwfc7NcPA1A5Czt3Ewrpz30IoLOhCAK2bwjdNQsMMFTXDrZy7wmDcwcInA7ZCMh/RQunGTsJARNRCFtgfw1yFwEKBDgDDRDjFQlKYo8H0qyDCuh2QQtcrJMPYXqXCXmz7QgQi6kKCpapCQPURQoeMrUJOxirDkPCJwvkfPcDqZYbB9A2hwl+b0ULeR79C2tyWQg7OIsN4FvVCuCuuQhpfA8O0hMJCPkwcw8/GuEKEIcJB7+agQdQm+MLkI8lCJrkPw04hc0LyPcxCJzTdQkb34kLs2grDdbi9Qr4oDMN2sYvCHiYSw+caLsOvfcvCLKnSQATCpcL+oxpCOI07w5YlvkJob/rCMq2lQj49hkJyqAZDuLBmQYbvmEK8tgPDlncHwzrn5UIwJC1CKCQGw2RW2kIejMhCt7SwQmu070JQQt5CDFI0Quh4gEJ6slBCXhYMwySblEJcCBXDErKgQnNwcULi2pzCfya0QghM2cGAARbD9JAnw+a03MJIW7TC7kfrQLDOskIkZ+ZAvt3JQitSFEGgNAnDZgoQQhCSvUIXoI/AHkcGw9wxdEK/CBDDLuAOwhz99cJEGIXCijEjw5Im1EJktrRC67UMwZYp7kJYKKHCbjnZQfS66kEAhhbDAJBcwdMp50KIAwND3jCowhAJFcMTC1TCGANWQS6qkUKaiuZC4kHXQo7sq8FtXodC8O6eQnDE4kIWUqY/skmTwVbgFMM2rrZCPo9XQqTHNcN8KfJCVoilQijlE8M5O8xCeFsZw35xIcOmdYPC+lDMwjoGC8PHkafBAswhQmJYKcOYMABDzMhiQh6z/kK6PM5B0v/mQgk2CMNUNQzDCrB4wvKsCMEtxDLDW1Msw6q6DMPWHhjDgJ2+Qi7rgcJ2BsnBODWpwrKpnkKWxW/C7B6NQiYf6UJWlGrCug3awsdNoEJYfY/CFE8Lw6ma58L9jBbDDDb9QEox1UKaUAXDxHDsQuC35sI=", - "encoding": "base64", - "path": [ - "vy", - 35, - "data" - ] - }, - { - "data": "jK0AQtK1jsL+3G9CC1DMQosJ0ULAiffBJJ5TQqxHBsMiwt5C+RGiQkSDikK4PL9C2tweQnRUBkI+DwLDIHDkQX8wAsPGnOXCwWVCwn+y1UJkMupCmsIZwnAIJMO2SSHDPq1Awhf5I8J0w8lCXPzaQpTdLUHUNelCpCH6wkAJOEJAMp/CUoPgQkAClEE+7RDBXmUNQXRB4sLNegXC5zP0QpE9yUKaZXpB6H5vQjxF0EL/bjbD9WbKwRhOFkI3nANCcNDvwtILzEIkZv1ABdq0QtJZDMMESflCYOPKQipvGMMQpdJCOGYdw3QG1EI9QXNCaN9KQpgkDcMg3ddCRLEIw3bvpkKtWt9C3L2WQtcqZUK4nffCZTPaQq4C3cL6I0jBTecbw6C+GsOC1BjCXBEhQrWVl8EiBcbCKuEhw1sqz0J2R3rCY/4TQvK48sFwAf9CaAPEwjo/YUEwjK/Ca7bywgmLBUJZhTDCtpadwgzBrEI2q1NCbBPNQkVOmkIGqMhC3IGTQtJatUL2tY/Crh4dww7IG8JjOc7CDh27Qqntq0LdWk7CY9TQQjq+30EwWfrC6ggow90Qr8IKOgHCmBAtQtBqAUDshRpC5a9sQgQ3U0I4D9DC2rxbQhaz1kKs00ZCU5vewppM0MKw4wjDvJnmQNqKn8IMugrCYrwNw1QI20JKFQG/6EkiQnfhnULcOKrBzjRVQh4yjUKd9wnDzjnlQYr4pULiFv5CkIsPwoSR5sKfnujAuGlNQqOBiUHQUulCGDXOQqMxgEG+rqhC8jzAQpIA3EImFjxCEi0HQni8CcOO+s5CtkSzwfhZH8OUxthCP+yfQcc5qsJBcctChuUFwzxfFcPqugDDBwjRwrTN7sL9ZsZBuJmUQufpF8PaQ9VCp4afP2JZ/UJeQWBCvMoCQ4hA/8J8Q7/CMp+XwftHl0HgxR7DKtAjwzBkEMOv7gvDQNLTQnqo3sFKCgRCtiMcwth2BUITovbCOSyuQnC0qEK6h7ZAdOrawjDy6cB1s25ATiPNwgrV38LewPfC3uk6QnH7lcFmQg3DyKXLQiytaMI=", - "encoding": "base64", - "path": [ - "vy", - 36, - "data" - ] - }, - { - "data": "LFB8Qs33IsGPSbRCEtG9QoHD50L0uJxBzm2jQjiy2MIMqu5C6GHMQh7gpEJsddBCMoWGwpDou8ITPLfC5IloQjDgisJL6CnD+/RnQJRBtEJp7tdCpBXkvRTN4cKUf+/C6I6hvnYuY0Eu3tBC+AHXQqMpWUJm3e5CSViYwiXKXcK2HH7BgvntQoRnRkLI6JdBgt35wqK2IMJEPn5B/ZDPQgamakIuQ83CYYKaQuf25EJsyynDPliFQfZXjUJoO4NC80P0wsqSsELMU+nCJgzHQvVP0cJUR95CNjDZQm7SEcPCwdRC+OkJwwej30Kq4qpConWMQvpiAsPQpthCbMXmwi4BwUKeoONCARsGwUDzZsI7McHCLlvpQpoVasJycutB3CEPw3rN9cJQI8tBtjV/QrALBUIdaSPDxqzywqsA0kJPC+JBtahVwr2cDMNWK8lCdiYdw5ryvcKe7BLCFAK2wgJcxcLVDzfDgIsewZxJsUBB5T7C7RXbQmk6gsHW3ZJCllC3QrLS0kJ+KRjDligSw2aQG8NmdynC78rJQrw4zkI2IZ7BbFbgQgBphEKS5rPCVDkQwx7/SMK2ss9BBlyJQi7PD8O2RnZC1dT7wVaqpEIG52vC0HqHQsAN4ELFhKtCZgmNwnZoJMM8HdPCu5UkQmmay8FCQCy+ZnfVwoYV00KcLPfCQHSTQoWmR8J4x/FBzZ6KQh72u0KZEtbC/nlwQrj1Nb/M6LhCIuDZQG6FgcKS/gJCZh+bQv6rssJQlNlCMnWsQoxTLkJk3LxCrtzUQuCltkLkDZ9C3feYQqpE4cK27NpCaZQmwwgf5sJyJ4hCeNzWwi2UjMG22bVCRB2+wgx898IahwTD+Na7wtxSmMKOVXBCXzXCQjLZ7sKcaU1CNqnKwtBv4EJg7JlCuhUJQ3j81MKEwgfC8uK8Qc5cGULiyuvCVIr1wtZ+AsNQTcjCmhfcQgJjHUHQeZRCvJngQOHmYsKYWADDtAzDQuucRcETR2ZCDgO/wv3m7MIpClNCiutZwnzOtMKmQ63CYF+WQsX748Js4QTDFlZiQsTlp0E=", - "encoding": "base64", - "path": [ - "vy", - 37, - "data" - ] - }, - { - "data": "4AyrQpCiuELzwN1CijaYQo7r8ELuLlBCSy/JQpXYjsL8GPBCtjrmQrQ2tUIrptVCGk0Lw97MFcOYMiXCdrCeQsThgsEYmB3DLng+QjTnWUJcxalCvhwCQqmpMcJUUYfCqpAfQvTlW0L1A8xCm97DQmyKo0KUh+RCpHgbwQBvLsMUUZNChJrsQo1wlEIWwylCEDVJw86yN0K3omNC3g1xQoDcBsLUFw/Df8SzQgJ67EKgcvbCHXFCQtphukJCZqtCrDHewt0uZELg4hLDVPbNQkbiX8LpiIVCKunZQua0+MICGsZCzPrUwtLP3EI6CMhCXlqkQsX52cIifshCnrykwmq1zELj79dCO1oBw87sFMOedWHCJ6rqQgbfckBMAWdCRCPnwoMypcKEQoxCEiihQmhIgEJfAynD1GiJwmxFxkKQMA1D0kIyw/nUIMMEcypCQpglw3g3F8Pkc/hAaCJOwu+n98IWHDzDkF+fQoSr0cJ+xhLDnWDcQp17BcMReYhBHvfLQkL030LaZiDDCmzvwi7GKsPayntBEBvMQqpw40I8aSJBx4bgQqAAuEL+EC7CbXncwhr1J8H4XYJCZD6mQpRPL8P7Pp1CVtADw12Ty0J1ihpAcuGXQnaF2EKMYdpCqkzfwQiNHMP0qWbCKnODQh5IuEF+PvBBxhJrwgwbuULBvCPDAG+9QsBC/MJu8XdCh12dQh8f1UKMIoTCFBWhQjYgAMP3lDHBECoaQtWaFkFI5HJCTJ26Qjg/I8PwjbJCjhY/QjTOdkIm+MVC8lDdQrQuMELLA8NCRi3OQvKmlcIIBNlCMCRWwxhzSMJyA/7BTAAbwwjlD0JUp35CqN5Iwqg+ssJNNfDCQ16VwqD/scHm36NCI+/fQqIulMJ43XvCRqEPw5Znm0IYW7ZCJFwAQ4MQmcL7P1tCCd5nQqjYUELmGYTCDwiEwgHp0sKC6DXCPEzWQhOBLkKIesdCApEvQjSBFMPORObCkovMQvSv9sK8uqtCZqWKwgzHGMO37aRCzKIbQUOdcsIkURXCQI3AQp9+BMOCnczCCD1Twu5tBUM=", - "encoding": "base64", - "path": [ - "vy", - 38, - "data" - ] - }, - { - "data": "slDLQsLfXENZA/hC4r0KQqk66UJIRJRCJkngQtR8n8G6/uFC1JXyQtZuvEIxfs9CZz0Uw9UJGMPhCtlBBvG8QmC7rUE4lQPDYOyWQlbzk8H56RhCU15cQth05UHekn3BQ3iEQjJPoULKoblChuWcQipWxkJAJsZC+tyrQgaOUMNUGDZDilnYQvZ0u0K8MGtCvWBIw9LP/ULx9qZCggwCwlzCDMPwjA7DUDXEQsQ+5ULy5XXCIiCGQhS51kJCjMJCRAK3wvyZGcHuXA7DVM7HQpqlNEGCvyDCScPLQhAMtcIIaJ9CnYR+wrqMykKQtNVCDqiwQsNun8Ih8J5CtuALwr8NzEKO1bdCNtMnw1TjK8NmYnFA4gnbQhiWZ0KaWZtC+BCTwmw6AsJOtsRCMHC4QhB0pUIirhfD3uBfv+HIqEKspF1DFr9Tw1q3FMPWgF7C/j8Ww5bZG8NnyBpCflQ2wfNT8sKEhiDD4LAuQ7zpAcNmtCrDzULQQgwiLcOGEbjCCGbUQjHT30K9XA/DylKgws/CG8N2xFxCEKe+Qpjh7ELFDAxC9MHKQsQR2kKYpJ9BMsWHwoJEu0HKuK9C81S0QktSJcP1DLZCzRsew7wJ40KEbbxC3xegQmZyvEIxbPZCtE4HQdA8BcPbUzHBD2CnQk6aVkKxWFNCLtHtQK4thEKEwiLDI1jWQvJRCcOOG6JCTuClQlr53kKiDsPBBCu6QnqxJ8PvZM3CyvVzQqra6ULKBZ5CNPnKQlz+KsNy5k9CALcWwgIak0JlJMRCRt7XQuADZ8LKtdNC2EjsQk9MosFp28NCdKNEwzvHz0FjjgfD0HYYwz7jikJI10RAmuQGwa60MsK9Q8XCTXw5whraz0Fpmr1CzXHwQmAGRcFMuhXDEJMMw4h0L0GixsdCmT+qQt4eEsJwOSFDlreeQrUWeEICf1nByQhjwSYCi8ISr5hAjdu9Qp0jikKWQuVCGoWFQjy/JsOUdLjCzErJQmb3E8MgQMlCyhIbwojoFsNapMlCbf3LQsUa/cEO9vdBkr/eQvZFAMPi+GfCwicbw6NgY0M=", - "encoding": "base64", - "path": [ - "vy", - 39, - "data" - ] - }, - { - "data": "duvgQgYCgUM5LQJD7XCAwj0JyUKyu7JCJPXqQsILaEKLmcBCaE7yQtjDuULMwLxC64gHwyKjBsNiCgJDDTbRQvJ4QELImcXCD3W4QhJSBsN04k/CyneMQrgRyUIcXu9B/rmiQjJkwUJMDpVCNAQvQgaE2kL8K4pCADg/Q7Q8RMPNv4ND4u6nQipA2UIW9IlC3K0sw1u6Q0PGsMdCXesQw/ATKMMwx/nCJNnKQkRQykImucvAzG+aQuyW5EJ9hsxCjmx9wrh898K4NPXCUD2vQqY32UL4eADDWpaqQvq2J8LwKCBCIo+hwFwLpULE69VCQ7uyQrA2JcLY5g1CHDASQjAlv0KknHJC+HokwxLaI8Pww9NCi0CzQhDWskK3LLdCC6o+wfgWA0IyJ+dCJdXGQi0ku0LLIPLC8Fi4QtDOY0IuSnFDJkdDw2BL88KOsv/CLqLwwkOUCsMdlWpCwUbFQRb71sJwb/XCyjeAQ0KB/cKbFiLDDFmzQjwqLMNiXybD7IPRQnwV00KX4uDCoNrGwQAb/8Lyw59CfPSYQgzK6UKExlZC8KCOQiMS7kIaxOtCZn1uwTbKQkKC7chC+Py2QjotDMNibcZCHbYYw+327EKHq1lDtpufQsUZhEJYXQFDmtAQQjXjy8IBztJBw4vAQrLvj0LgUYRCAw/KQp0Wc0Gu0Q3DNa3hQrCNAMNWWLhCvS6lQhRE3ELSuVNBLHbGQoVuJMM24f3C4DqaQjDvVEOA5LRCxNDOQiBaGMOTeYTBE3MWw6QhoUKUlrVCHnO/QpPQCsMW59VC4rv4QplZf0LmmI1CavMdwyAcykIeCB/D8a8DwxrUtULFNtrCDqPSQUp8aUGerInCNxWTwBIOZEIsy8lChiH0QnzLm0LfcynDYojzwvC8ucK4rc5C2nwWwugSmkG0u3NDHoa3Qrq4iELI2gVC/D++QXRtlcGAGiBCHn6HQjkRqUL68PJCtmWhQqYMGsPSiHPC/ea0QuJlDsPK5dVC3OkewXtPA8OU3N5CfsBKQ8CpyMDv+wlDnbzxQs5a4cIE0WzBj+Aswx74fUM=", - "encoding": "base64", - "path": [ - "vy", - 40, - "data" - ] - }, - { - "data": "ED7sQlLaT0OFDQFDkPYvwwamgEKgvsZCqmTpQm3tLkOCBoRC9mvkQn43qkIltplCjWffwstm08JI+W1DMCrcQkiohkLS6G7CYuTKQlzOMcOLVxrDlMqfQqpxKUOPMH9CB6SyQhh800LeaydCnOWIwV2d4kLWNmdBOJSBQyy9IsNFzXtD+boQQuZV7UL4j5RCPWQEw9zDY0P4JtlChFIyw1wMIcOGwr/C4DrEQig7kEJkYPFBO5SjQvNb5EKPzMpCfc66wTTLJ8NafrfCmnVuQoJAUEMUSBXDyEBbQj7W8EG8rAvCUIekQoR8SEIo88hChmiqQoJcN0FcjFfC4Y4dQ5ZHpEI2KpFAb4EOww91CsPrSmlDGw9JQlvU1ELaGslCxpeoQrISAUM2MflC4FzMQhiDxUIKrp3CpCxCQ1ZJEUGa3z1DkOkew6ZQpsL6mxjDvrGbwvhS2MKUr49C7WhYQkVvrMIRoZvCOOiCQ9FR38JLQQnDd117QoY4F8N6oy7DEoHCQso9uEIEfIrCiqRcQp8os8JKsb5CtNQOQhjW1kLKKIJCsG6NQOYs9UKuEHFDWKReQjp+gEJTDNRCVn+vQqxM08JY681CHFYEwzhN6UKwEIdDRPqTQq5OikEuGABDCu5aQqMsfcLUrkxCNZfPQrqepUK+x5FC48FFQ4QZpMIWPdXCMb/gQii+2sLBEcNCHtaaQtyPzULMdzJCNPjGQpXhDsP0Rf/CbJiwQjwfeUPMtsBCLdzGQsUW8MI2lvnCUuovwzePpkKkq5VCfnCIQl/IGsOktctCSif2QmQGPkOkzBVBpDnYwgeJKkMZRhjDMczHwrDL0EJknh7DhJVMQjQpzkIix+DBw8eAQsVYlkIycspCci3pQqiBOENqnCHDK228wrawGcMQ5MlCqTD3wnVt2ELkMnhDq7TCQjJjjkKyBYlChkRCQnNaa0LQJ3ZC6ORDQfpZuUL83vJC4MGwQkSa/cIS9JfBUCyFQj7Y9cI3TNZCvxtvQWCbxcLe6+dC6wyGQ+E2c0H0N3pDIIH4QrspsMJ06aVBOKsgwygwSEM=", - "encoding": "base64", - "path": [ - "vy", - 41, - "data" - ] - }, - { - "data": "eh/sQpo790IQVe5CGIA9w/YMZcBSj9FCQMLZQkZRgkMkpHBBbsLFQgp7hkL2ozxCQPydwk9qhMKKNItDEyTdQr7pokKD/0LBFKrRQr+sLsPAMTbDuOipQkAvXkPZpq9CY+W3QmYT2kICJ4fBNjPnwt4830Lc4ZzCFKl0Qx526MKEBB1Dco8+wk1X9UK3XZZCXmOlwgYDN0Mgvt1CYgAuwwRUCsOqCl7CVLKnQqKZcEEmvVhCsgSkQqC+1EJ7D71Cht8ZQnjaJMN8yULCvMmTPk0eg0P5/RDDdKojQKf1EENu3fjCdOVHQwnxQ8Ayga1CaPGVQr2NvEL0ShXD2ml+Q8XmbkLSe6vCOajYwuOpxsKKIYJD0IOhweCM5EJsldFC3DpJQ2BzdkOpfv1C7ZXHQpFOxkIO9LPBduSFQ7OUi8IGf7FCklzewrjd/MErjBjDnGqnwdolhMIldqBCfqqUQr0JZMI3R8TBC1IaQy65sMJelMnCC11vQcpX6cKp+h3Dg4ikQmQXi0Jm6iXBBzMpQw7XIsJOedBCNR4swo4VrEK6GI5CtKW6wnen7kLskYtDxGwiQ+2ikkIc5tNC8a2dQuIxeMKWXspC+CzLwqAA1kJok2FDhDFuQkZ8YsKbwe1CmmGGQiSFbcEI5YVCWnPTQsDAsEJGzJVCkNyAQxKoKMO/02LCRi/TQk4zo8IAMcRCAr2EQlqMsUJypIZCcxq7Qqj32sLcGunChhi+Ql+NS0PUX8JCzkKyQrQwmsITPDPDhAclw4EYo0J6zjRCgexQQRDuEcO8e7VCBUDlQtStgUPBTsvCshhBwjLYV0P8VgPDwYBmwuCn30L7oh7DDtiJQqoUX0P9cv1B1JA3QzA2q0Je6r9CmpbKQlb9gUNlbAvDhBpswvrDJ8OMAbZC5r4Pw8sTakM41ShDMTDCQlmRi0KmKLpCKDCDQiUENkOGLJZCxnq1wjyjvUJYeuVCMhe2QgexssJOMCBCHLePQeaHusI/W8xC9A0OQmYHU8LH8eVCelpkQ4zDA0JcMYpDxJ3vQoLyVMJuYzRCqLYGw971yEI=", - "encoding": "base64", - "path": [ - "vy", - 42, - "data" - ] - }, - { - "data": "mFndQsyk0EHm1sJC6Ggsw6qJtsKB+tJCmWW3Qlr6cUO9fYHCuNCPQjZG8kG7rkLADwoRwnoRVMGms1xD+dzRQo4Mt0IbykVCqkXOQvTAGMOXrS7D5EKrQvCsUkN7JdFCEg+0Qtz01UL8LurCbg4xw0Raz0Je1R3Ds6wjQwz4aMKWXGFCDA0Fw5y360LcJo9COhe1wfphtkJyG9ZCLowYw5Ab0sKM5q8+LKU+QtQxrMJ6YY1CLq2cQuOuskJGOKFC7G8cQ4cmEMMTWUhBJvPJwnhnW0PaKQDDerGdwpDxc0MoDRvDrCWIQ/w5qMJ5qYBCHghjQhCNV0OQpyzDFoV5Q6dzxUHl0RbDVCN6wvorNcKE2FFDnybfwsxC50Lcg89C/nF/QxSkk0O41fRCEOW0Qo+/vUIkf19CNsh/Q9hKEMOmiEvBGDpWwvYyH0IYYgnDxNhiQvlCHcGmcalCAAqvQkrXhMHlGCdC+SpnQvPyYsJWdVLCUMGLwhRVisIyCAHDfWhjQhe9BULqWJVC/dpyQ+AEwkHEstdC8mXvwg3FLkISjZFCyYoGw06k10J49V1DNuSGQ2qPm0IIc8lCzfx/Qvw6zsA7ubZCmJ5ywtxtrkJijgxDxj3oQSD+88KGP8hCyHmWQt2PSEJ42ZlCddrIQu1hs0LfF5JCChtdQ6qeOMMsM1dBBuq2QmwBL8J9HrxCLrE8QpynhEJVlKZCfZygQmGGgcLcpsHCY2vCQhiu30K0ZrlCGoOOQj+ss8EwfDfD0sELw0wFlUKy+wDBR3mjwg5J+cKYHZJCLyvFQtq4bUMdcBrDKufEQdgMRUPevcjCR27Av64b5EJinwzDgQujQuphkENHFwhDuFFaQ+5dtUKBJ6lCsIWNQizkdUOkX9XCglNpwX+zHsMc5otCkrYNw3z0gENw8IhCXFO2QqkHeUL8rNtCNsWaQlLEhEOyj6ZCQuQdw/rttkIYiMlCnkiyQkBnJsKeZQZD3LiGwlvWUsL0ULhC8NtLQnaFQUFzZNhC5qYCQ7DnOUJcUlRDw3XPQmbNOsBF4nRCsQDGwkXWqsA=", - "encoding": "base64", - "path": [ - "vy", - 43, - "data" - ] - }, - { - "data": "VyK5QhTQYcKvxmhCJkEQw4NeBcOuIMlC8xNxQhLvJEOAkxHDXkXaQd0WO8KRpK7CdheoQWD5dkJQEvlCDGK1QsLJw0JShgxDWdjAQqzb8MK2VBfDrRqjQsla/kKiq+ZCvk+nQkZ/xkLqdzTDGc45w0Pir0JyLDXD1fh5QpK/WEEE5YHBltgiw1imxEIwE3tC/kNRQpSKmEEHYsFC2KTwwiZtdsKqRqZCyp/+wQaYHsMaGKRCpFqNQqhOckLReGVC4mCFQwyH48I0DtpCaBgVw7rM+kLElMzC/rcOw5A5gUPsmhvD0OB1QzIEF8MlKfdBntDYQVBRi0M8rybDsFs9Q4Yt4sF7dijDbGr4v05L7EFQQQVDJNwZw/R230LYmL9CJh1oQ1CZZ0PjWd5CZn2MQj2hqkJIFSVDrsIjQ/r2JcMIqKvC39+AQePZE0OiFd3CSTgfQ1b+h0KsNKtCdzq+Ql4uMUKzFgVD3EAHwe8yXcGXGi5BRh8hw+c0rsCwO7bCJ1d3QQD8xcEo3T9Doi5wQ97B7kJeT9VCHREOw7BOHMJIc41CDKwOw2QKqkJRswVDwn2NQ/v+nEK+O7RC52smQhiNikITxodCYAnVwMQ6VEJjACdCAjEIwk5hEsPhnIlCMEWfQk0HFkMKT6VCpp+oQrsorkL+MIdCneoAQyp9LMN6cOtCopKHQqkrGEEE7alC/Gt3QVX2/kGd6LtCCiRmQhiWrsCLmIjC1qy7Qh5ox0GczKNCsPUtQtp4QkJkzyXDKGnTwmrhcEKz17vCSBMPw/aQvMKs2T1CC3WTQsxqK0P6wSHDQcflQhi58EId9WzCrwucQlBW3kIPC+LCmbCzQtERcUOan35DOM43Q/gMt0LVeoNCFN5dQfjfIkOfPX3CqKwvQgzwB8Oc7/dBaAkBw9gzTEML2NXAtxOeQjY+MUJgRPBCEluqQsbRekPYvK5CmPgqwx75pELK3ZtCc/akQmppnUG01WJDvvIFw30OVkDE8phC7Mt2Qhgv20IO0bxCOqRHQqiZYkLIve1CwFWIQj8PnELT449C+f1Uwl5uosI=", - "encoding": "base64", - "path": [ - "vy", - 44, - "data" - ] - }, - { - "data": "GQdkQqqH+sIqEs/Aokrbwm9cEcMya69COzqeQJbtl0I7tDDDWL0vwp56CsN46yzDmXXQQsxyLUOm4w9CfYp7Qve8yEJKpYNDFEGoQmiOn8JEvuzCaEiPQqRAYkIeNvFCgZqQQiF7qULcFDzDok0swzoadULyJzHDUJB5wUDQx0L6XZTCcNkkwxjoVEL8cT1CKlwPQ/HkGcJcDp1CZ06dwro9qcBKIkRDUNDewpqxMMO63bJCa3hpQgIyiUFmdaVBAl57Q1gSl8IQnWRDhNkbwxCHMUKz5YbC9D4iwyaiT0MgoQ7DsBImQ9i5K8MxOYDBxEOXwdrHYkMuVxTDoyzbQoQYycJKZiPDrpCkQoP2BkMgAjFCf8siw9IHzkK0Z5pC+k4mQ4jnA0PIWrdCjuf2QVLZiUIyynpDxHNzQvaKIcOEYAvDpJ/NQrthdEM5cZDCnPlmQyXGLEPESaVCRXXDQshFHUOc3nFDrtZxwkS7QULqBcZC9D88w+z0pkJ++i/CTGRJws8F6cLw/oFDyyQ5Q3qKZEPt+chC8GENw9zwE8MkvYFCAEIIw0cFNUJyPRpCngVRQ3SDl0JKRZJCamoPQRxdJkO6FZdB3rSHQv1H1b/hYCzCj5ffwjAqFMNNNKFBeiyhQnEOg0P2ualCbulIQlyhoEKsZ2lCVM5NQvFAFMOz31lDpCr2QXdGukKgCYtCorQNwnrlqMGA6sdCht2tQQcHm0LmbuHBaXelQsBbLsKM6HpCKqUYQFwiEUPIoQjDcKx+wj5XC0IAlhfDKBMewwz7WsKOgjtB3esXQscIrkJi+xfDHF9LQ9IYUEKkcpXANHY+Q8YWzULumZvC9li8Qh7hFkO4IYRD/uUCQ94XsULcHRRCu+qnwlpWikI4g8fA6jAAQ3pdzcLlngnC+T7awmZEAkPPIYbCh7dtQm1I1kAA8PhCuAqzQlyLOkOHwK9Cqpoiw9RUhkKZey1Cz2qMQqIfzULWw2NDfogVwyDRrkIWbVZCHXeJQnU+VUO6y41CW/lKwa0FgEIQIOdBgJygPvMUUkMoVp1C7CXAQL0ACcM=", - "encoding": "base64", - "path": [ - "vy", - 45, - "data" - ] - }, - { - "data": "HFTiwDpWNsNRs8DC4HOKwtpoDsMmNHdCRlSuwimndEAgpTLDczkHw/ZbIcNkLkPD7ktVQzxRfEPjvgLCdANFQdYdxEJgiJdDENmBQv4p8MEwjJrCvi5XQtxoD775c/BCMr5aQtTjdELAFi7DIkIUw1hzjkGGmx/D8suawg5PNkMZzfXC1lQZw3Y0usFRGrlBZolkQ3KKrMJZC0lC53TQwewxjkLQvHdDOh0Fw5QwK8PywLpC4AUgQqnQJMIbuQ3CDd5AQ2pi5MES1YNDVowSwz5pnMFMkanBUkwfw7YgAkM0mvPCb5+QQrHeJ8OHTJfCgnSjwiR4DkOlv/XCTIWbQWo3GMMolhLDeA88Q9cXYUNMgiLCtKYbw/6ZskLKGR9CqsCgQkL0IkLVVHVCiqcmwpUSKkI+y4RDHARQwZCBEMPtZS7DpEg9Q2ObgUMAyZ/B7exyQwa4bUPGApZCZr2+QmlrhkNqgJZDRjbQwkTOGEN8vEdDJIQ3w0ZaO0NoCHRB7EIEw96TOcNUYXJDQ7jTQkoNjkOCALFCqAICw2LlO8NS6FpCljbzwgien8EeYh7CRiLhQiTJikIa+j5C2BIVwhrUf0OpmoTCcAkuQ1/YnsIO9tzCx2kEw9kpCcOmeUvC+KKbQkqSkUOdiadCmB46wZ4ciUL+mjJC/v8nwZzH6cLNYoBD+nHHwZYaXUOOezRCyUbOwoR4ysL5wcpCLAP1wcpRO0MoA/lBdFttQkmkycJccfxBt8tawmJVY0M4i8bCNrE9wa97A8EQxyLDDGUZwz9lUMBn2BPCbJ00waqWjsCUtQXDbEyHQ/LArMAO649CuwyBQ1M2rULCuQjCPoi8Qnhod0KEYElDEeiLQvxJo0KfnaTABbciwxBiNsB8sZBC+atcQ0YZbMICid/CFfikwmhuQkKE9OvCOPPwQdwsX8KWT/VCOva0QmxC00L2palCAh0Qw2amMELFSenARzFKQi7QR0PKtDJDxCIRw6qVTkOM7aRBVgiRQj3weENkhQBCoMSDwjttiUKQ9SjCbo26wnb7hkOYI6RC7GyvQhlZL8M=", - "encoding": "base64", - "path": [ - "vy", - 46, - "data" - ] - }, - { - "data": "T1PFwqwAXMNIzRrDIKqtwc6qAsNiHzBB6agjw4Y5ZsJgXiXDCPM1wyjoHMOUSjvDRBiBQ2uod0MSnrTC1CGLwny+sUKsT2xDWpoRQizAAEJ0UNjBo4DDQT+aQcIVreJCIRLjQYrdxUEyjhbDY0rrwjYBTsLp2AXDPCUAw1Nud0P2SCPDXr8Fwz53s8KswkLBgt+MQ02s+8Ka/gZBHIIoQk5OMENw6V5D8koFw85FGsMy5LtCiDhQQaHFz8JYkNzCVu/2QnCQ9UGw6FxD5kQBw8ZPlMKw4ytCRowQwxBZJkJW573CzJWWwJIYF8M6XwLDCBr/wuy7gkIclLfCXip5wnJLJcNWe/TCzit+Q+TsgEOnd+HCnGwLw3+Xi0Lnkf/BdpcOwXJE58Hi/3xBRmT2wiggjr7M51RDrLKNwpHZ78I6OjbD8ON/Q8ZWTUPe41BCEG5JQ6CPaUPIgHNCMu6uQirLfkNDc3dDoCoNw5jQdEP23H9DAc8kw30RfkP3bbtClHIpw1XgSMPnoS1DNkpXQfaodUP1xolCkGXgwsJxPcMLKB1C3LnJwj5028KY1NDC+K22QQoSa0JiJSRBQrTAwshpi0McZPfCJtx6Q02bEMO3+STDtIsBw3ZV68Ko9QLDiPCMQjg8XEMiVZ5CxA2ywoooSELA/MlB8kWAwqVSn8K6EGJDSmrKwsfbh0OQz9hARvUIww6qL8MkhMNCU969wpBugkOYxAJDC39wQd7sFMOJk4XBRA3wwvCpfEMQMVjCnK5aQpKVkMKS3RrDUOQKw9VehkL2ZMbCVqaWwrKbo8K6WtvC3seFQ1UTXsJ7aDZDLEFxQ6vPcEJE4KhBmICyQhQyA8HKFfRCnk3CPyZgjELCpH7Cvok5w5oVesKHGjJDOZ9xQwQvIsAOmxDDV0A/wpw8DcKaPCDDIiI9waQcusI3iuNCzEyvQh/1q0EYf5tCRn7uwiYqOkFDaZzCqX6iQfSxekOgyuNCYF8Dwxw0hEMsvt7BCjWSQsgwWkNYqgPCRPfiwmEdjUK76czC0P8Mw9J3bUOuv6RCdCxEQ4iOPcM=", - "encoding": "base64", - "path": [ - "vy", - 47, - "data" - ] - }, - { - "data": "3/4Vw+LaPsNgaC/Du/4QQr4o4cJAfqnC7K06wwR04cKvEg/DU54/wywLDsOYtibDwrNjQyhmPUOuXQzDQIkKw4RPiELkPBJDYAqrwExB5UIo1Q5Czk+mwVwStsJ0R8RCBkIswch49cGo1PLCIjCjwjn9CcNec8vCpm4ow86/hEMbAjzDtivYwgMl6cLqL2PCTBZ/Q1wcGsPid0jCz5MHQz7yfkN8RSFDJnD4wshbAsONgrVCXhfXwciKCsPhgRnDGt9AQu213EKGohRD0F/Vwp5+9cIGLA1Df870wlccEcLk73jCSASJwlK6/MIgOhnDQK0Lw366CkDAlFvCt1wDw4BvHsN+iLfCYiB6Q5AgYkNoxS7DvLTpwv2pK0K1WvXCkrKlwr8WrsLqpkrC6JsXw6ZPjcK8pQFD0fLswqwDs8JkPwLDSXqHQ8Zg90IU/xRDKA0CQyzMNEOWYhJCQIKRQvHaRENSOBFDUggow4jbcUO803RDII8Kw6vvfkPR00FDzOwtw1yLPcOBEqlC7quJwhOSIUMWDxlClauywuPnLsMUQIdBVL6Uwq4kI8Pyqx/DG+w7wiReKkKU8zTChlUNw/h4VENxWwvDMOd9Q/8tKMP2VkzDlorrwkiTtsL2Ri3DHwNjQrjp/EJMu4xCp6v5wk39qkFzQ+u/f4/hwsj8D8Iq/BpDshEdw5oHa0OIFljCpjgMw77IRcNQ9q9CcFcEw1k+gUMUNWxDnMhlwgJuOMPYNabC5v4Zw1LIVUNPUjI/gl0TQ6527sKQ8AnDzELswsaCKEO8JxjDVwIOw2yDEsN7AKHCU+IvQ+CEyMIwQYJDS/MvQzhjikFigb9CnJqaQljvh8J8nDhCiD+awktIU0IaY/zCZhA2w7nJ5MKhqIBDWjxIQ10CkUJlnhXDwDnFv8Ii1sKycDrDaFmHwnpCycJQ3b9CGu+fQjihScKOD4NC4Syywo7k/cHYCRfDDgDLwRQKakOklidCAKzfwqsqbkN2fsfCXFqMQjPxGEPS2gbDdZEcwybPiUL40RrDKvcaw6XLLkPk3Z5CqjSIQ6+oE8M=", - "encoding": "base64", - "path": [ - "vy", - 48, - "data" - ] - }, - { - "data": "sJYkwwvBR8Iw8S7DsBvgQuTDscJGqiLDMjw3w/Y0I8OOl+TCgSA2w7SU88L3kwvDBpEkQ0n73ULIkjbDHPkgw2DXyEGcaGdCa7yBwuxMT0Pq5uxCyMOfwhagAMMe5o5CfNOHws8M2MJTn6/CzW0fwjmnMsOc0n3CkJw/wzu5UkMaRgvDc2qZwsmr+cJi87zCuO8hQ7YIGcNW0+3CGvZjQ05lg0MQCqlCoq7bwnDUycJGnaVCnICnwoeuFcMUQSPDg7P1webGTkMxXoBCFPWewpWQJcNIBnBDOwm9wry/zcL62rTBDNL3wmImv8Ie4RrDkDYHw8TsWMKgjCvBoxM9w6kXDcNNp1zCaR5AQ/xQG0Mm0F7DCpCxwpsCvUBSGBzDGLwQw8zACcP3cgbDsvUZw8BRHMMAghVC+EQdw+i2VcL+4WDA7vFRQwxu9UGI11lD3O8sQly60kItK6PAUFpEQuPDAEOjJkVCVOMSw+rSP0OcPTlD3vzVwuP0R0PMHYNDglIiw8m9JcPkwwPBlPAFw6QMiUJ9dRXBFON1wq4qGMMm7WfBxyUlwoabMsObAUzDF2jSwqaNlEFqKPbChjAYwxKN8UKyCQrD+wZMQ5+zKMMofFHDjZ3KwoquaMJOLDnDIsMEQrTgPEI7z19CGu0Fw2nQvcGtqxvCpjgdw/W1gUEiK4BCGi0vw/tEKkNu3AjDa2YCw8ioPsO2BYxCUUAPw/pQRkMaHHpDfFHpwrq9N8MULwXD3u4fw7vZCkOM+4lCvrhxQ1bnAsMuKufCcoa4whxodUOwZirDHJcwwzJkRsNIXTbCvqWKQhUmC8OkkYFDJnK6QnRjUcJSj0NDgtdbQvhK88L3+5PBeoMXwzrm10HspRrDDuUlw96UH8MjNoZDyHUHQ9YuKEPfyA3DeXGBQnYrKMPOxxLDOOnzwq5cwsKc54NCKm+CQko448IEyjdC8JhVwkT0psIXkTjD/NeywoFRLEN8NQ/CHEqvws4/LkMGvDLD1d17QoMUjkJx2EXD0V4+w0q2eUIG+UXD68gYw374y0KRWZFCikqGQyg/McA=", - "encoding": "base64", - "path": [ - "vy", - 49, - "data" - ] - }, - { - "data": "0pQDQ0zgEUNcFBxDTxIhQ7mmJkMKqx5D5dwGQyq5J0OrMRFDDqEnQ2cWPkPwFS9DWCk8Q/7QHEN67BlDq8YpQ1uzKkOgUCVDzQkbQ89rJEPZbSxDUQMWQ6xdHUPiCi1D/g8eQxiTF0M7BhtDFh0kQ5MSEUNM1BBDy7kgQzWYLkNQkA5D75IjQ7FBEkNrmRpDNgwVQ62gHUMFERlDTkQTQ4SzMEMJLzdDKy0kQ+EqJ0O/fTBDDAEaQ0DSBUOO/xhDHl79QrWVN0MaAitDxK4iQ4WhOENPIwZDy7smQ4h/DkOmQh5DtZs2QwxAG0P6pRRDhhceQ97IAEPvRhpDadwrQ06EKUP8cixDJ38lQ1ekGkMC4RFDr9wjQyT3N0MpSSND3zMFQ/KfIUPagSpD7lE8Q61HEEP2eyFDnqk+Q9kbGUMp7DZDoQwSQxz9MkM+wiBDa1X/QjOmJkMysylD2EglQ80vG0OfdRxDKlEQQ3yjCkONrTJDKlodQw6PAUMcIylDiIktQ8uwB0MI5i1DXZAgQyg5IkPBzhhDGCQ1Q6qoQ0PyDi9DFF02Q4KnIUPK7iBDxComQ5tcIUN9ERFDHiEFQ1NBNENxVSZDpDIxQ7LSJkMIESRDnFIEQ2GYG0PSAexC22kZQ/g9PkMgjxFDacQcQwLjDkM82S1DPUg3Q1n8IUPk3RhD2uwKQ8JFN0OBo/NCrJcPQ/66AEPoyyVDcskIQ6ulHEN3YwlDGo4EQ6ovMUM/GSNDxkEYQzeaN0PsVQlDOnIRQ0FlEENKtwRDEx0fQ7SJNUMRkQhDPAwNQ9mtGkPp6C1DlZgdQw9SHEM7nSBDdlQMQ8joK0MyuA5DL6UZQ8jJ2ELTzC1Dg1TvQulwNkPOjv9Cd0ZLQxeyMEPx4jBDKaUJQ+jmMUPQ6ThDj6MZQ2utGkPljxtD1u1LQ3LMLkMNzi9DWCQuQzeuHENERCNDxXUgQ1jWL0NKIBhD+ugXQwAvO0PnZBdDWCMSQxhKE0PjwjRD05ExQ7cNIENL8ixDo4oTQzbdG0MQHRBD02QOQ4H7HUO4kQ1DyWI3Q+a7M0M=", - "encoding": "base64", - "path": [ - "vz", - 0, - "data" - ] - }, - { - "data": "htXOQqY95ULQcxVDinAhQ+RdF0OEXexCCPP2Qn6+DENKFhxDF8kmQ7ZDGkMKXC5D3HQsQ5rHEUO36/1C5NgZQ2K7CUNx+gNDM5cfQ5ZwLEO0JQdDLJAVQ8OS/UJXDCxDNBEQQ4QW40K+VAtDzAMHQ0F0AEPz/OFC60MOQ+ABDUM+fehCP8UfQ0617UK0tCdDTkcGQ2loBkMJJiVDVDYfQ+1rIENlcBpDlpYYQ0hs90Jm6hBD5DQRQwUg6UJcjh1DZ7YBQ49jJkPA9PdCmEPpQkCjGUOXcAlDzVXxQhHVxkJmxO5C44ohQ8Lo10KeA+xCFe7iQs1qq0J2KP9CEAAlQ1bjB0P0uhVDMDr1Qjp5A0Py8PBCoC0hQ94yFUOS7RVDUSHEQkaxAkNgSihDeN0tQ/QiGEMytyNDi58TQ8eKFEPKCSxDxMgWQ+mpHkMXLgRDcYHDQh/2MkOHqCtDEq0iQ3IeFEOoQRxD4GPiQkEDA0M49BFDU8kFQ+c32kJ/tBtDEH8BQ4iS+EKiPRhD6jYZQ8WqGUPeQhVDXpkJQ/AaIUPKZClDkWoVQ0xBEUOgXvtCfTsFQzTPG0OsMRxDSGvdQsz/HkO2LhND7vgLQ8Z8BUPI/ghDWowBQ3bCJEMskedCb4cOQ6UIIkNCiepCzK77QkKeGkMnrSlDmoMSQ8TY7EI8yBZDXmD/QijRIUPYtANDLZrUQpCzBkNcnC9DSojzQqhFEkPAgw1DyHrRQpv5JEOaAvVCpCf5QqDiIkPMWgxDQ/8dQy4I7kIuGghDMNb/QqiWJUOkiQZDVgEEQ/BWEEOXfxBDgIUVQ2zoCUPcmhtDoDYCQ0s9I0O1hPRCitwjQ11y2kKofApDyNPxQrGfE0MEsvpCYvwjQ+u5I0M/2AlDWOzbQmpkBUMoHxdDRnLyQqBQBUPJ0vVCZCNOQ0ikGEPk3CJD3OwlQ/p6EUMmzQVDEkMcQ/aAPUOaZNZCFrccQ9DOHkMNzvJCyCjzQhom80LxMTBDxPAsQyDKJEOrIzJD/fT3QghpHkNkagJDt9oUQ9nCBENmee1CJ/QgQyLuFkM=", - "encoding": "base64", - "path": [ - "vz", - 1, - "data" - ] - }, - { - "data": "fpLNQvm5ukL+BgFDp48LQ8jZ2kISzbRCwkPXQoTAsELMLg5DM4sFQ+bD10JTBwFDgYsAQykY70K+ua9CvBbkQt5OxkLKCLNCl0wFQ6xKFkPUlbdCUK8GQ1CNqUIXDhJD3hDvQgokrkJKEO1CLLrFQnbm2UICi9tCVL/MQsBgyELRa6tC+h7zQkc+sUKA6xhDz+nVQvMUx0IIgiBD4KQMQ5r2xkKuouVCdLb1QvYXfULLXdVCrQr5QmYzvEJO2ApD5KLTQsBG2EIm/6FCVmytQnBVzEKeLA1DZHyHQippf0K6wsVCcm70QsyDlkKzt65CXG2VQpykkULUd9hCWPgEQz3xwUJgaMlCUqWXQgQO00LY48lCWa7mQs7C1kLk4vNCHpmsQrz7rULQvAlDhivjQihqCEOGdxJDwynGQlGMB0PAjO1CwngAQ75EwkLAFMFCzkaxQrywEUPmyAZD+pgOQ6B79ELj7P1CAA6VQuKR5EIopdZC5x7TQhjC2kIuE99C+q+UQmtY10J7Sr9CbOgCQxlA7kICkA5DjtemQixp50JOzhBD+aqvQmrE5EL4BbNC5lu0QpLKAkO6BhlD4KzBQnDV6ELcDNZCaxOqQkRWukKfhsRCjOruQrhgDUO+kNtCOGXwQqkf7kIam8xCQh/AQnrbEUNbcg5DNZq/QgNSuUKpDQBDi34AQ9s95ELdJgJDDiGYQsZ96UJusB5DNnfKQnxl7ULSrPRCBHbCQvXr3UJDBp1CSvC4QvQo30IW4AxDV4AOQ/MD10IaCQVDhH7MQt5z0ELqiedCv87ZQuV/30KZRcZCyowAQywfz0KwPfJCGCTtQjYg90K2B/VCKmILQ64Nu0IpPqVCMjfQQgGG3UKdU/JCg+bhQiSJ+0IY8qhCvva4QvjUrUJAtLtCBfeeQs7oyUKOJ7BCS7sUQw4y7kISIQZDwoL4QnAT1UKQKtRCM2btQqI7IEMGualCsssNQ9ze1UKaU8FC4FCyQn5Cx0IvLQtDM7gUQ802AkOXchRD6mqsQr+aDEPMYcRCkGQDQ3CXxkITft1COR7KQoAT2EI=", - "encoding": "base64", - "path": [ - "vz", - 2, - "data" - ] - }, - { - "data": "CZWjQh6tdkJi8qNCzwubQk8pckKa4GZCz0emQlJ4PELn/5RCxAybQpj4VEJM6Y9Ch9yMQiI+kEIA+QVCgkNkQr74WkKDgRZCahGsQk5/oEKDx4ZCIlfQQqAtHEJCxsJCzJSqQtfui0L+tKJCWGp/QrDdt0LSaLZCtPs0QoZZW0JiOjxCiPh4Qi5VVEKE9gRDEKiBQjigU0LC3ehCwRGSQjREN0Jqmn1CdTGKQvgZGUIUz3FCd9u7QtaKfkI4UehC4HRsQnTrH0LLYolCvwGRQnB75UHSKcJC2GlaQoLXLEISOKhCdFd6QjLPgEL/jFlCaUhfQiciQEIkWZ1C9uVyQqjNZEIyyltCOqdiQuqZlUKgInpCiitWQn41bEJzmp5CzIB6QmrEyUF42q9CdzVCQkaF2ULe46JCxjEjQuRDo0KEkHVCBJauQojVNEKotmZCtqaFQskopEJPBpZCWmreQgsDpULuZ5tCtFsKQtJ4qkKTtXVCtuqDQmDDrUI2ClZCWBhSQulMoEKu40ZCAhGXQtwWckJktbdCPNpVQjpcbEIkEtVCWNpEQmmPi0I0qTtCsP0aQuL5t0IwGOpCfFeTQvzUNUJa7mlCHfEVQkxeY0Ku2U5CUtGqQoukqkJEUqxCWBWuQoLOekJd2JFCbeZyQvEp6kJauMVCYsfHQUcYokLmY5tClfy7QmsUgEI8WuBC+B9vQtLmpEKMAtdCeMWVQtS3hkLMsaxCF5qTQvSZRkIuP29CpFxjQt4hHEKKBbRCHiuNQv60o0LLm8ZC1BGYQhxuH0LK9LBC0UKQQl7MdULebm9CxOGcQth0XUIkE3RC8jGzQpGMjEJk3LhCDPK7QkBnbELGA7tBuB6TQiz2iULY9MJCNihbQrJKdUJKkipCTD14QorpNUJPuT1CxmHnQbhve0Kq3UFCk+q6QtBwlEKzgrhCOm2IQn4XM0KmU45CqDlsQu4QzkLGp49ChAfpQv1wH0Liv3hC4mBkQtj1g0KEhY5CiBDWQhMJiEKeEKpCJAP6Qc4i3EJQK0BCahrFQpZwbUJOML1CJewmQvgxUkI=", - "encoding": "base64", - "path": [ - "vz", - 3, - "data" - ] - }, - { - "data": "mJIXQgJk5UDqXStBE9nxQEKBlUC6nhdB6j4PQo/9I8EoYBzBVKPzQDeFhcHXT6K/x3Qmwe9Av0DXiUHCRSaRwJAQDcCamtLB0EliQYLEpL9Mxr9B26XrQduDiMEEg9pBAsgTQqgTCEI43XhBrYQ0QZqF8UFYWsxBiH4XwpTd7MDI+ULBtjIYwX0NH0Bu52NCAHtvQKpdLMG2LwlCSFT7wHgBs0BWOObAQ7wPwEQOfz+Ik5694CfwQXaPp0FfxDtCvmqdwbgrL8GEZQBCgHsLQnDU58GbWCJBaYl6Qept3b+sytJBiPnEwawUy0GK831BOmCeQRqyE8CE045B2OdVwRu0gz9IvOJAGZ2LQaTvekGcuxbAkeMzwOLXwT78LHxBeE3qQMzT78FBIWJBDB6/wRKsCkJdLUlADyzQweBMxUDMMTvBsBmnQYKmZT++mK1AfEh7QTwVA0BabwRBTKaDQjr6ekEYfxpBePpRwawi40F45yK/fGkWQck/6EGI3jy/YvWCQUZh8kFRYpNA4JNHQGMJucBwTZVBivCLQWpWbsEk9U5CvTBTQfUq+kDCyZnB1PVswQJ4CULH+QBCoIjYQUi0sMGha3u/5lc7wQZWk0Bw3QrBFi7aQcgooED2uBBCWk4WQlw5icEmyLpB2pEeQUC3/EG2ggxCHnHYwWs87kFmoeFAPMO+QTTHe76G8vFBVJCnQR665EEaAAdCYZ4cQgFJZL+XGvZBwPjDQUfCgsFFF6hBwjYPQcaHi8EXLpZAaIKGwYIb00GQc7ZBtlavQewU0MAOJUBCLCiXQVlEV8E7Jz1Byxm0QKnUNsEkt63A3vCPQSh+5j8g5zFB8v3oQe+LhsD0PsjBu1KzQdI0fUF/qgxCZhhjwcvrysF9l/nAGR1EQWCItECwD67AbLLswUJlNEFOkibAep7uQamZREEiaQ9CDIUKQTq7SML1X65BiWVNwFzlDUK0NQ1CXNsVQkSYlsFiFidBXUoQQZzEUkHwACxAOB03Qgv0eMGdo/tArLNcwp4AP0JSPfzB98TRQZI7RUG6rQxCHKp9wF5QpME=", - "encoding": "base64", - "path": [ - "vz", - 4, - "data" - ] - }, - { - "data": "e7xcwvCFmMIi+6HCVzCbwnR+isIsdHjCuqRkwtp/wcK6z8vCsZ2rwuQzwcIPosLCfFvgwkCFn8IjACrDWDCewl5coMK7QL7C6Rylwu3oscL/xoHC/BCCwlYXu8Jekk7CqBjlwav+QcKidJnCJw2FwlTtgcLeMaTCWqsVw8Z0r8J32dXCrA6jwqj7lMLAbgnCfMCTwlnVt8JZ8knCfSy5wiypWcKMeMvCsCmhwklYhsL0nqDCYJFOwpaAJcI1mDLCDKAJw6xZlMLUrlrCS9hcwm47y8JiT77CZxxbwtD7nsIG5JnCkMjswkdcRMLFhUjCqr8ywkrQr8KgFJ7Co4nTwtz9mMIu6HzCxTJRwpPKicJLhcPCwo2HwuAMjcL4zofC4E2lwsrW3sJ2GKfCmFisworxdcLMYrfC2TywwoDIuMJuocnChHCHwi6+aMJ4NpjCOQqNwu8eycK6ppbCUj3CQP5lnsIGPJXCqvm8whY9fcLRGKXCYjN/wq8ffMKYH4rCOqszwunOYMKK+mLCFy2vwkSup8JQwZrCEh9dwgb3zcK2PZDB+PpMwqq1nMKWC/TCB++fwrorMcIxbHPCkB47wuApvcKMFaHC+HGkwqRtjsICvMDC5LpPwpp6uML60kbCINQDwrg878KIEFHC64mFwqZYe8Le3jbCnpO+wo1gi8ICwJfC7CidwrZJrcImZYvCGA5AwnN3WsL+1ELCUusxwvbHqMKTLWfCenBcwsiIyMLg6kfC8uh6wiSPrMICgsjCmBTFwvDhacISy6PCMpOPwvSjg8JTxSDCbHlWwnq+5sJWR4vCsU6qwq5nwMJgdprCEuGfwsm8q8KucMDCmBNfwsEg3sIwls/CZshxwiYBWMK2DYbCAhHCwjEf0ML436LCGJ5uwho0gMK36JnCgubSwj40lcL8z5PCTocvwq4Hi8IllQLCs1iNwponJ8NhBkHCmwqQwgQVJ8Ikhz/CLBlUwqhTrcIewXDCku53wm0MfMKuhZHCp+z1wfJgwMIHIaDC8uY6wwCyOMLE9xfDzkCRwqi+ksJ0I2XClkiCwrLv3sI=", - "encoding": "base64", - "path": [ - "vz", - 5, - "data" - ] - }, - { - "data": "d/4vwyCRM8PJpkHD3JY3wzytJMMMKyLDWNktw8gMT8Mf4TPDAp1Lw7krMMOPmEjD9gtNw3j8L8MUsIvDtg8iw/NzOsNYIE7DhuM9w9poN8O6CTbDNzUpwwZaOsMpKATDAG7iwgptKMOHm0DDBmgow01cNMOT7EfDm/x9w4hALMMfPGzD6GMswwRBM8OkGf/CCCYfw9ytNMPJ5grDBKsyw5Z1HMOqr1LDtOsnwzexGMP90zfDaiwWw7SGCcMivRHDphp3w4DeIMOycjHDnfAvw/bTScOK11HDOzQUw2lzLcOYD0TDPepRw56nHcOA1A3D3JwQw8g4TcNk5z3DKOtQw5FMHMPGlCPD3HQbw9N0NsOSn0/DYewhwxzHGsO6CTLD4Pgzw8ync8M+4DjDO84ow5aCI8MZakXDgKo9w64MR8Mw1jnDapAiw/AVHcOgwDvDEYElw2SsWMP17DXDMDKFwhgAQcPuIDDDJkhjw+huLMNywjjDvoEiw0IGOsPWQSHDu/EWw3J5GsOQvhzDvds4wzwwLMOCZkHDoSMjw94cScOqWMfCXlYdw1HbNsPkf3rD1qFAw+KUCsP7cCHDvnEPw8q6N8NFTSHDGj4qwxGAHsOUbFjDWO8YwygrQcOV3iTDalz8wpvjXMMZzSDDdhopw4bxJ8M6uQnDSkM8w0BaQsPv4i/D7uE+w0MLPcMy+zLDqoYNwwa8HMMwIgTDSL8Zw+hRLcPEQzLD0owlwxzxQcM+vSPDbfoXw2hpK8P6YErDYsYswyybL8P8OEbDaL40w3KaG8Oy3ArDl48Ww044XcNG3CvD6OAywyRaOMNFICvDXkhEwwaZOsOpxkHDNLoYwz7JasPoTVPDQJUlw+DFEcMCQy/D3shFw/4hOsNYATTD8DQOw0gCHcOuySfDPjpWw5BCQ8MSdSfDVG/8wtWjL8MDjtjCxaEww8Rad8PSZxHDoo8nw75O98Lm+yfDekYbw8WjK8NEoxnDHcsZw775H8Oc4x3DTNzlwuYPPMPc6jbDlB6Cw6TfD8OIpobDHmA5w55sO8NkPyjDwOEWw5SfWsM=", - "encoding": "base64", - "path": [ - "vz", - 6, - "data" - ] - }, - { - "data": "Mw+MwygRd8Miu4fDWEaNw6S6gMOu6HjDNlqLwxQEdMNyLGnDi9uJw+b/asOVFYTD+Np/wzxheMOuZkfDJK1zw8p/isM+H4jDdCuGw8AwhMPJLIjDSnp7w4kJZsNRyEbDdhJMw1AuhsNzGYfDokaDw8X2jMPF5IXDR5dLw2Q1Z8P+CWbDhqR6w/P8csOWp07Dzidmw53WZcMIGVnD4mZuw60wgcPhHonD9Npww3GmV8OWkYzD9G12w4FAVMM2om7DoBtfw5OaZsMWQIfDWOuMwzTubsNOeITDUIR6w/CtWMPIm4XDOGCAw7w4g8NsDFnD5sNzwwtpY8PSLYLD4v9+w/PkXsPUVYLDPAiAw8YFicNCe3bDUjZ+w8rObcPvz4vD/RVkw4DffsOkA4LDFo1jwyEjgcPKg4PDbI6Ew8xOhsP9+nvDTH91w+BNf8OaJILDje5gwxO6i8P2Wo/D0IQQw7DBjcNAJojDQiFywyRphcOIEn/DvnKBw/hkjcMep3fDiKB0w6CEacM3xYHD+3F8wzwYesNrGo3DGsWFwwiOjMMTRjXDfoaDw7ytfMNoNmvDkn+Iw7anYMOc/HvDGoNlwxY5c8NVAWjDWxlew9d8YsNpcYPDwON7w+4kiMPa9HvD6Slbw9s0isPHxXvDvCR1wzO2hMOEmV/D3o5pwwyLi8OxV4fDdn6Gw8I1hcPws4rDfHNxw/fGbsNJokfDUpBwwxk8dMMdFInDo4CDw/SOcMO/h4DDItNhw379XcOqcnzDKHFkw1ycicOAcI7DZyCGw/rwcsPHl17Dsrxjw4ydbsPsgIDDDFB7w5oMX8PkRnzD9iCGw7oEgcOcUXfDjE9pw8xLV8PK5GnDVs9vwyLsc8PWXoHDR2uEw1Ymb8N6eW3Duz5gw/8ja8O+xmrDvEmDwwwTjcM/JnLD8GRPw0WZisPAFTLDIN2Kw8IdQcPmqXbDdlR7w1bJRcNXR4DD0853w5jVX8MZTnTDfHFxw1buecM5bW3DDPU8w8olesPdcYrDejsywyJlV8OEV03DKWOOw32wh8MScn/Dojt1w/j/g8M=", - "encoding": "base64", - "path": [ - "vz", - 7, - "data" - ] - }, - { - "data": "rl52w5JfMsMwd1vDzOxtwxkcaMNOelrDKLB7wxRpLsPY/j/DKgZjwwUJRcPSm0/DXKs3w7YGXcOmngDDxGxTw2ScasMlLUfDe6Jzw2R0YcM4YF3DzvZ4wzsrHcMYgmbDrhWAw0oVecMMh2LDaBVhw2SdfcPIw0vDXh4Fw0hSOMORiBbDgSxNw7D5R8OT53bDyKRDwyu4H8Od4HjDd4RNw4iWdcOCO1jDTqpiw5BLRcMWn4PD3EOAwxYMWMPMWYHD4Mgjw1w2VsPSX3PDJ3t0w5WNKMMg5UXD6Kpqw/HdGcN7fUzDODw6w+DfcMNPoljDkettw4V7I8NeJk/D7ek5wwMdS8P6oGjDxixvw0SwYMME5DHDQpRmw9rDd8MJHnXDsUwhww7ULMPCJHDDQ+Y/w36SgMOWuE3DPg07wxUPTsOSlDbDGN1bw0CLbcOob0zDars9wwp3T8M4Y37DX45Nw4QMXsPCQWLDzN0aw08xbcNxKkvDVIlqw1OpZsO0ZmbDxlpvw2gIZMP+CHLDMANKw8AFRcOEWXvDUKVsw4hNWsNkumzDmdF5w9zaWcP+IiDDuJFEw9o8fMPC7YLDfBxmw2I3MMPq4VPDphoxw9HzTsPtsjXDiL94wwD3WMMOu2vDLq19w+a0SsPhHnDDZhldw8JOh8NS3oHDWWklw7KHUsMqdmrDAH9ww0NwVMMDIofDUghtw+BnZcNi4WnD/GZww42aTsPFtW7DxMNuw4BdKsMdGG/D90NYwy9GNMOuKTvDQMRDw+MXfcOSmlzDaNJfwwpaZcNORm7DMihew1pnK8MFy1zDCxZaw6yWGsN051HDa1BYwxbAXsMjgUHDjj96w4pAF8O4TSrDeCE/w4D6gsMKiXjDpBRLwx5TLcNtaS7DPC5Qw+lKZMPSgkvDIqtFwzxTTcOJ9i7DXrGCw741g8M8OF7D+ht5wySYB8NN433D3KBgw7AjdMNJmXLDkn+Cw2A9NcMjaVbDDbNPw3P/YMP6gmfDNzNowzp+M8OWXHnDFrDawqg4asMjEAjDXt1qw1SRT8NuCXvDImNow06mMMM=", - "encoding": "base64", - "path": [ - "vz", - 8, - "data" - ] - }, - { - "data": "+2Yvw0794sKe5yXDbBsvw+scLMPGmC/D24I6w9R12cKf0B/Dykcrw7SMH8PmqBPD3BQFw6SPL8M8M3/CYgwiw/rFPMO6zQfDRMlDwy5tKcMI4BnDZBFQw/LLtsKiCkzDTuJaw6E9R8Os4yrD7bomw171Q8MO4RHDzKeEwvVBC8P4dKDCWCYjwy9QHcP4pljDcvYOw/85u8LICVTDwsonw0xVOMNbhx7DGJM1w7tLJcMyqFTDpqZewwFUNMOmDVbDGoTRwvbCMsOgyS3DOsAow2Zfz8JG+A3DNSA3w1734cJVSRXD+4HwwupBNMMNcTPDDgJFw50p0sJufRvDU67vwgEDJMOcXivDJKM9w0Q+IcP8k9/CwlUuw6amTcNC4DzDTFLswiotz8JunEDDzPAaw566WMOy0hDDkmPpwnDQDMNQr9nC/CIiw0FmNcNH8BbDRugSw9j7CcPaWEnDJqNrwwg0HMOmWyTDViKlwjRIMMMAXxbDyGwyw4cKJcP/VDXDLc5Hw9zXOMPmJTXDXFsMw/SbDcMuJEfD6pwswz51FMPoxWnDpHE2wxQeLcNFTbjC3NwAw0h7WcMbxlvD+68/w1Y1+cK5+jXD3K4Jw5oIKMNQINjC2vFIw0BIGsMSnzzDPmBaw0D8CMPtLUnD+KU0wwqCYcOaml/DMpfSwoITEMOugC/DWto8w8vHFsOGkkvDgJFCw6zHO8OcE1LDBgpIw+QJKsMaRzHD7Z1Bw36Z0cJFoULDQCEywwhlFsN3lhHDYtclw6lxR8NHmRrDO7UfwwkPNsO+tEXDANw1w6b00cLevyXDzOohw5wNuMKtcCXDGIgfw9ulMsOFVR7D3u5Ww2iAuMJ41NTC0DYKw7VvXcNubkvDCTcaw49P6MKE7wPDHkkhwyDbOcNqQCHDHRoNw6iZBsN/UN3ClJxow2q3S8OXxFTDZudIw631mcI7m1jD9Awtw+4/X8PS2EPDIJtbw3llEsOVCh3DVmoew5QRMcNwuUDDRBpfw6iOCsNCzDrDs7o4wsBuT8MInY/C7rUow7BVDcMkkFTDohM6w35zv8I=", - "encoding": "base64", - "path": [ - "vz", - 9, - "data" - ] - }, - { - "data": "FEjowvMoRcLm6+bCktLiwvD42sKsrAbDmfD+whi6RsKKzvXCvk7nwj03+8KOM8HCEFC9wsmR+sJmGqy/jn/pwkrGEsO265zCzGUSw+V06sIU4M7C/Loiwzm488GPICvD/hsyw7yjE8Ou9OLCeZ/bwtNsC8NgLNTCKqmhv6pqucIG+GPBjR7wwkOh5MKqhjLD5ki3wsoR6cE2eSnDzDUAwy825cKiTtTCAtYBw67W9sKGjCXD45Isw4blC8PiWCXDsAE1wmHQAsNSf9nCS7DPwrInMcJSCs/CZWbxwjCOiMI+edrCD11wwiYt48LahgrDcmsTwxiYV8JOvuHCOLFmwlLR9cL8a9zCSUv7wlzDysK7ikbCcdnhwtVEI8O++gvDBIuGwhvQIsKvOw/DV83mwjTKGcOcrqzCqD9Rwt9uvsJwCw3CWv/Pwp5W68JKk8vCxai2wl7OrcJaQBnD0ilRw9IDwMJA1tbCoK+Jwerr6cJ8gMrCjLLvwiqxy8KK1/LCF28Kw7zjDcOYW+jCmryawui9ucI1ZRTD6j3Uwq0PxsImrEfDHiTiwj98AMOyEt3BCxOGwui+MsN4LifDymIVwwp6ncI0RgnD4grBwjbD/cKQlxvCNjsTwzKpz8JZswnD6cYzw3TNmsKSfCHDAtQKwwe3JMPk8DbDAM5IwpQnx8JggeLC6tMFw0Ouw8KSSRLDrFQSw745E8O+oDLDBnIYwzC0/MKmUdnCRKAUww6YJsLgQxPDsLIIw+0k3cKwUN7CHKQFw8QaEsPUCsPClgnRwoxa8cKYjRzD0CoLw2B4I8Ke9OPCLJTUwocm/8GcP/DC+0bUwjgzCMPM7vjCXtIvw7w/D8KiSFnC3lanwrA1McPtpBPDKEzdwiisdMKy+bXC2IHewnkQAsPK7O3CvO60woWsicIkBkHCDhE8w/20FMNurDXDNvMcw6YIj8HpbCvDyEDkwhATOcMH3gzDuVkrw8iX1MKmXsTCtjDgwq5N9MKuyxrDWHhCw3zhy8IGDAPDaCBzQdYcMMPTYBfBukTnwkI3sMIGSyzD6hX2wnANncE=", - "encoding": "base64", - "path": [ - "vz", - 10, - "data" - ] - }, - { - "data": "W+h7wr7SlkHY1oTCxNZWwrCoVsLMx77CmJeWwsSo/UD0uanCQPxtwr0Yn8JKJlnCVM9Vwixai8KMzHhCrA6UwglF1sI0ML/BjFPFwt6vhMIQ0nHCIpLowkJl6EG8ggfDBmkIw+e5w8Jx21LCFxxlwlsmrcLyfYXCYQ+DQhKkLcJz0E9CaJiOwpC3i8K6owjDTsYlwk2UEEJGk/nCmT6Zwu2mT8JWkGDC4bybwhrxlsJIU/XC1lntwooAwcLse+HCYK9IQU6wkMJK2kvCaDJFwgIJcEFmRYbCoPx5whpRccF0b47CXJLRv76FW8IW/77C3p24wv4v4cAAwInCbJuvQJDFocICMVbC8Kd8wpZSQ8LwH2BBzsFcwoaF6sLiVL3C7pYIwarpoEEJZrvCwgaYwmYmzMIch+fBRtIfQZLGWcJNBCBCRotAwv7bUcK4mU7CDgD7wYtyM8K0rNnCTGwvw344IcJGIVjCEOs5QlHGbsJyvEXCBZ2BwryKKMIJKnrCIA2XwjGaucIudVjCLEJJwRzdN8I3IcrCzopDwpQHW8KsMyHDJqdKwlATqMLaZxRCs+btwDxxCsP4L9vCTJnPwpJSBcLmRqXCwOdRwmyIqMLGG/BBRPy3woIEaMLgi6jC6lIMw8YNr8G+V/XC85TAwi8q48IkQgvDo2rNQHPWesIyBkPClq6fwn1OSsJ8BsDCXie+wo4LucLa6w/D1e3KwkgrmcKB7EzC9uvQwjAVwEHlW8fC6u65wqbEfcLCCovCrsizwigDwMJuNkTCUkNmwkDbY8JOpOXCbGm8wvPFxUH4dYLCpEZVwviL60Emzo3CvCpiwkTRvsIN1qDCErkHw4SEpUHKolHBYBi+wWzuAcNGmrfCJKOIwrBUgcDouUDCc8FqwgBMk8LaPJjCDBQxwvaHjcBa8H5BEJsMw1jpxsK9lRLD5zXowohTKUL65/7CvulkwpaDDsNGh6fC4THxwvowdsKQBRjCeP+GwhTtiMKUF9TCcMwhw/4SacIs0qfCvjmdQjq1DsNBiVlCHJCEwperEcKCtwTDjW50wjDXXkI=", - "encoding": "base64", - "path": [ - "vz", - 11, - "data" - ] - }, - { - "data": "pdQ8wRKKv0LYA4vBHvOUQDJGWMDfqWPC93jXwWoUjUIcqwrCjk8qwALF58HzOhHBmC7YwI4PKcFulwNDQNDVwVqJicIxdvNB1mNTwpLoVcEy/5DBCDmLwgPis0IIusTCoLy7wgovScJbdWxAuGPqwG7jE8IY37/BKGYKQ8F150DQ3fZCeLGTwdtLt8GKTrjCfDoRQVyF0UJ/eZ3CPkilwTR61UB8GsjAuuzLwQ09wcFaPqXCRCmMwkIeSMKYXmzCHkOTQs5kU8F4UFBATO49Pyi3nUIvxbfBd5chwYrNOUJ0qdXBnrtvQhA1bMAcYz7CJvwWwsIZNEL8zavBNg6UQsEJEsIV6RfA9mCwwPFgm7/thKhCzM1NwIBykcK4HEzCwUhnQnZ5pUIWiTXCQFkYwjioXsJ8QO1BHNqTQrECJcFBoO9ClmjBQISKzECcz64/eD8AQjq5RcDCLoXC3UUKwyqxb0H7NBDA5HniQoUkLMD4rpdAc4cpwXHFo0DhUz/AJmCXwf4wFsKuqJ5AFq1fQobjNUBeDWLCSbdCv2rCMcE4wfDCjLeaQP5cHcIoQ9VCPpdVQgR7w8K+uGjCp/Ncwmi6YEEky9DBYPWOwKq6H8Jyh85C/BAZwnZ/RMFsTePB9rfJwlVv9kGzhKnC+u5SwrldhsIVlrvCu6qIQoS1w8FunQxBfI3fwVSUib4SCkbConctwmNMJMLgf9bCJA5FwtphqcGzJPQ/zZhywtLsv0IikVHC86s5wuTIO8FkjL/B+QrvwYLEPsJoWxnBib0+wUB6Fjz8BWPC8q8zwvC6wELPlIPBvAQHwCaau0I44IPBsXMPwfzUXsLQktHBYqe+wnCHo0LefxhCOqssQvVGq8JxlRvC1gjOwRfGaEKcChjAlC1CwHy9icEkA/3B1lsSP50xekLGvKtCuTy3wmQBUMIzvtrCzGKawnrj20KdCazCLhyvwGidwsIO1PHBWpOOwsRxRsEhIMlBMz23wSqwccHTwG3C9Jn9wgzYHcF+tiHCyqIVQ3/S18KBiflCIrWKwcFOj0G6OrzCQeIPwDKABkM=", - "encoding": "base64", - "path": [ - "vz", - 12, - "data" - ] - }, - { - "data": "NvcfQkDpPUOJigNCBFR3QuTgKULvA5PB9pWgQS98D0Ng0+BBfwpQQo3KukFwoxhCyM86QgYVQkIiLVZDkGjbQab19cG0Ca9COlkDwT4WNkJctuZBWsG0wfn/GkNq1W/C7I1MwhoWhsA+MFdCaHkvQqipKUFCELhBRo5eQyY3bkIkkk9Dj+QbQnsy30FGvzXC8ht3Qs4nM0P+rv3B/NkUQhiSakLIIC5CQMnmQeJm70GKETHCnmS/wW8HMT8F9tbAx1ERQ9/dMkIcKk5C0lxFQgZmGEOuAtRB2pYoQnre7kL8B+JBzBIBQ7g2O0Kd1SFBIuB7QTiu1UKYOgBC8jgZQ4y3hUGYZi9CQmpQQnqTQEKnmydDuNkxQux688FinvbARscGQ6pHGEOueZw/5NJHQf4yOsEqCLhCYMYPQ5aWE0JhfE5DOH9vQvmoY0I5r2pClNjHQsxlJ0LEYcrBSQLGwpiJk0KB1kZCo3c9Q4COYEIoKHdCQXo3QsywUUIOJV9CDCYPQrIxZEEdUGpC9voCQyNyX0JsNFrBWKE6QlgPB0J+uZvC2m1fQlT0xkDfvjtD7WXvQhDzY8JtGyvBSj6xwIPQg0LFGwBCG3RFQn4k2ECBNztD8MhgQZ0kEEKwM9lBknB1wsa5qEL0KT3C+tTuwProucEa+kDC/mUMQzBNqkEys3JCRne1QRBBWUIMVJ7A9G//QK5e9kCe8YnCXJBhQP4KLEKVdmRC0IGDwUJbM0P+XKDAYrhSQExLLkK0pcFB5toKQprStz5RAQZC/GYJQpCcTUK2RjLA59HBQB2oM0OdGg1ChhlDQlwwI0NbCSVCmFkhQp9Hg8HSdBVCi0FawvHPGUOhM8ZCugDzQuBCLsIlPkVB/7CRQf/XAUOLgj9CXoJjQinbJkKKxn9B/vw8QiQmCUP2YydDSWYmwsIzi8CTQI3CSvYcwqrhP0ONqTjCaQssQmYJSMLChaFBqm68wQ9rJUKmPbxComS8QVaHIkLSzXDBdRG0wsVdLULs68A/TJZtQztzj8KosFFD3v0EQhbcm0LNc2DCwp5eQpACXUM=", - "encoding": "base64", - "path": [ - "vz", - 13, - "data" - ] - }, - { - "data": "6Ci9QjLfmUP02KpCHOXjQvMfsUKcNqlBKPWGQsbkbEOUdL1C8pLSQpK6nEI25a9CacXYQlQB2UJayZdDyhmvQhJQ+kDsVxhDKooQQvEF2EJgCa1CJD7KQUaeYUNjZ6HB938DwUy1JUK3LNFCJDTFQvvrZUJADKZCGxqFQ6dr5UJHHZFDdoLHQsbwqELGLmNADBnuQuXbc0PzmH9B1dvHQuspzEIo18BCx/2tQiawsEJGgtXAkVirQU5GYkKMYzJCGBxuQ6hh0ELeo8JCgqm+Qkz4c0OYQ6NCVjHEQibFUUPIr7lC0nhUQwQRyUIkp4dCvK6LQs+KOkPEVLxC/Dp7Q6jClUIyR7dCGAbhQkjqy0KyP4lDS5i6QoDQJkEk/RFCSkViQ3WxbUMuRDtCSjKaQpD1/EE9BCFDXnVhQ2T8sELBgYFD5K3lQoa7zULc3vNC5HItQ8bduUJOloBBxPlnwoKnDEOuAs5CxnSNQ/Zz7kLan/VC0HbWQoaV0EIgctVCENK1QjxqgUK6YdFCGMZXQzhw50KFmORBFJ2/QtUQo0LWWAfCzvzOQjx/VUJqeZFDIiFGQ07pfcF0mwtCqNYyQjDv+0J4XrpC9l/eQokKYkKQ8JBDhj6GQpQes0JE7aBCyNOqwdCEEUM0fRrBCO0hQklJnUFA+iTAQFxnQyNEn0KcSONC/lqSQjU450LSCBxCKGhwQrRcXkI+HujBxhJkQhJB3kLWF+xCKJjoQRBKikMmzCxC6XhdQoilzUJk8Z5CtNjLQrHvRUKwUaZCmbusQr4Cx0KcTEJCrhdiQr4JjEMG6bxCycfJQsb9a0OM28lCzIK7QiSpuUF2h9FC2mhQwVLceENiQTBDtoZcQ7InJcBQnHxCAKqBQhhmWkMFnNFCqWf2QsJD0EK2aYlCAI7FQjX+Y0MsaIVDYDsNQYRUNEK6PPPBNIqyv96ak0OlX97AOMO3QtDNi7+Se4pCpsu7QSa3yEJnii1D/GaUQkzPzUKw0+FBPBdOwqnBzEJ1syxC7p1/Q+E3B8LSz5xDf72uQgAaFEOcPpHBZO3ZQpiviEM=", - "encoding": "base64", - "path": [ - "vz", - 14, - "data" - ] - }, - { - "data": "tvEZQ1KBQUOE+AxDsgEkQ6o3D0MA8XpCIHLpQsSai0N4QihDIEUgQ3zvCUPwdA1DtKE0Q3DhK0MaFiZD/FYaQ5iHP0IGFmpDKvahQpEMLEO5URlDyGKVQh5HMEMKkapB0/kNQinrrkK6cx5DfaMeQ22m0UI8xhpDbfgOQ6oXLkMQuhRDWT8gQ25oFUOJw1xCLy84Q8o/EEOb7YBC7nwrQ5EzGUPuZR5DkJwWQ22XGkPkzfdBHy6GQlzt5kKkt79CJIalQ9MtJ0PW7RpDcDwSQ+D9b0O6TRVDjwoiQ0Tgj0NPkSRDXgmZQ4pRH0M2/PlCTj78Qu5FmEM4VyJDojWMQ372BkMCuxFD1tcwQ74+IkM0j3xDnKYUQ+h5SkLupaVCaI6HQzyGkUO6bLhC+OMSQ+CplkL7PW9D4e+CQ6ZQEkMRBRZDhGssQwEZFkN0mUBDc4N6QyKLGEPcCGpCYhpzwVxiX0PY4xxDCkAbQ/LDPUOU3jxD6p4rQ0GlIkPAPSBDP/MTQ6Eu50IeAxxDWvuTQ4ysOkOe9o1C1gESQ0gxBkN8mj5BqcAWQ/fezUICEGFDqlyVQ9LG0UFGtp9CntLAQt64SENt3h9D5p02QwrJ20K3oF1DgHj3QsKWF0MUuQRDDNaeQRfEXUPAsOZB9rK4QvpNekLUbC9CSBd1Q+NmGEPADSxD0BL5QgfRO0Pa8KZCsozlQrrUz0K7Ik9BtjbfQjN6MEMEAD1D9uSZQvBPP0M4LbpCmNTaQmABJ0O9kBVD8VIuQyr5yUKjPQtDhi4TQ4YJFkOMpcZCvIDVQpqkbkOaVCJDwbsbQ3QPKEMmViNDpDYZQ56ff0JlQSlDICDvQdx8hUMpTY9DgoWoQwrqGEJA7ORCBiTnQqzEhUPMoCtDVjtHQ91sKUMwvABD6U0fQ9hJpkPm60JDlHFuQqkAxEIw/jdBmK4UQj7eXEPW8AFCR8oVQ9jlREJkLOxC426NQtOiJUP6toZDe10EQyorLEOs0Y5Cjq0vwd1sKEPKOatCfFfeQisqzkDdTTND0A0TQxoGbENsDKNBcGweQ8roFEM=", - "encoding": "base64", - "path": [ - "vz", - 15, - "data" - ] - }, - { - "data": "fhNbQ5QQokJ2QUdDOmJbQ3AeUkN/atdCKgMpQzJ8CkMkjXdDr+FZQ81vS0M/NUhDpy6EQ5MdcEPQoFlCq7ZiQxYgtUJSSp5DLu39Qhpxb0N7+GRDWrX8QoiweEJAAIJCppuhQhCbBkMsqFdDu2FfQxSIGUPjfmlDwt0bQvYubUP2bAtCdXpfQwYMYkOiE9xCrW+BQw7ZGUKlM+RCcm1xQzeGWEOP7GVDiwZeQxeDYUNm8IpCvg/kQtwrL0MQ7BND2ydAQ+DhaEOG7GFDjLpRQzie20LQDWdDFN1nQ+tONEPhrGxDGjIxQ4/KXEOAXDZDwHw5Q/CfS0M+MWxDgkgaQyhCRUOok1VDKP9xQ4hoZkMHTABDWvdXQ/99tUIotgRDoOMkQ4boCUNB4QlDkCRfQwEt8UL2q4ZDOqUBQ/SzUkPC+CpCxBFpQ4iyUkNIhoVDtwJ1QzLlW0OKGs5CSZftQcBzpUP8HWFDTkHlQd3eh0McAoFD0ulmQ7rHZENOxlxD4H9PQ+BUKEPJc11Dpi5BQ+niiEPZp+RCN4NLQ+stQkMiiG9CVeZPQ2aZG0M178JCz79PQ5APjEKC+/lCM3QWQ/LykENVAmxD6iaCQ4oHJ0NVVbtCrCI7Q+AXYUPNiThD1oF8QpA9n0MA7YlCeKsVQ4re1EJmg7dCTeToQkTqakPgNW1DBCUxQ4y7iUPbbQFDerItQ+aiGUPYoGVCRmgnQ8Jmb0MsdYlDEm8AQxpVnEI9aRFDGK8lQ7YFbEOaGGRDGmp3Q8AqHEOcdE1DxzlYQ8xZV0NXDxZDcrkcQ4Gp8kIYX2hDH1hWQ8K7e0Jf82VDoKhdQ1b+1ELALGlDnt+VQpqXAUMqSWtDTs1WQ4JZn0JmkCZDwQEsQ4ODDUMmqHhDCsSOQxLmcUPED0VDKCNsQz8DQEOiwZlCrR/eQn2KHEMvw11C7LCaQmhW3UKr9JFCTJNdQ8b8yUKeBCdD5uztQiTsbEPwEItDH8lKQ+cPcUOXvOZCMmwAQgNucEOWxQFDav5hQWRrR0Kbw4ZClsZVQ2FUnUOxu3BCkqBZQwYWBUI=", - "encoding": "base64", - "path": [ - "vz", - 16, - "data" - ] - }, - { - "data": "ZwWOQ5JnK8DCzX9D6hyGQ+QYkENg1R1DGqBgQ1NdKEJ+l5pDtFiIQ6PwiEN/J4RDdrSBQzbWlEMONLTBApWTQxJRCUMMdShDplAuQ+TbkUOVNZhDrK40Q6X06cG6u95C0I4AQ8sWN0P0BYdDMFeLQ5bKS0Mw25xDzyMZwm41VEOuWyzCpruQQ1d0m0OoVShDd59IQ+VLNMKs3CRDesSXQ+YLjkN/CJZDnCaXQ1Dgk0M+UttCGv4iQww6aEMq20hDcn25QvBok0Mp5ZRDdkiKQ46WjkFXEZ1DEvSTQxAFsEJMvpVD7XiJQi6ojEMUtmxDroZ2Q01NukKoZZdDFhxnQpougUMSgJJDOkSPQ2xpi0MkUBhC1vGQQ2o7A0Nw0DtDmUORQjbmB0JukzdDH96WQ5pkKEOYdR9DMPbIQX4Mi0OyMjPCMq5sQ097jkMuJoJDz5cVQ0L/iENM4BZDbUOaQorAYUPqmJVDWKxOwlVqkEPKhHFD0j2OQzr/iENlEYxDmF+FQ0FcX0OIUpFDlhazQkakY0MwLB9DjhSJQ2bbgkNsVN1CHhyIQ74YU0Ms7yFBfXGsQnTC6EL8sSpDvJ9OQ5yEMEMhrqBDZmxuQ0QpYkPzpCBAen+CQ7kzlUO7t2lDDgrbQsQgLUPsQt9CxbNVQ7gUGEODsQ1D7jPJQZ7XnkMoVYdDZpJlQwpChUMarjFDGGttQ035TEMn5NFCeh9fQwibkEOBlY9DjeA4Q2Ks78CfRkhDNL9eQ3RqhENU/5tDpA6YQ/XmV0MU7oxDL7OQQ9hckUNWAUhDm8hMQ18S/UGqk5NDCWWGQ2LovMGq85RDzDeUQz7KF0P+UpFDtPb1Qj4PIEKcUexCwEzfQkEO9UJWa1pDHWJqQ80VNELa6HNDQLFxQxbmnENG3oZD6kGdQ8X+oELdaw7BlykjQ/xZX0MJm8tCz1fwQjH570Ht3OZCBJ+UQwL7GUM0yFZDH7goQxLMhEOGzR5DB9WPQ849l0M0xSBDUNacQpAMhUNFczBDsqpSwkQbw0JZVCjBuH+NQ7gZQ0PMC8xC8dONQ/xXWsI=", - "encoding": "base64", - "path": [ - "vz", - 17, - "data" - ] - }, - { - "data": "0QN4Q/V1jcKJAnlD5jU8Q7IxcENONldDfkSLQyBo2sFAIV9D5HtfQw1DgEPKk1xDeAwdQ3r0QEOgRqDCuTl2QwoJPkNfioNCDgpeQ7RoSEPW1mFDhrJsQ1EWvMIypCBDSmEzQ3qoZ0My7EtDbIZIQx5dfUNUJWdD7rvDwoIc4UInKcnCEMVYQ2ysgUNUm2RDlui9QsFC2MKoV1dDHI9PQ45nQ0MNHUtDMHOGQ5WJYENbfRhDBBlWQwsph0MuOnxDlNigQcdDUUOoWUVDOm1gQ35ORMIetGJDk2FhQxJmaUH8f1dDQdQJwfynV0Ny94NDoISSQ8EipUHSj1FDramGwVICgENmo2NDyuk8QxYLM0MkJwLCaHtgQwwgLEO4J3lDSUcawJXgD8KISmNDYNWBQ0hAW0PSO3RCRGFCwgbGVEMWnubCk5cEQ2ZgRkMxpS1D4PxtQm+6PEPPJ0tDffP+QuMN6kIgMyFDGOPUwnTILEOEDBBDjgdTQ7w6MUPhmEND5/V/Q45liUNc8T5DJRiqQE4c4UK2fU1DXtZdQxBsaUN+liRD2uBXQydVhEMclF3CrvyNQI4IJkOSXlhDxGmCQ07onkJOG4VDI9AUQxz/iUMIjIXCyjOgQwXKYUM6sYFD9kEgQ6RyeEJu2h1DesuMQ6QRSEPysUFDRFElwpzIZ0NgAi5DitqIQwQZHkNeK2RDoaSVQ54qf0Ow8BtDsHGIQ08dPUMygzRDLa92Q2IFlcLWJ39DKkiIQyGwKENPzGhDvzBQQ0n/ikNx7XBDPmpvQ6SzVUMOZHVDGJF1Qxn4HcLsX11DKigfQ1JPssJUC0xDbJZLQ4wuSEOWvk5D4tMuQxpExMFuHiJC/Bz6QT5yJ0Neh4RD5iiHQ7C+0cFF1RpDKUYHQ/wuWUP6BIdD8ghJQ+ah7j7qq5TCy5xWQzSVlUMzsRZDcuImQ8VnBsIGziBDhkxfQ26mTkNLEYBD9JNbQy7/K0OSeoFCDAh8Q3qjS0MGl09D57AAQ/ScLUNng2FD1b/MwjTqFkMgNIzCTNiAQ9hKxUIVvBJD1ktEQxjS88I=", - "encoding": "base64", - "path": [ - "vz", - 18, - "data" - ] - }, - { - "data": "4HgsQ+ZNAcPU0DRDq4HWQjwuFEPxpotDekJgQ+buo8IVYv5CevMRQ307JUPmbgtDKYiMQqNjsUKwhvrCs0AoQ+SRekNGUFvA7peEQ14DzUJhZflCICGQQ1SVCsMQzlNDaZtoQ3b0iENY9/dC2zXtQuJ3gUOEngBD94kQw/4CxEHWMxDDyIsAQzheOEMExI1D7LxlQQs0GsPdFoJD35DUQgoS4EJGo8tCho0yQ393A0Oa8UZDpHKEQ0rpXUPIZoVDgCMbwh5o6kJM0sVCeH8NQ4XqycLoDv1CII8JQwABPMJAe/RCi1iIwkV8BUP7DFNDZjdmQ36eCsJ1F+NCVgydwq2UNkMpYwdDcvWvQp/IrUKqpLfC2qQFQ5FwVEOlqJhD8KiDwgK4r8Larn5DB3MpQxZch0P0lXLBpGnOwtsmA0MODSvD12AEQlTuyEJiu7JC5ZOEwU5ixkLK84FD5oI0Q8Y7HULq8UpCv2oQw5jgmUIoo1RCPCnyQkyVsEJyx+JCFcYtQxqyT0OCDrRCznl/whJC4UFOHntD6j8PQxN3E0OctFxDd54IQzBqckN5y9fCwNBgwm8YW0OOK4FDUm+CQ8ifJUFIwChD99GJQsPzXEPPyvTCchFfQ/JSDEMuFk1DKGVYQ154G8HBgVBD+MmMQ7SZeUMC2nVDGmy6wntX+0LwGZVCdJ9fQyraj0KgbIpDq4p0Q/KVbEPitlFDmjd7Q8hKukKPM7tC4p6ZQ3DEAMOiyIxDKFloQ/T3j0KNRwFDSOzdQulYj0OC7R5D9JMSQ0yw+0LZ8XRDpiliQ3/OxcIi0/tCGF5MQuJ+CcOG69tC4s7CQqS1eUMqn/BCH2tmQ4Qfl8Kat5XBynkTwmSVVkO0RXdDnq1BQ/vkpMLXHJpCekNFQhYV8kK43EJDimLhQjVHe8KA4/zCD0mCQ5ZymENlGElDXsVaQ6+vrcL+6FFDECYBQ/gGfkPu2WFDwvyFQ37TnkJAMhbBkIwnQ8o/z0JyB31DGFQ3Q8gqn0KKQYVDZEIMw9orU0NKcuzCBGkzQwnlykFiEkNDodfXQnzsLMM=", - "encoding": "base64", - "path": [ - "vz", - 19, - "data" - ] - }, - { - "data": "qLDRQlTaNMPNQ95C0FAXQh+6hEIvbHlD2oINQ7ou/sKm7ENCJguXQnB0uEItnY1CcDEiPels6kB2YyDDflvIQgDenEMSeF7C2hBvQ8L6zkGPPTlCCySDQ3mRGMOA3YFDwfyMQ7XfZEOW715CdvRAQuQrPEPQQTZC4oAyw77DKsJ8pibDk5hnQiAw7kKkLoVD1Xs2whh7HcMF8XJDWAAOQl9YMUJEdqRBrK7AQpRoZULwXXlD/BuIQ1W0H0PQCEhDzkWzwprPKEIyucdBmiCAQvQgDsM8PDtCjkhlQlS0ycL6wUNCuIPownqYa0KgRRFDEOgZQ4PHoMJVgCBCmKMDw/p110JU0GVCSdXtQDEEj0Gymg/DwkNlQqYTeEO29GRDugjywiQJAMPsC01Deb+1Qqz0dUPKfpbC3C8Qw+axaUIeTzrDknUmwuAQr0HopDhBRHmgwl4EyUHQ4JdDWuRpQx+0r8EU77XBwhURw2hCPEC42qLBWNA3QhwimUGOhDZCoGm6QpqZ7EL6LilBmNzzwjkqDcJywoJDyuqJQpdemULC3ohDcQR4QtZfKkNOFhfDNjnQwkhCiEO2Y2xDwEtCQ6zjKcIDBb5CjzjKP0odF0MqmCfDkKUGQzuIgULYMQZDAkKKQ6CUd8IsXoNDng5MQ+nfjkMov5BD8/IGwy0uK0JnS2tAYqYXQ1vOY0Apw21DGAMjQ+rXHUMg74JD+Nc2Q9gvoEGOcrpBNOV+Q3JKLMMeSltDVd4kQyjUzsCE2D1CyH0fQnzqUEOAv6NC2FKCQjZFSkJAJTlDkjYoQ3TVFcPpbjRCDpbSwSgTJcPMmiRCYapdQRdve0PlqEpCDsCOQwTx68LOvofCEkDEwnLvgkOPrDRDzOjoQr54AMMDPU5B8oKbwdZwMkKeMvpCZ41AQliv58IssCfDCv17Q9WDVEMej3hDmMCJQ/31BMMpBYNDfkBEQu2IgUOOKh9DdFCDQ0rIYEDOSY7C5pu9QkWj3kGjrWhDPvBwQ93AfUCOO0lDGjQewwxhikOwnh3DOC7aQnXbCcL6zXZDDrYcQsrGM8M=", - "encoding": "base64", - "path": [ - "vz", - 20, - "data" - ] - }, - { - "data": "ZOJBQnLiOcN4QkdC6OuNwcWELT9M8yJDrUWJQrSkJMMBLknBPmaJQQKs4UE3DnpBRDlpwsptZMJ4xhrDSoswQshJcUOM9sLCpBUrQ27ZDMLAwV7B9LQ+Qwvs58JO7n5DduBsQ67tG0Oc9GY/lmQQwW0g2kKrraPBz8YNwzZVu8IG0vPCFqmMPyawfUIkZkhDUTK3wsLy18K88TNDhqCowSloasHqEjnCIKQNQuhDTT7AhpVDUmVJQ0Z6wkK+OPFC+UIHw6zSm8EUrQ/CIaPLP7YmKcPsVoLBM+okwewJFcP4qhTBA4cbw0J9osDeGqFCz/+nQroh8MLKbITBL+Uxw2IyKULOc87A1ltlwlS1LMLILz3D/R+ewBpGWkOKxhBDKWIpw9CkHsMAQAdDs3nqQUZKIkP08/bCrDwlw/PQf8Di4vjCNuLAwtDUK8Kk31vCtngFw1z7JcLMWmdDa5iLQ859ksLq4JfC7urKwiAJYsK+u57CfH86wSAjHsKcZTXBP/fRQQ4eJ0LcolnCtooqw973qsLXhkRD9hmZQM5Pq0HxdYlDQE6uvUQux0JNijfDCOYOw9RKjEOifCRDGHL1Qs78qcLhGRVC54Jbwkixq0I2/TTDQD2DQsRpR75gWoFCnnSUQy9ezMJamJJD2OwCQ2rjXENyFHFDWRAnwyqMqcE7V2zCrBCjQpbGUMJflRxD+Pe1QuZZnUKe4IpDktzbQs08JcLUzRfCFEcuQzp4I8M+uxFDEInEQqiHi8I6hoLBAgV9wfbjAkOfEJxBpZwlQMo9WcGXZ+NCv/LMQrLXQMMiD4TBelCkwp15/8KOEo3Bkd1QwiACNENixAHBVHCLQ1zMGcMqed3CDoAbwwryhEO+K9hCAFRUQozrJcPnaCHCDOCYwqIaisF7SINC4mNVwOV1IcMMpxjD1tE9Q6JGBEM2J4BDXIqQQzggLcP6Co9DvB91wbLUTEM4Kq9CgvdAQ9V8asJfDvnCwEMIQthJAsIgGhxDduWSQ+U7a8JNc+xCNuPpwtH8oUMexirDYUVJQmi4qsJWXpRDcgSIwYik8MI=", - "encoding": "base64", - "path": [ - "vz", - 21, - "data" - ] - }, - { - "data": "MBebP6nnv8JX6CLAH+J2wuQfVcKQE7hCWogfQeYYH8NJ7HbCFkn2wXQdscEmQ+3BlObYwppy3MK0/8LCGy4cwNbNHUNODATDeI7HQthqqcIEjXvCkTDsQojldcKYKURDG7ghQ4KFp0Jsai7CkANdwkgkIkKQX5DCubuLwksHBMNC7CnCqlE6wirIb0H6iQNDhGb+wp93CsKXztxCOnSJwu7mhMJSp87CllpWwSLDN8L/JnBDZKT1Qt2xHUI5gUFCdT0xw6XOjML5krTCMPpAwqR7/MK+s4jCWzuBwpD6P8Ns8GTCzMktwz8sbcJY/q5ByOC/Qfd4G8O+BnbCnJtBw+z3VsGos2/CJurcwgEcwsK4JTHDJ6phwionF0OAFphCuBBKw44iD8NEW4JCAOyawZfqp0Iv6iHDQd/6wp5DZMLWcfzBHi8Iw4fyxMIkJ9fCavMwwwW2x8KwoxVDsHd2Q0/86sL7nujC1MLwwU6p08KwyP/C9HRjwmqstcK8v3PCAibowTqqjcEVY9vCEfpKwxYA/cLL0u9C+To/wsZQtsEGIlVD5DVMwg4ZG0Ky3QnD05gsw/oBVUM2Gq1C7lppQkps8MIY8R/BWLnPwj436EF+A+7C098iQb/dYMI9FXBA+jtfQ8H5BcM2kmBDVIOJQrcuCkP0HSpDJjkDw+YnkcKk4+PCemKmQVyzxMK0aaFCK4r2QWySVEHZnV5DfE4uQu2UusJEXLPCKq7OQsYQu8JtcJxCVLcbQrQL88IbGYrCcBd3whpTgUIQv/HBfj8+wpayh8Iq0DZCcF4fQnwjK8OUiYDCfEv2wireicJg5YrC/KzUwsos1EKi/2XCmI1QQ+ZrJMNDdhXDApVSwx2PQkMJoihCd6DRP3b7GMOcFqvCEu35wgCwi8LyDm1Brmw8wmWWRsOYeaPCWPfrQnLhhkKXO0pDwlRQQ6LONMO0p1RDNOSEwhc+C0PURrpB1gLoQgxk3cICYyvDRieBwcZZqsKGCZxCVeaKQ4Jz5cI6Yz1CVhMmwhzXgkMYWuXCBJRIP4gMAsM1IoND8hWCwvJU3sE=", - "encoding": "base64", - "path": [ - "vz", - 22, - "data" - ] - }, - { - "data": "vnIcwrTRKUIkMj3C4enBwiPUxcL6iRNCEEIVwvBtsMIOTcvCKMWMwhzSd8Kaa4bCMJ8Yw8iRGsP272lAXZsnwuPptkKLOSDDsdQUQvcz+cIeKdDCCEVYQicHfEEUOARDMaK2Qj5asEFAKaHCzK25wsxvccEBDOHCdxAjQrXwHsPE26tCxNOvwpYw4cF3uIhCpZcZw7slg0LSsThCXL/awuVy4ML0vRjDn/9ZwsykqMILPhxDNLdaQlzSTMGa3UDBephFw6i74MJeYQvDjNexwgIwNsIGxOHC0HLXwoOmKMNOqMPC2Dj1wkSqz8Id/+/BBBLawahOJMOvN8TCFjzywlBncsK9s9LCWnEZw79AEMPP86fCPZrHwqc6nULSa6hBb3UNw/AmqcKkV41AkPVrwh4+rkEQGDTDSmJgwsKFysL8nqpCkbkiw16qEsO1ABnDL9tCw0SPFsNHNqNC8qg4Q+iuHcP25hLDchOvQpv+E8OvIifDxNa6wv3jB8MLRdHCjXeUwlDcgMIVIh3DeYQWw7L+H8NUB1FCgWK3wtiBbMImBhFDMfS7wnT+RMHNjDbCyiYJwxOwDEMA6ppBagI7QDhVFcMOCkjCNBAUw4JJoMGs1SfBmkAOwuc80cIE3j7CnHEUQ/45HcPKcxVDLk18QVR+g0Loq8hC1SFXwn7M48JS0SDDbtfywcj/DMPQ9ppBABKewdQ0G8IX8x5DmpNfwQ0sCcM/6QXDjrYxQgSliEH2YqJBELtLwWEvI8Oec+LC/DbKwhZSFUGec47CzPixwvgl5MLgbVbBooZ5wYw2qcIn0szC9BsYw5A9YkGHLObC7EIXw+4qMkISeMfCuFsJQwSq08KRXTjDeBFVwwLD6ELawWTBZNUjwkuDpsKTu/zCEWomwx5c5sLrD+vBrPirwue8EsPKrQNCTn1IQlrgWEExYAtDdKgCQxt03sKIxARD5PbVwrA0lULEWPfBrsY/QsNFGsNB9VHD5gZtwoLNA8OazF5BVEtYQ3zdI8NPX/XAlJisQkreQEOkzijBNCQnwnFDK8MX4TtDgNjWwriCw0I=", - "encoding": "base64", - "path": [ - "vz", - 23, - "data" - ] - }, - { - "data": "NiCUwlhnIUPfZKvCrFj6wo8oCsPGserAZaOXwtK3G0JDFAbDOCHOwls+vcIK2sTCaa0+wwDUPcOa7xFDHs+XwjxaHELEQBHDoChvwcu5G8PxvQrDtBQzv8fK8kKWN5NCeucAQm6x5sHDIt/CinT5wqqwb8Lg2A/D2asmQzHZD8NpHFxD6JX4wtqxhsJzRENBgrYNw4VtMUNA6BjBo9cPwxxRGMOeUkLDTW+0wmtE6cIOW6tCHw2Qv+imbsIh33bCChnwwoZkEsMQPDfDXeP0wgDgpUIsthfDBt8Nw1romMJ6mgTDoHvewRDKCsNb05bC0HWOwqR7usLpDADDRZOFP9hhyML4EQ/Drrw5w9jlN8PsPlhC2mkIw6/bfUGSMcDBR0AawjTAsEHKpjbCGvC3wlLS18FIYQjDkChZQjYtCcNjqUBDxoERw0ZwO8Merj7DW+MQw47kQMM4hdhBRBLyQoOPQsOqLRfD3CRtQyzaN8N4LzzDf5X1wrA+LsPSfw7D5PzbwpXsysKOsUPDyJxwwlyyI8McySrAhcwAw+gUs8JAB6RCLfICw+CJXcJkyb9Czo9twjjsmkIWcgrChv0xwiooFsNAWqnC2s06w5JfesLWiwJDzt+UwmbvEcPMFLXC8taqQnuC/8ItA6xCtxTywdCZAEHgDR1CQqWQQj1IEsPUkEXDel6SwviZNMOVU+vBxWB7wjOnoMLaAcZCjRJ9won/LMOgjy7D6PSgwOwGEEPvoOfBOlRmwvBpPcP3YhXDaC8Hw9DwFcKksNPCz2r3wuAyGcNkenzCerF8wu4kKULcTQXDGAkOw1BV8EJtDhvDuAQ7w7lKmcBhpAfDNjiXQqSxC0GouAfD+NvMwjGdSULzZ3fCfJ+ZwjSGA0J0qyPDgcxGwz7QGcPSA4nC/gXzwvLRGcLsQiRDbhAUwVS0AsIshp9CQueJQlQrDkHwBoZC/a8Kw2BBfUFWQpfCvT4KwdSfPMOiMR7DHr/CwryjLMOlLBHCUQkZQ0JiTMOVNEnCqBheQ3RUA0PG9ARDqvedwq1YSsNw3+xCYh0Rw7ooWEM=", - "encoding": "base64", - "path": [ - "vz", - 24, - "data" - ] - }, - { - "data": "nUPRwvCxS0PICO3CNLISw7NqK8PZhi/CIG/WwpyeLkNYgh/DMKoBw/+z88KnfPjCmBwzwxigJMPqYm5DZvrSwuSDacAmIqLC5NBnwphJMMOIkSbDcB8+wgthZUN1mrNBMoKFwUoCjcIbFAnDBJQXw+r0v8LYfSfD4BplQxLfysK8f01D/9kbw+IDz8IPRhbCJY/BwjVNWENa4WPClq8rw86QOcOmMjXDTp3zwpSBD8MWBvdBeLk6wsD3ysJgaszCYaaZQXRALMPuYj3D26UVw0u3TENojjjD4NsnwxJyOUIckyHDglDZQlb1JMM2c+XCHhnawqT6Q0IQIBjDSFz+QtwABcMW1yzD/iMjw9IYL8PCbSRDNZsmww51CcLESXfCChefQsKaLkPPRqzCqFLvwvxHg8LCcXDCsf87Q4IAJcP7g1ZDhabQwlsnK8M0DknDxMiAwlF2NsNKPIvBuD57QrHgI8N9cNvCkaxSQ+/3N8MWhBLDHJ4Rw6tqMcPzqS3DosUJwwhmAcOUshvDfoFlQsLD3cIW0TrC8NUfw8Qo5sLAn9NBDqciw56st8IMLFFD4q6QQny7wkHGa5rCeCiqwiHWxsISOObCPII3w5gmx8LyM2NDZFXYwn2qM8O69/rCW4kEQg5yfsKoiQlCRuyNwmjdFsJbm0vBxARDQ69EKsPmpxzDVH7ZwsTjP8MF6ojCguHHwsTN4cJOCDdCulTSwqi1LsNAsFHDamQ9wpCOYEOc643C8t/AwpARFcOu5TDDbIIjw0JHm8IEMwfDjIMYw7q7OMPIONDCvUvOwhyLG0Mc6R3DxmfHwqvhWEPYVzzD7MIkwyJPMsKV9yTDOJq6QYp5GUNB0oXB4SYGQrIrDcC2AcvCol/WwoBjIEMw3z3DYPIcw1vtOMOiKs/Cwl8aw4GH00Kb21hDDlRvwhzCksJkWddBDgegQZBABEO+oG9BKt0iw341EMLGs9/CNMxcwuYcJsMi9lzCoJIDwyODQ8Oo5ZbCst++QuCyJ8MTLafCUt9KQxStm0LyrGJDp5XfwvBtDMNJL3NCwFUxw+cVW0M=", - "encoding": "base64", - "path": [ - "vz", - 25, - "data" - ] - }, - { - "data": "NU8Dw1YOGEMK+hHDLqoUwwt0RMMpj5XCO3MEw3b4T0MmMC/DyFsWw/ZGEMNj6BDDvBDSwuq6ucIOWjVDdi0DwwJqHsISmydC5IG6wogGFsMJKi/D6nKvwnb/O0Pkxq7BHMFlwuzh0MJUqxzD4g4ow9A++cKmCivDpq4qQwH8EcKi+QtD+As1w2gdCcNanaPChVm0wQ8zFEOQxsHCeGAkw8LVJMMCJNPCNsgVw1hxJMN25kPBihCowv5LCsPgnAbDSUcKQ/ndJsM6HePCNBsqw4oPRkOk9jXDEHw0wy78DkORljLDJIhTQ1O5McOQ9RPDkEsNw1I7MkMckiPD+OVKQ0Q+H8MokzjDsCvPwojC2sKvcklDitc4wxRJk8JsCLzChJsmQ+xuakM8cezCIKYOwyb+wMKJFUtClr9iQ3cYMsMoWhVDrmAowiqqusKGDhrD0sQdQvAn4MJOrVnCVEo0QUgQb8LIdwrC9PQJQwDB8MJEIZbC/uUgw9Ku7sKKDSnD/FMew3JDFcONw4jCqOYgQwW+gcFSDqTCpaA3w1oQCMMcfbHBZOY5wzoL9cJNSEZDq91HQyCMo8EBxNzCWk7vwhrIq8CKzw3DlObmwj50A8MdyTxDTaQJw6thR8Oz2RjDNOwvwY1lYELEogLBs8bWwruWlMLreGPCVB9DQ1TzKcPOtJjCB64JwxDX78KAlMfC+ucDw0icCcPgr4i/2i4Mw+q28cIfpSjDOj+owpRNK0MindXC2sgBw3SYncKmkTHDZ/Ipw9it4MJCbR/D1uUuw6lpMMOU8wjD/r4HwxfkVUMdbynDY979wXK5OEPUpSXD8sm8wsLxmcLi8jDDGGGqwRoGVkMsDP1COqQAQzyvMMIa+QXDFqkEw68RU0Ofyg3D2WKSwlRANcOFHwfD9/M3w4zXSUMKQxxDWZHMwlHB28KU7pjBnMSewZgNSkMGQdbBRZQqw7h3osIcQgzDo9u6wl5iycLa2JJCdBMiw3RDDMMgdtPCAk8xQlSFpsLS+NrCcJUMQ/B89kHKyzRDYaEMw66StMFHvlVBUOEew66QFkM=", - "encoding": "base64", - "path": [ - "vz", - 26, - "data" - ] - }, - { - "data": "aAgaw6BovUJAiyfDcF/mwo7kKsOsgMrCxrIXw5xyGkOKkRnDROMjw/tvIcOaCR7DdYX7QOZRj0E57/dCivMYw8knjcLsPzdDzNPzwph/ycIyXwnDHFb0wprd7EKyN3HCPDa3wmCjA8O/7xbDZqwNw0KQEsO6QgrD7rfdQrKMXEJMQZpCuJUhw6IpKMO8MPLCC42sQvfKokLC8wHDsJXkwk6cwcJEywJBU8stw+48H8Py8jvCc0LlwgCXKcO/Zh/DRJBDQ6TJ98KIlOhAnskfw/jnC0NWu/bC3vQbw6dqQUNkmxTD7lE/QyBAGsN1hy7Dttsnw8HOOkNWwwbDbmczQ8ICMsMyQhbDpv5HwbPJR8EgShtDIUgcw4DTz8LwJ/PCWvxCQ0QrLUMDtw7DtcAgwzL48cIYJiNDdB4jQ7iLFsOkUp9ClkY9Qt70vkEOmp/CyiULQ/baEsG/c6vCP3IIwqDhpUIKxLlCWW6RQh4oKsGpYM9B3nMQwyRC5cE/oujCckooww7OG8MmGVZCguVbQ1Cm4kKQgdzC48Akw9bYF8OBy4HCKI0ew8azE8NHpA9DcpVPQ1SKasLEhwfDsIsUwwDk9UIgoSTDwEpEwVAcHsOaOQJDsPMiw7RTKMPzQizD/fZDwjkNSkNAsy/ChRAMw+tRz8LYwrzCelIKQznVA8PM5wZCgQ4gw7elQUAOcfnCougew/bjGsM2ninCaUQow8iV/cFMP5bCOrPowt2330IQGgnDhJYdw2sirkFAiwjD1A4Aw2IwDsPqwTDDhfgnwwmB8cKO0SHD/9ggw5owKUObewzDSGmQQtT37kJOALzCHkV8QULRzsL4OAzDFH5vwvgqI0Myp0ZDPPg1Q6jdm8LOfR/D4QwZw05zHUM+XmHCQJQwQrYfBMNyCCPDGlgcw2oiQEMM2L5CFTAJw9LgDsN/f2zCymRUwix8LEPEtnPCMksLw0Qa8MKTByHDGh/5wqZ4PMAvMChDUMs7w1QaJcI+oQDDppyQv74J60HlGAHDjpyjQkbLNMH2ZPxCVD4lwyJEzkIYANLBjMCywlzXoEI=", - "encoding": "base64", - "path": [ - "vz", - 27, - "data" - ] - }, - { - "data": "2+Erw2S580Hydy7DhLBjwn8l4sKw2PfC8IIgwxqwyUIiRuDCvrQUw9IdGcMipgrDzorrQnQRCkNpZIVCyv0pw2hgw8J1plRDl3sQw6DkxcGcNZPCdTsXw1VPWkKihrvCvmfwwpx8GMOBqunCOue2wiCpIcPvF6bCCvZFQogBIEP2Q1ZB/JPZwuDCQ8PujRvDXlhAQ1/veUGEVxzDCu4EwlL5nkC0LfdC7Gg3w7DX9cLQDZfCDEkLw2bVQcP5BzDDSC0jQ9GbU8JLmPdCdCDwwi5jpULpJtjBon3ewpxWHUMTm7TCRicKQ+lJ4MJsDUDD9no7wxpiDEOPXqDCAUoCQ1yrJsOtQbTCUJHKQqfNuEIyEM9CCTnIwmxJ/cKF2RDD7LUXQ6/G50KNzB/Dqjoow37GC8Ocu2JDIz7MQqfkycJd6rFAEiwfQ8pRCkMaoVxBahpPQ9TRx0KSzODC9j2Uwm4fLkMpgGBD5HYXQZmL5kLmZAVDjr3bwkqsmEKG3PHB/pwWw4BlCcPCqyFDWEgwQ8xJT0NRXATDOinjwsfQDMO0/MzCTuXEwnDVJsNeSa9CzIwZQyEEt8LXVBnDw1grw9YNT0MXOzbD14K5QrxtMsM354lCObs2w9Cb38IkASvDhHukwn7kV0Mp9pTCsuEow6wH/sLyLPzCpCalQmLnjcIKxwtDGMEuw/AF8EL81Q/DDBw0w8KTGsOmM57CTWU8w/YdqELGFzJCtHgQw9krRkIC2yHDGvEyw7DMA0NoyI3CMPpYws4ZJ8OGUxvDjDT/whxg+cFH7THD+IMxw+hH6kKEbKnCIiVDQ5ekYELvLV5BlPQJQ79j+cL+spPCLRy7wpz04UIfmCFDMKgmQ5Vd0sJoejHDGcogw1TUzUIliUFCQncUQ15QYMLLJjrDFEGQwgKeDkNQQwNCcqYkwzxtLMMgtbvCKrqiwv49/kL+eLLCjeelwn2OGMNKdSrD4jkVw7RZ1UK8mkxD6iwuw9gcpEKK0hDDOsUnwguGBEO2tQ7DOHu3QRC9RsKK24xCJQ84w1qDMUOWe2/CgreRQZLY4UA=", - "encoding": "base64", - "path": [ - "vz", - 28, - "data" - ] - }, - { - "data": "+yUnw0MgNMI/cRXDeqAiQmhdy8EA1w7DbsMNw9WnNEJUEELCItHqwry768JYv8bCPOc6Qx49WEMxXtdAtdUmw7cY88J+diJDhtwgw286m0KqU4JBG5suwxbHz8AkcvXCvKUPw0aPJsNelWLCFp9Wwd54HMM2lgPAro5+wReYZkPquV3CFH/OwYrkUMM4lTjD6gdOQ7QLTsIgfi/DOLKKQsnZ3EKkW0dDPQwTw5IrbsIoa8bCnB8ew4EHQMMrKiXDXH70Qlq4QELZokFDH/RJwj5Hv0Gp8aZCZwsuwo6R4EJQeYu+mHunQmRvQ8JK6ivDwBgww3K6vEKWM9hAwPmWQto/BMOO9GnAitxEQ6ZeK0NQLDZCJByBwV2oDsMWZiPDjbzJQpj2bUKbziHD/mwTw3uxGMOOsDRDQg4mQiTPz8FELJfCxOF1QyCXT0Mma9NC0qhCQ85PNEOJ9QbDpLnawmwrO0POyFFDEGNhwosfRUNcC1FDFk5VwsFdH0PKcppCZCLswi4a08Jy01VDfGf1Quq8PUMosRTD2hjnwTTM1cIOagfDjF8cwIw/J8NTBeFBjOvHQkKy78KyoCDDVBo3w1NYLEPcsibDgk4lQ4h8K8MHghdAcn0hw6QdAcKetxLDUjbfwqVVIEMwrcnCoJ5Aw6jeEMNuTBjDskLLQV10bkGNQlBDbk8gw2ELOkP+4xzDvGIxw56zBcMsct/CniU1w2B+NEPKNAhDnEUow/RCkcEiLTTDFjIzw7z7UkMKapNB5rNRQhrcOcMPMdnCU/5mwm7vnULo/yTDVv8lwxPZbELS2a5ApAdgQx+X1MBaZPNCTOFZQ0oJDcOPlMhBnBH2wtQ3d0K/tO1C7zT5QqDX/cLK/CzDXiIIw/KkOULyEARDc2NQQwQiFUIPOzXDC6Y4QsdXskJmpQvChO83w7xsRcMPhffCdjvTwrogm0LQjuHCPLKPQNA0MsMegRnD/VEnwxGxPEOq5CNDLufowtyYLUO4wBXDJtOdwtLzRkMmzAzDtAMfwjReqsIV0C5BKUomw/gQM0M4frHCsiP6QvinksI=", - "encoding": "base64", - "path": [ - "vz", - 29, - "data" - ] - }, - { - "data": "gBL3wsQ8J8NBuLfCCjsqQ2hNrUIMtx3D4KLAwjL+9MG3QlZCnvtVwhWzB8LuAIHB4PoxQxjfNkOobZjCPID9wo2EEsOFBc5C6BYhw/wEQ0OUogNDgO09w/uVo8KtIBjDVNgkw6mzGsO3Zl9CIyfOQvjw/ML2AuRCxQXXwkq6KEMblxzDpzGsQnUJG8NmvlDDDHYPQ9zSC8PKMCvDvM0qQweOQEMkXDdDtvlSwtZgVEIwVvXCNpEnwy6mEsOSg/7CFNmCQtzMLUN6NChDFqWUQmxsXcIZqDBDlDmBQvL+P0IG7fBC/BJHQbzkWUIcQvLCul79woITDUIQGf5CfDURwBSjd8K8l+JCxChRQy7IO0MGLxzCfNy+Qr5kFcPQLSLDfC/jQaAkU8GWPArDEDe8wjc7DsOQ1elCtGYTwiYntEJ25j3DeZE5Q4zFJkMdFDtDqkAGQ0I0QUMR2BzDHlgSw2wCDEPyGAtDgjMVw+6IPUOCCD5DcJdLQnX5PUOXAjNDcFBVwn6mLcLKBxxDGNhAQsObAUMU8xvDRgvCQlu28cGeMSnDKBz1Qpo5BMPFZ1zCQHj+Qf7GFMMEhw3Dy3kZw7TH6EJcYNfCWO02Qw0/+8L6arvCNpSxwuDTm0JYDcHC2tMOw+bLwUJ6KwDDsNk0w8xaHsNuTTDDjg5Owro1BkN2qSxDnmvwwtZHJ0PMKBLDIJMCw+o+ssL+ZhLDHYoLw3oRSUPGfUFDrCQ8w7SH5sLKXirD5x4Mw2rhPUNIFAdD3M0sQwLkJ8N2Ez/BFP5wQvIWN0P4Mf/CxEsBwwwlusEs+QRD8LwVQ2R9rMIM+0dD+q81Q9HjFcO+VxhDAbMZw5bFxMCfAn1Ce6tqQpmJEsMh1grDauSXwh5+7MEG7jhD2qYrQ5AvC0PGyPbCHBURQ2YVekFkBAXDECEuw2beNsOi0BnDhIoCw89hC0E80wfDTqYBQ5y8QcPgO+bCBHcow827QkOBS9BCeufZvwCDQUPF9wHDOm3vws7oL0MsG+rCXNIBw94L+8JmMpLCkpHTwobRA0Okee3Cbp5FQzJ3PsM=", - "encoding": "base64", - "path": [ - "vz", - 30, - "data" - ] - }, - { - "data": "PDJvwkjdlsNIXrDB0qNPQ0I0F0N7SArDPucOwjDB0sLirwRDHgGlQSiJi0K+0JZClkoIQwOkA0PcRyDDQEiFwva/IsPym1ZCflwMw0YuYUNCrEFDeBYow8wkE8MDdyrDEmEkw3aV/8LAFxJDoCMvQ3obqsLSpDhDEtRHw1g05kLAK4bDClAWQwAklsIWLjjDDNa5QhDUWsP0gA/DSlNGQ1KiNENmmgZDJH5WQkb/CkNckAnDMosVw3AYr8JCcJrCrAoyQUifZEOARfNCK2IkQzzWBMNQtEJDdoITQ8yFZ8GqvDlDFKtWwiVZC0MpCG7CH61xwk2alcFuAzxDckOgwtzshkHQDzZDZnUeQ2jfD0NbPADDRTsgQ+yqCMO+OgLDrrYowvQ/ocLfl9PCafemwZK/6cIoD3VCpOLawvLqKkNPPIzDFQUAQ3b850ICFlBDqUybQjj4EkNTbCfDmBMrw0zTwUK0nKhCqNt4w/4uEkO+4wxDZlUQQ4YnFUO5b0VDdImxQRq18kFGBsxCfi+uwb+gnUIQFA3DC0MrQ3oUdkK8Qj7DUsQ6Q6ddo8IkGQzDOVjswVZDJ8OuRuPCuWLXwrGujEISAcXBKq8RQ85Cf8I6JETDa0w5QT5MGENRRhbCoDokw1CHNULkhBLDutsBw2KfEsN3jzTDtvn8wlpISkPShvFC3N2HwlR4/kIgOfHCyBR7wlSHBcJ4ASrDCu+owsJlGkOeQChDuiolw6A1V8O4aQjDWXWrwt56CkNkIUpDtipSQ8vk9sLVnaVCKZ0PQ7LZT0Ml0KDC6rCmwgqq1MICyERDvCa5QsJVHMPq4DFDrJIBQwaIBsPwdlZDasItw8S1jcJa6EpBpCMvwaipG8PwWbnC0lXqP4FhzcKDUhtDFjj8QjJ7P0OoCTHC7AovQ0gEYMIYjmzDjgcPwxCS9MLwLizDSvYSw5YmasIkzBXDPKlFQ/KGK8OiPIfCWsIRw3bcFEOW4z1Csw2yQtTfFkMOscrCT44Vw+6O/UIe/KbCivljwxoiHMPAaiDDczbQwebKrkJEMwvDQhElQ1njlsM=", - "encoding": "base64", - "path": [ - "vz", - 31, - "data" - ] - }, - { - "data": "rlPEQQUqVcPdamlCDC8oQwVgO0MgpcLCjKM6QvwrTcOaXjpDW3LMQpIjIUNi+RlDIAmxQsTkl0KYR4nDbKWDQfqIIcMft2Q/SaXTwrpDNEP+7j1D5HH9wo8vWsPoLDDDapIMw3Aeq8KmDEdDgFlIQ0pGx8HoVVBDhvKVw8a8dUIILGnDJG04QynAcUFN7gfDXEgnQvzPR8N6RsfCPHchQyR1C0MZnp5C7tcHQ9CcPkP0QRTDCv3owjbCbMGzWwPB3l9cwvWzO0M2kIlCqKRUQ17CacPsDCBDsz1KQysotsJ+E0dDWJ4FwwSQR0OQtGdBdO68QSxTpsIunjpDpJg1w4RNx0IHaFBDaCXPQtIvukJiaXvDzI9CQyyV5sJ+y5DCuZIAwzYGJMO6W27CACORQrCClsJO4Vw/uABGwz4dWUOKuDHDot+OQjqhbkJuvStDKTdoQSxSukLEkhbDMoY9w060QkKiSOhBuh9vw0YwxEICNq5CVjdPQ1uiy0LzTR5DbZfZQhhP7kLgJClCJjbQwsXAxkGTSeXC+clOQ2YXEkMqYUDD30ZIQ5uiIsGK1YDDqufKwvqmMcNf3pDCO8Ekws40sUGsEo5CHr/KQs+6a0GM/6LDWqPhQoquR0PKwwxC7sA0wwDNDsG0uSDDbpdFwsz09MKATh7D7Ntfw+x/SUOyuntC/3EKQFq3o0KIPp7CLbbWQXDsJkLAEzzD4B07wa7LzkKfIwNDQjzqwlcNiMNnj6PCjJxSwTBypUI940tD2hMqQ2o/UcLOPRtDWkxAQ0wQKUNOvo3B9ua6wY7jVcOMzUNDZIURQl6wZsNp3QdD2J6SQvoh1MLaOz5DCiA6w8zFGMNUMDrCar7PwloXEMMdn+fBGgC2QnZXQ8OYxupCwCaWQrVgO0PIgDFCNXwVQ4DAE8MxInHDHuW+wpL2z8Gvly/DuAYfw6q6D8PSUxrDm9dKQyVDBMNWKZbAbvXWwsDlwkJvv5jBmPATQ0YpzUKG4WnCZPEvw6RejEJQ9QLCZLaOw0BcOMOTAo3DxBF7QiZQEkL64BvDifT2Qjx4TcM=", - "encoding": "base64", - "path": [ - "vz", - 32, - "data" - ] - }, - { - "data": "597PQigl3MJ87ABDhsT+QqrQNUN6TdbBkrUEQ3bxnsMyVEdDnIEnQ7prUENaREVDyvQHQqRSaEEVUXrDtxLGQiKJA8PwPmvCa1Vbwp53A0NevxdD4lF+wlCrOsP7yhrDAYXFwsDYy8FvlTlDfPUqQ0jJVkJsJDJDt744w6Yt1EA849jCiu0pQ1bXrEKwdYPCjig6wUo/s8JyLRvC0GTuQsKpuUJOgoNBheYzQ8YDO0PqbRDDyF2Bwo4Ha0JMtJVCqF0Pw/3EDEP4ivxApgdAQ+aXg8PC4+1C1QpQQ/gUPsPyUilD6iZww0g5VUP/7K9CqTbSQtSdKcOcrRpDAIuaw5zdJEN8XzRDSN0yQgJ8D0KuZYrDEGUyQ4WPp8KM2WVBreRqwyCwjcPWZNI/mOYYQ8y0Q8EqRobCWFSYw3U6QkMYcJXCLlZmQdrOgcCm0ftCx3tjwmKe/0HypubCujg3w5Ze6sBGOu7BTAHGwisqMkJs6+NBQltMQ94XQ0KSF+RCFGQ1Q325Q0M6c8zByOBLwwLjC8LkdZPCOro2Q+jUQUMNWCPDrNUrQ4CTkEI45o3D1LBCw/hpH8O3ZXLB1WAdQjJN9MGijQ5DWudIQgUpuEKkRlTDTEUvQ8OMSEOidt5CL3orw0Rwi8ICHiHDeJAnQnwNpsIhPu3CvJGBw0KQI0P+BPS/OTejQmzp7kF+VYrB1dnfQlm0/UIDOTjDjFyKQrKcQELJkq5CN9YiwtrEGsMeLeLAarWCQjPosUH2aiRDKmn7QqrCF0L5NEJDWuQ9QxTw90JlsWJChrA5QielmcMk2SNDRuyqwTQ6MMPALbFCKJA3QQDxccLY6xJDOGUmwwP9h8N5LfTC/xRqw/jY8cJubkBCqY4fQ1Ywk8PCXZNCECuLQaQ+FkNeR+RCdFLuQrxqi8PoAfDCIG75wWBhkUJv/BjDGkMWw3THgcO3VwrDr1MqQ7aol8JOkotC6K9KwmPFIkLeXcrCLqYxQ7irQUIXqhRA9rRFw0wzpUB0Ix1CKVYSw8HvUMOsJXfDV7cDQ8kXvcFO2yfDdnybQjk5vcI=", - "encoding": "base64", - "path": [ - "vz", - 33, - "data" - ] - }, - { - "data": "apcdQ9wN48F8PDBDPnOrQgDeHENNd4lCL3NBQwTfN8OQiyxDr/xLQ5aSPEPBzjNDDA/uwTqpXsJqiQPDPpQcQ9TzksKR8gPDZAtXQSyWoELm/NpCqHuJQSJAj8Kg2ufC0aMNwro5S0KmiBpDoqIIQxipCEOOzg5DxOCmwoQoTMJA+arBbmMPQ+T+BEMeRn5B1tOLwmREnUCaFw1C1EuSQhr/IkJ43mTCfr0zQ7pOHkN8I/vC/sADQb708EJQ0RlDLR2Kw87ItUIIYYLCe9MfQ19+CcN1EJFCwgMyQ2kck8NQLAZDIr6Nw15ONkOulBNDQtUkQzV7mcPUT+9CbJNiwxv4SkO8EBJDImydwZgt6sHUyyXDUtUWQzNjH8IK8tZC6JCBwxGpgcNp/ZVC+ilHQ4izkULfdRPDEFk3w/oiH0P0mT1BSGw0wt5NnsLopZFCjhsLwxhsGsLP+13Cjp8Xw9pnmMIM5MDClBsBwS1thsF+oxLCH9gqQxReMcE+KoNChqxeQzRtY0P8n9TCQd+Xw2Q/0sLmsW7B2KgXQ16DMkN1FuLCnLoJQyQuD0NCXiHDwfehw1iq9cJxdmtC6PLmQpjAtsIOuTVDkogVwdt2FkO7Y9jCaY5BQ3ABKkP2Fy5DHDwHw6ySD8NDMgvDsIjlQpH9vMGSpmzC31YFw1Ik9ULSSJnCiLgXQ1Fc/sFq7IFCSuUpQ6MVREMr1RnDvAYNQwp6T8FZFhBCGtFMQpgnb8KX8ZZC0eADQ2acM8IEK/FCBpucQioF8EKfvTVDhm4iQ4Xlk0Kg1AJDyGvnQlF+RcN55QBDQGunwo8QjMLQvw5CP3pswsh/wUAej8dCkNP7woCYecOU32nDSjGSw9JapsJV5vhCjtlCQyi8LMMOj71BZjhHwlCM1EK7cx1DmIWqQn5LjMM1cO7Bpr40Qu4FDEOi8OLCNSb1wjT8hMNAaNfCJFAGQ+LGscB3wA5D8YXGQdbBt8HU6lDDliIjQ556W8HkjKJCfhlNw3CajsLX3vtCtQhRwsxKV8N4IQXDq5ksQ/CZxsLmkR/DzDbZQYAKwMA=", - "encoding": "base64", - "path": [ - "vz", - 34, - "data" - ] - }, - { - "data": "t9w4Q0oOK0Iiy0FDXccpQlOU/ELmPRVDSCJPQ32Vr8KGIwxD+yc7Q/qeHkM0vBZDGxLXwsglDMOA9TzCEn86Qwc8hUGxoGrDMES3Quoy0UHHsn5CxqHEQn74tkG5Z2fCILQ4Ql6nAUPcevFC+iLGQgDrRkOoBdBCkr+ZwCHS48KJfzhCiGTgQuWhH0Pst7VC2MAIw3SFmkL2YdxCCpa2QWDrk8GumhPDDMYcQ6q3+0KoArfCR9W7Qkx+JEM3sFBDbouLwyyJFkLRsR7DgrP4QnFHPsLadqBB6HIOQ3//Q8MGkr1CpJIiw/SeEUPFCDtDpodGQw8UWMN6kaNCgHIBw/eEQEPko9ZCXCu5wjSN0sLMPKDCnDztQj1wlkGuzytDmmQiw+AGCMMz9BNDzPVFQ5bTHkOUhnXD74CbwqbS70LSYqtCOmXbwofPLMOs90RBz4pnw/dI9MKwK/JBPEjIwoC3KcMSLDPDYK1kQkgZtcLHu97C420GQ2uvoMJHzD9BrBVLQ0j0QUPark/DpiFRwxIxQsNgWnZCXo3oQhJsFUNr1inCBKzGQi41PEN1JpLConNYwzqyf8LaIQxDKMQqQ3ZGJ8PxATdDXXihwjX2OENPXdfB7vIpQ5SIBEPB7FRDNriPwnjSdsPnvsPCT6QgQz7XZEII/YtB0vIuwrrankIssiXD0BpGQ5Xx2sLEWBVD/MBGQwE1X0OkNc3C01A/QytWpsJg4snBnDD/QtOlfUEuthBDNKkwQxL688J6YJNCFpPYQSB+LkNQ2RpD/H8CQ+iDkUHJ8TxDMMgrQyKE08Jw57ZCWCgbw4itkUHiH8fBh0QQw5K/sEIEoEJCgPt0wuaSBsNM/JDDovZCw4KP08H2FjdDQvItQxDUl8J0kwrCEc0DwyBjYEJQTjFDgo88QogWKMNncyJCXczxQmCLMENS01/CD5CQwqoWIcOebGPC5L2/Qhi+iUKqc0VDfSTYQngpwcKK+aHDRp0KQzR2sMJQ8yJDRaAww3bTI8NqQEVDgRSGQcCSL8P270rCsEA1Q05MS8PQbAXDbKvzwcUaiUI=", - "encoding": "base64", - "path": [ - "vz", - 35, - "data" - ] - }, - { - "data": "NI4sQ/Bj2kJmNyxDnrV2wHKatUKUoT9Dhe0yQ3J2dMHsoc9CWoceQ5am/ELUBO5COZVOw+xjdsO+VJxBmFAxQ5rM2UKytKHDwuMgQ31KAsKYi1dBDJ4gQ8K7s0K0m3BB1dT7Qo7sPUNcWqlCDOBpQkSvXEMPanhCnpFwQrS1OMOiIM1CZYyZQhi0JEMzRxNDnohZw3TIA0NgIipDTH4GwolxsMIMfYHD47wBQzfstEKy+A7CsrgnQ30jPkOQS1tDfDcvw6QXpcHiLYvD6CasQs0lqEEQiSTCgrTNQtIC28J+7ktC9piTwrIS0kI+nEVDXiI+QxwO5cIjuSFCjH1LwiL2I0NdJIFC7GkywxKJQsOH1P7AiKakQnwBtkKq/EdDdLKfwi4qU8JspUpDaCItQzY4VkPpaIrDeIkhvuBhmUJIvhVDB9s2w8rbjsMsq2PC1vCHw0SmXMOqhe1CJNv2wbFumsNyi5PDzNLXQiCzOcOXLEfDfua/QqxaIsPg2UPCCewqQ6waHENzIZfD7UbqwnNjmcMpuQ1Dft+ZQqNj7EK83xVCFjpiQlohQkMALPa/emTjwu2cdkHpxk1D8CpJQ3xVhsMiIyJDfcsowxrpNUOlMStCa8cNQ6zOskJUxEpDDGpyQV2MmMMjRv3BYDo3Q0SbD0M/UsJCKrO8QdZXBkLyR4XDiqxNQ37dV8MGR09DAWo0QxpXQEMNJQLC8+ZVQ3ixJ8N42MvCCrQuQybSn0KQQD1DkOBDQwSAVMPI8bpBY9PvwcWsSENY/PdCh+29QiJ7NsIygl1DfsFOQyRM7MG5KExCPi5yw5cuqkLmVcLCQc17wzOjIUM8ev/Ar1avQToxXcLFQynDFDbjwnqiS0KqRVhDJZMRQ4QfJ8D4H9LCOEprw+Y7c7/CPyFDgjZDQPNYpsI8pMZCdKs0Q4ZtMkM4mXJBu7HSQALqoMITtpZBRhFbQm4/BkPQIFtDONkwQ28lOMPXZF7DKuDaQokYN8MUYFtD12X4wqAfhsNaj1pDf0uRQjr80MIE2oBBZjEhQ1seosNMvq7CElnGwuIZBkM=", - "encoding": "base64", - "path": [ - "vz", - 36, - "data" - ] - }, - { - "data": "Fm0WQ7KnLkOCWhBDvPZdwoqkSEIrQDNDznoSQ35zNkL61H9CKZb8QgkMuEJqTqpCjrGaw2Ank8N/p5lCXrMbQ3cYJ0P8GD3DUqJNQ8jixMLCSivCa/JFQ0IICENGmK9CUqo1Q2l4XEN6aThCqkBkQeL3QEN214VB6bfoQmKwgsMIuxdD5NcSQhRpFUMFDDdDBouEw3vkKUPRzU5DckPGwlZFLcPCaIjDqqPGQm7eT0Jp7jdC2B5UQ3RaNUOk1z1DPkvCwsBmrcJ/wHXDaJQyQk56m0IyDufC7Q5uQmo5F8IUJPM/rzptwLy8c0JS/S5DtXUkQ1+MLsKqKbXA0ruPQaZXAkPgx4xBV3SKw68vi8P6uGZCNM8mQhhYJENktTJDnpALwV4DSEE4klxDZIkQQ21pUUNOtSzDQ7J2QgbU60G6oktDlO2Ew9zAZcPYJgjD/AE4w0pXjMPZrzJDUng0Qt5Gg8Pe1G/D3IYUQxI1msN6/JHDXYNdQu75fMNu1fHCNR0HQ8LZ6EKVXUTD7SQZwkqnUcOU7EhD8pQEQqmKqkLG/NhCjG8GQW6IKUMqdHJCqI8XwkiGwUJaIWlDKno7QzDZVcNu/ghDNiWGw1cMHkOOZNVCjpHcQhAqIkIEcyxDLzHFQnj6KMOVh1hCNXooQwp+TUPnoSBDK+OcQn7KgcFWWmvDDOYzQ7chnsNpy1ZDQsIZQymAHEN6BC9C8j4/Q0JdhsNFqUrDYDtAQ35tCEOO8klDzcsvQ9rblMOC1fzBKnvAwiZWNkNul7NCVsheQtDF8sKNEUdDnvVFQ5YUGUKb2NJAIF9yw4iqBkPWWTvDjqePw7qzTEPL65HCLPTJQqSO8UCqq6/CvLglwtgJB0MgP0hDaEbkQlJuZkKwfD/D+AGWw2TihMIKswpDkmBIwhLZOMEuABZDToxYQ57eHUPEGq1CNfrFQmd4VsFUKthCSOIhQQaXNUPhqkBDSIRZQ9YejMMK7ATD+4qXQogTlcMes1VDSWNLwuf9ccN8NDtDpCnxQvDPisFsmpVCDPAHQywtWsPAeYvBBo45w7h3QEM=", - "encoding": "base64", - "path": [ - "vz", - 37, - "data" - ] - }, - { - "data": "KtL4QmtHcEPyWOBCcJvowp0RXEBUvRlDKBffQobDyEIwZqJBdtC2QkyAXUIP8kNCalZZw9K5PMPAmgBDSEUCQ20XPUNlXsnCr4FQQ8IYL8OkudfCwG9IQ1ZOGkPKgBBDf8VNQ+K0RUP8kIdAOuQKwuTqH0P7YwTC3AYmQ+onQsM+OEFDgLQQwR2IAEPGt0JDVgUdwxJNCUOwWElDjYIxw1pSh8PCXC7DLqCCQl5xGkHOTgdDXNZPQ/QMHUN6hxpD+3v5wdzaJMMw0xTDb11zv1gF/kJ4DFHDzllBQZpSykE9Z1jCZpZhQuTqUUHE8hBDLE4FQ3hQXEHTIWrCRlykQnKUuUIZRwrCovB8w4aVQsN5IfJCvGiDwDpnWUPEEhhDuWheQrgfiULS+UBDApTiQnLcMkOCv6vCZlzjQg7PssFWJClDW9VhwxriBMPnU17Dji/Iwln+PcNg0ktDFj7fQqQIJcP+6/jC/l8hQ5QdhcMYOGDDbQ9CQVljXsOeHlDDzHTBQo67lkLOHdDCVn3/QcxD4cKAfVxDlsCCwbCXSUJakR9Dst47wrDCC0MIDu5CGB/GQV55HUPj40tD6vEgQwLQ38LJBdlCllhrw563AEP6KihDgvGWQiqZaMFa1ghDrigbQyR9o8KSMANDcZwRQz5tXUNQhEdDbqb6QlkPkMIy8QzDjWUUQx8mU8OOSDpDoi31Qhi27EIcwtlC0XcgQ0WjecOIH53DZnstQ3OvOkPUJzRDGocUQxIOTcPITrrCyCcxw556HEO8Q1BCNL8+QQzLVcPqYSZDUjUpQ3jvy0IsmC7CmsX4wscaJkNkeZHDcj80w1+vQUMn2RbDlvYcQ1Czd0Lzjr/BBLbYQfaFRUMu0ipDsEOgQsLF20IQaIrDKqpKwyMcDsPQ/N5C8YTrwlipV0LqJj9D+A5OQ6scBENdhQ9Dse0mQ6rTOUJIdTFD1jEewlYtUEMwZx9DJrdQQ1yQaMM94mXCP9MTQsSvb8N1ZjRDxkLdQQLfFsNIzBhD99AiQ7j3ZkI4RgFD7VLVQkbvA8NC4YZCth+Pw6HmTEM=", - "encoding": "base64", - "path": [ - "vz", - 38, - "data" - ] - }, - { - "data": "Rk6+Qi1XHENrfZhCqgFBwzLSS8I4uvtCzu2UQtQmGEMyPd/Bx+lXQsb9eEFo/B1BNjEEw9xIycKJ4zBDqpTLQvhVKkPsKgfCCp02Q971g8Pw1jjDLMMxQzbW7UIMuDNDwkw4Q3mYJ0PI9ijCOqO0wtQf+EIu07HC1BdIQ/StwsI9pglD09h4woA+zUJYqS9DWsqHwn/ll0LARS5DyOOEw3aaacNCObXCIiHXQfcMF8I62kNDo400Q4DA+0JwM+dCNDLpQW5FgcORI4zCTJZRwoKeKkOI8JnD6HYhwn5wp0I5Ke/C9tzdQoKtHMITstpCplbDQoXEgEIBxvLCkDMRQ3PhTUL9A7vCIuUaw+pO3MKYdjlDWCxiwvo1XEO0wvRCZl3oQpRT70L0YR9DSBSfQlKSEUPdOWTBJm0eQzqGoMJX9pZCrhDywjR1VsLtuI7DTbDOwYyY0sL5zDdDSFgfQ+xptMLLDzTCbQ/UQoI5KsOsmgXDMnMLwjuxB8MbkZLDMoNfQqSvAkIChtzBbB7CQhg0G8IOkkJDGj+TwkieTkGanT1DLtrgwnK51EJaPTBDXOagQsTIP0Md8ShD3EoBQ9bWHMKYeZlCujgXw8ACvkKDqmRD+7ISQkpYmcLkLMNCJK04Qzxug8H56jJDWmfrQmp0QkN6a0tDqu0lQ9HLCMMyKG/CCD3iQj7N/cLQ9xlDjOyuQi4YnUIEcxpD3ov4QvgMGMMUmG7D3vUUQwAmMUNsIxhDkmnoQta/5MLQoyPDHpiJw6I//EICniBBIRgXwgKZmsN05gBDuakGQ8xpJEOW1MzCnf4PwjG9AkPOtWbDvAq5wr0jJkP+anbDDA48Q7O930KkaftBfDjAQpxYXENrWghDPFctQn6kHEOrlkTDiEbtwpBdYcOZu59CPvFQwxwq60KIrgZDfYQwQwSzy0KoATRD9tpHQ4ivzULG9VNDMOfAwurSQUM0sfRCHjs0Q6RADsOIsSZBYdkGwTK4EsMMcBBDCV+6QqIQjsJPoOpCTC8vQ0rG3EKI3DVDjgOTQmEcd8J+1AtDtChSw9IC50I=", - "encoding": "base64", - "path": [ - "vz", - 39, - "data" - ] - }, - { - "data": "CGx6QhxXY0FazRFCSXSRw+NP5sKNWMBCCMYLQnSTSkMzjaPCKiJaQdIC5sEFAgXCss5wwsLF1cHyjkhDyJmMQshlE0NTR7VBWtkXQ8CHh8M644bDvikVQxSvg0JkbzxDbNwcQ77eBUNtpr7C9OIaw+czrEJyhxjDlmQHQ3akmcGUkrFB1jT6wlTVjkLeBhVDcPWrvs7DPcGchg1D1mFlw6rhEcMiYY7BbaeLwXtyuMKKtVJDtgwVQyV1sUJKZ5NCnqCvQsbujcP21um/55zgwpudLEOMnmPDclzGwmwHDEMGKUXDXmIiQ1onwsK8uIlCWHVmQqqn30LYe0bDLo1RQ0aqvkBC6CDD0ouPwoYrE8KKPnxDjxnrwvaNPUPOHbRC2L8uQ51NKEOeUfVC+KUrQnp/3UKcRD9Cqig6QzoWEsPAWyrCoGAUwlJVbUECaFfDdrcjQrJF98G+qB5DrVo7QxIE0cFyDYpBIOZAQGjluMJdFGDCXlKuwghtccLEHE3DGjNCQZaaRcECbh5CvzkfQ0WtsUHgwCNDCsMNw1z14cHUdT5DM4c/w3hti0LIWmlDypcEQ0InP0OkfANDzAO7QurLikFMsCRCIs2cwpNIZEIkSjZDTsTtwFR+EsNL5VxCioczQ7cfGEKKBUJDhhiqQipHI0PItDRD4AcgQzvuVcPE9ytBS1+VQtIkZsI8Le9CkYdAQpi8E0JQ0jRDqSinQhTAjsJg2xzDRK7wQpSnqULgf+9CGv6eQikRFsJLz3LDAad4wxiwt0KGkhbCdCS/wqxKY8NJDrBCmDLAQv7qYkMj4C3DJz7vQRQykkIIjw7DwD6ZwX7bB0O0RpPDYCo7QzDjH0O7gqVCvO4pQwmQQ0OgVMRC7AFDQNRnQEM2V+3Chs88wnB/hsPkdC1CMMqVw5oTN0OIYtZBGg8NQ3SjhULm6D5DoCw5Qx1RHkMLXEFD/rcjw5yoJkN4KKVCri8TQ+I2gcJ+25VCihp7wtGJjMLAjNZC+FULQxDwxL3UHaJCkAHLQlyYD0MWsVdD5PwPQtCnxj2z8zdDWmT1wuY6QcE=", - "encoding": "base64", - "path": [ - "vz", - 40, - "data" - ] - }, - { - "data": "rgbSQeLjvcJdbvnAbm1jw3dePsMaDYFCNGb3wFLVKEPwag7DquDywdhLn8K286PCs9RvQEjBG0JhsOVCMIkNQnzr80J0ZpNCZiPsQvDpL8MqFGrDtyfoQq71FsG4HypDKtX7QuYiw0Im0R3D1itlw3HbN0IGGWDD3im4QRaZKUIUC+/CWu1Gw/PzB0K2gehCCNRVQtAx9sIKb9FCMI0Pw4I1j8KKG0NCSnyMwt5LHMN6TztDZoXlQir9NkIWmOVBciwUQ9wWO8PIw3NCbWU4w2PStkIeohHDKo4lw0yQQ0P2eIzDcVZTQ9mLIcNWCbxB5FZJQUaqHkP+2I7D4CBxQ/5sMsJ8pGvDIX12v0yO30H4aSZDc3U8wxNAG0Mtb1tCixlmQ3noVUPTl6dCaXsnQNb9lEK8p89Cuer9QlZAXMPj4xPD1h3mQY5LmkLO7gvDr67MQlRWEUIIpgJDFrw6Q1KdA0JtXYxCuqITwy7Vx8FOnjRBy9gSwxnPl0CopvLCaD4NwobicsLpCstCqZBaQzSLl0KSgAJD4Hhfw+hSlcJqRSpDYomMw0yF7EGqZSBDmFI3QwJuKkNM5LhC9MpWQt7egELEOE4/rYtjwSbUZ0FMIzpCVEFswuI7XcMutxpBOsAfQ5gprUKspC9DGsA8QiL4AUNSQRhDOCqjQphDlMMMwpRCXiUEQuTaf0ByBadCZuFvQHzd4cBU4jVDONwZQuq1UsB8Ha7CVPWvQoJ2LMLuFKdCt10ZQqt36UFUUojDpsAaw2C0VULSE7rC600kw2wVDsNYoDBCutJYQoAqT0OFgYLDeMKjQsXZDMEAH4rCxrU3QpjCz0LoLkfDOpsnQ64bT0PJBwVDLuN9Q0sfJkNdWmJCz5InwkhWAUMY0lHCJG2FQTgHQ8OD1ms//0NTw9KmfUNuFdXCvpTKQk4X0EGyRixD0AUiQx1/VkOuVydDmIxzw+NABUPnSSFCbg7eQi+mOkD4JgtDRK0Bw0uubMCPNIpChbInQ6K9gkKE+S5CQPYBwq4JIkOEBfJC5oHcwJwzaEJKV0VDPrtQwkLt/8I=", - "encoding": "base64", - "path": [ - "vz", - 41, - "data" - ] - }, - { - "data": "9GhtwUYJIcPol2XCNK4Hwy0/hsMeJvNBvn9awu32GULuFFHDBf+dwppkDMNadQrD+hB9QjwQyEKnbMfBD/JwwCS/vEKbuPRCMr6jQsaqu8KM2xXD2sKdQt0g4sLSMRJDc1a4Qqh9a0K40GfDtAGPw0hLS0Dop5HD0PPKwrfnt0JO+U3DErGIw+wCNcHsVJtCpOjDQo6pXMMXwIBC9AKOwnR78MAYouBC4YcHw/cCZ8PGqCBD2wWcQi+MVsA4zZ/Bzj9WQ1yC0MKVEvNCoRCHwwFKJcKl7pfC0LdtwwnDVUMYioXDuhkiQ7/lZsNmV9jB9MkZwsrgTkPf4HXDI1L6QoSeysIN5pPD9Qd3QpNnrUKRTNRB/J6Dwyzv7kIdpIBBKgsoQ4uOC0P57itCxEIqwjDGEUK0oRtDznqPQZQ4ksPLF1bDO1ekQpQ7CEMwPorCQXofQ/Q8xkL+p8hCXtwmQzAEtUIWNutCPKplw0Z/FEJUP49CHK5XwyKkekJSw0zCbiavwnN248LemSBDvKxWQyuu+UJOGb9CJM2Zw3CdAMN+9w9D5CmQwz77a8GqeYVBZIRYQ3MiEUPch09CoS8XQUTI0kLa6TfC7DEyQtVKBsJovJjCDK/zwkz9jsMNzB3Cq+AHQ5oLBEOS4hhDzBRBQBEYvkKnZ+9CEpRBwp0EZsNqdwVD44REwaI5d0ICGDZCYG88wqIcWcLFaiRD+Ig3wbSMY0L2IMPBfUxOQgERFcNClC1C63T4wOMAskJuMz3DEUWdwr+1IUH+0x7DKl90w2mYisIS3TTALB0SQdr8p0JYU5XD0j/4QpyF5MJLManA2dnUQh63jEIyV+nC4j0PQ1G2FEOU8zhDqHeEQ+BxBkM+2TZBVkm6wviiTUH0jqxAdNiYQqZ+8cKcs0TCdG0JwwxNSUP5BUXDcOlmQj5Vs8GfkRNDplwIQzpzTEM85ApDCj2Zw5aovUKoJpTA/jeQQhfkfkJUr01DoAFUw3ztZULG5OxBsGw0Q6eS/0IalJlAPFchw1p/IkPcdLLBfQdjwtVL5kLwpzNDrjbxQGQ/ScM=", - "encoding": "base64", - "path": [ - "vz", - 42, - "data" - ] - }, - { - "data": "wmN4wizbKMN5t+LCrHWFwhVbisMHvuPAbGDWwrxBvMIuD4jDsF8Fw4u4V8MooUzDyq/xQmTfHkOoJwnDPqZBwpbmgEIk9CpDe/EsQgNPy8GcbpvCf0QVQiRUX8O2YexC3GBeQnb0i0GdA5PDWpNUwxk5LMIKDWfDNlw4w6n4A0N2AivDy2F1w5kFhsJapQNCUkgHQ2MsNcMzgKNBFEgYwf8MSEIK8i5D9rxaw3wTk8NzaQRD/jsaQv3Ca8L4YpLChH2KQ1p+DMK/VjZD5qGYw7r6HcPD1mbBSLyVw3ZN5UISpT/D5QMQQhfnkcMsNKbCXKnBwh7hDUO+SSfDl+yCwEW+JMMwImbDQiHuQm4DDUMnTpfCLXmHwzKdpUJEudvB3EFQQko03MCAsim8QOO8wtUmg8DLSktDE03nwmKhecNCIifDDY78Ql6UQUM71VzA5FxTQ54CH0NTOodClRYNQ2rbFUNZkyFDdBAnw103wkIQIv5CkeCPw4ba5kIYmxVBXOERw2KuLMOFWFlDrhDhQk7xKkNop2tC4FmEw6LWQMNGZuFCbgVUw25/gMLgBsDCZmrzQoTu6EL+7BZBTzEgwpbTDUONTsvC/GbIQrhisMIalBjDojRJw3xydMNuKrnC9nHZQuRCMEOA1/5C4CVFwjaKaUJfG6dCj80mw7UhFMNGvjxD+Px3wgab7UJw0qFAROLUwqab08Jsew1DRMeFwuwV4EIaaQpCzZQkQUKaR8NguKO/bXduwu7MD0P6Yt3CkDZywUrAHcLuuGvDqjOYwxKYpcCoJ1XC4vEcwuYIDcIsBFjDJxceQ2K4VMOKfVJCO5gkQ5AFDEI95D3CEEXmQhWE/kCsgV9Dq2f6QsJkykJ4YhfCkL0Yw+TF5MK8AmdCgl8GQ8S0VcLkidrCg1GawoWnWUJwRy7DZ58kQdMAo8LSBO1CbLnZQoi4pUIIgNlColdkw4IRT0KC5VLC/JrxQfIT8EKwvYhDWRWTw0Zu6EJaxjzBZn0oQ2lKPEMeWxLC44hGw4JfFUOODP3CzpXnwrsgLkO0YR1DenFyQmRTM8M=", - "encoding": "base64", - "path": [ - "vz", - 43, - "data" - ] - }, - { - "data": "IdnqwmYv+sK6ti/DdqE1wVgVVcOqeUXClAInw9c6KMPIVHPDjK9Bw9MnmMOee4nDdDcyQ+xXWEN1W0DDhq7Iwi0W/UHSUl1DVrLjP0xMBkJoJ4PBOj0VwQ2rQcNORq1CQpV7QXZV2cE6R1rD7oYLw1CQu8Jk/h3DgoY2w7juIkPxbezCGrsyw6YYCMMVqpbBLZUlQ6ro5MLMA9zBbIAxQje/zkIF6GxDrb+bw1EBYMNm5s1CsBWHwGJe8cK04APDcU8RQ+D3x0GwxXNDcAxhw+hgQ8Nl8ihCnuBww1wV6MCaHffCHA+ywkBtbcP2KxDDeoAjw7IvTMF04MrCx1O7wuQZaMMGJB/DYTUsQyDFPkOpKgvDpAZNwxr2NEJiL5vCTLZfwhMy/sJTkTbCzHgbw8uEQMIn/kJDEBBKwzBFL8MTdNLCfCoiQyiVZEOJz2hCjtRPQ5mhV0OqFwBCjhHdQkfBVkMumklDGCjXwjyQHUPzXDJDbkx5w7bOI0MoTX5Ci4RSw4knbcMm1ENDhFyZwEz+UEM67aFBKPc+w5qmhMNkcplC29EOw2k68MLs6h/DLg23wZ1vqUKFGw7CSpi/wvZnLUMiiynDMTMaQ5T6FcP3sDXDrkWUwwoRMsOiuxXDIrOcQiYFS0NhecdCJHDgwtkBnEFDyi5CSJBAw6pvoMLKWV9DtLzpwjiPMUPMCRvCkjgwwxitIsM1MORCSD4Aw9ywI0N3+LhCYDAVwj3GGcO7wU3C4MrrwtzIQUOENS/CObshQpQzwsIaHZjDvaBqw2QPVkIcI9fCCvK1wjom6cKHyQ/DldccQ/4tPMNVXtZCFBNdQ5yeL8ABXlJBxAGnQlD94sKaZdtCFjCIQaO5hEJfyLfCES9dw66tPsNwB9VCbApAQ1W58UCbEDXDVjXIwezxUsI+gPDCDrclworAG8MUcatC+RSfQgRhHMKR5ZlCZrIZw4t9fkAS3NDCi+p0wczdLENIUzND4DJ0w9OULkPcz1/CJkEWQ8Lgc0MH/qLCnhAWw0xAA0MwgzTD9ME5w2yXbUMaNQRDkgvbQvBO98I=", - "encoding": "base64", - "path": [ - "vz", - 44, - "data" - ] - }, - { - "data": "hGc2wwiUiMKqk2/DtjwPQtX8FsNU2cTC0thpwyvYJcNLUzHDVPR+w3gZi8MKc3HDxINrQ7puYUOcQhzDvpIhw/4ToMC6pyFDzYsswuAjrEJuMxVCcYF4wloG98JECE5CkDHiwTrfl8KiGRHD+caZwigbFsPr2bnChMcGw8xyGUMOQXbCTqDrwqSKWcMsGp3CcOgTQ5zrQ8J29J/CZf65QpjzGUPrqlNDlrSIwzZuGcNAUJBCXCNNwn15OcMSC0TDNi5zQUKAnkL/FzJDcOkYw6CQFMO+iMBCRE4rw+yWw8JWqX7C6igjw2gqJ8OgtU7DWoJrwxSG+cKsxTXCSt8Vw+7Ij8Mz+73CIi1cQ8Q+SkNwtizDbHYNw/w1zkCe6wjDCewCwxOBOcPk4rzCgKNjwwwJwsIn5M5Cwocxw/6l1sLpbwrCbpIuQ/BzCUNGoulCIYz4QrcvVEMOJOnAs/qWQsmFjUNDWQ5Dfp9BwgzDXEPRfF9DECAsw535TUOUHuNCqvWJw88vkcNeaqdC0FHCwpTrC0MmoqjBuzH7wnRYdsNo6g5CdLajwoe6NsMOSSfD+Bv6wg61RkJsm6fCfksewzrBCEPnkHrDnrVOQ2wzWMPBPg/DOriSw2Z+4sLW7FDDdmMxQrd+30L2k4tCaog7w7j2ssGMdse+ku0OwzpPuMFm1xJDUuUwwy9OcENnO67CHq19w1JzYMNuAqVCqVBCw5N6U0OWchdDBn26wveIyMJRddjCiME1wxD6VUOkkF5BwOm1Qi/tJMMYD2/DdlElw8vy2ULWSyXDL4gRw1ibJsMeL6bC5oXNQvMh9sJ2/x9Dn8VSQ/3fLsLA04hCBDVAQgx7LsO42Q7C5H9swgyW7EGy+xbDZTGOwwh4JsMsshhDjHx4Q3rRfkLWxYDDAkmyQchX78JgqXjCSLPDwjyHd8Mo/ERCIz9AQp1Q6sLKmSxCbuu0wjZOQ8LMuR/D3KKCwpLfXEOOPktC4JQxw5NIaUPYw8/CEhj+QtrjLUM2RgPDPn3HwjD12EI46hrDcIuCwxVDWUPsWNFCeKsbQ0XJaMI=", - "encoding": "base64", - "path": [ - "vz", - 45, - "data" - ] - }, - { - "data": "1jF9wwBaskA6yobD0H6bQhgwvML6VB3DAFOTwwbj+sKLauTCaPOBw3oRR8OWBCnDpL5LQ1UB80L8ed/Cx8hnw0KlO8IdiERB/Z24wuLNBUOAU6tCBn/0wqkpbcIacUZBmCabwo2wAcPIzafCpue3wVUiVMPOFRHCfLShwmvszkIjXeI/bnR+wlq0kMNVXBLD1s2qQv+0h0HcMwnDKK8JQ3y0SUNcsL5CSCNKwxwPucJUkx5CFsrPwlCVc8PsjYLDAieCwvmWAUP8wkVCYva2wkaVxMI8UxVDfIbVwrV/GcMTQh3BdQYtw9reysLy/oHDnwOUw2BSLMOMD35AZhQrw9oga8MC3hfCU249Q9La+0JjeQ3DQbOowqdMCMKVUVDDugQww2U7HMMgtBLDupaXw4uCGMPYpIHBMgb+wpJZPcJuBztC1pEAQ7iBTEGKoixD4piPQY7h6kJUWE7C/u0OQorIHEN4t09BXMNiQV4KiUO+uzBDDo/RwnK0IUP7XiBD7gOKw/DyXsPyhRLCVDAfwwA8gkEkxoPCrJ+Hwrf6KsOyLzDB8crWwTaXd8Ol+AHDUPUwwyfuK0HGQAjDJNRgw0dLNkKOJJ/DLP9YQ5WGiMNOhbrCDQNZw0vGU8L6J4PDx/67QG4WIcLOxxRC+qGFw4yZiMJqMUbCsgq3wp2s1kE9AAtCHoduwyEuVUOofQ3DVvSVw8NujcMC6zlC4gWBw5LeO0MOj1VDFwggwwq+HcJILizDVIR0wyB6DEOS6oFCQC4KQ9rHccMo5yrDx8XQwhKdIkNphV/D9WJIw2hcJcPi8PHBYo0NQYAsb8KQZFNDtkXIQlIPssKA3fBCoBMBQWq8GsNePO/CMH3mwsrGHMHdYFXDjNRdwwRV7sLU4UNDMKs7Q0Z26EJ4h4jDbPeFQtRLIMOycRZArr0ewx5Ro8O+DwxBs9lcQex7IcPi2ddA1IgPwlxd1cL1kljDPcnxwtIDOUOQ2zbCYGftwkAcT0P4rhzDME7GQgiVdEKoRTvDiDU4wjSYoUJrHuLC0DmLww/CpkKDlJVCVPpGQ/HSnEE=", - "encoding": "base64", - "path": [ - "vz", - 46, - "data" - ] - }, - { - "data": "RDiNwyYW1kJtQFbDWHvoQj0UJ8LGQmXDlg5qwwYqncJWWWbCJtZEw45OBcOANtTCPsWxQtyCur8SqnPCjzGUw3qmwMJwosXC7moSw/1NMUP1DwJDvsE9wyDf7j8A9PrBJJEFw6KkPMPS9v/BNsrEQVIpicPpfl1Bst+bwWLmu0HqhJpCGjZqwW5+gMNsG1rDIWuHwWoTrEJdu0XDgpIyQ2zySUOqG5HBlvgMw5QqH8KkmJlAYV0jw/r2f8M2eo/DrHvnwljlMEM7yF7CL9EWwuZbLsK5U0pDFFRDwkscJcNCFx9Cd5UGwxSeKsKFu3XDcBZ6wxUtDcMoBERC0NcIw3/eKsNbg1dBv4O3QqAKo0EuLL/CFVQDwkjYmcJssY/D7IYdw6oV5sL8fUnD/mmMw7QSWMME9+DChAWSwhu8yUD20g5DFopCQhpTr8I+2V9DB6KawkAEvUDWc83CWCsVwR61yEG08uvCrpGqQrzKJkP7eZ1C4AY/wrgRjEKqcEtDkzpQw87YE8OpIPXChTA6w7tJxsKgbebC1q12wZ661cKr/4DCUoPBQUNdiMOyBabChmYaw1YqBMJyN0HDyh+NwzTfp8JToH7D12D+QvmkasMIgvDBfn8Xw5w8RECiGXvDdJsZwsiyDcNYCaM/Mb6Nw0xn78Iai9HCpEQTwipwj0IMUIzCNseNw4Iho0IkFEvDTSxtw/e9bsPn+axA7ImMw6aQskLDsopD6YRtw1m7/kFC82/D5EmGw+R2/kGu+91CIsc2Q9DQmsP4q93CLuZJwuCIVkOKL4jDFj54w7yo+sLdX4tB5BnqwpaAOkCeclND6K6uwdUEDMPYbypDilYWwrJP6MJaDSDD28ccw+yPUsIMZ4fDVo8Zw9CUhsIaPzdDcsKJQtB/JUM2h1XDTHDdQkoAGsMmRpxC5kFdw/nagsNOXhHCmHPBwV+9GcM7rgTCdzhLQUpUKMMrdIXDUaQ2w/tOrkI/Kd/CLYaEwtbWr0JQo1bD5KeEQhS9LMK2oXjDDOFhQZCrPUIUFH3CuJxYw6y6ysH46yhCtZUvQxoa6EI=", - "encoding": "base64", - "path": [ - "vz", - 47, - "data" - ] - }, - { - "data": "WuVew2hqdkMg1xnDDzwYQzW55UBmDpjDDO8jw6DcucHukNzAnlcFw7jVm8JC5FPCWLmdwRgru8IRh4+//P57w3+gHMPUqhrDGfJMw6SRVkM60ipDuYaBw6yVe0KFVaHCqOpEw/6VecPAWlZBUCSHQuBLh8NMFmxCEF5UQrgzpMIKmzBDdI/0QXT3ScO0ZYvDeHADw2QxIUPq437DSqRHQ40d5kK9PMjCpAKvwjYD4UA+/gTC0nxlw6YhUcNnJGHDLi8Tw3kOXEN01vjCYlUuQXpPlEHCDnhDSD9iQB58AsNL8qxCHaGxwj60IEFRaUDD0g48wyiS0MKlQ7ZC7v2wwmai28LMsHJCtkK4wedKm8ISYgbCkoJnQUR09cJcsozDwMbkwr/+h8KGvX3DGodTwzzrjcPCZCvDu1xZwUyUXEJoGHpDEIF6wtrzF8Nu1GJDlHgSw8gUq8LCKSPDqOBxwgadYsJ8SzrDtM4uQ7RjIUJgxPXB68fEPznvDsL2LjtDNfcMw5g6pMJzcy7DVJIVw7omJsOHAirD0HIFQlCEV8L9EfvCloWRQtJzVcNMjcDBcuHmwl8OpsJaNnzDPQl4w+yhLcNMbz7D2liHQY93L8NZJ1NCEN+9wp47XkLMXUDDLt+0wtzcMcMLBhzC/ltfw2AqMsMQkCbDRvfBQawV4kKcUhDDPNxnw39HzsGIlobDoL8sw47gJsOMiibC4tNiwwS12sF0Kz1DxjGaw+Yc8EJuxJPDeCVYw+NNksI+uxhDUAJYQzUXgsM1t2fCTc7Nv/hQZUOvO2/DgGNxw/TajsKOynZC0tBQw1CehkJMbORC8Nvawm+dRcMiJlpDPuu0wnkLkML5cQrDdkctw6hEyMIC7oTDix28wrRaDcGSF8RC1IgNwtP+UUPXnhvDyNYaQ0Cr58I3cS5D+sSJw6DcRMOSZK3CRpWGwqh/7cKWw5vCOIFkQk6zZMO6oHTDCB54w5UDtsHrVhvDjESSwX2wx8EMc4jDJhvfQTqp7sKi9YnDnsisQgiT3kAAEibA6pIcw2CvvMJCJcxApImdQnY2bUM=", - "encoding": "base64", - "path": [ - "vz", - 48, - "data" - ] - }, - { - "data": "3Egjw1ocdkNQdcLCFIk5Q+JNV0Iu1nDDQFrLwvjANkIADBxCsjyZwr5v68GWCOTAqI+/wt2fGMOiE5NCEnU+w4OWZ8PMnRrDkTuDwzirK0N+0U1DrByWwzBh/UIuGAjDn4KDw+QKkcPzrlhCgvfVQmKUS8P0rMhCLi4QQ/PYL8Ok4JpDFD6SQsDAFcO54YPDqHJKw6hocUOUC4bD4ukKQ47SYED7chrD2p0cwoKERkJKepfCdteSw4TCG8N2oR3DeO8Ow4QOO0Nm1CXD2jxgQj6xu0IEZSlDTDBOQr4/qsJMLANDPpYJwrxNZ0IhWAfDqXoAw1i8ecLdTgND5i25wSB4WcK4K9FC0gvjwkIYE8PJrVFCIc5qQnbSK8PqwFLDTAxrwvRhScFa8oHDJgoVw2klicMS0S/DzaVcQvSNyEL3NWBDzEwkw5kSMsOomhZDkA09wz0TFcMYl2rDEInswl4A2cJU/iTDTvOVQ7P3RsJUPejCCsM0Qo1v78Lq2sdCagKiwi0508GiiSXDqpjFwheUKcNOv2XD8LqfQkbtDcGM8EDDlf7vQpTiFsOP7lVC9TmKwhvBDMNA+ZDDOug7w67LLsOXkAXDQBKPws0M7MLsLClDBkcxwiFQ0kIs1gHDZbUYw5b6EMPvP6rCHHQkw7bpc8PPdWjDWjPCQvp9F0PKzTvDA2opw/5yvcL6yZDDpkTkwpxRycJhTL/CEGslwzaw58Lj3opCFbiDw7BXaUPqYnnDDOQdw9PEE8NyjD1DNfoVQ/YXRMPUWiTBEBIvQlpWDUNcYjLDxf48wwCjuzygtc9CCDg4wyznB0Mkmnu/350jw6ZSgcMgD1BDrDAYw3y4ocGAJtLC2KcDw3KxGcP4d0/D1GQrwnvmcULQpgHBcJ7WwpyoS0MXsc3C7EJIQzM5dsI4NJJD4nWBw1zBCsOseQ7DayrrwnCbksKTKgHD7knFQrGoicOeADjD/LqXw47F2MLeWCnDY4PWQbKIzMI4hH3D2h+KwRYtKcPC80zDEzU3QwPGKsIO65dCm9vMws94CcOGywbCchYTwvBnhkM=", - "encoding": "base64", - "path": [ - "vz", - 49, - "data" - ] - }, - { - "data": "q2p7QUZUfEEeBn1BbxB5QZUdc0FEyHJBMDB8QTGYfUFw93VBquBsQStIekEqtn1BBAh7Qbxud0FTymFBSiZ1QZQXf0EVRmJBdtt1Qd94gEE+tnJBUdtxQaBYekFLM3tBIu+CQcT7c0FYqW1BMGB5QZ+NdEFmTHdB+DVSQbyifEEwiGdBE0eAQW8QgUHS529Bq+50QcI+dUH8CnFBjep4QW/sfUEFv4RBgL15QW71dkGFJoFB3vNoQeJ1iEERH2lBdDx6Qa+0e0FVoHtBpM1yQf6JgUHCx3tBZiB7QeugdEHyUHhB+ZSEQYOedEGTAn9BLERzQViIcEHNHXpBPUKFQbtQcUHiSXVBtyB1QUm1eUEkP4BBiLh2Qa76fUFdPGFBip59QXQOeUGJ6H1BEFR6QZa6bkGIXINBzGR1QcDCgkGZ24JBXn94QbofgUEwZ2lBXxV+QSu2gEGnsXFB/NuLQRNDdEEvcXVB+nZaQasBhUEiaHZBM/R9QdvKgEHMiXdBbQZyQSxEg0GL4YBB+kOIQQdUgEEdz21BXR5yQeaRbUFM5YJBDmxuQRhYc0HH+35BiC9iQatNf0FD8YBB2GV3Qfkmd0FZDHpBGRFpQRy9a0E+mHpBPet5QSNSgEFGmXRBoHWGQevna0EO+2pBdOp4QSQgc0HleHxBOk+BQZKTd0GfFHZBmEhqQSdEekHwMnhBmMpzQesHeUGkT31Bsjl4QaFOfUGYVm1B4odnQRzLgEGoMHdBjWJ8Qe8obkFm53pB2u90QeI3dkG4hXdBzz1vQQcpf0FwM3lBAB12QTDFb0HKnnNBQmSEQclEZkE3an9BsW97QYENcEEZJnpB8aF0Qakcc0GQOnFBU/R4QXApe0EJ9XBBISptQfqpgUFxG2dBzkF6Qb47dUESeW9BlH5zQb9KYUHOEHFBvRB2QU+ZcUGeSoJBnYljQcq0XkFQIXhBr+Z/QQrHfEFIrHNBgVxsQewma0HysXxBrmhmQSJUfUGKfnpBrT6JQZo1gUGCgm9B2UtbQQZUhUEKvGNBVMduQa1ic0EHz2hBeRl9QagQWkE=", - "encoding": "base64", - "path": [ - "x", - 0, - "data" - ] - }, - { - "data": "6jFuQa4AZkF3oWxB/WluQZfIaUFpM3hBNeVsQa/fa0H8R2tBi4hrQSjMdEEIXWtBlVlxQQxtZkGmN1FBkOFxQfUSekHZUlhBbLx2QQXhdEFuc2lB+t5sQbVEZUGfP3VBci9/QcbDZEE2zmZBM7JwQX8dakH3qmxBXtpGQX4sdEFwQVlBY1dxQYdhfkGLo2lBW5lgQXZXX0E5h2hBTC5nQQiAbkF043tBl3VwQYmYaUHXNnhBMTBfQX7cgkHlFmFBGWFlQUNJaUGOO2tB5k1wQal+dEEKkW1B6N9vQTLebUGxOG5B5eB5QdtUbkGlk3hBAItmQfZHaUEpbm5BdeZ5Qah/akEW729B2RtpQc3ycEESR21BHpJtQXXhckEmhltB6WV0QTxtaEFX9XBB+pdtQRX4YkHDT3dBWmRhQV/jckH2X21B8TFpQc/VcEHfzGdBhel1QdcFbEHgtWdBTC2JQWlwZ0FIrF5BnF9SQbFGeEEBf2xB7CdwQSKCc0EgmmlB3stlQUKHfEFsSnNBrsJ8QbSGdkG2G2lBT65tQVL0YkEpB31B70poQaogZ0EK1WVBxJBWQcHmdkGqiHFBuphzQXTraUHGwmxBvUpoQWhpaEFjPmVBgMhnQRnucEHlk25BRp6DQYBVXEFyvmxBbGh3QRg5Z0EWdXFBHGB0QVZFcEHjkWxBgPFnQd9acUHwUWxB8ZJoQQr7bkHlInhBjV5vQZo/dEGUjGBBgZRlQZ2Gc0GFYmZBCBZ4QR6UYUHNmmxBjc5sQessaUFV5HBBXTNoQSu7b0F6y21BfHltQUM0XUFFDm5BrGR5QWWZWEHaKHRBDhhsQc21Y0EoEm5BHlt0QTLSZEH/52hBnYNsQfkweUF6Wm5BDhpmQSBZeUG4z2hBvzx1QW0bckGegWtBatttQT6oV0EP1l1BcEJsQU7QakHewX5BBGBgQZUsS0H5bXxBPSRxQd4+cUF6HmhBuhBkQbtKYEF9snFBP4dbQQN2ZkErjWpBSUiDQVY1bEF3/mBBYBRNQdfpf0GnWVRBd5NhQV77ZkGnTmFBFHtwQTd7TkE=", - "encoding": "base64", - "path": [ - "x", - 1, - "data" - ] - }, - { - "data": "AFVKQa++QEEf+kdBo2JNQQ3KTkG9HmNBmm9IQQzZR0Gc70xB1ZFUQfP0V0FrsEZBp2BQQbh6R0E/9ixBevRTQbH0X0Ef4ztBW9BbQR7DT0GgVk9BcmpSQVcfPkFok1hBHxNkQYqYRkEnpE1Bfp1QQSYETEFd/UxBqrYkQejEUUHjrTpB0ChIQR5QZEGbME1BeZU6QVpuOEF/IUtBMHVGQfWkSEFRVllB1zBRQQcXSkG+dFpBeQZDQUx8Y0Euy0NBTig9QbYxRkEqDElBoORTQYIfT0F+oElBMHZNQbpzUUEHLk1BSxRUQZebUEE0Z1pBYhhKQVxaUEFp4EtBK+dQQXlZUUFlAFFBLQJLQSBDUEGJKkZB0AhOQVBUVEGCO0RBJBRPQeVIRUE4+E1BQUZLQcvTQkGI9U5BrAI9QW3uR0F8LUBBdT1EQXgXR0FpB1NBln1RQSlCREG2PU1BBlZ4QUu0RkHmSTdB7K83QTjaTkF7pE5BYHhJQSMOSkE4GkpBu9dKQS13WEGSg0lBKItOQR/hTkFFd1BB1hRTQfvgRUETll9BhK1RQbfmSkHjMT5B4RQ5QQCcWEHMjkpB8NdWQbTlSEF5LUtBD3pUQQ8HVEHexj5BRc5CQYpYSUGkXFJBmQxsQWVzO0GqM1hBNYBeQdDyRkF9jlFBm+NPQZAvT0Gu501BsEZUQdQoT0ELOEtB/c5KQdKsTkGsKFpB8kVRQRh2TkEKEUFBCUBTQY0rTEHCa0ZBGVtcQUsOR0EAmUlBS8lOQU2QSkE/oFFBMclQQY5oSEE2jUxBq3NPQVEjOEHCvFFB/ftOQcnoNUHn2EtBh29IQfr1SUFEXEtBC69ZQaAOQ0F50U1BuKxKQes/YUFZS1VB94lNQV1XVUGbZ1dBlM5UQWCdV0HJZ1NBHYFVQU2qOkHbdTtBD15OQR5tUEHkAmNB5z1PQZz3IEHFB2dBSHlIQbtDTUEnFU1Blz5HQTvgRkGbsE1BVeM9QRoYQEFru0ZBrslkQfATQ0GqE0NB9acpQYXyX0FYHzFBGatBQf6fR0GmCUxBqt5KQXeSL0E=", - "encoding": "base64", - "path": [ - "x", - 2, - "data" - ] - }, - { - "data": "tKIVQXiHD0EvwRdBa6kZQeq4HkE3PzhBzBAUQQ7UF0F9eBxBQswkQXeZJkH61RRBRIodQeTWHUHOEu9A5sscQZRHM0FuHhFBWg0pQRZ/FkFYLh9B97QhQTkrC0HwPydBZ+M3Qb/MGkGXdiBB6usZQQ40HEHKtRpBQOrfQAGiG0E4Zg1BYLsRQUgmNkGmgh1BYDQHQYtWBEHLdhxB+rQcQRq8F0FkgiVBx58dQSUQHEGFNCxBFkMbQZtBLEFqihZB9UMDQdmKGEGfJhtBdtAcQVsFGEG7ThhBdMcXQeo9H0HNNRlB3SkcQTfwGkEvOCZB5BEeQe5dI0FodhhBuKkTQYuBJEEydBlBYt0cQa1uGEFQYBFBHFAaQRroJUH9AiFB4/sUQexbFEHfVhlBXNQYQRyiE0E+NRNBZSgMQcAYEUHDtgdBABQNQVI2E0GxGCpBuMwXQc0+EkESASJBGsNMQUTxFUHMzAJBfhwPQXVRE0H+bh9B9coSQf8CEEHtTBxBNnQgQVdeHkGW1BJBUlMNQTSoEkGBmSBBzaMdQTi2GUElrTBBvgQiQbFZIEGs+gpBMDAOQadQKEGfwhRB4QkjQSLcGEHZFhpBNy4qQUYOKkEMoQ1B3X4PQQ7yEUHwaCFBUGc+QVvxDEHO3ipByrwwQSETGEEGrSBBTWkZQQXZF0GxxxtBdC8nQUL5GkHHHxlBhAYcQdgdG0FhIiRBLS0gQUwjFUHWsxFBmFQrQXheE0GvHR1BMKUpQe6vH0G9tRlBTmYbQWInHUFmfBxBsFEhQStEFUEqZRhB408eQZpnAkHnuR1BMQAQQSFkAkF4uBJBIl4XQe2kIEGyshhBH2IpQeLoDkHOVSBBNUQWQaz7NkF5kCRB9WMkQVIyHEGrMy9BYRogQVSlJEE1nyZBAT4sQVjfD0HvgAxB1Q0gQQt/JUF8HzRBR5oqQSGgxkC4WD1BOpsUQX3VF0EKFSBBodUaQRCUH0FxxRdB3UATQcJHDkG5OxZBF7YvQfzcEUGpQxpB22LnQP8FLEEBGfhAa6wTQVflGEHx9SRBDfgVQZeVAUE=", - "encoding": "base64", - "path": [ - "x", - 3, - "data" - ] - }, - { - "data": "ykikQNHjnkBvRbNAy9KrQAYHsEDGAPFAn5WlQIQXrUBp8bFAbfu+QDlvvkB+UadA6KOyQK7Qv0CCVkFA5PKiQKTt5UBwI7FADWG/QJ6PnkBVHq5AY46wQCMOmEA9q8JAa4/0QEjzuEDuYblANpKjQNpisUAI1q1ALo4mQFm9pUA5MJ5Aa2ekQOdn5UCEZbJA8KyLQPEkhUDzd7dApJjAQLjvskCWwL9ACa+qQJvHtUCEe9lARADGQKxdu0AXq7ZAjJBZQFTNuEDgirVARJ6iQAqbpUBNVrJAk2KjQIyYr0BI/apA0gWnQM34o0AToLNA2G+6QIF4wUCXyaxATnOTQJM7xUAZY6NA6qO1QPPDoEB/vpdA7jWrQH3rzkC3N9BAA7yRQBB9sEBg76dAy5itQIPxskB/4JZA5LCiQL3fnEAyUoZAj2iKQItPq0DaB9JAkH6WQGQ4pkBDgMZAUY0PQWO/rUCU8IJAITOvQC+6lEBYTLpAQWqeQN6AlECqB7dAhXO9QCPdn0B086VACJ+EQMZymkDbG7hA7FKkQCRVvEDbmOBAChawQEtzw0CM549A+KCuQIzay0AJRahAecyzQAGps0Acqa9AibfOQP3a0kDU5aFAwDmbQKFGm0DWu7VA/z37QE8epEC2t81AK+nZQADOtkBeRL5A/s2mQP42pECIQK5AdK2/QCi9rECVB69AP5+zQH29qECUwLJAhbazQCmyokCHIaZAgmbYQFLXmUBvMsFAa/G8QI66w0D+IrVAD/6rQEBhukBRkqlAXmywQH5rr0AddKZAIzyyQMwyb0DkOqhAvrWHQIW9fUDc76FA1nyyQGJ2x0CT0a5A4JDKQDz4jUCn/LhAZvOdQNLt9EC8HLVAAM3QQFfrokBMdt9Ax5CwQLRCrkA5CctAxqXdQImVsEDtz59ANkrEQEea0UCBl+RAqCHcQIvrmz9x/f9AFAGvQCEWp0Bn87hAR3S6QEGUxEAm1KFAcMmzQHlgn0DjKrBAGkbPQFoZrkCaFMNAkEsqQGFrwEAKWVFAOhi0QCcYtEBvzsdAf9OqQDVVi0A=", - "encoding": "base64", - "path": [ - "x", - 4, - "data" - ] - }, - { - "data": "ZyUQPxRzmj6HE20/9PQFPxHDmT6rgR9Asv8jP6v89j4yEwU/Q3s+P2GQzj6vdAY/ar0VPyjuWD+/OwDAKdmFPeAsCkA4I5g/WuL4PsZ0yT0rb2Y+BuYwPrmlbT7pz24/tlI9QJr+Uj/86yc/kJYCProCBz+PpQg/EJYQwIC6dLyhams+NFZVP2wj6z/+rQ0/ASVUvndy1b5eDnk//JuBPw9FRT9VIlM/aRI+Pi3vLT9fyf4/7ZvYPzRbBr3Obps/F90BwObIbT+aHxw/ITqlPVatmD6IQFw/Pi8nPtfFET6XHww/+SpsPrjF+zxgMza9pqs+P5INUT/CHyI/cg/WvnxneD/evKA+aFEpP2SYwT1vwIy+kib3Ph2y6z9zSOs/KFdMv1UKeT8YHaY+azIcP950nT/Z9y2+tM6CP3dyoT5Wfb++LIYTvyoGWj/L8aY/YN8svyz4Mj+cuKw/+A2KQADnVD86QaW+RcKPP+GP/b1sVhM/rJ/0PtPS2z1hjTM/9uEoP38Ekr6xSzY/VktRv4CooT7IASo/AOk5OxDjsD8yTQ9ALMzJPdiOlz9tr8q+QTWiP1EttD/29Sw/2c6DPicCaT+3Wws/uJWWP5WWsD+2IB0/wahnPi6HeD6zybg+PDs3QBpecD9EK44/GPCzP5+akT9bVZM/ppuPPgLw8j6Udvg+vpTvPrUr9T5zoDU/1CkfPy+vlT4/n4k+4imaPu0U9z7uETI/KxLUP0Hfhb3jKIk/A4p7PuXzfD/lklU/Q7nhPrpqbz8OUo0+2kQvPpoGXz8tUt8+DEvKPihknL/nKhE+jMpVv/zdNb9R3jM/TvhgPzHxqD+hvyw/gKSdPxfsXr/Lmgk/vitcvl1MP0AwFhw+bs/dP8clzD0yGvE/GDyFPjCIMb7qp6s/6NL7P5RsnD/IUBM/j/PPP3Bu6j9Veg5AxKb+P8W7fsBnmktA35VnPwTO2j6OI+4+J9CRP1zegz8Gjpo907idP2/wCj9K5Hs/BUOdP1mLhj8LxNM/gagewDeqkT7G6+u/4DqaPxUOTz/UrX0/yOwzPzThFz4=", - "encoding": "base64", - "path": [ - "x", - 5, - "data" - ] - }, - { - "data": "ZF+BwGJdicCCIoDAyJ6LwLJBlMBN9kXAaoiAwDF7jsAMWpHAdRSUwBlLocDCO4jApdSPwOdRl8B+BcDAlCOQwIVSWcCLiWXA44agwMvqksABv5LAkxqjwDs8h8C4UYvAVn4JwJa7jsA4A5PAOhOQwKs0kcDwBo3AgNfGwLNGnMCtw4vAn9t1wLEOgcC//5DAAKeSwC8dl8CgM3zAY5mRwNH+jsDArZHAbXSbwFKIjsAMHE3AZHJNwFZSsMDQPGLAhnjUwN25isC4cpTARwaPwHRfj8DBbIfAcQWPwPR7o8BDhorAIxCPwIlSksCFB6zAIMmSwN38kMC/4YnA1aOiwBwDk8BqS4fA2GyQwCeRjsA0/6DA8WKLwL4gRMDvc1TA2b23wAoRb8D2i5HAyRqKwLj9XsA6tJfAFWRYwHxShMAjyo3ARjOfwJfAgsB/ZYrATKK0wNiegMAcl3rApFtQv9tZfcCFLozAA+FcwDqtksAWLprAto99wIQ7gsB+GJLA9/OZwNB7osB4pYLAVXOpwJt3gMDqN5HAffORwLJQYMBDEjXABO6YwH4+h8AaNp7ADeBWwKhEdMCC03/AeAugwI+5fsBf147AfXyNwKZ2jMBfuHjAXDuKwNQKh8BvY5vABAYmwE0CasAzApPAeU6SwADFbMDmiXTAyKWRwNXChMCspY/AkIyhwFhMjcA3IIbAiWqPwG3/jcAzk6HAYDCewGdhhMDKGIHA2Oh+wAPBlMCUIpHAGW2pwIwBkMAB9o3A6+2MwF9oicBr7ZLAuZOYwCgYhcCJBorA25SWwNvWtcBi9pLAgLytwN5gosAFp3rAPtOGwLe0hcCf/YvAYB6DwB1KtcDqc5fAXQSjwME2CcCBGqXAjK5nwARHksCH1W3AXeabwPEcqsBUGYDAD91gwJWWWMBR23rAyMtFwPjrU8Ak/j7AL2VcwLwx+sAZKwzAqOGHwHi9jMAQ9prAMKxxwAFtjsBM4JDA9RtcwG0sgMBXZmzAOeCFwISde8B8Q07A7HfHwOQgrsCpQMHA9+ZowLi5hcCweZLAXqGFwC93ecA=", - "encoding": "base64", - "path": [ - "x", - 6, - "data" - ] - }, - { - "data": "lpT7wBKP78AIIQPBK8UEwVCqA8EoxgDB1Mr8wENm98DZNgXBON8KwWFfD8EppgHBZ0YGwV5iEME5ru7AuNf5wBpNBsHwad3ADTIUwccBA8FzawHBek8UwZdD6MDMKhHBLXfewJ27C8HZCwnBDjH8wBoyCMF2LgTBGOb5wPPoBMEDxNjACfr7wEgnDsGOtg7Bbp35wCmh8cCGUQTBV8oNwZ1wCsG4fgzBVmsLwUbVBMF/h/nAbAbxwMQUGsHXwvTAawQQwUMCCMH4HAvB/Ub+wGl99MA6RAfBgOb9wALLDMHLkATBapv1wBEo/cBZCxbB1IAMwYffAMELzwTBeBQBwTvoDsHjuv7A0/0IwdGq+cC5gwDBcRcDwcXo7sC/LPrAABUQweaFzcASKgjB1o8Cwfwk8sBQePzABm7UwMJd98Ad7OPAPk7/wPXWBMHcKwvB2HQPwawBAcEiIQjBG1q+wHQ888AL+O3AHpq/wHmT+sCphQzB7LX3wBMq7sDOAAnBc5cOwbPCCsGINATB6M4BwcBf7sD/cAvBbxf7wOXi9cCQfvLAF9UCwb8xDcFzdubAVKTVwHG7BsHJCf7ASqcQwcqg+cDXAQXBF4YMwUy/EcHGcdbAL9b+wAxI+MCmOQzBJGn0wP0Z48ANNRTBRLIVwehZ+sBOAAPBfZn7wImGAMFM8wXBu04TwUC0AcGnZATBKrAIwW2SA8E4DBvBzzUQwQMS/8CH8fvA0vkMwfEi9sAUQRHB0esWwcsXC8H9GgnBXn8BwcgcCsGCpQPBhbsDweTOBcFOeATBvXUMwfulA8HvAgDByowHwRaU/sDHefzAV14IwRG5DcEfOAbBqUAMwYycAcHWgQTBAT8GwTSw3MCzPBPB660EwUDc+sDXjQXBZ5gGwQWYDMGS/gfBLYj3wA1w18Bw6ObAgmrtwCnF98DVU/zAlhYFwXICF8EaDuTAu6kIwY6KCsGjCw7BLMH/wDSCC8ERU/nADMrqwMFV/cD+DvbARWERwfchAMHs/O/Ab13uwKbcI8HCrvbApfX3wLRb/cDSmhPB3OUEwTKoy8A=", - "encoding": "base64", - "path": [ - "x", - 7, - "data" - ] - }, - { - "data": "0SgdwfAyBsFUQyXBvqggwf32GsEYDy7Ba+odwYkxC8HUSx3BiT4mwWT2J8FlVB3BYA4gwWhALMGP6efAS5gSwRiJMsEmWffAOZkywWGTG8El3hnBAp01wWwa/sDhqkTBIa8hwS+EK8Ei8yPBWw0TwY3NI8El7h7BryfxwMOJGMFww9zAj6oewXTCM8GHTzrBVz8RwSdZAcG+7S7BDEgowYm1JcG2/SjBz6EiwbpYHcEJ+CXBF2kdwcUnO8GeiB3BwXIXwfCzIsFIyCTBUGoZwdyiB8EfTSXBEmMXwXZOIsFc4CDBc2cJwRroFMH3JzTBer8qwfmbFMH1RiHBEyUMwbRVLsHAmB3Bu6IkwSKSEcHi1gvBhgwfwS1JIMHwrCXB0XsewWdk18CZGSjBjukdwYEpGsGXBBDBnZXswPXKFMGGlvLAo4YOwQOlJMFaiirBwYgbwQFeIMHvHSzBUoUhwSkHD8GSRQjBrfTAwIaSD8FYZSTB4uAawcJ2DsGN1yHBB5kqwbKDI8GLqiTBQI4MwXs5DsFF/irB2l0UwWlTHcHoiS/BdxsYwS2RMcFyFOrAfDXtwHI1M8GTsB7Bp7IuwcMjF8GeVx/BhuspwX+eNcE36ODArYUYwbvmFcECTyjBwi0uwfvpAsFatzrBpAE7wV1kHsFttSzBOLINwfR1H8Fklh/B3GkvwW1wGMGtkSPBTLslwYDAH8HZskzBK7YuwYDDHcHEAhjBluIywbeOB8E67DLBZbs0wVxnJMHDgCPBnsgbwch1KsE2cBvBq7gYwQf1I8G/dyXBqSgtwXpzCcF0SRfBCToUwQd5CsEhhR/BSAYowRxiNMHDsCDBW2U6wXrJB8GcrRnBYFwVwSRtG8GvkC/B9O0rweAlDsE8GCrBg64ZwYJZHMGfSirBOdwZwXO88cD/qwLBTMYkwZ1MIMEgIDjBLa4vwU1mFsFLXSDBsiYlwT8CN8Eu3irBaeEjwQ2PJsH8Iw3BDYATwVIRH8EJshvBc85IwQZvHsG2ZBzBjP3kwFVMVME85/LAjTwfwW0cFsErTjzBubIjwf6ty8A=", - "encoding": "base64", - "path": [ - "x", - 8, - "data" - ] - }, - { - "data": "AqolwZrQ+sDeUi3BczkjwZGeHMFQ/T3BKS0lwZGQBcHQnhzBFkoowbocI8Ga9yDBJCcgwYilKcHj9sLAH/4SwV0BQ8Eke+fAD+g0wQVnHcHCyR7BxdA7wdNN5cD9117BVjA1wb+QL8HFUiXBkMESwZo+JcEGeyDBgvTFwJJ8FMHTj7vAMXElwawyPcFZ6knBMz4NwXV/48C8+zzB7Kcjwe/DIMHLcCnBorMcwQLXG8FH1zTBAX4lwQTuQMEh3iLBKssMwfljH8GDah/BYQQgwe3K/sCz/CXB46wawXAkHcHegCHB2WgCwbVMF8HTVDbB7C0swfR3E8GW3CHB4bQBwcAhMcHcTiPB5lkkwSODEcFq2gHBC/4gwR42LMGtYTLBJoYUwT+LvcCxcy7BTNgfweAcIcF0GwvBkO3VwBtHGcFcOc7A6SwFwfd7JcHLRy3BwVkOwZjqJsE7rjPB/MBMwcK6DsH0+wHBnDqewKh5DMFk4B3Bu1wjwcX3EMHKkx3BoAEowdh7IMHwziXB80EBwfCsD8EgajDBxC4YwarhJ8FRj0rBZ4EawQoEO8F6HMrA0xvYwLQ0Q8GIwSHBO9Awwc6eGsFG6R7BRWcqwc1nPcE/YcHAg8EXweAzHMEIvSnBlN9EwRQ//sAj30bBt9BFwZHVI8HZHDnBvmQHwWTBJMH+5x/BEr4uwcrGGMEkvyTB3t8mwcWAIMEg+GTBGc0wwQ4CI8FPohrBcyY9wVs8+8AZ9zfB+e82wYiZHsF8cx/BRLcewVsSLsFX9RzBBnUawRrgIsHwJinBsyoywdKN9cClVRrB310LwWUU/8Ai9yXBQVYqwfoOQMGjTx/BK75NweR798Ak4xnBqM4MwSuwKsFPVC7BNJ42wd0/CMEFVzHBnzYSwVJ2E8ELEDHB99giwTpJ3sBQZfLA3Vk1wRKZKcFXK1nBlGs9wQ2eBMHLozHBwFshwQ/DR8GZhyvBOvgqwcyqIsFh1gTBgRAawcP7JMHhjSDBkeBmwex9I8EdzifBFii/wLOya8EH5s7ABzoqwRgWGcFCcErBA3skwXzRoMA=", - "encoding": "base64", - "path": [ - "x", - 9, - "data" - ] - }, - { - "data": "oM0bwWG6ycCQySLBc/gUwWtxEMFa5DvBYvUawXXd5cAu8AvBjPwYwVlUCsGOtBLBsrgOwf3aEsH2Y4rAW1IHwTh3QsHjxb/ANsskwRT7D8FaDhTBYasvwaTjrsAWzmTBjcUywaiEIcFyJBXBYeoHwdg9FsGc9A/BZreEwOcZAcFe8YPAVxwWwYuOM8EPRUTBh1PywMifpMA0AjbBJbUKwfDVCcG2KRfB7g4HwYl3CcHipDLBqn0YwaTrMsEvoRTBI+TrwE2pCsHwdAnBVrAWwT/x0sAKeBDBel0RwcIfBsGIHg/BMFjcwCz2DsGPcyTBWrkZwUCeBMF24g7BaivTwDpoH8EsBxXBnvgQwVWEBsHrYtTAVKUQwQfFI8HW2CzB7H/2wH4gj8AKCCPB0RUQwc1HFsHVi+7AvVGkwEHMEcHILIrAHZnawGjvEcEmFxzBBtDjwLEvGcFRdirB9XlewfLmAcEWNtzAarVPwOau98D7GwbBjBQZwYWuB8EYggnBcPcOwRQCC8GxMxLBrAzNwKVhA8Ef0CTB4EQQwajCH8GKtk3B/HQQwVndMcFGS5TAA/mpwO9pP8EzNxLB5v8fwRX7DcFfiQ3BP4oXwfrhMcEaqYnAX2AIweYpFMF2/hjBLElHwY7h3cAN2EHByag+waWIFsGI3jDBHOTkwPVtFMGBPRDBl94awdJmDcHxwhTBEx4WwQXcDsF4CGnB+l0fwTYTFMHttA/Bstw1wcUbycCkFSrB6hUmwYmWBsG5PwnBR3IQwbhoH8ECIw/BBiAQwTfwDcFhahjBYBcjwUzvvcCABRHButLrwMHZycAzwRXBwKsWwTvMOcEebQzBjhNOwT1px8CGyQzBEbfrwEFsJcGbfRjBVzwuwQHP5cDnniTBGR71wJwD/8C6mSXBL2sdwfaXsMCjnr/AOpIuwacnIMHy+mPBbCU6wTjrzcC5aS7B3rIKwfzNQcEMlBjB54sewQjMC8EmbdvADakQwa4LFcGSrxLBI5hvwbtNFMGPaCDBAi2GwMCmcMGm45XAdB8iwSEADsEv80bBf84PwZxgPcA=", - "encoding": "base64", - "path": [ - "x", - 10, - "data" - ] - }, - { - "data": "MyAEwepigcA+HQrB0hj0wDJ378BWPi3BY0EEwcAsrcB8YOHA9ln5wP4uz8CHPezAV8XhwNPY3sBgJArAC5jmwJD9NcFDOonA1n0IwWjw7sDQyvPAKrEWwU46SsASLVvBsTIhwblDB8GQF+/AXhzrwNFm+MCWheXA39nWv2JIxcC9vfm/l2TuwJeqG8HMDy/BCcK0wCe+IsCY2x/BYHXRwG2C1MAOnu/ArijQwGKx18BbASXBegX7wMoAFsHxjvLAiaOtwKkS28CzodXAIXn+wAo2k8CbA9vA1vH2wLfSw8BvU+HA6yehwLKp98CfiQPBASrzwLwK18DLEuDA+xWPwIZ6/MAh6e3A2pjiwFoJ6MBUw5DAzBPnwAtRDMGq7xrBqBCrwFE+KMDVoQrB33LnwF/u/sAPQrLACyJEwPQX+8CNzM2/DsCYwL4H48D7+vnAGl2VwD1898DkHhbBeS1cwaVu18Ab/aPAOo+av94/w8AI08fAgfj+wKzk7MCSedjAZUHUwPSg18D89OPA2HaCwN5G2cBTqQ3BZCT4wE5fCsFIuz/BH4f1wJ4UG8HQNiHA6ChZwKGbLcGR9OzA1tYBwYVb6sCxI+PAhKDtwPQiGMFf3gbAd47fwMZ4/8ARsvbA2lk7wZ4KrsBj1DDBeUEqwfhB/MD24xnBe8WkwABy6MBU5OnAMc30wEIR78DUyPTAoLbywHgc48CpoF3B6oIAwer37cAeJfPA/C8iwbmggMBbNA/Bf3sHwfzExsBhctLA3fHpwM3kBMHGxerAuK7ywO2I3MCQvPDA1Z8EwW0GaMCQ7/XA9D+wwBIOe8CSs+nAJ5vmwCf4JsGVSt7AVYdAwRXFhsCNCerAxPKnwM6qEcH30+vAVWYYwQQrpMDTYQnBkpWxwEHqycAz1gzBFGUMwXSdZMDf7G3Anp0XwSLGCsEKoV3Bh2crwdX+gcBB4x3BTWHXwMFUK8Eam/DAu+EEwaB50cAHaZnANWL3wDgZ7cCtdvDAsi9owcGu7cAnVQzBVsEAwOqNZ8FuDR7A6SIMwYxf7cBnKTfBcs3dwBrjBr8=", - "encoding": "base64", - "path": [ - "x", - 11, - "data" - ] - }, - { - "data": "qQTEwF6QpL+uGM3A0kaqwHpFqMA1ORXB91jJwGsjScDLAZ3A4nmswHrjfsAFz6DAQ5uUwJvFi8D/lV4+uD+twAyMIMFWdBPA2SbIwBE4rMAbdabA4DrpwOGNAr8kPkXBcr8EwZhqycD0np/AEw20wCArtcBbs5rAh+l4P9QKcsCEytw+25mcwFlM8cCPPA7Bw1lSwO7XwD4JHv3AP5qFwA3ejMBvjJ7A4duGwDEDjsDKPQ/BzVS1wCNc28CdeKrAOhNFwHHJl8C1Po/AsNe3wOX2CcDW2YjAKI61wC29T8Cd4pbAPwUwwNhwu8Dg8q3AbtqhwEGAk8CIHJXAeBD0vyEmo8AYdZzA03KUwLrJscBzQvm/dR6cwIqs1sAbDwDBM3IbwCKvEb8QttHAxfycwJXxwcB7d0/Ax4kzvxQ3vcCAfqg/2IwYwGJflMD4safAw73lv3OTpsAE6vPAvLVKwf6bm8BnGETAhutyPypYgcD5mGvADki1wPYltsAMJJPAKSV/wM6ekMCqOpXAWXyrv+EDm8BcD93AOHG2wGqh1sABGiXBUfWzwPVC9MD0+Cm+CZmZv9G3EcGRY6bAHt20wLwlpsBEB53Ao3mYwABo58CB5Js+1EShwNJAwsDULanAueEkwd4ZacCwGxfB+rULwcc1vcBQ8vDAlToowMtrlcACPaHATNejwJnhr8CzTLLAhx+pwNZCmsAmFkbB3FCxwDjPoMC0CLTAmlsFwcoUpL9pktbApOa9wEiDZcBNs4fAwACgwJ+sxMBtVqPABRCtwBQ2k8AoUZrABzS1wGDkcb8SebPARTtUwPHpib+XcpXAVUuPwAf7CsFSppfAUoAowdPB6r+2zabAShkowPW26cDZw5fAURPxwG0SJMAPKsbA0/9CwB55jMCb8tPA63fjwPmTp7/s14G/ZX7qwAcw2sBEyEnBilsUwUxJqL9ikwTBb0GSwJu0CMEsr5/AgA7FwAR5eMDY1hTAhAm8wHBrnsA1F6zAdzZUwZu9nsDAX9/ARl3DPp1UU8EYQEq8fF3XwOoIq8CDcB7BTjePwMd0+j8=", - "encoding": "base64", - "path": [ - "x", - 12, - "data" - ] - }, - { - "data": "haRgwKEN0z9yv2vADbgiwNr+H8CMCOzAAbp7wGcSB78e+hzAwQgjwBJ3q78EjhTAGvTwv+O+1r/KkCFAxu1CwJslBMGejj++ErRpwLcgM8AwrhDA+nSYwC3hC0BQhCXB6nHBwPK9csDD6QnAebBXwB3OT8DLtw3AkKBaQCOWjr8hWy1AHG0BwCf2mcDTzcnAehIuv3X2TEBUrarAsf3Wv69VB8DjigbA4/Hdv5+Q8r8YDOfAiUZMwL55c8CxaC/AgUfkvh2hGsDG0gzALeo7wDroCD+Lt8q/GQVIwGCgmLvvewzAbp9FvpX+WsAnvArAna0NwAlLBMBg7gnA5GxeP8Tl9L+jcgPA5yz2v6N4VcDd7Fw/Rt8PwPIiicCWIL3AVCxGPx0uwz/kloHAADEQwN7CdcDCeyW/ZyzcPxjdXsBCPn1ATf8WPqZEAcCG4w/A+DmeP1u5D8D1crDAd48twYBXJ8Bpq12/M0I8QF/x2r/ZQWK/lkY3wIVKWMD4AhPAJaOWv41XBcDXwwLARfDDP0VVIMBs6ZPAoBxEwDU9isDFGwHBZt49wMSDo8DHYAtAQ5qKP3pB3cC3ly3ARRo1wMSQKMDr7RrAsLjbvwXrjsCsISlAt1gzwI+SacDHLyDAB4sGwdnp0r+I6u3A/MjKwKD1acCtWKDAYLlJPtA48r+5GxjArscSwD3mQ8Bly03A2sgqwFR5EcBO8yTBHdkswDBuEMAUXE3A72/DwLKbzz8iioLAJzY/wGC0P7/1fOW/MfQUwMaHacB2nRvAr/gowGFOCsBul+m/Ep0mwGa56j9uFT/AaEB0v7MT8z+Is/G/L3fPv35/0MCXeBTABHgIwWJYOT8Z9ifAQsmOPgdypMAko+2/n1yiwLi5lT6ngVLAPiivvraVE8BV933ASoSewOEGiT+lwec/ASuWwHwAk8CsOivBTDruwM6SyT+SVsrAuCkSwCW+usDhGQvAybFqwHDjeb+A7a8+9wtnwA1dC8BjqTzA90o2wScRBsAtNZrA5j4qQFMcNsF5LRpAEKuGwMp3M8DpNP7AD/Luv6H6gUA=", - "encoding": "base64", - "path": [ - "x", - 13, - "data" - ] - }, - { - "data": "XSsTvxnge0CTEiS/w33+PvN9CT/FsaLAIsWqv0FbCEB/41Y+Pyz+Po0upj+lqQo/b5aCP3Lqcj+JH4BAqK9pvnKrxMBf3PM/d8ldv+KFQz4U50o/lwH/v0wvjUC5KvzA6/FewKgbjL9MgUw/Sls3v5TeJ7+ixvM+NJWVQH+w0D9p3YFAUdVMP7zk2L/KG1fApVn7P911pEA4VBzALgtJPywYLj498js/x3tLP6TFKj+c5qbA56MPv7pG176olgs8xH4NQDA2yT1JAwU+AgmjPuUSRECb94E/Lmxjvt3sS0C8bcc+d8kWQAJLFb/545w/b2VBP0TZOD/Cvr0+UBlbQB46pj9Fqzs/qYJiP8daPL/28VlAJMnyPhUY1L+bVmHAo/BxQLjiVUC6qai/Do8CP60zt78V0/4/r1x0QGXONb+JW6pAeiIoQLE3Fj9OsW4/A5+CQPYhYD+Pw0rAqHQHwSYAAb7/1KU/IeqDQMepPD8zRPg/3DF4PqxyML+WLf49VIXRP9ds7D7/RgQ/POKDQNXrhD161AfAhtZRvaxG0L+e2KzAIx8QPjqsEcA9IH1AqDpMQPYejcA0I7O9/vsmPokvMT7MhGo+Zdi7Pzhcsb9qUolA2ujIvomXWb9cDuM+i7PEwMQM7D73Q6TAI5JlwGHWnb+59A7Adls7QL2zQj+MvPI+RvAoP4YKq74iTjS//F7bPbErzD4PpvjAvy2cPvIVGz82AAC/lONkwB6ZgEBPFp2/JmAqPuyVBUB7lwg/z/T7PloSdL99EeE+k2T6PlV0rT6ONaE/j3AgP9kZhEDuaow9+Ji1P2MVjUASA0Y/7YqPP/9sgcDounM+Yc7EwAz0RUBwwYo+TdpFQAXAL8AEq48/FF4SwFIGQ0DJkKK9EqMWQMIqpL3ga3y/qgkbwD7aT0AKM4NAMiTiv07TB8DSQwTBUIiqwOovf0AdJYPAW+MDPuqdMcALgkI/WlV8v5Sh+T/WKjxAy9yGv5QMLj8MRry+KoQQwUrBbj+neBrAdCFvQFyXEcEa7oBAkvarv2BAvzyo1bXA6JsiP+ZSm0A=", - "encoding": "base64", - "path": [ - "x", - 14, - "data" - ] - }, - { - "data": "1HoeQHPlbEB6jh9ArLNbQJy7W0BHMCPAC6ytP+eYb0AJqDpAuAhfQBhucEDMD1ZAeDhxQOdeVkDhJEdAgdcyQCjbccCPN2xAtWr7P6vUT0DrO2JARftiP7CzoUB3r6HALc0/vyvl1D/HG2lA+DUJQPDS/D87d0RAQu9mQOhwhUBjOjxA4xlUQHSIzj92PGC+7fCKQLsnn0DJ0Rc/JeZBQHzaIUAwalZAEBROQOWrQUCBYUHA6kYGQBP8QUB1kjBAcTR8QEvbL0C93SJADr9kQLCihECPBlFAtN03QCSHp0CmKjxACQaEQLBLH0B3eo9A74BqQCqWTEDeRzdAEVSPQOy9iUDR6k5AzbRiQDTtAUAcQYNABeNFQHxChj97mXK/SwatQJpfeUDe4r4/fUBMQFRVhj9N0IhAmM6SQJ36DUBwf4tA1+aZQGd2QkDRVH5A2EvFQEbHdUA+Ty+/a3O1wIMQF0D8kExAp2I7QCBqRUBl+49AEd9WQAlhCUBY9ihAe6iIQIA+PkAMKDxAnoixQBhmJ0A5DPQ+6olFQJejmj9Xnx3A+jBWQP0/NT+h5mFAGYSPQOJI279xvyJAWV5JQBVcO0BzIThAPuGNQIob6D+v6WlAmjADQCU6CkDjy1ZA6QBowIgEH0CckyjAWIIev1txnz9IBSg/uDCJQFdDSEATH1BAZSNkQA/oG0A64us/8hI4QO/bQkBgPpzAdotSQO9XUkAiyhFAEStcv6ARjEC7T9k/6AFUQDTBlEA6Uy5A3oVOQFc45j+6eVBA2NhgQEq1NUB4HYhAve1zQLD3jUC1rlJAgZFmQB8MqUALiUhAyx9iQA86sb/YDTdAsi9gwKe3eUBFq0BArRKYQNuicb7/yoBA4m8rP7hWkkCtY0hAxAKXQHmXEUAjeAhAWz2wPlRNikCRoYZAmmeiPwzD8T7m6K3AKrVAwOVwiEAa2tq/oaYsQOue5z5m+2hAAcTfPwOkk0CWyJ1A6YLSPzJ0VEBm4g5A2GbJwIlmdEA8JfE9SOccQBKIzsC5OkpAu1zXPyIANECLf03Am9w6QApNUkA=", - "encoding": "base64", - "path": [ - "x", - 15, - "data" - ] - }, - { - "data": "5B2qQK175j9LBK1A9fi5QJgCuED+v/I9Lfd8QJCIO0CpB6xA+mXCQNF3uUBgXLhAzGm5QHzCp0BnZ1Y/qCezQDZYn79hAohAcQyWQAehukB/qbNA9cBtQB+kakCLz/2/0ooBQHaAikCH08BAamWcQP19j0CdlqlAiLejP89UwECAjOs+PGarQP8rmUC6+ztAdOS6QPgyQ0D1H2ZAFuieQKmCl0DBva5AsaSpQL9CokCvOje//MmUQDcHx0CLfapA4KNEQIFhqUCT3JdAuEzFQCBOOkAIGKFAG7+3QBHBl0AOQahAmGJjQJ/3rkAobOpAdI3IQL9BT0BKOaNAL/JGQIhw2kAiHqhAMrS0QKrwkkDEnSVAxHSqQIlRbUA/Jdc/C/yTQIeC7j/m2YZAE/qvQCF6XkDAcahApu86QLRKoEAfQ/c/9D3JQDDCo0AprMlA9BnNQDVaxkCWS+o/IT8mwL8ahUAq5JNAFdjBPVFanUCyEclAfSe8QG/2l0Dc1J5ARfHOQCUtqEAuc6BAHDSTQJgmk0A5a0NAsjW6QEDUe0BnHBo/HPO/QPNFaUCMa5I/dpRRQO3Ihz/5MaFA9BW9QIcamkBzs6dA6uPQQM3gm0C1IIs/TlyKQLasoUAX/L9A+v1xv/X7cEA05fO8ZhMZQLqxakCm42BAGq9MQNKmo0AwFrFA7lzGQE5nl0AUWIlAcH2tQBNrr0AiPuK//fXAQARDrkARJJVAt+fzP8x/OEAxhJBAWz3GQNOkz0Bwg5hAa96wQJLTjUAdb7VALtu8QFdhpEB+aN5AxebWQGZdLUB36r9ANgKpQCqkiEC1B6NAyfyqQB4orD/rmahAFU0yvwbjCEBMFW9Ae1tkQN9CEkDenNRAptNkQJNcY0DC/bdAfwPDQAaikUANVKJAG+9EQNSKKkBKLBJAn1eHQK4nQkAEbxXAHugSv0TBK0AGqj8/QPukQI3paUD5bchA1W2MQFVu0UCS651AwTGHQFaorEAJ2ZZAuGJSwLJfwkDcLilAGMd6Pst5YsD8kFY/RoiSQLF8k0AUYR6/YS2dQGr+7D4=", - "encoding": "base64", - "path": [ - "x", - 16, - "data" - ] - }, - { - "data": "fSPqQGm3Bb/mTvNAax/eQLZ420ABlTFAdDLFQE/iij/r4tpAgmv1QH5x3kBhduVAXtS6QN06vkCsy9O/5AntQGDhrD95jwFAL7PjQD2I4kBkFdBAED3JQFZAmD9JT5g/NdyVQD191kDc6+hAr0vYQNKr1EDlaNBAhQ2rv8kExUDY+grARcnNQK+K40CW+rtADsOlQDSUvD4AO8tANDfDQE/vwkDyX8pAuMnPQOD6yECkGc8//JbdQNRfC0GIGe9Ak8aHPxjL2UDRdL1ANrzrQOoGQj/ztr5AkSfqQMBCM0DdYNVA4o7CPzHT6UC0cRVBtOECQT1IvD8nlc1A/rBIP6srBkGPrMtAf6LOQOE+w0B1vr0+zqrRQFXTxUAt2YVA0TYjQN7kg78LnNRAWi/bQN34tUAtqoJA2kkOPneN3ECir3O/0CvHQKtNxUBWz9tAvWyRQHQM5ECc4IdAIqsbP2qgZEBGwJpA1Nc1wMQBpUC2nclAMy/jQFUYyECoD81ASyf5QN844ECCL8BA+yYJQJ75kkDvsq5AiUfmQJsywUAecGhAnK7nQHTHx0CZP8y/LqudPg0EckDmD+dAMnkCQeach0Be1NVAgebRQKyc7EBg7um/j/jBQNYI3kC/hABB7p/jPy/5KkCaxSRAxpClQEGdvEADbsVAzCCKPxUwyECpKM9AvLkDQTA/p0AC8M5Ac7HsQChP7kBS2bc/aHEDQZwJzUAaTq1AOgaRQNuBLj9rZd9AgCIHQXYM10DAU8FAqabWQJYH1kD/s+BALUPhQFFpzkCdLhFB+34QQYYZlj40BupAET25QL+ZCkD2DsVAIxDBQOeSf0BxHddA9yoJQG+vtb64PBVA4luFP1FmlkDtEAtB5VjBQA6vpz/grNFA0s2kQJlywUD+6udAK4mdQHPNTr56YIW+P8ncQF0mqkAMbWM/5pHxP+aUAj/BFktAH/jUQPVp00CwfAVBfCvYQNDD2UAzwiNA8f/BQLPKyUCw4dxA2GkGvvro10BslJ9Ak1QCwDhh676i39m/F5jYQAk0f0B4uP8/qJzBQIN+IMA=", - "encoding": "base64", - "path": [ - "x", - 17, - "data" - ] - }, - { - "data": "RdruQO3UMcCDVgRBJU+9QMsEuEALlqVArQbuQJ5XeL9flMVACZnsQP1ExkCERtBAT5prQNThjkDCe3vA2n7lQKtqdkCmpJW/qnIPQaPbwUDY2qxAQuUEQYntxb/8ColAyrTgQIrnB0GysstAlpzOQFWFAUEvO7VADylxwOg6iUAZeY/A/GKyQJ9e6UBcDgRBPy0kQOk+GcDPBAlBz82qQG43r0D1YZ1ApGazQIHRskAF+ndAEukKQT0MHkEiEw1BEWqTv/eBwUDz1ZtAL9HGQHQfxr9Ld5xALhTRQHj3uT7Fn8BAJVxavxbk2ECWgh5BrK0LQXV+Ir9JhbhAzd3Yv+qVAkGr4bFAtfelQASnsECE5fW/OAa3QOm2BEG8usdA1G/tPCHAccDLtQdBWsTFQLPg7UAlddo/RIwtwKxXz0DdgWvA7rWBQCcooECo4K5AUbHPP+DKt0AC2ctAl5dxQPgOuj+bJhtAwlOqwPrAS0CctIpAdnXHQGvHs0CHVLpAYi7tQAT49EAUm5hAoLdDv0YwI0Bjgu9Abo3GQGSmzEBrd81AIxXCQBEKAEFBs4PAxoQzwLDtyECehQ1BZ6QWQUtXBUBXTsBAPwWSQFB4C0FMD4/ANzHMQM/j0EBriA5BSaqMQNmdhD5sVqFAbADnQNWL90DMXgZBSeufv+CDsEAfb6lAzO8RQTqcZEAdjAFBaHECQTX5B0Fsi5FA7NMVQZq4qUCikX1Aa6PWQNZF0r/BQwtBw6wXQRTjlUDsbaxAZPq4QNffAUGuZMZAYAi+QDhkskDDjSNBCgolQa/VC8AotcdAhKaAQJgysr6MKadAN7mTQFnDykDSTsBAzyCbQKOCNMBXqL8+eevZv1Zu20AxhRtB9zjoQA5tmb+056ZAdhcRQN1bsEDYAPNADWaMQPgGRcCP7THA490PQSHM2kD7pIFA9dWHQBpj37/cxK1Aknu+QOQuEEH39BZB3IQJQYGumEDLKQy/mwa5QNZCokD6ughBocdBQCTHpkBcn9tAOsSBwE/tKECIt4DAGE/mQPuTBUC5l5BAhtGoQKXyocA=", - "encoding": "base64", - "path": [ - "x", - 18, - "data" - ] - }, - { - "data": "6Qi8QJI0lcAtMOVAET1MQJPeQUDp0NlAYl/dQOk0OsAqa3RAsO2tQGz3W0BmdX1A4eAqP5lE2D9Fr7fAlk6nQJjzvkDPn4bAsqscQfO7WEC0qEFArE4UQSN/gcCTu+BAT5ALQW1vE0HB+GNA6hWIQOvLAkEd5FZAPJ+2wH5Brz88EsbAUmpRQDw8ukDZqhhBupQsv4bWmMBcmBxBHTpTQAqoWkDM4wpAaatBQB6DWUCO3LxAsnkYQUg/E0FwswtB7JVPwLK8YkAGLx1AOwJLQKUQasAySB9AlFN9QGQiCMDN+WdA2MdHwOSJjUBOqwlBvgDoQLcgK8A8RmRAM9t9wI/dv0BAjFNAWXomQH79YkAf237AoeZTQOi1HEHC2eVAlCYgwC+RwcA99BNBXoBwQFldBEEvIH6/V+KlwAOThkCdZrnA5sM+P4guFkD090BAUnvJv+sBOECX4/tACH7VQM/sd78Wxo6//ufhwHfzsD5mY7I/vQpuQKyvYkAqpmVAAx2lQFjyy0AO0wdA0tFkwN54Cr6rqQxBuWJVQAXxmUDwxApBEJBCQIvCAUFBgsTAFFyxwGrPBEHhNhhBrFYPQfBn975sbmlAeYTUPyGoAUFu0NDAat2JQBXrikAL+gFBLKLVQCoYEMDiROVARuvxQMEoDkFO0B1B6ARbwG/hW0AGEzhAoFoDQWCBiz9zNQtBiG3ZQNj2+0C9uOlAessMQZG8O0AB1ss/BGX6QFByb8B7YBBBOKgJQTn0tj8UuFpACkBVQDUU/ECHB2BA23RGQO9aTUDF0RxBjPIfQYy2jMA1glRAAEVJP038M8Al1UBAWv3jPzOF/0CPcGNApALlQPsGn8CaXdK/auWHwEWUCEEHShFBBSzNQOebY8BvMTRAplCSv8hgZEAb771ARBMjQOQLssBdQZ3A9lYhQQSi0EDXhNxAA4rJQOswdMAAQOpA305hQPkxJ0Hn3Q5BBAoYQT0ZxT/lI2bAIZ1oQLQvI0CliBNBvYW/QI4OHUAKLvdA2rmywCQYsUDFBbzAdoW6QEmzLr6ZvNhA70hHQLXW2cA=", - "encoding": "base64", - "path": [ - "x", - 19, - "data" - ] - }, - { - "data": "EZhYQBR9u8AUB51AHv8WvvyZrb0zI9NAWFGZQKiPkMBo7iw/U7UkQLbum70QOxg/UTQcwLK+rL/PhdvAxDoeQA/J4UDGo9jAoCoPQarwWD2CyZM+qEsHQao5vsA/hQ9BFb0TQeCYA0Go3iw8cdiTP2qVz0BRius+Yw7bwMDC5L9D7d/A4MzUPupRZEBUMBBBumd1wL9Ky8B7TBZBfNc1PwR2Lj/tbV+/+kERPYgQET+8Iu5AGZQMQUpa40DX6dlA496gwB7+dD4c4IK+ZIPbvug7qsDn4Ca+5u4JPwFMjMBrvt8+KgShwEzrlj8SQ75ATluLQDZjjsCaZBQ/Uei4wGcKMEAV2PE+8FTGvg5DXz8NQ7LA2G2bPimEJEHM28JAuaCXwGGw9MCoygZBEssgP9CZ7EBaYmTALdPfwPICgz94sNnA1OctwOr+Mr8mPC4+H1eSwGjfx76wWwFBTkoPQbAHUsA4f4/AfR35wKPpIsAfuN6/OvfRPvHgTz+qxhk/NAjzP17iYECYa12/Rim+wD/3M8BbfAxBuXtHvvauEEA71x5BwlvuvnW4z0BjMO7AXgX1wHTKFkEunwlBzK3UQJgdQMCiSS8/4ra6v9H/vkDp3fbAkr2HP1+PqT+rN79AKEgDQVi8j8C4UwlB2Be/QMloDEHLayBBS+ClwJu8OT8qgAQ+vQm5QNRfxL8qSfBAOOt2QDL6rUCdgxRBZl3SQDQZDj5J+Xm/akjfQHmZqcDlUu5A6prEQKg2A8A4u1I/fl6PPmJStUD0EcM9Vvg9vro7oT7i7fNAWhoBQaOXwsBIGWS+xfUpwPwam8C4L9Q+BlOvv6ZRA0E9ma4+t9cJQYJp08Bz8l/AgJXKwN3lFUGNXthAZfeFQFGWr8Ds+RY9aQ+NwJu+eT9uaFBAksmrPjaF7cBs48rAASYZQYwGhEDU+w9B4n31QGWvr8Bz+AdBkaquPoxtJUHXJdtAVwsNQbIo9r/WS8fAdaNFPzCpY77PdgNB68AGQYp3E7/8u9lA9UHMwPpF+kDmEeHAuuRgQMZAGsAPxwdBgejTPmnT6sA=", - "encoding": "base64", - "path": [ - "x", - 20, - "data" - ] - }, - { - "data": "mM8GP70jvMBJBwVA3uxcwFbsR8Cow5BAeDfvP/ZKssAzjCrAuIAgv2WGYcA86DnAoyaowFxVhcBHwN/ArOsPv5vuwkAqBQvBohfPQLwPUsDT9yDAyN+/QF6X3sDaGhdBYxT6QJXptkA94mLAAGMNwFPwZkDQ3STA/2TawBMWl8CJLdPAwEAiwP/PfD+oHNlAXSzSwIG72cCgUetAYNoFwN6DD8DW/G/AczI9wP4/GsDfSP9ANNrEQMV0hUBqVGlA66bKwEq4SMBxbDfAjwJ2wNpKyMDC4CvADpZDwBioxMC6GDnAN3jLwMXEFsAcwSNAMMFYP5uoucDYiCjALX3bwCtIYb8sjSHAfZlSwA4d/7/Kt8zAJj8ywMj3EkEsZ2RAKh7MwIDbBcHQg8ZA43cnwDBNl0A1ubfANov7wDdMHcCDRcrAEOW5wNMgZ8BNtCzA5SnhwP5ZY8C0ZMhA14UhQZ7EqMD1p+jAC/vpwDsUpMCDG5TAsQhDwFMMBcAg4yPAWAPVvwBXgDqOimzASNXxwL6BpcA3x+BAq7JmwOAxHL8G/hdB5CpywF9RdkC7dvfA3xgPwenPDkGSEsFAscpQQGdWp8BV0BfAxjSMwJffQUCHYfXAZjoZwPhH97//YUFAU9cCQSv8yMCMlglBOwNYQLmE2EA41QRBskfIwLvfDsBmuifA2MYhQEcSfcCvB5VAxlyePnbD/T/cIx1B7oNXQFEWK8Dq7ljAIiOSQMpHvcBNipJAWrw1QEt5p8D/bALAjV82wFTBGkCZGFXAmjJYwFXvKcAAMIhAjVGhQAav3cCSMWjAmwG3wGf5wsCQzhLAlJ6JwJ4Z00AcDT/AySIHQXO+8MCh6qDAhnH2wBECC0GT5FpAT4muP53D1sCu+i/AhBHmwCak8L8HsEE+Nv/1v4TIBsHipdTAxcvrQATnaD/u5xtBHhfyQC770MALgARBn0Y8wMUDCEGdMHBAop/LQF+Vo8BrFAPBfrQQwHgeOMCzwq1AYw4dQYTQW8CX6ItAua/FwATQC0H83OXA7xxOP5EMjcC1hxJBLyIYwDyAzMA=", - "encoding": "base64", - "path": [ - "x", - 21, - "data" - ] - }, - { - "data": "IUAZwBhMiMC9y3K/8SnNwHtWvMCUSNI/ReCkvz7Nt8B3yrrARst0wLjT08BwAMbAG+DwwLXDz8AUdLzATnplwAZYaUB09xzB8BJCQNhPyMAWIqbAqf8pQILm3cAC/QNBHxGaQHV2F0DthtjAY9uuwHDMaj5h6q7A9XKvwF1L5MAdyZvAeFWqwDHz1b9+WWdAmjoKwV7Wv8BbO4hAtBeZwP4ooMAI1MXAzsu3wD6ap8DtG9ZAZlQaQM5zWD88Txm9TlHewLT+xcBrNqXA7pbawF5MxMBBdqDAOynMwLlp4sBZtr/AKOfZwF37uMDKJYu/9UkxwHc40cBnsLXA4pXZwLU5j8CU1qzArMG5wLFflcCZtr/Aq6S1wBnxz0D5wgI/3V/gwDjA/cCA7kdA/Bu2wF5glz+lqejA0uDvwLrSucB4UozA6JgDwfLWwsAOBKvAC2oKwek3ycCmxkZAC3QXQYj32MA9QxTBjhKywCL65cCr7N/AfmHHwCb4mMDyrbDAG0CkwNi2Y8A5UcLAv5EAwfIP4MBgDIFASeLTwOMHXsA9QOlA2mrVwBIpQz/uBdTAGVMSwXN+0UB2OB1AAjAFv59N38CuH6nAIM3awIxYY74KZsHAwiC1wDJDosDWd4a+UrHEQKEM78Ah69NAWPrJPgvAV0Bm5KNAEA7JwDYkpMD3MaLAbLaBv42GvsA7qoE/PW9TwBi64b9PTglBd2Buvv94psDAU67AGFu9P6Q3qMA75Y8/fAdFvx6f+cASCpvA9p63wG5skr9jhM/AwXHIwNCwrMD4kbA+PEK5P0Itz8Dd3NLA75MBwW2PysAfDJvA/u/WwDuec0ADEcHAGGbQQM8D7cAax8HAxCUAwWstxUA4hKm+EiHPv+3k2sBkranAZf4TwRj+lcB+DDvAidWBwHzYA8FA/LDACUWCQGQsHMCY6gxBCn+vQEYj0sClH8NAFsG+wP1Mr0DeGVY+Ops2QM1A98A7shPBwjKlwLFip8C2p9M/xTMXQfo4vMA4YJw/KoWZwHZT9EAbcL/AMqT+v35uv8CvPgBBt1ifwL6bgcA=", - "encoding": "base64", - "path": [ - "x", - 22, - "data" - ] - }, - { - "data": "WiWmwJjVkr8WWXvAKWwNwQKSA8Fe+7e//7KLwKRulsC1kgnBw4jZwEdEFMHv9RDBWKAQwe6NAcGk1VzA0YbNwCLnKT8I9B7BXIVCv+pmCsFLm/HAjJ16v/N+t8D5jr1AVdeLP6nKoL+lmBfBs1oFwYiBTMDAp//A1T00wEdDDMEcJeW/WYv4wEX8h8CcRIc94yYdwVqUdsAyGS0/rB/kwP2o6sBgTP3AmiYDwVx698DJtXlAkaDUv0SJI8BZW2/AfxjQwE/aCsF0O93AJVQUwTR2l8BwtODANbMSwW0o1MBQxgnBoUHBwN8vDMFPU5XA7kTGwC29ysCGrATB+i+lwN2H+MAdAP7Aeaz1wGLX2sCofH/Ax8QCwRIHNEC0nCfAZqXDwNzFxMDGEJy+zwEHwQJoIsAasfvAGHq5wKQNC8GEMaW/nokbwZm7+8BjJPDAZHsQwdPABMEipf++RrHpQLlm9MDfniTBvlMewDnVCMFJhwnBy+0Owdrq38BBEwDBrCQEwTI828Ap/fbA0CPewI9SAcEn4/4+5IgRwQH0w8Ax5oBALZ8PwT70GcD5lH/AxTj9wOJLRkCl7rm/L++IwBezAMHpOv3AKLkJwWNbXsBb/zjAPrkIwYW1+sAcx2LA/9RAQLoX/MDb+1lAyYkowALUC7/G/p8/SNCfwE3k9sBMRN3AzMmPwMCM7MCXozHA2OvVwLTvq8CtGcRAeR51wDZT5sB3o+LAVaHiv0OnTsCT+BzAa86KwKSUF8H6O+vAupACwTYslMCgbxPB/04Lwca59cDDuWfACq8SwNfbjsB0XA/BXuQYwQIarMC4xt/AbAoGwRLIBz++6gjBWIxlQGtSvMCI9cnAbTPTwFZ1IUD/VILAojOQwPvKscAm4+zAh5UlweDq5cAb0rvABxu+wC0DzcCanjvACAqSPlS+s8CEhNRAFscVQOoQpsAj6ixAErcHwaDv6z9C7FfAZTiDv7UZGMH+kw/BPf33wG994sAsdhfA8TzuQK1W9MBZoQXAztYGwAAUqEA2sFTArK6VwAPw3cDlZahAYmXlwItDIb8=", - "encoding": "base64", - "path": [ - "x", - 23, - "data" - ] - }, - { - "data": "m273wP/9G0CvrdXASFMpwfXeH8Heuo3AQGHlwMv9EcAHMizBdR4WwW8XNsHZSDbB7wMYwagzC8G/BPo9nDMPwcFyGcAh8gvBfDiQwOskJMEkaRbBNamRwBGiTsCTgz9Aqe0wwO9lmcAHtjjBGgMpwcCxzMCqIh/B+uI+P8CBFcHGaP4/hT0bwYn+08AgDmDA5W4dwVZPFr+AoD7ANYEOwTh8D8GOOArBWm4jwRUOHMFYsAA/s2azwKmJucAzAOXAuxqQwBy5JsFxaPrAWhwxwfGR+79V6AfBeP8zwaD6jsAjvyjBgVh5wKGpMMHCJv7AB7gTwfs5mMDiYCTBGRsBwG/sKMHJwh7Bfi0KwcqdAsGkFCO/gJEhwS/fnL91mLLA2blnwE6tPcCqT27AtAQswcMQwsCF5ubAG94vwP7vLcH/MQxAVP4gwUv5CcGqUA7B4Y36wI61E8EvqoLAW9KHQP4H88ATjyHBMKTHP2QtEMEEwRHBa2IwweueBsFYXhzBtdItwULpGsH+hgTBD1KJwECpAcFfsEbAZlwuwTr7BsGIF6o+ykgpwbSKrcC8x8G9b1OjwDlaN7847KfAlQD4wBIKAsGBcyLBTlwWweR10MA6Fpw/qN0uwRoFIMFeu9LAhe33vm0f6MDAoXy+GSuwwDHyjcDk1DDA8HsQwHUSHMHhmfnAPNj1wO66AMF3bsvAZmkawXOMCcFsakJAOxzlwM1cBsEgcQHBOxGdwGiaBL6dvrvACi30wC7UHsFjSxXB3LYewTo5+sAtXzbBH2MpwbWXFMFj9OnA4uS7wJhQkb/4DSrBwFIdwS5ESMAz7AfBTQEQwfniM8CH/SXBzpeMPrdSM8AWcKrA5pJCwO34ur/yBfHAfSTkwMJRMcCMjwzBOJIiwbPgEcH7BQjBmgjuwLo3OMA5uDc/SLliwLo7B8HaK3FA9miNv3f5FcD1R4m/nkAlwQ20+7/5D9fABJmawOlKIsHnPN3ALR4ewXq5AsG0K8bACZuQQKkvBcEcBqjAoO65P6dME0CSpPU+FNLjwAHf3cAeJOA/ZGYLwXAxPkA=", - "encoding": "base64", - "path": [ - "x", - 24, - "data" - ] - }, - { - "data": "1HIeweAmqEBuwBDB66M3wVFPMMG7eeXAMtUYwZ2EiT9DhULBHg03wRn8TcHIIVHBUE0HwQNc/cA0mGlAlQgxwR0uqsD6SMDAXsf+wIHuLcEqgyjBX9n6wLwbrj6y0ja+P6LNwLNYAMEtqU3B2Yo+wUgwE8HPATLBaUqBQBVrC8GGJ55AQBcvwf0AC8E6FtvAJh4Iwbv/N0BFvM3AwdIdwdWNGcH0h/zAIyU7wTNtMsEv+z3AybUSwekNC8HhWSHBLDN8v8hiM8Hg7e3AJ/FBwdY3yj+DuRLB23tHwRq5ab/0oznBPB4Gv9IkR8GdjyvBoqE7wbzsyb8CzDbBneDqP/ILS8HR9DHBs54FwY7LAsFnCz9AfRc0weCTpcCgqQPB+lY8vedyoD8oiNzA3KFIwYotE8Hun6fABj6aPyVqQsHp351AnpQSwTk6/MBeiRLBPiKkwPW2CcFCIO3AhpFJP/kZxsAPrAfBSuaZQE58A8FUggPBahJGwU+PCcGjAinB+gtNwXcZPsHlUOnAnooFv/ZD2MCy6M/ApQ8+wXCdJMEG2FnAlHA1wYX2AcGE+HVA8pNdvwG4j8DooQrBqvkrwbDp3MBnkD7BUOMLwbbKEsErtZtAnmFLwQZwNcElShPBpXl9wG5qrcCAiHnAdDYBwesuAMFip9LA1sawP1PjL8EzxejAlJMmwZw78MAgihjBDQRBwbIvNMGh/Ze+vXIgwcg6B8H7TALBMoj4wG36QUA44Q7Ba4UnwXohDcHxjSjBjdYswTz/KMFAo07ByE88weZ6H8G07SfBkQERwftcJUDdfDfB/4YMwVBL3T3y0BDBHCYDwU4+v8A4rzTBE5ZEwBSxrz8CzDDALIjVP2fMqsDWQCjBw5cVwerkgT+2FRHBqTQEwZUUI8GYDivB+h0GwW0Q0z80OINAQo3jwLE+LcGrlxQ/eW6PwItmqj891pjA0UE1wSSMtMBMJRrBCtoEwVTGE8F1VkbABr42wShkAsGPUBnB5vWXPxYy7sDWWgHBhyyOQBFqVL+llYNAFhoTwWApr8CgJfm/0goVweuerkA=", - "encoding": "base64", - "path": [ - "x", - 25, - "data" - ] - }, - { - "data": "wYE5wfYv2kCPOC7BZLw0wVYKMcHf2RjB9ks2weodgkAWbUnB6WRNwRpDWsGPa1/BGtm0wKqNs8BkY8FAJqFKwZcS/8DZFNy/UFcvwaQBJMEegyrBLu4qwZByc0D7JFbAkR0bwYGOLMGG/lPBiUpCwZOJN8FahjTBnaLGQH4C2sCeN9VAydQzweYqJcEJrxzB1TK4wEk1sECtnxfBHn8awZigDMH2bK7A1WpIwbsLPMFMD8jAPxlDwQnmMMEQ7EXBVJI9QFawLMHGXKrAu25EwdNQkkCaygrBazhKwY55PUArojjBNAhEQAPTTMGXUE3Bk6RYwZ8iGECI9zfB6tGkQMQrYMHC6zPBt3PWwKt10sApNrhA8jQ2wUVIDME5PyfB1mFkQBPanEDnKhrBC1Zbwbr+PMEvPQPAqxCVQDb0RMHN4MtA6mngwJnNrMB5KADBR26ov2GdxsCzfSXBjB0vwA1hSsA3HqzA1xPXQK2kvMBI5bzA2p1NwZka5sALQCDBIN1fweX5VMG/S5TAD5JZQMLdfMDEJxjB0W89wVHcOMGcvd3Ah/kwwTPPJcE/ZdBAqqVrQCLj/8BZkDjBRwNSweuehcArU1HB9mHKwKLVNMGm3d9AbopcwVQTOcE05jPBpqnmwJ0jEMANXerAJ4gjwXPLMcGOASDBCHGRQBkzMsEjIKfAzo5IwSSCqsDDzkLBvcVcwdmsU8GswmfAU1xEwbdq4sDmjNjAZZMjweN+qkDf9TfBAzlLwepFxcDcUCrBM08owXnQS8FZ8FnBUUVBwXfqFcFC7U/BY9g6wThNskAIwjTBzaXLwO5YVUAHvwPBlzK6wDADDcE83zDBlMnHwB+WoUCaG3s/PT2+QKfgDcHq703BK4swwWu7jkCgofjAKwaVwCaTIMGC7kTBWTcIwSFjs0AOQMpAQ0sjwYg8SsHV0inAJm3zwN1qlED27wLB+3g0wXFTD8FcST/BFFk0wZZ71cBIdtQ/9ixDwYcN08CrHEbBR+YOwCzAnMBhaCfBdbDMQAwGe8BEZtBAPnEswVWkHMDJ0LDAka8IwdH5z0A=", - "encoding": "base64", - "path": [ - "x", - 26, - "data" - ] - }, - { - "data": "RONKwYH76EBVoUDBq9AcwRsVHcH/uTfBeQ1JwYaWwkB5hj3B1KRWweOhWMGzZF7BQui0v/Ah/r/vuutAlSFawRFGJMFMXE1AbPFVwa5UBcFXjhfB1EpPwYCIy0D40srAOfNGwQZbT8GEPkjBW2YwwRKHUcEMRiPBDOTpQOmLasDuAexAYgckwQNCNsEW/0LBTrjZv8OU40BfXT/BkXAAwTr8ysDCd9C/zbJIwVYVNcGmWhPBzwtpwXVXS8ETAF7BJp3DQEMCEMHuLte/KB81wXZG0UBzqtbAxFQ5wW0FxECuWyHBwdW2QBgDP8G4cGHBmVxowVLRsUAHviPBefzmQH51ZcHGKSDBZ9dxwDB3YMAayelAtzcjwcZwPcGcdkLBJL/KQL6h4kCvDD3BlU1iwVnoXMGNINw/jy/ZQAg0MsFmKNVAEz9rwC4yvL+n2LDAPMUzQPpaF8B2lUzBOj/DwL0DgD9czWm/CMbyQLpSC8A6zhfAlzNEwQDUh8DcU/zAJQdkwQVPXcEiJTG/MbPNQPxSCT0BX0DBEygowdsyQcFEICHBFNQXwbQbQMFK9PpAgADdQHlhMcFYy1vBRN9rwS+BAb7ZtFjB2pAZwBvMS8EJufhAXCFgwXhTJsGIpkjBeIwhwQ1s5D/0NibBpQU9wQIcWsHY403BwsPVQI9tH8GzzPK/VaFewZ0pzr+q5mLBXn5rwRX2ZcFRUdjAT8lbwWjSiMABcnXA6MFCwWe81EDaEFfB0rNiwTf6DsDcvBbBEsUMwWKvY8EYJFXBL0U0wYAT6cAId2rBw7xYwSWL6UCEcx7BzbQnwKNQukDfw7rAUaEEwH1UM8HvaxbBxJ4RwTl/7UB4U45AtOQOQbSPPsEwUWfBcINAwQSK2EBBxpnAdGwAPv2ABsH4LlPB9pfswP62/0CfFe5AHYVKwQZlXMFuvLfA/eolwe2j3ED1qDLBJqEfwWC5O8GppljBN8FZwUx0LcCpc75AIZk/wWnvX8A5rmfBgzyxwFHjjb86fUTBvnzuQIK62sBUY/hAeZg7wV8EuT9WDg3B4xjEwKgNzkA=", - "encoding": "base64", - "path": [ - "x", - 27, - "data" - ] - }, - { - "data": "9AJQwUt32ECYrUTBoCfcwNiJ5cC+3E3Bm6hOwZCb5kAbjR3B5vVPwXLRRcFcs0rB7SxPQLAYDUCgS/lA7CVdwQQTQsEC6d1A8mZxwV5ypcDtndzApItowZvw/UBKVBDBXohowa7oZsHloSfBo5AHwRA1X8EEkfrAAlvvQD9juj4/aeZAdob5wLA4O8FrEl7BYpE2QH2r9kCsv1vBgByfwEtPHsAdgipAZAk4wZ1fGsGFFTzB3XmBwVrvVsFhPWfBSvUAQfi/u8B0eiFAnqkRwSej8kAA11XA+GIUwcysAUGnK+XA1sLoQD9THcG0kGTBF9dnwUkt9EBV+/DAulgBQcGHV8Gz4+vA4FnbPEWh4j7zmflADzzzwCVqZMGYllPB98D8QA4PAkF52lTBAQ5bwdppccFP059AtLr5QADOCcGqpb5Acub/Ppi8OkCZSQLAV7PIQMNqBUC5hmrBWkgSwbhGnEB/cHVAfLPxQLS7C0A4y90/BEAowd4Agb6FLojApVFXwT4kVcE1LV5A/VQAQTmugEBjCl/BtKr4wOU/OsHQBEvBubHRwAZfTsE5/gFBqHMJQQJyWsGwn3LBLRl3wTcwgED83VHBYl0KQDCaVMFN5O9A5ehSwSAL+sCwvk7BFXRIwWOho0A0AlDBRExLwVDCd8HFDXHBi6n7QBu57cAMbvk/yUdmwZLOKkAAR3fB9mhqwU/FaMEsQBnBPPNjwTmZzr6GbCE+WApYwcHa4UDEE2rBORprwd5WD0BimNvAFnmzwMl1bsEYQDzBzWMSwXVqdMD2AHXBXeZnwSbS/EB3VebAULvxP19s7UDq4wPAwjURQHH8UMHgScrAeJk4weT3CkGhOdxAKdgkQVnoZcE3BHLBOFNCwQkYAEH3hCK/gROcQL5srMCifFLBpn+WwCeJDkHuWPJAAv9kwetrYcHejQjBBBNLwX7fAUFbLlrBCXrrwBjeXME71mPBXERzwUbO9D823wxB/y8mwVZoGj81ZnzBO2cJwZ81P0Da6lbB4g32QAttF8G37QBBB2Y9wXAGn0CUWzvBb/YNwDysr0A=", - "encoding": "base64", - "path": [ - "x", - 28, - "data" - ] - }, - { - "data": "lUlFwbd+qkCzHDfBxjAlwKmcU8Dwd1nB4YVEwaKZ8EBRDdTA77E3wXI1H8GWZyLBiiHjQEwruEBMxOxA1VtQwYirV8G0ChFB091/wa4lhL9WE0TAJIZ0wU6rCEETYDTB1xt+waw7ccFAeeLAYg2SwCtWXsELlYfAA1nZQJ6aiEDKC8ZAZt99wC1RL8GrMmvBKnPQQLvH6UAOU2rBc09Uv8BfAkBMD8hAd84RwSKe1cByKF3BzZCHwX1fT8EpFl/Bty4PQZIJ0r9+sMFA7pmzwMJ4+ECfk1s/lGi5wF1ED0F1DzzAn/78QBqw0cB8N1PBDWJTwVtHDEHyT13AjgP+QMPsNMHsuV/AiRd0QPF2iUBGoutA3qJuwG+vf8G9dFjByswFQRIuBEEMbF/BmtlCwXfMeMHFIONAlDH8QAtBm8AL6ItAv0KPQMSoz0A3Sew/TOwFQa64wEAx9X3BYI07wWxJ80CJXOJA19PVQH3pvUDolaxA0T7ywHtEdECBh7k+tPY4wYK2O8FiHdVAep8FQYVA3EC6pHLBAcxuwH8eIcHshWrBY00bwDdzTcFJVvBAceIRQV+eecG+SnvBx6VwwTsH40Bp0TjBo6rHQORLS8Ehj8pAhkkwweWXgcDTUkTB/KBmwSGF50BEVXHBgSVLwfexhMGK04PBon4CQT2zaMAmUalABMlcwTaVyED0MH7B8LRVwRR9WsE/Vz/Bt51ZwTNuZUASmYRAXE1hwTjI0kDQfW7B5NRgwQh0w0C7b0nACCybv1FXacGFdw3BbgS3wApFBD/hCm3B64JlwfYw8UAWa0/AQP20QJZIAUFz+RFAAbi9QPBWZMH7fwPASUNXwdkSEEGsdAVBZkgjQZ1PgcEaVGvB5HUywaqOBEEL7W1ACt0GQYmTrr8d+D3Bd0grvwQhC0GknthAFStwwaEDVsGuai7B6BNowVbTBkEoUXjBpSlgwDofcMGmt17BUP5+wReGwUAW9B9BTOzmwBawkUCiQIHBu0E0waWvy0Ctw1zBMg7kQKt8O8Gv7e9AOowtwfw17kAIA2LBn5cVQMi7ckA=", - "encoding": "base64", - "path": [ - "x", - 29, - "data" - ] - }, - { - "data": "/T0ewRDRFkBBxwzBdyFfQJB0DUA9slXBR5AgwRFH2kAx5rG/lB0BwWKCp8ASeKnA0XcdQUq9AkHHPbtA3Awnwf2xZMEtZyFBVLp8wZ7bhkDr3RxA3BdtwVNJ/kDTVFTBXpqCweClaMEYUai/3Y+wPyReR8H245g/e2WaQK5i8UD2+HNAnl7hP0wtAsHFKWPBEiASQahjrUBdRWXBrkeNQFAO2kAR0QpBer2IwK32wL+XxnnBQCiEwVuzKMGzHTzBJNIMQRYweUDswghB0EIhPCOn2kCu9LRAqtnHvt2iCUE/PT9A4zXxQF1pp79wqSHBliQdwToeEEHKHiJAhv7QQB5Q38A9iAdAGqngQK+X9UDIyLRA1ZT1PyV7h8HqM0nBGGfyQHyQ6kASDVjBxiAMwWb4bMFGfQNBpz7aQAqgVT/2WbQ/SV3xQP/5DEH7ScJAcEURQV5dD0EAg4LBePpgwdRrFEEMIg9BD1iPQFSqCkGBdAJB1NUewPH/8kDCDLlAptb3wIejBMHsvAhBJRrrQPELDEFxCXnBlhkLQD6pzcCy0H/B411OQGXdM8Ff3bRAhJAHQcsBiMGPfnDB14lMwZwiFkGE0fvAJKkYQXDHI8G7oHVAG8LLwI7etD/RliDBxnh9wa/VCEHUZ4bB3WowweAihsGwmYfBVLzpQKhb/T9KMvdAg0Q4wQ9cD0FBU3HBzwwewU35MMHpu2HB2/Ixweae5EDsIftAe/RXwRJbmUC2dlvBA3s3wY2bDEGwqwxAVI2OQNobSMFW1WHAgJ0zvqGmsUD3cEnBJWpJwSgKvUD8wSBACPcDQeBD8UAMcthAetQFQfMca8E0+2lAFA5vwRBvA0FWTw9BHKoGQXqvisEdlEnBERcEwQ1E7ECzb/9ADssnQenBdUDLCQXBjq+PQFv05EBTOJBAlfVkwcUmKsHscVDBvMh+wSTC9EDzVIfB64QKQGxccMGiZ0HB6kV3wRu1EkG2sxpBvq3Bv+GZ+0Cm7nPBaTpewcovCkHedVDB4rKpQCdWXcGCgbZAufb8wGmUD0G6nYLB9xPhQGG+Zz8=", - "encoding": "base64", - "path": [ - "x", - 30, - "data" - ] - }, - { - "data": "rrvQwCBaWb/fm6zAG2rwQDexzEBm9j/BVaPewG2zqkDaqk1AmAGEwPx7cb5aaIC+YGUoQY+TC0F1MG1AtuzewJ3aYcFn/h1BVzxnwXnx7ECVZs9Ah4ZRwd2+yUC7zGHB5xp4wWz3TsEv1nJAa/LAQHcSIsFq4a5AFKwUQPZhD0EfvW0/k33GQO9qisCAN0TBLEIgQXjZLECojkzBklv3QDoiFEGM5xFBPyhAPyU2SUDvCoPBy5ZuwfFC5sAwvQvB0gL4QCmf7EBHzxJBohuWQCKzokBbuAZBiy6FQHGk50CGKudASuXKQI23UUBzvsnAIUu2wHaaBEFS891AZpaOQEqJF8DqO8tApw8DQXkWEEEK0VRAZUjIQJiShcEb9SfBf6q8QOVpt0AkyEDBDeSWwOinUMHs+AFB1cihQEoBrEA+qLe/qpoKQTmFE0FPgwZBFMkGQd1TGkEJc3rBixxywQmrGEEkDhRBfvbaP8BjF0Fdxg9BqQ8RQH0HFEHyBA5BzihkwDnvisCUUQtBlYixQFfQEkFn223BS13TQAfmCcDH/n/Bv3zlQD4QCsEdaFJA0X3gQOeTicGhuVXBeQ0Ywcb+IkHPj2DAb78qQQtv2sCHGIk/1lCZvyPetUBVBuPAoS2BwWTIC0FHUovBvH4BwdsnfcFY7oDBSh2yQOHHxkA9EAZB638GwWF9HUFN7lPBlZGywEFe98BHS3HBgNT5wCXWCUGxnBhBvOo6wQ6aEkBqBjbB6mX+wMXYFUH8l8VAT03+QKgtFcFrpc0/eZSPQIaDBkFjYxjBpakewUbea0BKzdZAsPkQQf+kvEDQ6Q9BfgsOQSk5YMFIzOxAHtR0wTMN1EC80ghBfN+4QLKwisFEvRnBBdiQwHcftEA9cCFBXcEpQRCK60Da33vAGQn7QMV+n0CYZsw/b2NGwdCR1cCaVF/B55KCwbrlwkDNoonB5dvMQL88WsGS6xbBfgJdwV1PIEHLcgNBsIlnQMiPEUHtVlXBRNB1wXNEEEGcIDXBTaQxQP6EbsGb11VA5yCFwIWuEkFoTYvBlFgWQW1z2L8=", - "encoding": "base64", - "path": [ - "x", - 31, - "data" - ] - }, - { - "data": "w28JwEplXMC7xJm/WPghQfN8G0GZvBbBIxU5wMiCO0BDsulAjdnmPn4/mkBcMptArg8hQf5EBEE7TUM/y24dwJeCT8EMSg1BxUpAwf+pEkGR4hRBqhwiwcp4YUCK32DBNMNXwb9DJMHPOwJBA3gZQQze2MC8fAxBsPFKv1JtFkHsrg/AovobQXzOjT6WQA/ByP0eQdaUWr95myHBk1EcQf7JJUHdWQdBcI60QFs550Cgd4PBpSVCwTBsPMCkjJfA93K8QJAAFkEC1QtBcjkHQQGvFkDpJB9B7TgAQY/ynUD3eCNBLY+KQJVp6UBRAt2/o0JAv3bH1kBnpCFBNZLQP2DKJkBkcRhBdBkFQfUmE0HnBoc+TCQbQRwqeMEgnuXAbhJWQA0gWUDs5hnBB0vOPZbEIsF17eZAeD0gQH3lDkF/fmbAodoMQTyTCEFz4BdBvvraQIBXEUGxNl7Bozx0wX4MD0H6wgpBx5HTvzTtE0GhggxBJpfRQFr7G0H/+idBP3iSP1lLkj6l1vpAPMJAQO98C0Ep/FLBxdIeQT+4JUBlF23BYvoeQeWjncAXDYU+Wx+ZQC8Bg8EUzyrBmVSjwJOqIUGAXcE/2p4pQaXCHMD7wfS/vAWIQJlYEUEkOVXAfB14wSriAkEvlYnBS2V5wGo6XcEgvWDBKaYxQHE8FEF0LgBBOpKKwHCdG0HL/iTBQ/jGvp/4XMDGyXLB129kwHQfEEH7KSJBhO8IwcJ3dL/0FfvAT2NbwJUgDUF23Q9BRzofQTyBncCBb85AFhUGQenGHUGr66/AVp7IwGAARz/ayxtBbqoOQd1TQ0CatB9BW60FQZT4RMEINhpBPWlrwQw9hUDDP+pArHIQQDfegsET0LPAqBn8PFruOkDVPzBBF/4ZQflmGkEpapM/2W0iQVnIBkA+fu6/jKQVweQgvb/qeV/B6n1+wWWLbEBSxYTBnzkYQbo8MMEqtrrAba8wwbeZGkEGqrtAFSsCQdThE0HwqyXBpsyAwZG8BEEcNAnBYcU2vzP5c8Gw+2A+wOGjPivtB0EaFI7BelMoQRkVVcA=", - "encoding": "base64", - "path": [ - "x", - 32, - "data" - ] - }, - { - "data": "CWwmQP35mMA8mktAQvU4QYYFP0Hc/7HAjRrWPwyM3L6dqSVBp6aeQIW3DkEzWxFBMuMJQZdl3kCH6RfAktsdQL9hKsFTNeBA3WIIwXBoHEE3ZC1B6mvBwDwOpL6bvk7BctUjwXnu0sCzvjJBBP08QXS1JMARYi5BE5RdwMZND0Hp9IrAVk5CQbaum0DudJDABrsPQaa7g8Arb8zAT9sqQcJOJUGFm9tAq7wZQQmhI0GNbXrB55YDwSdh2D9AMty9VjlOQMt6IUFxJ+tAFLguQZB/m78AiyZBIrsqQR9U4D9AOz5B4BO/P6uAIkGa+URAswyKQOrohUCw8j9BtyfMv4aY5UAr/jZBYzfyQNTcBUGxiy7AzL8/QdW6VcGwWy/A8Iy+PeqDsj7MusjAHOWcQLsYx8DvurFACXkuv37CMUEe6JPAf8gBQRq53EAovRdBI4OPQA5X70AOyC7B/OVjwcXy8EALyulAZGKDwK+sAkFvD/ZA2MUaQZU9E0EQXy5BSvm0QCcJm0DdCsJAeiknvc3A7UBZ7SfB4w8/Qasn20Chv0TBAdE3QTbF+b6vQinAxPPrP0nMZcHHF+HAgA4YvFdxEkFg8shAbZkXQfqME0AaAWjAytsNQUe3M0H3WF4/sSNbwfuZ3ECgz3/BLsp+P18MLMGxByzBEf1+v3uiMEGGY9dAKMCmPukzC0HpJ8rARgOcQD+CrD+CwWLBbw6SP3R5B0FkcxxBuKGHwNQLccA+3lXAg3nJP64r60DhSihBhpcrQQa1gj7UeiRBb5wxQeV8IkHW3FS/GtH2v5JqEcBuTDlB4JH9QNHUSr+Pmh5BkY3eQBlOGMH8lyhBhJZPwX2GSz/Dk6ZAho3dv+N1ZcHVJ3O/QxuTQIjfIb8j9C1B+pH2QOShKkHgS8JA6QE4QQI5mr9AvY7AFNOqwI9JgUBNQU7BoidowcZsAj8+ZW/BC8w2QQxB6cCVeMa/Vb7mwEHXBEH7QjFAsMs4QbcMB0GBT8vAWO9+we7S00BF3ZnAoYt1wCCeasGXoTPAhouYQJyy30C294nBySYpQQYubsA=", - "encoding": "base64", - "path": [ - "x", - 33, - "data" - ] - }, - { - "data": "iTLfQM14psDuIeRARjVAQdyoUUETSC6/Rye+QIpcYsA9uENBlLoLQZMYO0HQkkBBHmjJQEFDnEA0YI3AGurgQAeb4cCjrY1Ax+SDwGUjF0HBVTRBMc2Vv9hegsAKWCrBw3u7wPRSCMAIrk9BaQ5OQWgbAUAmrz9BgZKgwPLq9UBDWKzAQWFXQZP9DUHUmws/MKPmQPc1yMAVzva/Bn4pQfzjFEGpz45ACf5FQWUTQkHa2V7BzFJXwKAIxEAS65BAlMInvo3RHEHvkaJA1j9EQcsbh8AGDh9BS4FBQcFw8b+jVEdBObvmv/LSO0Gozu9AAwUMQVi9CT+NG01BFP52wPefK0HeGURB4uDBQOpK00D3w43ALmJTQdXhI8FO4w1ATmpEwHKQJsAybw3AWroOQXROs7/qIExArvVZwAMzQUFN0ZXAk+3VQIRRjUALighBIiDEP+sCoEAELdjAYkU/wZTHqkCl6aZAVlGswB2HykAlR7pA9ps5Qa9O9kAZIiRB4SIUQb2oB0Gxd19AA28+wPmhqkBAKdrA/oBNQQdiIUFvAwjB6JZAQTMOgUAWtYPAdubBv3+hMcGbDCfAf8WiQAQQ6kBnlyJB7tXsQOSd10Az2YDAFyxCQQ8MQkF+Q55AbBwpwVExm0CIKFrBIsy3QD5M1MDCiMvAWESKwBAMPEHsDpRAl9edQIg62kBQZb6/aOYVQeHCvEBN5j7BgSi2QEzL4kB25whBqhRLP0HlsMC9n9E/6YjLQEFbo0Acey9BcJInQXagrEArEU1BmO1KQdWhF0Ej93tAL0cpQC4hhcCiKEdB5MnEQCs8jcA2hA5BhnuZQHbvtMDK1CVBpyMgwX0sMMAW4QVAh+SVwCMKNMEs/3VAX+kGQfgXdMBcvxtBSeCfQOtTKUHNGSNBto4/Qa2GZMD1fbzA+AIyv2/gDUH11yrBafk/waZ7L8DnlUPBq1lFQX5wMMDE/jtAZm0iwFkHw0D5d0q/y4BbQX8b2UAfJsa/fSlqwR/Eg0DveJK+f8i6wHO/TcF/LJLARiIJQS1DlUD5Z3vBYnQaQTRoVMA=", - "encoding": "base64", - "path": [ - "x", - 34, - "data" - ] - }, - { - "data": "VyooQdXcnMCGeSNB2n85QftyVUGsa4tAuYAUQZTascAWWlFBe9M2QRpMVUEnFV1BzNdNQFjiC0CuRq/AgIErQQb5EsDkQJE/9etNP2IbBUF37ytBtrx3QAeS1cASdujAC+8tv3kQKEAqSlxBXVhPQUy0yEDpkkJBK2m0wHEftEDMLLPAHiJdQcaaQEGYObFATcGUQJIs5cA3/jFA2K4ZQY897EAwdrY/I1hgQa9TUUF93TLB/Lz7PzY4HkF4RAdBMaRNwAKZCkFmCgJArflKQRyiw8B4EwpB/thHQVDsk8A4T0FB7U+GwDYGREHYfTBBgTFBQe5LU8BfUktBqNuawP9eT0HIQ0JBbMB4QOzzf0CkYKTAiyVYQcNLx8BSBNlAtX2hwNjVhcCZNQlApKs8QafYaUAUs4E+a0CdwNyfQEGfi37A4kuTQAg6nz+BidhAZ4bVv4Hl6z/Qjc6/0kAHwabSGEA1Xh1AxyC4wD55dEBFllJAsJ9IQRjUqUAKRgtBcZ45QWwhLUHFhpw+hC2SwDR6HEALJhXAhPxMQQD2REGbLGzAW5k7QYQx/0DoypLATe1vwPg81cBRjgpA2pUXQXMykUDJt05B4pyPQFBDJUEI5GvAKfRgQQB3P0GKmQVBGyXFwCjS/T+1HiHB+LEbQchY1783A5q/6hnPwOHeOEE48Og/bJQNQar+g0B0wmRA7+9JQYPsFkFPnAfBR9UXQeIankALDdFAyIO2QDl3ysCFMsxAGHElQXIHEEDa8SdBR0UVQUulG0FrA2NBpMpUQdV8/kBXcwJB6DjcQClKncAyeEdBaElpQBJU3sBJheFAGY4AQGHXeL8JmhRB6Fq8wGztn8Drcea/GQuwwJLB48BnpQFByjkzQaJsucAR+PRAqt/VPwmHGEGillNBM7o5QfcYhcAEyMrASBGBQOUhSEEv/evAWcEEwc5Sm8DClAXB4hxGQc6pBkAsJuBA6cseQHFoTEDDGnrA6EVsQYw3i0AEVV9AZvI/wXp8ej8tDolAFDjcwOwZGcHAtqvAu9E2QSw2xj+zzVDBMIn6QAaEGcA=", - "encoding": "base64", - "path": [ - "x", - 35, - "data" - ] - }, - { - "data": "uHpQQZrhfsCelERBluQlQYjdS0H1QwpBFVY4Qcxe1cBJkVBBIWpRQQ6ZYEE/xGlB69XBvpI0Zb9qz7jAnJBVQV8cO0Ct5hXAqn+zQMX0z0DnxRVB3xIGQQwB/sDFDEDAcz2TQIWY30D2uFpBNMRCQc8XGUGInDhB06SvwA0FNkA4SaPAcO1UQaTpY0EiwB1BxVixPx6i3MBUxuNAQ+D4QCHxlEDhD++/NY1rQRsIU0G0ZuvAbjTfQA6fSkGgmDJBshabwOFW2UCAiLu/pOlEQdgh4cBkJNFANDZAQSeNw8AV+C1BgB2xwIzFPUHxFVZBIVJhQQfhu8AGETxBcD2fwFecX0G5UzNBRP+XP+q6Oz+p5qPAQopPQd+tw79ljSVBqa+9wEiHmsDf5cVA6C5ZQZCSAEGQQinAFA+vwNpXMkFCWyrAhu76PxKqCsDJ4olAO7OIwEQP0L8kkHNA0Ut+wDVcjr8D3Um/eYGrwDWVRj+vxI8+Zw5KQT+eCUDVx8pAvxhNQQUTQUEJ/DXAtkCcwHVwg78tRh9A8W0/QUpGWkGE5M0/JGYqQcLCLkFq2IzAXsuRwA7Zrb/Yl9JA3AxLQR9oSz+tx2lBfUNrP1PbTEEz+zbAuCZuQcdiLkFKeytBn+lQv2mdwr+LIavAk55KQdppYUDlnINAKF7ywKy+KEFVSa6/r2s6QfhDNz+SQQBBa0BoQfeJOkE7nIDA2DFCQfjAB0ChOnFA7vAcQQ9UyMB+jCRBlIZSQepacb/3gRNBZlDsQAKUTUEYMGlB+xRRQUjmtUBXRzRB9lckQfWFnMDlmDtBiaYEP2hcA8FLC41AZjyRv3rPd0DUke1AEqdxv9D/xcBjjZjARjakwKBECMD4ADVBmYRPQUno18AgMZZAfdf0v4XV80C2h3FBYrEmQUPfdsCQir3AdogDQRBDbUGCKk3ASwpfwP74vsC4rVzAppw6Qd231kCW2yFBpNDjQLU6Jb4ZzqDAVkdtQSDQoD9eifxAVeUAwSgUFcB/OQFBpbviwGBnncCiOK7Ad5JUQUJq+r8plBPB4M2kQOYfkr8=", - "encoding": "base64", - "path": [ - "x", - 36, - "data" - ] - }, - { - "data": "Cp5pQSuwIMCVo1ZBmAUGQbYHNkHvqTxBBOtMQQ1w38Cs5UJBK41dQVMJX0EtlGhBCBJuwMLwXsD/r63A/dNvQYeA9EByPIfA4BoaQUGTgkB/P+ZAruM9QdXQ/cDOo9Q/gN8SQRwVJkGge0xB8sIpQb8vO0HqCCNBB52VwB2G874Fp33A6MQ/Qdb5d0GmFVJBEjUKwPUHscC/8ShBkmilQOPPoj/VFIjALWdpQWVWSEEUiCTAFvAuQUt5ZEFLX0lBX/yxwDBiiUD3cIPAbHYzQfDz4sBgd25AlnEsQR1P1MBTxg5B9bXBwHsQK0GetmdBFD9uQSl07cA7YSBBpdyPwK9yX0HGyBhBSzjbv72AKcD2vpDAM7Q6QU5nV0ASBExBN5u+wFKamsCYzxVB5ChnQXefMkGzoY7A+wSpwLk5GEE2X2S/RIaBv+HrjcAh76o/n0SswOS0jsA0dwlBf1OBP7xKcMCIDVTAvxWJwJduF8DAIi7AMHs/Qbb1tr/uKFFANbZRQfmDRkFfyJLA9QGMwFl9d8AzKt1A5j8mQSCuYkHnZNZAECgOQZ/OTEG4DG7AwMGRwJuzhEApRB9BxOxoQZt4SsDyOXZBpWoywAy+YkFWI9m/Vn5sQX7LEEGruUBBKIWVQO/Jg8AMRyI+eWZnQWHhAUHn2A1BLnP3wP3iDEHPJnrAA2ZUQTZ5McDP3TNBod5zQeh1TEGWfnU/QSdYQVWBjb/K1tI+6JxMQTQ5rMApKlBBMGlrQVOsccBRS+dAIxSXQPa2akEAiWFBTSFBQf1pMkDUTFBBgr1HQaLhiMAreiRBJtoowAZKA8E9UI8/NlFqwB+QAUHPA5xAS6aEQH2C0sBb/tPAd16CwMjHSkAtsVNBCpVdQYNy2sASFH8/6YyVwAuNnkAux35BmUUGQZDqQsDQCJfAQMw1QcL8fkFStK8/Mbv2P0PlycCzG/8/EvIjQSymKEFY10BB1d4rQVRWWcDFyZfAW/tfQX0YBcCPFDBBj95GwHe3k8C7TSxBZQXQwCfqBD/4m53A9AJkQVr+jMAa+IrAFwjbPzrIkT4=", - "encoding": "base64", - "path": [ - "x", - 37, - "data" - ] - }, - { - "data": "kjB1QafXEb/eD1tB57C0QO3oFEHbSF5BszdUQWKz0cAamSlBFMtcQX/6UUHy51pBP02swO1akMAe9Y/AaDZ8QedCNUFyoZ3AYllHQZE+mT/DwYpAm7dhQWHF18Db3MNAjLdIQT4RSUE2rDJB8IkFQT9MTUHY6AJBflpRwAVwY8D1fg7AHH0eQS0BfkGBiXJB0PSXwE0MTcAh0ExB53vxPz0BFcDb0p7A0RZbQcATMkFeQilA1N5XQT2AbEHKRE9B0wO0wIz6pj9oHKjAuawXQYy5ysAxjrY+9BUOQZERzMBfMcpA1Ea8wPSSDUF+1mdBkfNqQecDAsGlMvJAYqhhwOowUUFi9+dAC6R2wB9WoMC/HFvAKpkaQU9p90AQZmJBhDGpwJdZisBuUjdBeJFoQVNJUUGcp6fAxAqPwCng50Cpa4g/kupgwAWRpcDeyem/jsOpwIMSssDKSkNBSfO7QIhGn8AYvYfANS4lwNHghsD8v5PANRMqQbM0jcCCIJC+lK9JQRuQP0EsFKHAh/VTwGUKrsCUXiVBxp8CQWEWX0Fj+i9BdtrPQDa1W0GgAynAhUaAwCn/EEH0cEBBGoxzQeF7vsAevnVBS+GqwE/uaEFY2qW+kcVdQREy0UD1cEdBTa0XQaGWtMBBgLRAm8xzQYOtN0F6XEhBwPvfwOy5zEAFXqXA8S9eQadAm8BVV1NBLLZvQUK3T0HQbLpAqnFcQc4vccCztjzAh6tpQUXybcAQT2hBI3hyQTzFocDvtpNAGDy7Pxz8dUE1d01BOPQlQUDdA7+eH1lB3pVYQa84TMDn0QJBnCKTwMTm3sBvPBfA5F6RwLsCNEGPDuM/FuAKQbBmycCqvPPAn+QkwIn//UCc0V9BrrBeQbbZw8AzuDfA0ZCtwGjo2T8+GH1BGTWwQPg99L86hjHAT/xSQTQjgEGGMblANyLgQGD3v8Aes+JAmPwCQVvgU0EPOU9Bg5VQQa6gp8Dgxm7AJ29FQbHgisCFa01BR5MQQGcVrcAY9EdBhWGkwKEEvUAVS3jAvW5mQbK5tcAYpJM/iOoEwASi0D8=", - "encoding": "base64", - "path": [ - "x", - 38, - "data" - ] - }, - { - "data": "rFp0QSRTwT9y9lJBsfkOQIgX00ANk3FBnqVPQURirMD+0wVBbFVQQXRiOkHSx0FBcJS0wKLdjsCTr0HANxV8Qdh3XkGEAp7AbVthQR0V7b8Gy28/t2pyQdhSkcDDeR5BNEVpQR0XW0HvLw5BLLuuQOrfUUH5sbJA2Watv/dqscA43ZG8RuzjQAbsdkEz9n5BTKPBwIxemL7EG15B453dvzjXncAUPZTApXBBQRvrEEEYquxAGF1sQXaYZEFOK0dBUTelwP0K77/FWq3AFuvkQB/TmMC4VUDAUDXNQM1nrsCJj0pAahujwAy+zUCewVhBYqVZQZ8VAcH9dY5Au0YKwL6tNkHx2YxAwGCVwN1Ww8BfrvG/uWvgQBdRL0EL+WpBDNGAwAKMWMA9YUlB3MheQdNIYEE1Z6jALqdHwGdajkA5qS5A2JCYwH9knsDrp4/AXgaOwHd6q8Dz5GhBNz0hQQDcq8DdHInAevTLvoq1ksAmhKbAQsoKQThiwsDvS2nAsrE2QfjHLUGVw5TAJIDvvx15wsBhYElBlY2rQI0VUEHvqWJBXiFkQAccXUGn2J+/FatDwAwITkF5O1BBbfJtQScV88BmgGlBbkbKwB4FYUF0EYs/HUJDQTf3X0BOY0FBGMZSQUaCzMCw5iRBsaFxQV2AWEHIVW1BTDqswDgGWkBIn63AOwRaQW7rtsAOeGJBONpdQRd5RkHs9SBBOctRQTIQo8DFyZ/As6N2QQ0qqL/Vx29B4A1qQVTbnsCNasI/Th8CwAAcckEaFy5B0HMAQQL/ZMBQGFJBvl9ZQSD83L+ttK5AkoyrwCMNk8AnoZjAnnWLwAitVUFacsu/btZDQYu6rMAyd/vAnRVQv8yIOEEmcVxBtr1TQdyklcCkoLTALvOcwAo25r9qwW1BuBHkP9sUE7/wFGu+OMBcQYUmc0HsAxlBfhAxQVtmo8BwrTFBQT+xQHJ3akHZZ09BzfxhQWCnr8BS5xLAh34eQbq0psCQU1pBt5zrQP8MpsA+V1ZB8Aw+wHIjKkG14xbAL8JcQUtqxMBLOc9A3EacwIizH0A=", - "encoding": "base64", - "path": [ - "x", - 39, - "data" - ] - }, - { - "data": "8fNnQXtBO0DTPz9B/ALLv17oVUA9JXhB9D9AQfrsXMCMxbFAfiE5QRf8GEFoCx5Bs9uhwBRiccC2+oa/O25wQYlneEGuqo7AI0RrQWYshsCQmSXAWf1yQS3Y1b845UtBsM13QbfTXkHq6r9AmZQEQGuzSkE/2h9AWxtaPwwQzsAmJgpA+T1uQMFhY0HX6XlBfCXMwLCNKUAPk19BNcKUwIcEwcAsrGrANBcdQe0hy0CAMTFB83FwQT5sTkGAPTNB5OeHwIRlicDqo5zAZ7+JQHMbGsCACaTAb9VeQMuie8BiZa++2AFvwF7tYkCOcTxBFRk8QRq06MCoEE8/gKcAv36GEUF4CZM/CAKSwGK3xsDgeKq8jblzQMY+T0GIRGdB0t4QwKxpBMCSEE5BZNJKQW8hYkFQTJbAhDaov/HfoT8vh2VA0K+fwPilgsCOoLrAsgNDwLfIisAbjX1BMJ1UQeXapcA/5nHAAY/sPx55hcAu35zA5R3FQInu08AVmrHAQxkaQTxqEkE072vAtLZXvtb2v8AlcV1BzfgFQOcGNkFofYBB/vl8Pq9FUkHIgas+cWbmvyVvdkF92VFB8WpaQcPhBMHBW1JBxIzHwF9MTEGRbAlAyfMdQZSDBj4tCDBBIDB6QT/jz8ALblxBrjRiQbp7aEHU0n1BLZE3wAAMBbq9KJ7APKFJQWpGucB9+2NBz+Y/QfpeMkGVuVVBPF46QQhyrcCfzLjAIZp1QR1wtz+S6WhBeAxUQYiRgcAta+O/2wWTwDAIYUH3awRBAlqjQAEBpsCW1j1BHUNMQQhe2rtcdQ1AJdOowOy0u78k8LjA4/FiwDbuaEGqtYnAg6ZqQcAHe8Dk0+zAogGFP3UIXUHK50tBcGE9QbW2IcAoQeLA1q5swI1wmMCQv1FB5SkWwCk4Uj+DOxZAWGtWQeUPWUE2jUZBh9JeQYska8AGUl1B+PgYQGBebkEFTkNBkKtjQQdnmMB4NiG/szLYQGw3psDNpFlBsIk7QQwIicCbAllBXKINvpW8ZkGilt2+VqtHQcPPvsD49y5BxKvIwJawIkA=", - "encoding": "base64", - "path": [ - "x", - 40, - "data" - ] - }, - { - "data": "Mp5QQWYUU0BAvCBB9k2SwKAKiL56E3NBdtcmQRJdPL/2qhJAdwgYQczp3EA/GuFAROl6wKUTKsBDtpU/ggBaQWaPgkGYHmbALINnQbM8osANF6XAorllQWgpuz+dQmlBGTt3Qf1CVkG6zyVAUz3Iv48iOUE7ZF+/YmUyQAY1zsCYq1tAFT/TvariQ0Fuq2VBEOO+wN17m0BeaFNB6uDGwAyOwsD+zRLAkVrdQCThREDhvFlBlOhmQciPK0ERPhVBNEo7wPYko8C2k3bALCiGP6r2Bj99UL/AnEN9PmAy878RvW7AcSLqv3aitj6IwBRBUeITQTQSt8AFLzvAFQCdP9y9xkAPlA7AVVp2wMqhscARNuU/1v9cPprsXkFXW1hBXNQNvuLv5r7HCUdB2XotQVCSWEGa6GnAcVI/P/oWA8CKKVdA+vSPwPXeMMBOKcDAYeSpv/YCM8D6/YFBoot1QT08kcDRCjnACj5TQKVKUsDN7X/Ap5VKQNfuycASm8HAlEjqQC0s3UDQ5BPAGNe7Pw12qsDwEmRBJlO0v8IjEUGoCIZBEPNDwFU0PEFDuuI/rDCsvvfohUEVmkdBtNQ6QXdKA8Ei/TBBJkOtwIDmK0H97RVAoqLdQGW8TsC9qxRBCPKHQQrtwMC+VIBBPolGQZ6sakFSXH1B4IyVPj0wVcBW4XjAsHkuQS7VqMDqzFlBuEIXQQG/FEEJT3lBKwkYQQUYocBv67fAuAloQSkua0CPfVVBVhUyQcquKMBpjJDA/cyywHFCREFMVaNAEWbbP/gEr8AmiB5B+h8zQWRN1T/Ycau/F+KRwJpK9T9nCLvAQIcVwG2Db0EGMarA1DOAQXWo8b9uIsjAQR8sQN1KcEHeHTBBsh0cQQiLLD7kyO7AsWcGwPhTysBo8SlBJW+wwIZgA0BV6IBAyJdCQaQoM0Gj22NBE/J7Qe4037/xZHdBYJ+Gv3xbYkGIgCxBTjNYQdkBXMDqf4w/EmY/QEMsksAUZk1B3GZxQQw7OcBZEVFBn+QqQFJhiUH4Wco/DbcnQdIcqMBqhWNBym7UwP4Q3z8=", - "encoding": "base64", - "path": [ - "x", - 41, - "data" - ] - }, - { - "data": "G+EuQZIkNUCim/BADJLCwJlccsCCGGNBqCYEQaZgDEDFY5q/uOfbQKP9bkBfLWpAyF8awOP8or8W+DpAamk5QQf9gkFxLRvAT/RXQbMjncAF8cjAQ2tMQRgFh0BJEnhB8aZpQVnwQkGiDI+/37yYwDdKHkHlj4DA9ONwQF04t8ARXFdAJ5F2wOnuGEG0JURBM7SewI/Pq0CiajtBUt/WwEuprMA4Gi6/ZAJdQEkvEb9BOHNBO81RQRlr+0CRjd1A/g+gv2cbmsCELRrA3bkUwCmGTkBxWb/AiYo/wHvX9T4Ht77AE3v2PjyQNsAYTcdAZU/FQMRMVsDa4bLA2s8cQJz4OECO2KLAEf0twPI0icBTxDRAApNXwDUXYUFlCT9BCMX9P+2lnz9DpzVBvnwHQW/lREFmpg7ABMAkQO3MncCYWQtAthVgwCcEkr9scqvA67MJPw6rc7+ZC35BBFiCQVLuYMBxP92/hbpIQAw/BsAuiyvABt4cvoUVqsBpV7TAZVqSQJ0Wh0A7Iyq/DpQxQGGLhMCrF19BNLuRwERsw0CEVoNBUqSswPLMG0EP1RxAP66UP4+hiEEJPjNBcuIQQZDn68DYCgZBLPyBwCj/AEFj7dE/48RcQGjYvsCULOFA8T2LQY+qoMCFVYpBH4cfQaYtYUFBpG5BO4tSQCm5rsB8XBnAROIJQfxlicCaW0VBjcnKQAqs3UCHGIZBjzjZQEqtg8Bbn6TAvhNPQW4QlUDs/jZBjMAFQXXacL+v3LrAfLqxwP0ZHUH3xb4/zWbwv+PWncAQTuxAfrMPQX2xLEBKrIzA66JWwG1gmUBdwqfAV+piv8WxakGlBqXAUbeDQRrgEj8WgYzAAmRWQHRodUEXxgpBO/3gQIg4MUDJneHAOD6cvmj01MBPp+5AXS/vwM37IUCUroZA8m4jQTeKAkEeVHJBUI+FQYk8DD80gIFBaxCFwM69SEFAaAxBJIdBQc094L9CLytAGU2SvxVWX8AzIDdBDuiKQUARmL88VD9B0pSJQBD2lkHQeDtAe/T6QPpbgsDBroJBwwbIwBfa3D4=", - "encoding": "base64", - "path": [ - "x", - 42, - "data" - ] - }, - { - "data": "dk4DQdRS4z+dbY5Ao+DSwOUCy8AJskhB0wuyQDMPhkBA+47AG7twQDIbPz4cCKy9ns0tv6W5eT7xd2NAyEQPQXvme0FRBYK/ghc+QWhyg8CFIMvAl5woQeNmr0BGt3lB3a5QQZ4lJkGIp4/AW5nRwIph9kCWL8HAk4pjQD1CjcAmTRNAPeLQwBadxkCnKBdB9HdewKD7ekBUNRlBcZDNwAavhcBI14A/1q3NvvZlgMBdA4BB978yQWP+jUDsFoNAiDYmP5lMecA8Yy6/4QKfwHh9lEDs2KvAwAS0wN32KkDV1tXAh58lQGVHsMB6TS5ASiEqQJb1EL7D29nAtEkuQBEyLL/0adLAcfGnv7l6I8B5LDxA6uDCwA3JV0EU9htBdEBcQGRHGkAaFBtBHmOzQPAgKEHHkQa/vZBcQPfizcCJZNU+NXwJwN0DHz/hcYTAbFMUQI18fz/rEW1BXxiCQY/rCsDGace+KsLqP6A/Or/lFoy/yRFZwAp9ccD1T5PA2mfAP0MQmT/3g4g/2O9MQAunIMAa309Bi2nIwAHGIkAT/HJBuGTIwO8I5EDbDg1AeV4RQFV+hEEvNBZBdbu8QPYOu8C2zaRAbkQVwCg1mkCT1vA+bZ7DvsZn6MD1iopAW+SHQf3CXsAxaY1BQ27cQFiLTUFwwlNBZcadQEMEx8DLEhq/gI26QKZoO8DbzydBjwYxQMYQhEAPGIhB+5FoQH9uMsAhXYPAxasrQZV4iUC+zA5Bh8qhQCDuWT9Gfr/AWFubwALQ2UDRDBLAOPSewCBGd8A9dY1AeI/HQL7+MkA05sDAzqzjv9OywkDbfoTAPCwoP+9rW0GewonA17mAQdkXMEC97d+/cPcQQACGbkEmLbtADg9uQNbUiUB7tb/Awv3BP+F9w8CA321AwkAIwYMN5j9GR0dApNL1QD9EkUBfXnNBcBCHQRujJkBFHIFBJMG9wI6VI0Ey38hAw0EhQT6K3T1womxAcA+ewMLbBMANFhhBtWSUQQP3KD86biRBYxyMQCeSnEFRKU1A/sqTQIVfHsChuYtBL6OowIqgf78=", - "encoding": "base64", - "path": [ - "x", - 43, - "data" - ] - }, - { - "data": "zZidQKY8zz4mBnw/8/HMwF/078D1OSRBh1gbQExxm0BUXNXA1fyiPv6iVMDPOXDAOVKPP/Gj2z9cCEtASc24QC+HZ0EMWgU/wzwbQdotOcDi/7XA45j3QLYljkDkTW9BFa0tQecTAUE8as7AlYjgwDbuoUBXZdrAmHAbQNEeKMCIkkw/D5j6wGwPE0BdZMFACczPv3h3vj9LwtxAl8awwP+WJMBRFiFAs6GCwBf9yMBb4oBB1C0LQUs7KD+EpXs/2lULQP9sJcCNqpE/9rrCwLVfkUDslYnAdxDbwAese0BJIs3A+1BtQIjX2cCd/n+/RjWJv4DyQUAoI+HAfToPQDophMCoftrAuVZvPrKVAL9LMhpAhlbtwKqVREFxnt9Ai2d3QHjmIkCZ2/BAf9oVQOUuA0FOGKA/Gz1EQGkB0cDLh7i/HZoSv7zZDkB2DSLAeZJnQASBMkCeFFJB+891QXPoE79obH0/8o0qPqf5ND/VUBs/ABm0wGFL6L+dPknA2MrYvwm3+L+OCiBApu4oQN26Bb/ZgTdBumnSwBiWsL/uylJBBUPFwHRdgEC5JLE/ROAbQL6pdEEkkeNAkRUWQHmqacAueb4/IPW+vqqBlT/sb06/JReCwBry5sChXKY/zh59QfFJtL+EZIpB0OpQQBz/MEGmei5BCa+bQP05wsC5KKM/K+gpQDijob8sNQJBsXmGv3aDgj/iYoNBJmBXPqt2lb/1xy7Ac4z9QO/gO0CFxrxA3XqwPy7rIUA4+arAxZtswP+rVUDa+q/A1BPUwAddHMB/UpU/7tFFQN4XDEAQSdLAnAPcPHBMpkD5XyrARvgFQEVvQkGjfUHAfcNvQY2kcECX1rY//c65Pu01XUG/RSpA8GRQvFjIjECOz4zAMQRKQCnsncCGmcu+dA0NwUItzT7MY7A/2xqWQCDhAD/+ImhBPxuDQQxqbUBQhnZBJHbQwK3W6UD2/FhAdbbxQA6O+T/1iFdADMbmwGlO4r7t5OJAjQGWQS90F0CS8QBB0b5ZQJzwmkHW5ylAQJdxP7veB7+QB45BEfNzwLFpEMA=", - "encoding": "base64", - "path": [ - "x", - 44, - "data" - ] - }, - { - "data": "9HqaPwmvg7/WKCXAoDa2wEEn9MDMF+xAGEl2v+SHjUBo4vHAs6ZIwEDitMDX6srAnd4uQHyaMkCYwgdATYYJQLVOSUHKMu8/wF/hQFaCtr9JNpDAaGOPQGX8B0AIw1lBeOoBQagIqkA+FePA2ULTwHK8BEAPEdfAK0JVPyv3Ab/xz1C/F+4BwUy88L9kcA1AelTiPhnXmb/XFHNAGbSEwM3oNr+2CVVAP3rLwDzr6sDVlHlBFQ+5QDI2S8CLMg3AOsovQDFIhr8zoSNAyFbEwOlkWUDnMDjACOPZwOX0gkAm4K/ASoRvQNdG2sCrNpPAZJ6UwOv2m0DJhNLAJJSnP1py2sBB7MfA7PPdP9pTzj8Zxbo/wMb1wCjIKEFtfW5ACq9YQMGL9T/w451AgUmSv8IbrkCsVCtA3QrnP309t8BLNEXAnl6IPxihSEC48jG//tF/QKk+fEBx7y1B7gdbQY+Riz+u0AdA7PnDv1/SAkD4Ig1A0UrRwJiMxD7uF7S/Ff6TwH+olcBL2EVAMHizP4sixz919BZBIDfBwMHPmsDgvSdBxFquwDDJCj8z9JQ+G3PYP2aiVUGYrY5ABTGyv0X4Xb/IMBXA8z/PP6MaJsAMv/m/M33KwNKCyMAXvuu/3odfQcXdgD8M5IFByg8xvwqbDEE5dgBB8t1pQBMEqsCowzJAtw47vya0ET8HV6tAXdqVwJcfC8AxJnFB2QNOwP/JGD/99o6/EkmTQALCiz+y2x5AFIEawFadcECeloXAFEoOwIyaz76cD+XAX83iwDeyT78W8ArAmPWOvq3DlD9YwMzALZPoP+YpP0Bif2y/MDNBQGFfIEGqlb2/3mpTQbgGakB29npA0JvRvwyzQkERJzi/KF1rwP4nV0Ao3hjAcqKIQGE0VMA40ozAJrQHwcJGjb9fwg+/zh2yP8adY8CWoFFBCEV0QVtkdkB2A2FBKhrKwCgQfECq2YQ+l8WTQGHoX0BD+9o/l5gAwYKPnj/Y/4hAHouQQduuWECnHqtA+Oz1P2SfkkEbqMo/S0Q1wMC2vj+IaIpBxIv9v4uTS8A=", - "encoding": "base64", - "path": [ - "x", - 45, - "data" - ] - }, - { - "data": "mM8owD9gE8BiJrTASzqSwIaX4cCvfntAcfWDwEwmUUBZr+7AuSi9wCCaz8DjS+/Ag0xnQJc7PUAFWUI/xMPYv6yXIUGmcxhAcsV/QOOGJj7GGT3AhqFqP5ckEL+Q7TlBy7idQKWQDkDi3tvA9+mywAhKi7+Rq7/AKxJiv7tA1z+DWBXAjqf1wD5ctMDMHOe/RoMaQJ0/b8Bo7ts+5eMZwKfomz+mST5AQnHmwM/j8MCUS2hBIC0iQLIc0sA5AKPAlHYnQDoBEz/SVT9Av/qwwMMj3z8mipq/BUS+wD/hWUAG84TA4pc9QCP1vsBlJPHAHFfrwIq3q0Bq8rPATKwnPvV8/8DahKPADjw2QFAZVEA+no4+GlXmwIeJBUHcn9k91SIRQOcDYz/XJQFAWkyMwHGeFEAzWFJALKxHPsOVi8DnwofA+q4hQErhPEDTQJo/Y+RVQAkMfEDMegFBEzQ1QQ1yDUD4XSFAlK9DwId2PEBe3VNAz2bQwN2MHkD0Iuw+ltvQwPDUxcBLZilAsOr6vTpFRkA0V95AeOeewPvS4sDPF+dAjyeKwMLxPcCD1lq/OroCPw8YLUG4mMQ/PGmewF42BUDhKrLAA8JQQC12vMCJ5zTAgkbbwBQ5l8AwApfA3uk3QdIsPECvwmhBSp6PwKDqwkA8BZdA/m/zP3NThMBUCF9AL2WAwDtGC0DO4w5AFvLnwMeQn8BDYVBBStHGwPpPDUDttxw/vqFnP5KSZr+c6ZC/Mci7wLR/gkCjACrAC7MOv34pgsBZeu/ArSDYwHlNZD8Ls6jA3htnwBE+db3tEbfA0vhLQLLkkD5P+Go/xVo8QKbT60DW+Ds++VotQWU7M0AQ8qNAm4NawAEKIEH6d4DApMrKwM+A3j9ZcM299fiFQCfus79EVurAXJ/ywF0FHMDblhvAOZAAwC4T1cC4xTBB2/lYQZl0UUA2kUJBnZGywPJqmD6dbzjA0JeyP8egiEDHkee+cFr9wIC+I0AzMpg/WKWEQZsLVkCSCg5AKcxfPisNhEGpx48+rsq8wPv9NkA8eIFBJsSvPVP5aMA=", - "encoding": "base64", - "path": [ - "x", - 46, - "data" - ] - }, - { - "data": "vP+7wBfMR8BglPDAbG5HwDPIvsBumW091PfGwFEm2z/A+tTAaF7uwHpNzcCxdPLACA9RQASvCEBZXzG/4tClwCeZ4UCEcPQ/qF8xP5df3T/QhZS/vMEtwP4xTMADrxBBPXS0P3g/g79vz8HA13GFwLlXgsDZ9JnAIqEfwMgFY0AOnWLAaPnVwNqsAMFl47LAbNByQDTiuMC+uz3Avj3YvkQ5OUA1rNc/g3/lwDmE4sBFi05BVmtjvyxrDcExs9/A7fcDQNWpCEAZrB5AwvOPwGMu8b1giRU/BcCRwM6sCEA0LyLAdaPYP/3RkcB8yhHBunIGwWO8m0CJgInAq1GBv9ZB+cBNaWbAATtMQCjlg0B/SHG/+MfFwMEPuEAdgl7ADwxEP0qzjb49Moe/w/TNwEgffr/D3j5AW1a5v48xKsAgpZPAfa1fQBpE8T8MSjxAePryP4hFM0AEjptAMr8FQda6FUAXme4/7NKGwGt7MECQUGNA2Uu7wPtFfEBuphBA10HgwEnEzsBZnr4/soDQv6Y1Y0B1oIJAhgtjwDKIBMHpP2FAC+85wHWBu8Bx8/K/ElVGv9SG+EBgaL+/5f/1wEN3iEBE++jA1+J9QBtQ/cCr81TAr+DMwB1ZNMBQAdfA3zEHQfhQbUC3hURBZoLlwA6cQ0CKZo8/wZWXve2pKsBOh01AOYjTwMHPN0CNKoi/+CsAwXBd08DVhSVB50EBwZpMTEA1mwxA8sc3wKxFMcC66pLAL9gDwYHXUkBMpW2/vDOUP7rw3MC1ld7A7RK8wLN7HkA8p/PAjJ/PwM+ro78JgpXA+T1jQEu7HcCCjyJA3tHwP8sRiEAAhuk/7Cb9QA64xT+tTqhArzuYwJd+7EAgLdjAGUT5wIn+371JBwtAjH4sQIxBIj/ydQrBTEnFwNfZWsCYhn3Adh6mwGsn+cB2lAZBluM0QVo8DEAq+BtBl9GOwCzfVsDs17PAu5j2vxyceEBodiPAe7fkwAZzPUBrSv+/o71lQc2aGED975G/ot7Avyg0X0FBQ4e/5+30wNTEUED6Y2dBLYEGQF0YXsA=", - "encoding": "base64", - "path": [ - "x", - 47, - "data" - ] - }, - { - "data": "KLj5wJqTOsBX+gTB9kG1v6tDkMC3bm/AZWbkwJ6SD73eYavAYj/9wM3UuMACEd/A0EP2P+frPD9ESwTA20/twG8mX0DXr3A/EfcpwMlmREDeezw/SWW/wEuBrsBpUb5A8PsNwMiYhMDJkZrAi3kewM2DxcCDRFTA6y5ywFvRkUCFNIPAlRipwKN+EsGfvAfBfEF/QPzF3MCcO7/ALrDMP/LgckDgsna7Ni7SwFTWxMCM2ixBOIGGwJW8GsFV3+vAMiGfP6Z2WkBQ2bU/vaNLwGtf+79tPBBAgX01wI/sDD+KvkC/UnxXPkdYM8AZ2BPBneUAwYuYcEDN0izAR1kDwIw91sCtk+2/uHooQBrQd0C5LQLAE9eYwOawNkCOAcLA9gVav2rctL9ASn/AIozjwLD8g8B5cAFAaYE7wNaWRr8Fw27AqShmQO/Sxz7++YNAzhOWPTVtej9Mz6Q/g8ucQEAu7j+cwBM/yxmWwLJUwz+4BTZAXkeYwHhTi0B0uGdAJQrPwKG+vMC0uZQ8OVA4wO9iQkBGJXI/Kfr0v0LXCsEPn92+i4Cov1vV78CCpS3AE5z7v21MiUDKGIvAP/AMweBsnUAIr/jAiKBgQFEcCsH4yFTADiqswHt3Nr9sdPHAWDSdQLRZYUDU1xdBhsQEwUI9Pr6dcSPAEpECwGz9gb+6HA1AX3v7wC48J0DgQIbAxODvwN6l3MCdpuNA7GEGwVS+TUCfsEBAxGfBwKXShcAI++fAWY0QwVtm0D9omF8/mv8rQOpOAMHov7vAw8iTwFcsZUAGgwjBs+0EwT0cFcArTlbAqVkoQCMmncDMo1lA+36gPi0aSj/Atk5AUM2QQIqD8T2PwZJA0IuuwHICjUCIqQPBgd8Ewe73+L/Zh3hAn+LRPplyJUCPYA3BeqmIwBygfMBM6JfALJz0wB4b8sDTuahAyo8IQXhxUz+rHNxA8spEwPFX1MDX/+nAmJGgwNFuG0BdV4nALSG9wNk6GkCQ95vAnIc3QUvBaD+U24bAgLBCwONXK0HSURHAk8MFwYFEPkCR/0JB7lthQIunGsA=", - "encoding": "base64", - "path": [ - "x", - 48, - "data" - ] - }, - { - "data": "gwEKwScSh79qFwTBfqTWPoklM8C3C8zASxrmwDq34r/eh23AusPywJormMBP77vAIFgYPl6nUL/UD0vAjRAGwdrq3b6UuEy+Lzy1wJcWdUDB8yFATF0CwSEG4cDbgxxAEdKwwIOS0cDGSVTAYS0gv3gc38C0v86/pn2OwFTniEDoZ0zAJtdkwDrLFcHcwhvBB4c8QH3hzMByg/7AodJRQJeEZkCR19m/3u6xwFt4m8DDvQNBvaHbwNe0FcGVf9PAIeqNPvsfgEAfKfI9CpHXvyj1YsDpO1JADr5vv1xyjb8gv4k/+sylvxJvXL9GzgTBhkTawJKYEUBhkW2/1wc0wHXdoMDIsJM7ryK1PysMMkD4gzLA8klGwLSnYb7n0ObA/A8XwGewGcBDYMfAOqDcwOALx8DX2jE/nxWCwGwylD9WIp+/EqspQGMcl79eCItAd3Tiv1Wihb98MBnAOTqNP2Zdij/xoFu/GhlvwE0J8b1vEbw/0VpXwE6FbUA6V4JAshqpwD48mcAgC7u/8ShvwHsv9D8HqRDAmxYuvl0vB8FDcYrAI7+0PsBPAMFMiUnAy208wGhXCD9tjs7AnD4HweptiEAjWO/A89EMQGb0BcE8ICfAxfB/wIxguD/4yOzA5wWCP8L5LUCcUMdA1l4FwZbMWMCML77A5UNvwDZbNT+Qu0Y/qxT8wEGK5j+haM3AK7/GwNgCyMBuPFxArwbywFuGGUBbkDBAKpb1wL8lkcC89gXBwIwJwRq+1b43QCVAqghmQKq698AZ3YzADe1FwM6dbEDo3wDBjfAMwThZQ8BfYOq/lAJmP0mz1cASsE1AG/Gpv6tIL8DWU39AcTdQP4wCqb93R1hAKsapwJ0IlD/OqQPBOtYBwfheYsAsoZBAcxr+v41BgkDftQPBg6L5v0SlfcCA9HnApfgKwTpr0sCLVOE/qH+pQNwJIr9L4mdAYePAv+RrD8G8I/jAGZfowAg3xz73Uq7As62KwPm3pj9OIdXAaN7/QGfHOr82ScfAqiSBwKtE20B4u0rAIeEEwX4SD0A1kxZBmsR1QNx7nL4=", - "encoding": "base64", - "path": [ - "x", - 49, - "data" - ] - }, - { - "data": "1IDNvqO+pT5RdIs/OBlbv7j4/D41bCi+tBycPjmFkj/mza49tt8PP+dYEz9NKF0/jNy5vRE4OD9yuAu/aHAqPlG8Aj99PuU+R+qyvYAsJr7WOqu99+mTPwuslL/Qcou/7NK8P/OYoj1PzWU/U9YEvwFvRj9Opdy+nox3v8vYMD+Bzm8+jhnzPteGUT+VGPs+Ve2cvz5uf78opzY+S3SDPszYNj6UjKK+M4d+vzanf76sI8e95pKev+s6o77WKKo/JRvaPQZDJb4XjG29nHiSPHVTEz/vmPa+7DGTveBXojx74JW+IewzPz+8uj2u1vi+mBmHPoeivz42yhm/jGNXP5+VST8lbDI9u1pqvqTEXr9N0Xw/dGk6vhHgur6/AlY/xA7hPveCnT9R+Pq+kKDqPrn70r6WB+4+G2S6vR0/MT843Gs+eWFav5AFl767L0Q/BCuFPvgLvD5kqEu/PSO4vR+0gT/ToCm/Tjs/Pj0dqD7gpQ2+dEQhP8tHk76aEby9dlpdPVuUsD51yZG+6Pocvko/wL4pmG0/u6YOvlVAPb9/JNQ/tBK8PRRWoj+GMxs/WiFgvTbrRD/lXxI9oSlhv4/Xvb/18j0/hAHxvuJSMz+nxHE/PECEv3DPiT62gjM/gFOIP/jIMj917tK+YrsMP6LTnb7Bro4/eD6yvfMQAz7E7PC+2XTOPftQOL8EANq9SHHivi3vXL4wyae+LO5+P/DQer5y/b6+ibRTPsv/Zz+Z+gO/WF97v15juz6Qy7q+QQcZPab3eb92Xiq/grywPjpNwL1ztIu/UgM+vj1ys762Nca+Fgd1P0S0AcBef3e+P9UZvt0ZJj8igCw+iy7rPiagtj5SuYA/l+dQP4286z43r6y+V2KbPJmAW770rr28n+Aev/DhXz7SM2+/YekAP0T1zD+Nz6K+x+0KPj80uz9XFMS/6x8kvT3Jlr+fVm8+wKY5PtD9AL/PFYq+GzlnP8yhtD5wZgS/pLTSv7RQNj6ujaW/8HplPyHyxrz/Rgo/gZQsv1On2j+zY12+dF5EPeXzhT8evYq+kLbGPnP6lD4=", - "encoding": "base64", - "path": [ - "y", - 0, - "data" - ] - }, - { - "data": "0YSuP8CN4D9ueRZAGVsmPxr33D80/qk/u1QJQI6f+z9NKdk/V6L2Pxn/3D9GTM0/46A0P/Oo4T/xug0/CXGWP2wz2j8Nmw1ARFeXPx28Yj9knqU/tD0bQITl1T4wuj0+S7xLQNNM8D/kAg5AzuEqPxU7FUBzE5M/njzsPv5alT+vE6g/iQClPwJlB0BOBfk/RhQUP4zfGD8OlKs/R5C5P7pgyT9P420/BrJcPo0GkD9jdEc/cZoaP3SPgz/VChpAsA8lP+Qqlj8yI8I/Ozi4P5El7j9zBIw/tau4Pz53dD+coL8/H64MQMQ7yD8ZYhk/RGaOP8LRoT+qpo4/QtMHQHe2lT/+lcA/Ti1ePzk9ID98Uts/TGCeP24NwT8mDAZAiYquP1HRHkCEPk8+u6WxP6N8cz+2hfQ/JP+pP8Am7D8G36g/QfsqPp70kj9bgRpAopmuP6v1vj9v6X4/MWeuP4rpL0DonIA/ViziP8TWCEB2CAZAJfCZP+EaqD997WA/oRisPx4enz8lQaA/hzC2P+JHpT/23Po/eaaUP7wwIj+8eElApTSpP34YAkBDb84/YMfaPy/GLECIusA/7Kw6PwqY/D2kdwlAoS50P82toj+6qw5At/ttPw33aj9ZguY/70sZQN/LC0DVt48/0qIMQC9nrj8/ETtAjsyQP+scmD/C9Bc/S2e0PzHCvD/3+pI/JxkiPxjZBD8Vg4c/H48nQCbPyz+vvNg/ZOfiP3Cy9T+3Un4/HJkFPxXY2j8z7YY/tzDIPyKDQD+0EJk/NSbFP465jT/JWz4+EEHNPuKL1D4w9b4/BYLTP16Vqb5EPJg/p5DiP0tgnj8OLNU/9PWOPzEx5z8IJvU/AHEZQHeI/D83voU/0V2RP/qtYj9QRJE/X7PMP7YR2D95UoQ/SP3tPyxaKUBr+Hs/+tOyPyPnREBZBCs98EG7P4zQPz5Pxtk/CWuePwVczj9zdsg/JwoMQPfMsz+k4u0/p1WLPsi34T+79KI+6f8KQB6qpz/S8sE/u48MP8TiLkBmhFo/UrzhPygbK0A1qZw/voetP3iWpz8=", - "encoding": "base64", - "path": [ - "y", - 1, - "data" - ] - }, - { - "data": "q5c+QLgyKEC4JD1ADwkiQNn8F0C0oC5Ar3NTQDvjDUBSty5AdhgmQGtPIkBESgBAZYnpPw4REkCcA9M/neQSQFDQK0DPUmpAcW8eQG9uB0BrwChAHwVLQKY0DEBaadY/JUePQAfxRUCjRTZAvvAQQMeiTECLGjdAikzrP/5c1D/m7A9AZoAKQBKHRUBC50dAoo4iQNPaFkBmzhdAvEUbQN2JIkDjTwlAdTLgP74kIUCpRtE/VxEjQMxuFEBZjkZAnNOuP8BTJ0Dz/y1AtkMoQLZsMEBwczJAgvItQBYZB0C34zlA6nFRQCS8KUCsnO4/ixMGQC0nDUDOiD1A4JM7QD160z9RKClAmC0OQE0SIkDhoABAFc0rQI9CTUCwFDtAThsMQDDJVUC6NZk/TBIKQM4cEkDkFDpA3TgnQLleHUArzxVAHNWnP9QBLkBKyF1AKWUVQMmjF0AzNjxAcfsrQMPDekAI7CtAuudEQBsiX0AlDWtAWI7yPxdrNEDbXBJAqqIhQBEbBEAmnDBAszIzQBvANkA+TRpAnWMkQDpDAkCkFIdAu4kfQFweDUA/Pg5ADNJNQEbEg0AYczBA/XAnQGwW/z9VejFAfJodQBdU8z9TLDtA3kQ/QCOo6D8hyx1AqSpbQKPqUEDyVDRAftRVQHgNN0AadoZA2q8UQHy6GUA4mwRA3DoiQBseXEBd5xtAPcUCQKddvD+OYxtADYNpQJtyQEDcVl1AXc0yQGJSGED25ylAlycNQM/+KUBDoStAmGcqQM45NkDBSkNAIfwZQKNXIUBoztI/ifmrP5Ejqz+PK0JAYS0IQFUOvj+2/itAB+9EQH7u6T8YFSZArB/pP9IqOUCtah5AapphQD/3SUBJ2CVA/bANQDjaB0AbnhRA7DJhQManMkCHAkVAkPQ/QP4EUEAe5hRALTkfQL2ehUBm5d4/weQsQAKSxj/DCDdAWhIaQNcYUkCxJTxA4HhEQGeUEkCwRWtAVIUTQF2jMUCdORBAEwVLQE+oJUB4rRFAQIXeP5aVW0Drqu8/rDZJQC/TbUBIsCpAaXEOQFjNCkA=", - "encoding": "base64", - "path": [ - "y", - 2, - "data" - ] - }, - { - "data": "FI2AQGpkS0Cj9T1AnDGIQMNpSEDbGHdA04xyQGEAJkA2ElJAZYA8QL1vSUCzJSNAzENBQGzYPkAPTiVA+ThhQC2KW0DoFZRA6WRmQAWoZkAruGpAowBVQH0Hd0AhyU9AfCeqQHTRZ0BK5ztA7V5/QJ1cVUC7tHxAXzw+QE8IGEACWEBAxhNVQJFgbkDsZnVAsviGQLFheUBwmVtAmm9aQAxsVkBh4E5AH7BiQMnmb0CQ7RpAYtSEQDQUXECAQFZANnwEQKZDcUC5oFtAArJhQLkJVUBk3HlAYKliQEsqXEAnfmJAS9F2QDbFV0DZrUtAhixXQESaSUCqIn9AuwRMQAcoGkAO6VxA7Ot0QPh8h0B2Eh1Akd5uQDAKkkA1Gk9A9H9CQGTga0BzoxVA0hZCQMUsXkBNuVBA95NnQIUzPUDH5E9ARssdQPAQeEDVCnVAFkJMQMjnSkDrZohAe+ByQML7jEBvJIFAtM97QPYNhUBRy5BADms8QDKkdkD/mHdASKJjQFMlOEDPMG9AiKZnQCNvb0D0jDVAZApxQOCNU0AEVJpAT8hlQJ7fI0CbtS5ATDGIQM8cn0Ady2RAX+aHQGXMeUAcVDtA4P50QGEWMkDB+UpA5SWSQGN6QEAkITtApfeDQMJmekDj/IRAk7SAQLMpdkB2KpxAb7ZcQPyPbECk7XZAksheQPFClkDonWZAop5pQMuVIEDvk2lANOOBQFc+Y0AXmpRAxZpXQKRdNUDjsXxA9pJzQE/aVEC1dXlA6q1YQEhXjUArXYdAy19UQCUjckDc2EhAAZEbQKraDkBZmnBAicg4QM/pTEDW6HJAPBRmQPUVK0BFoVFAES4nQOZaZkA7jD1A6fGEQMlCgEBPmnhAehFMQBG3WUDBIF1A3VaaQPw2YUA2fpJAZh11QBbAV0BeYl9Ad1BYQNrJlkC93FdAwFRhQFx0LEC4PG9Al3trQIMaiECmE2dAaS5aQOufS0BQqpdANm2EQO8VWEBLAYZACZR1QCfvZ0CzvkFAIwguQDL/bkC/ySxAtoV9QNZrgEB/RHBA9DhUQBdZNEA=", - "encoding": "base64", - "path": [ - "y", - 3, - "data" - ] - }, - { - "data": "OICKQNBaXkCVtUVAl9ikQPIRg0A7MZRAAjRuQL9YRUApO3NAEJVQQMKbaUCp60dAKPSDQATjfEDsKktAvtCOQE1AekBukJtA4reMQJ4XmUBPHoZAk/VUQBc5oEAoApVAFi+1QJZrbUDhc0pARUadQDHXVUBXFoVAi6JqQP49TkCr7l5AY0uLQBZUgECZ0HpAbG6pQBZtnUBEWotANHeIQNp0g0CocoNAr7agQAldjkCS2kVAI/6aQD8DiEDvm15A8y8kQGbmiEAICntAWg+DQL18dUCj2odABBV+QKSsjkBV3XRANRd9QChddkCuaYtACuqNQKc2dEAd4oJAYgtVQOurTUBj9YBAHfObQPYMn0CmAjhABu+FQIpKr0Cedl1Au5VsQFM/ZkCsdGBAXXyBQGN7i0DBTVtA3ceGQLnqXUBARXhAWCphQCHAiUBCamxATe5yQO2Ic0DiYpxAO2CUQEStf0CHY5tAubqGQJnCgUAds5BA/TWCQAEYiUChspdAV7iHQIEZcEDnvYNAX2l+QPBpgECu51dAjQ6LQD2yikCUCp5AiOeJQPRQRUCFikNAQ4WRQHuxpkCdf39A51qnQIznpUCU3lNAPs6XQP0/Z0DGKk5AveysQLUnhUBxhVFACquOQOj3gkDpEp5ADeOHQIWig0Asr51AnSeLQEKOjkDROaFAdD6FQCtepUC974tA72ObQBGDZkCJIZFAP4F1QBDKa0DEnKFAdo1pQGPmWUCF/I9A9k6eQJ9ue0BOVItARtp+QAgCokBHnI5AauqFQDtsjEDImY9AaD9mQCRwPECvhnZA8XtrQAwgkkB8UohAN1dsQHXuZ0BAfIBA2I9WQD+3c0Ab7GVAZQ2GQHNvkEDspJFAVTJ/QHgSj0DdE4pAgqutQOeNfEBQU6xAeuaIQP2zTUBqcohAbomAQGmmlEDP8JhAxfqAQAjuV0ConYlAGuiNQCgKl0DdGndA+YRhQD8lhEAp8p9AORyqQCdVakAxIbBAQNuEQA2sh0CW029A+LtRQMLfaUAGWkpAxhOBQJ3IYkBvU4pAVtqLQLJYTkA=", - "encoding": "base64", - "path": [ - "y", - 4, - "data" - ] - }, - { - "data": "yc53QCAAWEA4yklA/l2hQCyHkUCs8ZhAUCJfQMS2U0A3oIVAa2daQMTSgEDm0GRAYQWWQC/xkUAU/D9AmLCOQD4UfUCRDYBAI8yRQM1ro0DlnoJAXt1MQEfRpUAhG69AhhysQMaHZkCtfFVA8vaVQHcdVkC/bnJAoPhgQIZ0ekAH0FdA9PiPQBALckAr3WRAJvmsQNsGoUCSkpdA3gSPQJNoikAQ9Y9AOuirQB60ikCQyF5ARnGVQIk7i0CVE19A3dQgQPWqgEAin4RAuW+EQK2KfkBCtn1Aos13QOIvlUDqeH9AfkptQME8e0AHOpdAHxiWQPi4dUBsvm1AAfhMQPiPckAo84RAu9maQIMUk0AXtj5AazOAQL1Qt0AUn1tAIYFxQA8VTkDddoxA1JiTQI0HkUD/H1VAW/+DQLl/ckB8UX9A/E6EQOuUfEAzAEtAb2l0QP+QgkDwsZZAgeWhQJUrSUDkcZtAGCRvQElXWEDtj2lAgMSTQMJ4gEDlk45ALLKHQNFji0AkFntAKLNxQF8ec0AJqm5A1weDQO+SmUAf1ZBAXmKHQJxLXkAIVTlAIDZ4QGoMl0CP0H1A/u+kQLELq0CpimpAKj2bQEmYgUAdkUFA3CinQKEJmEBqZmBAFG+JQLvCdEApk5tASDV5QBDadkAGb4pAoXKOQFXph0BINaNAChWKQOEZkkBa241AjjyiQH+FkEClGptAD01VQJEZbEB5WopAaABhQA7ubUDmZYZAr/+hQIbqg0DPY4JAQX2HQJtnlEAlKnhAcxOOQGUyg0DWC51AaUqSQHWoSkAG8mxAmy+BQGnIokCvNIBAAX1tQAn/iUCGL4xAWMNzQN1LTUCkEHZAnVVfQCH3kECdQ4lAO++KQFBJlECxEJJANLegQKNZfkCg/KhA4OWEQB13OEDTG4lAFymIQIwSfUA/ebVAeCqCQBreSUCO5ItAbjWGQP9JlECTSXdAwZNbQLU0kUArIodAM1ivQIGWZ0DrCb1AQPyAQNiEhUBmUYRAE9A5QKcVU0Ag+DdAAaJoQIe3OkBXJIhAu72SQEaPUkA=", - "encoding": "base64", - "path": [ - "y", - 5, - "data" - ] - }, - { - "data": "Mzc9QMTKKUBlvjlAKVZuQLJDakD6enxATUw+QBg3MkD1G2xAmNpPQAp/cECME2xAFIN+QH1fekD0gss/IhhTQK01U0CogA5Al5txQMP3h0CnD1NAqJosQBPsgEC44K5A0fuKQPLVTEDh/E9AaaVLQIFkQkClZkVA+uwKQMz0dUC3rwxAIthXQKgoNEC8gDBA1hSIQMU2ekBe0oxAwpJgQHaIXUAiJHtAtO6NQDK7SUBV9FVAQYpqQJP4XEASxEFA0efPP8GvP0D0WmhAQKxbQN9NSkDCKkhAdgZMQC1uaEAL0WZAmSVAQPLgWUC1nnhAarplQFe5LkCtlEdA/t8gQJ3Ra0ApX11ADXpZQCf6RECooRtAaChOQDZ0o0BQcTdA7S89QOTeAUAbVo9AbVh6QGaCdkAF6TVADJFGQAnKaUC6F1VAu4p6QCLpPUBNZQtA4uw/QKchaUCR/GRAKt6dQJSdAEB+xm5ASOIKQBQWE0ClHBxAE1NyQHVpSECPsz9ABkJUQLCmgkBatExATVA6QLtaRkCES2VALs5GQGdniUAoo2NAOiBPQOfBW0C9bOo/b0wXQKHJXkAvwlZAp3NyQGYRhkA5sGRAt7NvQMkoaEBVYQ5AlN51QNvDhkCZHV1AmBZfQK9GQ0BgNWZAgtc6QGv3QUDHlEZAkqtZQKlESUDKp3ZAD/1nQPs5M0Df2WlA3W16QHPcikD8no5AHmUkQBoPWEDP7ydADgc0QO/sUUCyOEVAhO52QCjwWUBjWklA25xhQHhzSUAJxjBAOqZkQOGOP0AbjoZA89CLQCOsJEBLgE1AOkZpQMnCi0AMwUZA5AxXQBRGg0DxeGdArEduQIpfvT+ouEVAXz0DQAjhd0B+JE1AOV91QC4jY0C8xXBAaR9VQD4tUkCQw3xANDtGQJPMBEAav05A8Q1+QBZIKECG1rpAFiZYQD4v8j/oAW5AEfBDQEiRfECWp19AZ2o4QK1Yc0BZHSVAkEuMQECoS0DgY6dAFYpZQCnTTUBRK3VA0EKRPwBoIkDioro/7ukwQBOo+j++qVtAJudfQA/AMUA=", - "encoding": "base64", - "path": [ - "y", - 6, - "data" - ] - }, - { - "data": "c9C8P485mT8VrgNAilWbP9k1uD+kDOY//nnsP4G7nj/0Reo/ydITQDITE0D8fCNAtO/hP2yq5j8YuiG/Y36hP2E92T/Awrq+ZEn6P1Z++T8oQNo/58/ZP2e/sz8ld5FABLMcQHJgB0DukRhAJh94P1xjB0BWR+s/ykuxvbRcIEAXP8i9BCiZP97smj/6Qro/W6/NP9/Euz81kU9AB/GvP5e1wz94TvM/rTgHQHNzkj8SURZAmZniPyUV3z+bRvc/dt37PQrPtT8+4Pw/+uTjPxymlz9h7NQ/rYnpP42HtD8HG/Y/kAC0P7SO+T9uSgBA8hemP6eI6j5HZPU/PEmRPzMCEkCVGdc/Vjh4P5DRfD94Io0/R87YP0yAWUAOfMg/LRqnPyFhWr6Hj1pA1eDeP9cSDEAR7fU/VS1tP1sCEEBcY9Q/9sQbQBKmwD+h4EA/NDm1PzDp9j+DF7g/CYOEQEmP8T5HJ6Y/47savxaiYz/tMGA/iijKPy3UyT/pSog/JDTKP+UjLkBUht8/xom+P6+W0T+mhh1AD77HP3roG0BzYgFAPVXCP6+xFEBQIei9ROB1vEKfwz8BBwJAZ4iuP4XAyD+sQw9AnROuP0/68j9l5wo/adSuPzA6DUCFgyRAZ3D2P5mRnz/8faM/SbPFP7JOwz/91qQ/6JiUPwrdsz/aaaE/fpL5P6YOHT/9BfU/lTOxP4k9N0C+m1VAHtGwP/+yA0CPXOo++yPQPxzL4j8jfbU/D4LFP8GKzT980cc/kjXMP4JqeD/NNqo/SDPGP751sD9fgyBAWtY3QNejjj9i2P4/2k8PQFNSEUDPyLw/aiwDQFjzG0AfAcA/KVU5QOKxdL9DlZM/fhz/PbilFEAKjbc/WXAAQDaAoz9Hoc8/311GP/c45D81J5w/8B1XP3rREz+Ftoc/HuZCQPxCLj+UZKRAKRfdPwBeczs53AVAXsG0PwbPKEA9rA9AKZrdP4363D90yxg/KZTsPxBh/D9WuVNAhTgPQCVkpT+Jwh1AjAGkv9S9qj+suC6/dsykPxCGGz8Apug/AIKhP4xTnD8=", - "encoding": "base64", - "path": [ - "y", - 7, - "data" - ] - }, - { - "data": "/ienvnjMDb9MOrk+Rmyev6G/c79H3Xa/0bsFPSyyLb9gsjm/TND7PvB5ZT2KM+Q+vUZ7v5dRV7+mtC3A6bZZv+Lp2r62hzTAt36/vkG1jL8LrOO+uEm9Puw02L+uKTtA8glBPTjipz6EKw4/SWKOvzZHyj6y2O+9C6AUwIS5Qz4PExrAWBh/v31B9r7wtJG9pQzFv6oBtb8hvbw/nf1rv/i2Mb8W6ke/teFxv8PbN78Ibw0/ZEAQvyyOkr5q9sQ+dqKyv66flL5Gq9u+rSAAv3tMk7/SCIW+0tgvvklljL8Vbh+/UB8av+S9dr513py+ykaWvwRZ+b+OWPW9o4UCv5U8lT2laCG/tQiuv8ZTgb/xYQO/eB69vkyQXz8ijE2+Xp0Uv7SMHMBfJLw/M/SAvyCX372F8q0+tgLNv5onRb2sMBK/lDzXPAXaa74akx+/NazPvq2AAL/BaWS/j7MwQC/Ggr++Ire/68FOwGXf/L6Suhe/duWCv4Ti1r4NIS+/zrn2vgKBIz+U6qK++Cc2vn9IrL7AUPY++k2wvvTXsL4KFEE+blj7vhCTpT7GJAPA288XwNsTMr/88mU+jmulv4Bjv7965RS+peudvyxK2764P62/PUWvvx8pL79DsGk/DAIqvfYdfr+3N56/NHW9vcp7r765qD2/0rGwv84N+74AXqu/FEGEvkMIsr/NyuS+MuGyv9DIDj/s/t0/OGI5vapccr6Rjsa/9tn3PTZBmL7e9eW+TpSIv7ClGL9kWMW+MrJBv0NXj780Eh2+fLNOv46yor6pP4E+0fUhP4kxIb9WL9m9SVPavbziA7+ySOW+8p0dvoc/sb1Mb2G/bUS/P3f8ScBssYy/FgnOvz7hHz75zBO/NL8av4nTob9w9HW/hnDPv+IygL427Mq/kYPXv+w3jb8KerK/MgrLPx0voL9sWmtAHlD4vliV7r+d2BC+qAGxvvX4bj9clKM+o8M/PpJXWb/h7KG/caKlv5Cgxb3rigI/4ihFP1arU79FY2E+fYFbwKCWY70ZvyrA1bO7vkpuLL/xIze+QfB4v3iiVb8=", - "encoding": "base64", - "path": [ - "y", - 8, - "data" - ] - }, - { - "data": "58UUwPbiDcA6Itq/6kNLwP66MsBTHGHAB50OwFQtIMB0JkLAb8TSv2bUH8Ae1gPA7dxQwIUDUsC+PI7AjqEswG0SJMCod5nA1kEuwDRsasBhgCvAHSqMvzSpjsDRMGY/55QZwMuq378lmNO/fusywE9B3L9rZSDABS+HwN3EH8BDMYrA5ScnwAPfB8BtFs2/6PSIwLoCgMDwrBO/ETA4wFKaLMDbX1PAprtowKoDFcC/Js6/h/M0wOGQE8C0rKe/7o0vwJNBDcBrEzvAHDAzwCL4UcAnpxjAPs4cwDBESMDAR0HAG/khwE39J8BRYyfAkRFWwETZgMCEbCfAXOgFwEwpE8BCQTPA9/JKwPpaLMDQVwTA8r0mwMyU9r+MNAzA+uUXwDkvicCER1i/dVNUwDB3J8ADosG/haR0wPJJJcDZji3AAtEjwLrhD8CNOPK/0wERwHFnOsC1GUDA4bt6P7OpEcANlXXAv+KowPoq5r+QqP+/iZhFwEGTGsCuvg3ANbohwA1p278ZZSfAwff0vzVBFsDdsuW/PtwWwOEDTsDDVNe/xHkgwJ798b8ARmvATv+IwKZcNcB2P+C/I+BtwDCUg8C76jXAhyxdwD/PL8AplEDACUxtwFI7W8AS04m/LIYCwFhgRcBSXmTAQe/ivzM3FsCscSrAdf1mwBiuGcB0uVbAY7siwIQ3OcA+pznAFI9ywDPLA8A3LdW9PhfGv4dDOMDxy0LAn5DDv8OMF8APvBLAw3pgwO0+LMCEOx/At080wDTwNsBVd/C/+UkzwA2vDcDPagfARxLqv9OXEsA2iSPAXaAtwGwXUMA5cRvAgqwlwGolLsDEezDAiikuvvRkncCFtErA5lk3wNAACcAqnSHA0YNLwP3qXcD6A1HA2rlkwD8cIMCT1n3ABz98wBwUJcAqv2LAM3A1vtEqKsCR8Nk/uvwswNanYMAYFR7A0twRwMQjbb+SXPG/O9i9v08ISsBrEzLAUVqCwCKRKMAgziPAzkNOv2BDI8CvSh7ABNekwAkZur8nhInAsZcHwBL26b8x6wzAdNguwM64L8A=", - "encoding": "base64", - "path": [ - "y", - 9, - "data" - ] - }, - { - "data": "gmiIwMNbZsDG+XHA2VqUwNhOhsBHY7fAMXaOwHjmgcDdvJnAiaRzwOhnnMDG95XAgw6cwMwCpsD2k7bAnhSHwAhmkMD6mMfAou+awOZIssDSSpTAHhciwPB808BvSJ2/KcuSwHvwcsA0w3vAztKDwKypdcBzjJnAXiK0wMvJnsBaGLbAeYh8wOR8Z8BBGj/A5MzNwLOvv8DKzibAdueLwHhgjMCoBavAyem0wDAtcsDK/W7AyKyWwI3fg8BudT7Ab8Z1wHj7h8BrGJ/ADO6XwAyQn8DRTo/ARhKVwJPxlMBY45jAgLCFwOpLmMBDjJXANOSgwEcbssAgHp3Ajr9dwCAUkMAW25HA4pKMwLSIgsBCsVrAhmGUwE2+k8DwOoLA2958wNqftMDWBE3As/6hwJLxncC0xVPAnwexwHt1nMDZuo3AdEibwCjLicDm10jAIa56wEwpncC80JrAEGZwvwSIVsBVArjA/P/UwKXvQMAqtmPAIiyRwM1Ph8CsrnXAbBuNwCplgsBBnpbAFdlcwHkLhcBJa4DAfFeKwK4MtMC94FfA+/GLwHZFgMAjUJzA6R21wKWWlsDDKHPAw0S2wMsKxMDdK6PAZNSmwMg/msDc1ojA0bmtwLEfsMBG/UfAhPl2wKHRmsCBFbPANe1VwEOmisDDBIrAD3iqwD9WicBDcpjA3E+UwO4kfcDdfKHANGKzwGXklcDHtPm/90BBwAaGosCvvYHAET1HwBqkhMDsxH7AjheywEIdj8BiT4/AIMqOwFKZicBalG/AjZqLwK/Rh8Bdo4nAGBiGwJvUbMBmq5rAzpGgwH36sMAbb4vAtROawJmWpMA7PYfA1Tjtv/3mxMDCY5fAesdtwFkHisCV/ojA+KCtwPBtpcB3caXAr9ufwL5lksDuyLvAu6y4wKJQb8D2oaXAydv5vxWdcMC6Ve++D9mWwCmBmcDlrJPAJVuKwJAJLcBNbIPAl0BJwJm3n8BrdHvA7RnIwAgBn8DibKvAcIcUwCKggMBpQ6LAyJfKwF8aMMBY1q7AisR1wHlbQ8BGQ4LAUmGEwJRLiMA=", - "encoding": "base64", - "path": [ - "y", - 10, - "data" - ] - }, - { - "data": "i1i+wIvLkcBie7XAEc+2wBLArsAzPPLACVTMwMmWp8Dze8DAeeq5wAVR1sDqhtvANpy+wAAFzsCUo8zAYkmwwKCfxsBOLOTA1izUwNTh2sA5rsPAUzV2wC6t/8DUaFLARELNwDyhtMA+scLA/6ypwEgvuMB/pNDA2/fMwH1z3cAFhM3AcSKmwO5UnMAAD4XAivr9wL+N5sCs1o7AEhSywKzWuMCTetnASrPhwKn6ocBuIbXA5OLFwFpVtMBelZHA2AWVwAMdxMB0dM7A9cjHwFn4xMDp0MbAnSjNwE0mtsC3wL3AkZ6twLvly8AbHcvAUSHHwCAB0MDpVNHAzzKQwM//ysANIb3Amm+pwEMrqsCT843AiCrGwNHY3sCm0LbA3g+kwGrbzsB4dK3Au5XHwILt2sDZcZvAq2bUwLdl08As0bDATVTVwDdBxMBoyYjAhtmlwOP7y8A3E8zAF1oywC4DicD0EuTAPK7pwFkpgsCN4J/ACH6zwNxousAYEa3AqRXAwF6OyMBOK8vAqiCUwB1KtMByNcDAtSvCwBlt8MBqj5nAj9G+wCg7vMDAI7PAmlLPwB1ByMAVK7jAkNvkwOkA8cDIkNTADMXOwOBN0cCkH6LABnDSwOff3cAvnKLAzrCtwLVsxcB7QOnAcAqXwNy6wcCNw7TAuqbOwBy9vsAgArbAsYPMwB7MncB0QdrAyCvbwJcR28DRlGvAWP+LwOVM08AsnpzAkx+RwBfwrcB0+63AybrkwE/vusDp2sLARfy3wP4Tr8Dk4rPAY3O0wGS9w8Aq/sTAGHDIwJRyl8BcNNDADJ7awFxa5MD84sDAAtvPwIyn58C2F7DA1fRbwP6g2cC6urfAccqGwC7axsABvbjAl1rowDh4ycBA49PAkLK8wGwMyMCIqOjAx+/jwFHqkMB5tcXA33llwP/vlMDNcCfAEpzOwAUBtMCxrs7A4MnEwHLKiMBq58PAtQKWwOqpycAqOZbAPUj6wMnM1sCqrPDAxiVswJy6p8CxGOnAf2rbwHOLecCGfcLAS8yrwEIUhsAw1LbAbv2swHElp8A=", - "encoding": "base64", - "path": [ - "y", - 11, - "data" - ] - }, - { - "data": "go3owIepncB7Z+fAh4XPwNAK08AnLRDBEo79wGrrvMC9/NfA+/7uwC0C/MDO2gXBNr/RwHTn4cAcE8zAqwXUwA6Q88Dxi+7AsK4AwTL17sCkX+LAEx6fwA0yB8FXjqXA2Ov6wKY15sA4hfjAi8LLwO9y68BGtfHAM0bMwPgjBMGqI8zA1hPKwDKbu8DZqKLAeRQMwRmr7sAJ6MHAB7nPwM2I2sCLVvLAkt77wIpTw8BhferAxWvpwNEb2cAUwr3AaqOjwH8H8MDuROrAyd3nwCxW1cB2T+zAXCTzwIKXxMAzKNXAAwzFwPZ77cBTqPDAp8zfwJAM28DuK+7A1reiwGNq9MDB6NvA4nm/wNW1zcDwXp/AXHLlwFXaDcEY8OHAR+i3wESy1cBTKuvAMZfbwH1LBcFZQsDABHzhwLuo98Di27nAlDH9wBlp7sD+WabAQ0C+wOzu6MDFQPPAsn6OwHANoMArNP7Aqb3jwEl5nMBSzMPAWGLMwM0X48Cs5tjADUjmwGa2/cBB6ezAA0CqwF2T1cDqFfbAjnjrwMDUDcGNnL3A3w7lwD5o7cDK87bA0WXWwMcQ78CBp+zAWCMBwfS9BMG8n/HALwDlwGfY+sC90ajAE87nwI2Z+MBbENrAN83WwMZy4MBlJwrBjiq7wFF17sA9B9XAUrDcwNgT5sDxcsvAkW73wEHRtsBQOwPB37jywEI+BsH0DKfADtmwwIMi7sBt+LHAfH23wD2TwcD8W9PA/TsDwQyO18CkVubAKzjYwF5Wy8Da2ujA487VwKCL78DPre/AMBf8wP/Hp8DQG/HA0TsBwe+M+8ACyOfAOF/uwO1BD8G/G9TAhkGbwMZq2cDB+MjAFLaJwJax+MCK693ALCUKwXry18BJzvHAdmHJwMcD7sBJeALBP7H/wEVNnMBqWM3A4QSgwDEvqsBgvJPAr9f8wIfWu8BHAP/AoQ7uwPNYssBdBfjA2BjAwO4P4sBsQaHAS2sMwb/R+cBR6BHB8sSbwKxgxMBt8RDBSf3RwMnDm8BGk8DA/UrTwJCUosDABOPAtbfPwB41r8A=", - "encoding": "base64", - "path": [ - "y", - 12, - "data" - ] - }, - { - "data": "DPsBwenPjsBKXAXBbO7fwJx978AzfCDBahgQwQv+u8AC0uXAHfUIwW/jBsHR+xLBiALVwKb65cBEFK3ANMruwIQoC8Ggi+XAfMMQwW0878BlJvDAi3m7wNXV+MBH/9nASpsNwdoVBsFzkwvBR0HkwIggCcEVafrAG+iowGw/DsHcMarAvzzowDdnz8DlbLfAgU8NwUqzz8CjWurAu43iwOHn78Ap0fLAUO8BwaxW28DUPgvBSpkAwYFk8MDTP+DAZdOhwO0MA8GGdfHAwY32wK6RysDKxv3AugEDwVlRu8BlYeTAlwnHwKwt/cDjIAHB9ILrwLTn0MCEjvPAVdigwJEIA8FYI+7A9+LMwGTj5sB3KJvAA5bxwHDcJMF5FwHBhQW0wNZtxcDLGw7B9VfjwDZOFsH9k9PAO9vTwCpXBMF4VaDAUk8IwbfSAMFNvrnAtuDCwC0h88BA5AfBu+a7wKYJrcDPqQLBKCG9wLtFrcDnHtnAfXfbwOG2+8DGZ/nAFKX9wC/FD8EPg/jA0iGswH7I5cCpNRDBLRMBwYwzGsFUe9fAWqX6wO68CMGnTKLAngrIwPBWBcEiQQrBI6UHwe+0BcFqQ/zAiN3nwP15CsEni5fA2HbvwPJTAMEJmgLBMST2wP6s6cCv+BnBF8DVwAH+B8FIaurABOHOwBH4+cAv39rAd7IJwRoZxcAzwRLBpo77wMLwFcFig9DAEanMwJuk88CTU77AiD3VwP7YtsCt/+3ADy4LwYQm48D9g/fApDruwDh33cCOCQXBxwPtwIIkAsFfkwTBq8MOwRDDoMD0x/3AFRILwb3J7cCmi/rAEJv2wNz0I8G2ifDACpbBwNMRwMAJ18fAY8Z5wI5pD8H+3fbAc+MXwXrdy8CIqfzAiG3FwAHZAMG+3gfBUpkFwWiolsBDv7XAFmXEwCA1t8BNNszAC28Qwc7lqcBiDRLBqw8Awfmx0cD/aw7BBrXgwIMT6MDJv5zA+JsRwWKCA8FUFiPBoGW6wIDM08DSzSXBRcmjwMtVtMBu86HAdpXuwI7GssDRDAPBtI/pwJp+mMA=", - "encoding": "base64", - "path": [ - "y", - 13, - "data" - ] - }, - { - "data": "5ZgGwYEUKcC2wQ3B4fHnwLkf/MDtiynBeDAZwTn0mcDyGenA28oOwY6GBcHAOBTBC0PGwKek3MCQSTzAxS76wFf5FsGIxcbAftgZwfiW4MDHsu3AvMHOwKPFs8C6RALB5doWwQlxEsGpkg7B8cLtwMNWFcEQUOzARu8jwNJcC8HXJC3AZu76wGwY1cD6acLA2VkBwSa6ecDPGgPBCqjowMoj9cC9IOHAXp/5wPm56MB1IRzBdGgGwVMm+MAUePbAa0+HwNluAcEjY+fAIrLxwEnwmMBpwPnAorwBwbE1ksBxUOvAt1SrwC5u+cAOJgDBZYrpwFpSq8Bd1ubA5cqAwFs/AMHIj/HAXhHPwPK378AH6GnAK3DswAoyNMH/EAvB1jKPwKiXlsDFHx/BPGPiwMUpIMHzkM/AFIOjwDIwAsGrVi/ANnoGwUU7+8Azw77AAjKvwIpn6cCnfhDBMN/fwPGKq8AIs/fAJ+VQwA/qscAahNvAdsjfwN4qAMHN5gHBixICwQcEF8E8Ku7AV/2SwO8b4cCX7x7BpkoBwXc1HMFsqubAZOn6wKUaE8HWLlPAOrafwEpfDcFoORfBJzUGwfsT88APEPXA5/bUwETQDsEO00bAKlzpwAAl9cDBtQ/Bs40FwSyB3cBi4CPBdBrlwD3IEsFCh/TAYzyawMqf98CVZt/Ah2wPwbp7xMBaThvB1Nn1wM2VHMFJv/DArSDdwKjg58BLB77AO/TowBVRe8AYcPzAFgQKwaKW28BxRPTAYZ71wDxf5MBc0gjBr/X1wEfQ/cDRGQnB+vIVwUQ1bMDK+fTAjZcJwctgrcCDV/fARSDrwOpMMcETb/3Ar6nfwOVthMBDI67AnZo3wDZZHMHfBwHBM18cwXsjnMClD/HA/ECvwIQIAMEo3APBvDcCwUdsdMCczmPADwHewCsau8A16PrAWv8cwdZDX8AnvR7BPnL3wHZ75cCOSxjB5mP2wI5D2sB9c4XARBYMwXZx/MAv6ivBySzRwHqi0sBwgzLB3lTjvz7VxcByDC3AaZT6wKJGscBouA/BoFf2wDsoKcA=", - "encoding": "base64", - "path": [ - "y", - 14, - "data" - ] - }, - { - "data": "ver/wNjeRD/t3QrBZYXgwIe27cCKqyrBDeIYwUQK9b9uHN3AnFkHwcFn8sAe+wfBWb6hwL4uxcAfCZY//DzvwLSnHMEk44zASlcbwTI5xsDofNrA84PXwDdmzb9KoRHB2OsYweJVF8FB/APBxYDiwBdXGcGiac7A5JG4P68u8sBIqbs/stj0wGIkycDomsLATRXMwNb2aj4v1AnBe4nfwHCH48AKA8LAw1vcwERH58A2cSfBptQFwcrz7cD8Uf7ARfwAwJQZ48CtZ83Ao3vYwF1uqr9yfN7ABAPnwPoc87+uhuPAOddAwCAH38ByX+vAI3jYwGJeNcCshM3Ac9/Av7XD5cBb5uDA/NXCwL824sCT4j+/3hTXwCl8O8EhCQ7BlZ7xv/aH3b+9jSfBW6nTwMZXIsFLOavAN10CwDw558Akpjs/K3TuwPW+2sDxla/APjZ6wN/SycAm/hLB/Bf5wPeblMDlU9PAvweIP1tVpsDXx8XA26LYwEIs7MDmfvDAETX3wAMHFMGS/tDALDUowBLDwcB3gibBuJ3nwLQkEsGspOrArTbhwIuKFMFf6q891m4nwDdlD8GEmxzB3VT5wHWqucAuC9vAOaaowIlICcFwagw8pk/UwLws1MA5vRLBMoEKwZTMtMBslCfBSC7nwKooF8Gv7fLA+m+pvz5z3sB5wtHATvYLwWlVr8AcVhzBOMbgwCeqGcHSLQPBUfTfwFTmzsC6DKzAvAbxwKRFlL6XEP3AN/7+wIYDvsDZ+NvAhZjowPOy3sAdIPzAIHXowE5O28BUHAXBQDETwYsAQL/eI9fAsO31wJnJwb9nEN3AAWfNwJCLNsHAxu/ABzL0wPRUHb8IQ1zAJZh1v1PTIsFB3f3AoC8Wwdod4L/XL8rA4hqEwHSL5sA9/erA95XnwMGY6L8TcYI+QCXrwLC4tMB74A7BMLEjweRm1TwoOyXBW7XWwAVp7MAPshjBv9n/wEpFtsBOrSvAmof1wAdZ2cA/GyzBk1ffwMd2vMAlOzbBT1AyQKmLz8AyCZs/lDvzwJtHlcBcLRfBC8HrwCDBQD8=", - "encoding": "base64", - "path": [ - "y", - 15, - "data" - ] - }, - { - "data": "/EvWwI0ggkDh2fTAFmK9wK4/vcAr3iLBX4QNwWGQFUCFgrnAHO7gwLx2wcDql9fAmOdDwPG1m8A6/KBAlBLGwDRwG8FBC6+/uX4UwaHYmsDJrrHAsRfUwJc9R0ADDRrBIWQTwQvCE8E13dLASVq6wMzWE8F3EKDAOjWjQNO7p8DYladATsnLwJSapsDr2bbAkM5fwJz/i0BDZgjBsMy8wHc9tMBF9JDAYMapwBRmx8BmnyzBn9z8wAJPz8APmfXA25TFP0rtpsAGhZ3AcgqpwALYQEDKSavAOHGswCAb3D8zN7/AYAV1P2NYqsA1bcLAc162wJxkvD/QFqTAOsn2Py0YtcBEcbXAmEGjwIVCtsBHbDBAWUquwEE3OsHt2AjBnLbMP9wNGUC0JSbBPPGwwNgSHMHpgC/ApfAHQLBLrMB4rYFA7GWvwOh+ocDATYTAZMSgvxMpkcDGxw7B4yEDwUs5M8D/iJbAtQ6jQGzSgsD6wJDAcLm8wH36t8B0V7vAzFLTwFSlBcHrg57AaHjgPmRwesAVDybBjwWtwCKq8sCu0OLAIpmrwEx1C8EMZGpAWoGDP60UC8FhnxnBUSfVwFGTJMDZJavABAA9wHP58MAstlNADyuuwMium8CzBQrBHnsJwdsPPcChqyTBOUnZwOSKFMFUEOXA7olEQDBurcB//ajAey78wAxCeMDqERXB2866wNtADMES6gfBW6bSwD2apcDAVH/ACG3rwMbkaECs7e3A2x/WwDd9hsBahqzA1pO9wPqqysCEvsTAFmi8wBy5oMBqGvDA1sMFwTrFK0CdDabA5pa4wI2eQEC3VKrAx4CdwFm5MsHHpb7A7Lr9wMCZYEDBOtQ+ZdLBP7dmIsEGWOjApFIDwYgqGkCJPIHAeF4AwKNHscDN9LbAZ3WtwAPhoz+r54RAMC7qwL15osA3ThnBl/YjwTVSb0BBFCXBry6hwMww5cClbQ7BG6T7wCyjccDxFIK+vci3wLvXocA0HCPBAxDkwCFqi8D2xy/BdzTTQAed0MAsO5tA8rzSwLRrGsASABnBUj+/wJENf0A=", - "encoding": "base64", - "path": [ - "y", - 16, - "data" - ] - }, - { - "data": "QnKJwCCp0UDPorPAYVtnwFA6TcDxsBDBwlHpwGhswEAMF17AS6KOwIbUaMC9gnHAIlsWvk+pK8DKPv1AtSJvwG5AEsHzZiBAjVUEwWmyK8CyXFLAonDCwFf+4EBhURrB4a8FwWNoBsE9Fm7AUb5TwAgSA8FUrjbAOIb5QOOgxb//Qf1A7IBuwIGiTsB+2p3A/CoMP+Yg8UB6bvvAJVFhwJvNPcBm8w7ACB86wPgsesAK8SrBLjrfwF8YmsDek9nAqpuYQLJnIcCeDh3ArNM9wAuk00AIBDbAndYrwNdmnkB0jV/ASU6YQAEaNMBbcoTAVwKBwGUIrkDKakLAk5mdQJi3WcCgAUzAe4FLwHVfQcBCSLVAMDlOwNWyL8Gpr/PAp9iXQHF/ukBZUxnB2WNjwFA+DMFAGoI/nES2QPJrJcAQitBA+9cQwKCoGsCyU9q/Vg7tP7qn8r83AwPB9PkCwegzBz8ocN2/Rrn8QKkn5b9u/Na/njN2wJJjNMAArzvAodqTwGvv08DQSB3AdjhdQNaXh74+cRzBb6wrwGFIm8DFds7ATiszwL5+68CAqc1AaNeMQLP1/8D5PA3BONOewGG48T9BZT/AoptWPr6KtcAMQLtAkBZnwDqaFcCN3ObAjOIBwXhyuD/vkhrBoKq3wOUjCsHGPcrA5BrWQFq5PcCSzDXAy4PIwHAbd78zagTB2/eBwC3u5cB6sAXBaV+ywOjVQMCuia+/gGDVwIFW2UAIk8zAKxiYwJY3xb+N6TvAuu1RwADlpcD6DE/A1JRYwBmKG8DdiMLApZHZwLnisUAYoTjA0DYnwHkv20A3dTTAQrsswBGHJMFhcEXAU3j6wEAp2EAvMI1AjCtlQHR4GsE+Ob/Ab8zBwG48vkCChRy/jOlIPyU8McAmHlHAp9sPwBOPgUDZNuNAVFLZwOwKgsBdhhvBnwwdwTP+10BlqB3BUzQpwCx8zsDb8e/ARfXnwCaygL9ZiRhAQbQzwOMoJcAOFxDBGlnewGJj57+Pex3BJy0UQXbwx8Ag2vFAGAuRwEMXjz/UpBTBiu1QwAh4y0A=", - "encoding": "base64", - "path": [ - "y", - 17, - "data" - ] - }, - { - "data": "xtpNv4EgAUHfsx7A9V6FvaD9+D4f6uPAy9CVwIwvC0Fg7ME9JWdLvx4Lm75KIJE+Ad84QKvl4D6TTBtBRUBwviYJ/8CkYbRA31DTwKjNPD7A5wM+SvqfwPehGUE37hDBLBnewHcy28BZiY4+puyzPpg2ycCCjpE9M+YVQagVLEDZNxZBgruZPriWo76ZnGzAFMePQCTKFUGM/9DA+i8dPva+LD87yzI/gHOnPlTwOr5kZSHBZDixwKyHHMA1zqbAl1noQAlvNj84vVo/9OwAPuTsEUEVJBY/8P0hP74w7EALoJY+HZX1QPF7wz50Vcu/hSndvyFWBkEES548VXjkQG2W8b4mMcI+xgdRvl6lND8Cb/dAdP/DPSIIG8HxCr3AOxzkQOOtA0EGMP7AIC4Ev9GD4sCWn5JAlugCQdDZQj9XRvtA1bLaP7MPZT+cp58/T8ySQObCnj/n+9zAz3z2wOy3dkBHVgVA71AWQYAsqD/Xjtw/bTIRv0Unhz9Eg1U/VPbVvw0secCA0Fc/P+O6QNOcaUBTHwjBNeInP50ZSb9ZxqzA5kbdPqulocB/3ANBmgzbQMoB28CaLOzA5BMswKrmu0DhwmA+HqlXQB7qO8DaJO9AHWOCv1tlMD8cQ5nAlczlwC34r0BYfwjBnIh6wAm07cCkraHA+C4TQRQwxT60lgU/2LJzwBJiHEDctdHAiCTUvy4CmMAK1fbA6lp4wM1O8z1xfvA/1eyqwHT0DUHOF5bAADcKwPFmzj+utO0+w7j0PgjOWsASwBs/EcdMPo6ANT+uioDAblKPwCyJ80BdFxo+Clm/P92FF0FecQo/aO+5PgcnCsF1ZTg/yw3owNCnD0Gvb/FA74ahQG00CsE2QoDAZAcvwHspB0HcREVAvMJXQEssZD+xJ4C9WB4AQJGZwkCwUQ5B/Yy2wKUcIMC3ExTBuN8NwYMXDkGsFw7BheWkPkz/psASS6fABHzCwPmtBUAiVY9Acal+PzstHz/NzOPAnP3MwGdQqT9kzPnAMC0rQbkTtMBK1RNB0tqov05XjkA5YQnByRYfP4nL9EA=", - "encoding": "base64", - "path": [ - "y", - 18, - "data" - ] - }, - { - "data": "2HY9QMcxCEH0wZw/tUVzQDusf0Dl94bAUvN6v9rTJEG4oXRAYSRIQFATTkAs7YpAtIGqQPHJX0CSmSVBeUZbQP6jwcD1VvpA2o2GwFthSUAN525AvK9TwNe3KkF1D/jAETmdwEjMjsAX7IhAP9l/QIIrV8D3IU1AfHIbQUFLykDihBlBNCCLQC+xMEBl3/6/TPrvQNwnG0EFDI/A1A98QOU+f0DGz1pAXpdkQJzQe0DGjQ7BX2hiwN/+wz7S0jPAYT8PQV1EZkDmSnpA5F5WQOITJ0Fly3hA9hBxQJWQDkGBfINAzwQZQZtsYUBcJaI/FSl5P9lhJUHvoFdAY3gHQWKEJkAimnhAFEBAQGOMhEDWyg1BovhoQBg19sAfa03AYrYJQfhMGUEweKrAsf04QMbokcAKM+xAfgAYQeshdkAbXPxAWfmnQOfueEBZWH9ADq7TQAjKeUA5GZ/A9ezVwAHr0EDtbadAYzIZQXIBhUAo1phANphFQM3JkUB06IRArLneP/SWXL6J/XhAF/XsQId72UDkIM7AFHdvQGDraEAlFXrA6lRiQAoA37+n9xBBm2gFQXLmpcAv9aTAVJYxPSeODUEnkmBApBO9QEG74z4CvQFBk2z6P4hcYEAWf7y/Ide2wNa/CEH1vtrAg2CcvxBbssCJnlXARVUoQVo4a0Cm5HBAurgcv2f1q0AV/oDAYEeTP7Qitr+vks/A8Xm/v6n3WED3vJhAUMJNwOOsG0Ex6xDAMWVaP9R8i0B3WG9AuvKBQOGGfr/W/IdAtal4QDDmXkBTPK6/ln69v6qmC0GOG1RAwZ6kQANPKkE0DW5Ak/pXQK9xwsBXoYRAO03DwBvbIkHfvhtBe728QBz64MBM9a+/E/WvP6hfHUHUWsZAOTipQMuch0CSC05AnbG5QNln6kBGORdB8Nt/wFqGqL6rNAHBXcHpwH7xIEF/UerAHVdRQH0NXMCA8gXA53OIwJfRlUDzAr1AwgqQQKIeaUAocY7AkIiuwBg9hEAscpXAsZQtQX0fk8AHjB1BQO0TQHAz40A4dOzATzeJQBg490A=", - "encoding": "base64", - "path": [ - "y", - 19, - "data" - ] - }, - { - "data": "6E7LQOH19kDh/JhA92TgQOR210BqBYi+u+g/QIHSK0FajN9AEhvUQIWcyECI9fNAUJPgQMxPvkBSGhxB+DPVQKqpSsCw0xFBa5qOv+Ybu0CdZ9hAclSAv6t7IkHOLrPA1N0PwO8bor9rC+5AQGffQNTzlz5u9cFAUGoLQYHLDkESvQZBvlrvQEk1sUB0N5w9Vv0WQdOnBkH5pti/K2/fQLfqz0APGLJALgrLQE8F7EDymeDAGsB6v1JkS0DiBD8+/8gcQYXyvkCLF8hAeJzHQADwJ0EMVNFAUPLKQDKRF0HQ0+NA9bQlQe8rxUCqwXxA8KdhQNAdNEGv4MxAuRoNQUvFqEB36dVAi7G5QGnT1kDBNg9BqG3VQOeYncA4p78+K1ERQc/aHUHnSOe/wovAQGWTkr9pyhNBt7kZQee9yUD5DM5AZWf6QO0UxEBh8sZAK+X5QD5guUCFcBHAnESiwLguB0FeEOxAOzwGQdqRzECA5uJAEm3OQBES5UAaK9RAf7WcQLgXZEAqSMZAEOIAQSuzD0HxpFzASzLGQK9R70Bh6P2/RUXEQC94/D+7GQ1BTUMOQX8UP8BKegbAk1AyQPZiLEFh/MtAJfz0QK89ckB8mvVAQVmRQKv1ukC5UwdAdnRowB2wKEH6z4/AmM7pP46fPcBzBZq/Kl4pQY03zkA2HMtAqF0uQJCV8kBktja/vuBvQJMcEEA28pLAs0WYP1w6xkA9VOFAWFqevuM9E0GJ/iM/9HZvQFTwykC53c1AkULZQCTJ2T+h2eBALrncQLBMuUBw8MU/tZTiPyblDEHuUsZA3h/3QMVnI0Gcm8hA/Xu4QLB+H8BFUdZAOTOIwD5TJUHxWS9BnqjDQDHil8C2rMM/tq6oQC7GIEFFwQdBPaLPQIDA2UC0/sBA+UsMQa7f90BLkQpBOUfWv9BY/z8dDcLAVaGfwB1BI0Fqa6LAjuK9QGBSlb/QpbY/XZvhv9rQz0CrutRA6pzkQFKGwkCy2oG/Ym2BwG5Rx0DMDvu+AnIZQT2uRcA4vRRBwse0QFliD0GBy7PAvFviQJfrzUA=", - "encoding": "base64", - "path": [ - "y", - 20, - "data" - ] - }, - { - "data": "LY0SQSourUAHnfpAI/IUQb10C0HK3HVAeJ7RQD0DHkFzaRVB4SIXQQUrC0HslR9B3SX+QGsw9EB1wvhAQNUUQZdcGT84pxhBp5AMQKqX/kDdrA9BMF3CP8L/AUH51iPA4XBcP1zHC0BxRxpBr9kRQcoQfEDnNgZBewXIQNRmJkEo0blAqKoaQVmu+0B3owlA8BslQT6mtEArurI/9u0RQS0vA0F/0eBA/XcIQQJ0HkH2NYfACdflP/8GtEDWTEtAP6EbQcFr+UDoffpAVUcIQU9CEkFBnQdBUcAEQXe8D0HmABNBXFsfQZuYAkHJ2MVA0ni0QPHbMUEi+gtBpSABQfUh60CRPwtBxqD7QLJoBkF2uPpAqu8OQQYTtr+RW3xAvfkGQYZkEEEb3wFAOaAJQaWgJEDp+SBBJ9wGQShQAUHmimVAgTsVQeRG8UCmrftAIKYBQT3J3kAEGHw/0DY1wBsuGUG27AhB1Vy9QEjW/UADpAhBrPwRQU40DUEMUARBROXvQJ3+2EAG8/RAoVP2QHOmIkGQr2s+87gAQbW8J0HumYE+gsQBQeh+rUCHfuxA2NIHQRZanr4Gya4/GsyjQAd9OkG2+gpBnSQJQSAo1UAA5MBAzHvSQDhK80CYXq5AzoNpv4m2N0EO4Lu/htqTQBpCiz71x5I/KUYUQR27CEFWkQFBlsu2QJnID0H6gTJA0526QInssUB59ADA+2BuQPOUA0GZrAlBhsItQFMn4kBi1l1A8QTFQCS770ClRgdB5jIKQfZchEB4xQ9BqucRQRdx8kDqhYdA956ZQE0L9kDZFAhBgNUSQUUEAkF7BQJBuSjsQBG91D94ngZBmBHSv9HtFUGwzTJBqfK0QHMW3r/DU4dAJhsIQQC6D0F4uh1Bd7jfQMxuCUGSywNBiPAtQQX76ECNmMtAYJJ0P4Xbf0ALpkrAAoTjv3/4EkGg5wLA8KYBQTiDpz80bphAkgKNPyQE8EDF8NVA2d8PQZw9+0AD8ilASewJwLnx8UCK4HVAfszaQAWkib+iyu1AFhsHQV9zH0EADkzAqM8OQWaJdkA=", - "encoding": "base64", - "path": [ - "y", - 21, - "data" - ] - }, - { - "data": "ACQ1QQso0D8uxCNBZRcrQe6yH0FHqetAIq8WQRxC70BuPi1B0Ao4QfLZJkEaFzdB76YBQeiGB0FbzY1An+80QdnLiUAplxFBd8qmQDTXFEEoViVBXSR2QMqZnEAccHM/7Rh1QHgwq0AtXS9BfcElQZ8R40B0bCBBdOIlQDaeK0GxjAJAgmQvQWMaG0G+2HxA/6kiQQO86z+w3IlA39IlQc2OEUHYCfdAAcwhQUkPOUFlrAG/9xyJQCOV8kB/brhAe8MJQfyWD0F8WwlBAJYhQeUFyECX5xpBnr0ZQV296UAUjCVBQFwDQWkNGEFpZPtAkW7nQLfwHEGGKCRBNzXAQCGXDEHmNR9BhHkQQUBtEkEEwadAKeclQS5UFUDYCOBAXpjPQMdR3kDGorNAjygpQUUmvECfSxxBWwq+QKhIE0Hqo6G9bO4bQYN+AUF1Gg5BkuTtQOhZ60BI0IJAC2rfvdSpHUEnBw1B5X8bQMmsC0FqExFBsZYuQbOiGEGk8BFB+1MXQdajE0FYXwNB2G3GQDYXJUFVdnlA5lwUQREeSkH6Sh1ALOMWQVHWBEGXlpRAOybiQMuLHEBOTpRAZ2jcQHOaN0FbwiZBK7UKQWKzDkEwyklAFAwBQVrVC0HN5QNBnwcDQFdJNUGQz/I/TDveQEz5XkAsTVRAREvNQLplHkHXZA5BrBQCQV3iGEFdFrxAhVrrQOnpAkGUOXA/H7W7QO61FUE5LRdBFoSsQAdcW0D2drxAFFr/QGE4+UCa4htBhskaQSqaw0CD0CNBdzYpQTeUC0EphM1ASF7qQBj6pEDDcyFB5pEYQa9rlkDMiRNBNIUCQTJCskAxUxZBg4WrP/qB5EApmCRBTdyNQAr70j/oDc9Ar4IvQdFAz0BNuSRBEenZQFO2GUFINB1B7g1CQUnDuUDIPy5A9I9dQKiVskByQ5Q+79b0P/8U2UDdobs/eWYaQWyZZ0B9h/JAKPFzQMaT9kC5Yb9AMmYiQRfZDUFwi7xA+KfRPS3wAEG10/NA0rozQNCnmD/n8oVAt+EpQa2lIEHE3iG+su4dQcLh4j4=", - "encoding": "base64", - "path": [ - "y", - 22, - "data" - ] - }, - { - "data": "SjxNQeZrK8At+D5Bnh0zQbWMKEHoWyJBcHs4Qct8YUBMcDdB0oxMQRSeN0EK00FBT0vvQLhABkGD5vg9WOlKQZv17kBIxvdA58D1QBohHUH3LS1BUlm5QA1RWj/jfYtA393IQH32/kBPdjdBSIYrQeh1GUFozi1B4GTTv6YjHkHqLA7Ai3s2QUsKMEEvx6tAwZ4PQdVXFcCydNhAN1YrQUzLEkGnOvJAypoxQQtkRkHB01dA2WHIQLGtD0EyEPlA1qbGQPodF0HmFQdBJW8vQb+TBUCG7yFBCfYjQTbTh0CKgypBqC2gQFLPIkEt+Q5BGqsEQSDQ40DDZS5BaJEkQBKKGUEU6CZBo1ETQcVnDkE7baQ/pmwvQeJMuEA81RZB3YpJQJYebUCH9QlBlbk+QUw/CEFmvwNBz+wZQL7cGkGgH2zAzEkRQQmr90D6wRFBTRO3QDyT3UCk09VA4sMpQMRrE0ENcgJBzuTKvyuaC0GSxQlBjkg9Qc47FEHPOhNBxv0rQaDrLUGDg/lAmGNgQLsFFkHhAeNAxbUdQRImX0FjqopAUU0hQQEiKEGPUVo/JqORQMfomkCSQOtAyi4BQVPdIkHLVjlBjRX+QB4xKEEflPu+wkIQQcuUE0HB0iVB9CSWQGkBIEF1s55ArtULQac9x0AeWKJAThcQQNxTJ0FmXQpBR2seQa8ZFEHNTAVByVIFQZOtIEEKNHJAcEfwQEVdGEFg+hhBO1nyQCVCiL+hYflAywYTQcmw5kDEDSRBCB0fQajW8kDJVy1BC6Q0QSaQEkFs7f9AeU4TQV14sz8nZC5BQQUNQTaG1T735BdBxaIAQUtoDUERHRtBJOSEQFgTZUALwQFBT+cSQGfKmECBeAJB3EhKQTTYKUA45xxBVfq9QOx9HUE97CxB4LlIQbXgS0BGl8y/e7GyQHGv10DcrG5Ah72pQLq5PEB9q5dA6rQnQZuBsUDPoBtB3LXCQPg040DsfI5AUo8qQehwEEFeiQZBqlMXQFYg9ECcpSlB6gD0v5XyUkDWXym9n0lCQT9YEUFl3jtADsAeQS+AQsA=", - "encoding": "base64", - "path": [ - "y", - 23, - "data" - ] - }, - { - "data": "lM5aQTHmvcBqfE5BLVAtQayyJUFhFENBEflNQaDLsb9UWTRB3MFUQZnbPUFx0UBB2zDAQFc16UALsYPAstlWQeHrH0GRGqxAiFAYQUmRF0FzFidB1k3pQLpxVMDBM+tAqq8BQR0nH0EmbDNBZs0jQRD1NUHgLi1BduSowBSE+0CfVa3ATzwwQfhePEFa8stAzXDXQPaXt8BGUQpBWykiQdpDBkG4Gc9Ag+g3Qaa0RkHfp9lAHPP1QJ66HEFw7BJBjL8WQICkEkGiQOlA5qoxQSpTJsDBjhtBZPUiQcyx6z2SsyJBaD4yP6ZTIkGAsRZBhzENQfQDO0DjpCpBwd7Jv3OYHEGpMCJBI8UEQdvd8UBsvkPArm4rQSqFCEGJQTNBX398v64EsL4grC5B4V5KQVEJJ0GCDq1A2SXSv26gF0GPXcPATPDqQO7JzEBGqgZBihdBQLzCs0DqKwtB3JqjQM4R8EBVSdFAcQqXwIge+kDFqOJAp8A+QQT2/UBg8AdBqao1QTRGO0F058lArgofPWMT50BTUBpBZXgcQdgpZ0FGwbhA4asgQaMWQEGycEjAW/CSP6ca10D9TRZBtykLQYEG9UCVuUJB5JvKQGfgNkE/TnnA0BYXQVl4EEHu9jtBIrzaQOzd60B2sO5AJM8fQSnWBUFiQMtAd/kewFH3IkEKs+ZAghMwQdWP/0BHyyFBWJwMQTpIMkFaashArsYJQTg8CkGsDA1Bap0TQbFTpMAGURJBzbYcQfvytkBkJx9B/EsXQUwKCUHguCxB7Uo0QRIYDUGKAA9B+WEmQY9+LsCUXS5BNWDgQBsyesBiCQ5BmR/eQHK+NUGN1BRBlvHRQGbDX7+hD4xAFDAQv/a76kDSCBRBWX9YQV4j6r+L3gVBp/CKQK1DFEFcJzNB1JBBQZFwf74V2KfATYzmQCiI70DDhdlAEtsBQTrK1b/KKe5A92UoQVX430DkdjJBWlv6QNQXtUAMLgNA75ooQTm9A0FnjSJBwXCLQEf3xEDI+0tBVXW0wM9NokDH3YTATRVQQdiw3ECj6bRARvYQQaexrMA=", - "encoding": "base64", - "path": [ - "y", - 24, - "data" - ] - }, - { - "data": "YMhdQWbf58BiAlJBYaEZQc51FkEYbFhBiCdXQb9PtMCsNyRBCslQQZa6OUHyrjRBFsdmQJ8/oUAoSdLAU8ZYQbZMPkFXCgVAuo8rQXZ/A0EUsxJB5CQFQceCx8BLpBxBoCcVQTFBNEF5tyNBEmQPQUvaRkFC+R1B80zewO9jmkCAyMbAKZccQX2+P0EM3d5ATc5kQHD63sBhhR5Bw6oJQV/z1UDpZIlAyYo0QfbzOUGDtRlBUy4JQVo0IEFgKh9B7qwOwG2AAUHxWp5AkQIoQReoxMAUPAZBKk0WQeqNgMCjjg5BQN5vwE4IFkGA8xRBv2wNQcRhCcA0zxhBYuWkwO/xFUGQrBBBKYbGQN7BoEBjMsnA6awZQT7oKEFJW0VBXt6ZwBq4g8CAKkdBCBRMQU+4OkFYHs0/rBmgwJwfCUHSy87ATGyWQI4yfkAlhNVAw2OCvrmkWEDEUyJB4d3jQHgRj0ClaIBA47+owEfJukDhKI9A21MzQZL4rkCNG99Ax140QVDrO0EcCGpAw1VawJ85d0CmIThBcSQQQW9MYkHbfNhAGzoUQXCDTEHcwbnAQJIgwAM+AUHv1ytBcZYMQWwLe0CJz0JBV8FxQP63OkEVlbjAc6QVQQkJAkGvzkVBhU8HQSXXYUDJ1BVBGugqQRQ5HkF7HOVA8d/DwN/YEEFQfI9AsgI3QRrJsUC6vTNBPNgLQcEHOEHcWQRBgHYSQZjq0kAtNOFAu3glQZjO6sDWCB9BrAAdQeKvVUAYhAxB+OwCQbzJEEFqEiJB3vgnQRi780BiBhRBizkuQQ7vvcBGuyBBtKGIQCvQ3MAV8ehA8keYQAAHUkHaAANB/80HQfVkm8B0hRS/hqxNwEg6FEFlKRxBgjRaQRn9scCB4bxAVSMCQDls+kC1/i9Bx44rQYpHYsDq8djAi3wEQfpX+kA9QhVBv/YkQaSJtcAUSBhBr2EbQbss/kAFiz1B+h8QQR/uV0DBcVq//IMcQYqqykDFxDJB93m/QP7AYkBfG2FB3BLcwL6Sz0CMeNHAYf1SQdKPUkB/hPtA/kTnQNyEtsA=", - "encoding": "base64", - "path": [ - "y", - 25, - "data" - ] - }, - { - "data": "Z/dVQa7+2MAoNElB7zfvQC5u80AhxGJBvAJUQVMz9sDNFAdBe6dAQUEfK0G8tR1BNivyPlJ86j8Wo9vA/pNQQT/sUkHzOtm/fNQ0QXlewUCJMN9A0Q8OQWhV0sB5CjpBgVkfQVnNPkEkfAhB9jzdQCgrTEGcVf9AO4DSwAHXjD+3bKvAIUf2QOuoOUF5suRAaXIfvuKrv8BgqChBEPrBQL8VgECQdpo/1xknQZO+H0FsUTxBi0MPQYruGUGmOCFBYea+wI3WxUBMBL4/vOkRQUmm6sA2pb9Ag/f6QPqN3cBP6dtA89XWwL8f+0Al5QlB0nQFQVxZxMASJPFAMRnkwK7ABUEnqONA+oxGQEqmwT8DPfXAfifzQCtePUELNU1BbZrowM6BvcCEO1NBka5DQfW6Q0FFOiLAV4jHwOvG3UAZSaHAyAe3P+MULz8kBHpAA9tcwEZq7j7ivjBBdwEKQWXSmj4RfE0/IfyGwI8qMkCMuYw/7gUbQYMxAEACBpNAjSUoQfBEMEE0fD8+0wa8wBrql769/0pBir/vQHJvUEEwYepAmAr1QCdITUFluM/AHDCiwCTxDkEebjZB+eAFQfpyHr/9UjlBln31Pu+rM0EuV7nAi94LQRF8z0CjCENBhzAZQb3Xjr+GPStBivQsQcMcLUEaxPBAAdPswEIS4UDZ2FQ/O0MzQe/t9z95hDtByjwDQVBOMkFscBxB3AUSQaf7W0CcY4FArbYuQZvo6sBr4SJBrCcUQbb4xD41y9ZAk17CQDXBEEEkUA1BmSYPQQykrkAlXQ9Bi+kqQfod7cCqkARBA8RgP8sl7sDlEpNAWj7WPziMYkF728lAPaEeQfka28AsmKbAmD6dwEwzKUEV7RpBVlFPQXRD58AD2RtAE7EtvzDSrkApaCNBwsgEQXx0sMCixsjABcwMQVYi+ECuCzRBJn8+Qdrd/cBSvy9Biz7/QED7BUEZ4DxBskEaQas5/T4u2F3A4gcGQUyJUEBj3TdBXQ/nQNxFGz5IX2lBX7LMwEdS8UB9ddzAZJVKQeVDm79dphhB9TaLQNQMjsA=", - "encoding": "base64", - "path": [ - "y", - 26, - "data" - ] - }, - { - "data": "wf1CQRKDpsByoTNB/5GPQFEbnUBZU2JBI2REQRa4+cBJxrpAAkAkQRujEUHq9/dAZvQvwDt/478hvbzAtv49QSkKXkEZEpXAbmo0QfEjR0DXInxAW10PQVp6pcCCe01Bv8sgQSjnPkGWc8NAFGmEQEbtRUHx9KVAjG6hwEGbMsB732rAP1iXQExmKUFWot1Ao4NywF3qdcAzuihBoAcpQHtgFz+NTQrAvNwOQXjn7kBk91RBTKgNQYDCCUFwFxlBAzMAwdSIYEBNshfApTDdQGfc2MBiWSVAx1WxQHLFAcEshoJAmt7wwHWhskDGb+tAf6fqQKJK/cD+BJVAcfzqwG5Y2EAsNIxABBQSv3orFMDaAezAycCWQNB1RkFDw0pBSRL/wAklu8C54FJBxdEwQXRxQkHOcrzA0HOywFl8kkCi4SvAhpADwD0iMMChm/4+7qS5wBS/IsA5wTZBWdIZQduHesA1lyLAP8AewBUGZ79uex7AW9brQKwf779+d8E/zu4QQQGSGEF67lLAqMnYwHogicDyJFNB+oalQLYoMUFJJO9AUUekQJQ1QkERjrnABi+3wMgkFUHBZDZB8NXuQHJrm8BgxyVBnxQ6wNafIUFbPpXAMQzzQKvNg0AeYjNBR1wjQaEepMDuHjhBG6olQVPnMkEmH+9A6LncwCnChkAoyj/AaN0kQfuaDMCHdzlB/9DlQF5yIUHBVCxBGE4IQUr4xb40SxA+J0EvQb90vsD64R1BCGoCQTb4J8A0oXRAbARLQILzCEEjZNxA/x/SQHhyHEDobAFB1KgcQQd35cDaGLNAOYIpwObSxcCAD4Y/6knjv7KgZ0E74mtAQ2YtQU5h38A5uv3AwuSwwOLJNEEubxBBh4k3QThT3sBvpcO/j9dLwPVBFEDzNA1Bml2VQE5EvcCvjJTAjTUMQcmo6ECBqEhB1t5OQYqTBcGo/j1BUUuqQOfBBEFLjjBBNbsbQSDOHcBaJaHAeVLJQOHDDb8ufzJBhCIBQdJtUMDzEWVBGOSfwMvnA0EhTb/A5Dg2QWHUqMCFaitBp/4oPzPBGcA=", - "encoding": "base64", - "path": [ - "y", - 27, - "data" - ] - }, - { - "data": "QEkkQVIVO8BivRBBH1deP80Qvj8fHVdBe/UnQTHv18CbcydAjWT3QCJV2UBl359AbnalwFl3msCkdYbAAZQgQSDCX0GhbbjAbJgqQT9HiL6Iysc+aPwIQfMHPMAp0VZBjvAZQcakNEEdjkNA9x5aP2QPNEFcWdw/s/o2wHWuvcCinMS/lreMP3vwDUHT0clASDnFwE95kb+2xx5BrC2cv/P9OsAvQpzAVFTVQLpfhEC4BmRB+LkEQQ0s30CvvgZB0j0Hwfgbrj7vHq7AdPh7QCq1p8AcCKu/wD8pQAxK9sDtIUM/pDvbwAFYL0AEdLFAPxe6QCHZAMGCPpI/MgTKwEY1k0BW04k/Uy+CwABZscC6QMDAIz+XP4bWREEAzT1BxgjkwIzvmcC9J0ZBeOMSQZUbN0HD2u/A00N+wBzH1z8LcJo9uoyfwDLCqcB9az/AgqPYwH8bnMBYkzRBJmYhQcex2cDU+JbAcE7ivmD5iMB8CK3A+GaLQAATqMDiPeq/TQfeQEYB60BaE7fAE07EwKNv18CkyVBBkFAKQMnzA0F0dOdA7ozpPzD/KkEPO4rAGJehwG9HFEHBDSxBFyfDQCSA6cCUaAdBiLGwwLJnBEFDUTnAEEG8QD7Enj9uqBZB0RsmQbDR3MBN8TxBwJIUQfntL0EKAuFAiHaswM/AWz8/a7/A2dALQaDVssBK1S1BI9O1QHC+BUEsATRBLE3qQF40gsCUznHAM+QmQQYkb8A4BBBBkxXQQJYLnsCAkds+PCxivgGU8kANlolAE2dbQJRBgb/RW9VAEMkDQYnmucDHDQlAwWOnwDFhfMCrxi3AyuyUwHl/YUEdKRE/HRs0QXF5wcBPxwvBrlmkwI17N0FSl/lAlVYSQahZscAgrKLAmLqYwKaCmL9mLtpAjg2WPcKVpsCZsBjAh8sCQQVfy0B14FJBeGtWQQuG78Bke0NBLMz3P8ol90DZshhBjbEUQQUTmcCmzKvAVyNgQJNkhcBUOCNBT7AIQbz6uMBFV1RBcqJCwBGiCUFTVYrAd/gUQXI2+sAKajZB729JwCa87bw=", - "encoding": "base64", - "path": [ - "y", - 28, - "data" - ] - }, - { - "data": "wVfyQPxRgL4m6sFATVg3wELuDcA97EBBhY79QOeUncBemWu/ZXyRQMymc0DFFN8/ABbJwNsYzsBGEwTAkovvQEIEWEEOda/ALJoXQU8cY8CiS0nA3pr1QMS0rL6W6VVBVyMLQSwNIEEk4sK+a80iwOt7FkE0jwDA7lWwvvpz6MA7HUY/G+0swGy3y0C5YKlAxz7RwHDO2z+N4ApBV5CYwPrMtMC31cjAT3FoQDyNhT6/x2lBz4jpQHwjl0AQldRAeqT4wJUDNsBbmN/Aoc/WPtq2RsBJlZzAU9oUv+AvxsDFUijAXTWpwKVb2b74Y09AklVzQGL55cDjRCPAYo2PwIkYAEDR1RjANFzNwEmY7MA16nrAOgYiwKkdOUGM4CVBNtuowA5fTsCmIS1B9UfTQKvVIUEoWenAGuTwv/EzuL80bzRAul7JwLVuysAdo7zAYRDIwL56v8DcTSpB6s0gQaF9AMEMDJ7AtoDSP5w1zcBX093AjblaP+cR6sCVYJbABxCIQHDnkUAAH9DAwWSQwPwD58A2EkRBlk+bv2j7k0BT7NNAYgDtv9RGB0EyIhfAwIprwE6xDEFdrhdBZZ6JQKEN98Dnx7pASanawMgEuEDlOUi/3SZlQCWC6L+Z0dtAnZ0hQdxS3sBkDjpBLAPyQJZrJEHwK8dAft9QwGc5JsAnPuzAGcvQQAgU78DpvxhB/I5tQEl5wEAAcTNBnhKxQOvs0cB/59bA5kMVQRQHh78NZ/JATvmKQHQXvcDdeT7AS3ZgwNwqw0C8Hpw/lopEvjtHhsAGz5dAovHBQMrobsCuLNm/O5m3wAuLmb9XurbA7C7DwCtCUEE/IybAKbEyQVZOjsD/dwTBQCaAwNCtMUF6dMBARNu/QM61XcBqauzAYRylwGtbjsAeuIVA4ZuPwGkcdcAKrSg+vFHhQD5bn0D4ilJBB1lVQSq+uMDhi0BB5vjkv0JG1UAx2+tAJD0FQaFuu8CJh5XAIppFPoHd0cDvgQpBLVIKQWxK3MCSNDdB91RFv5vlCUEKOQ3ADPDLQMvaCsGT8TlBhmfAwKf/FUA=", - "encoding": "base64", - "path": [ - "y", - 29, - "data" - ] - }, - { - "data": "7g5UQIKyPkArbMs/tDfEwCSNxMDUFxZBKmd2QBp/AMCUhJ/AKRCSPTCR776CjR7AJRO9wIiAyMCzzFI/3iVeQLFAQUEiq4XAt2XoQMQVyMAktsvAtw69QEB+N0AelUZBFDndQPHx8UC7SYzAaOW8wN1jx0Azt77Ag70vQCtyysAmZVlAuQfRwHsZD0CnjmFAMJ6iwBo1mkC1aMpAyU3uwBE84sDx3MDAs4pIv0TWjcCWXGRByw2wQOJlqT9uIW9Ajte7wA7mtMDoG9nAGD54wAz6Zb2f4vLA2dOKwH8TWsDc67zAexAowOe0hMBAagc8nbxVP1cppsCyrcTAsrDJvw6juL/Oj73AYarewDSz7cAB0kO/917LwDLPHUFMTfFArnELwH27Xr8y9/1AJN4nQE3U9EACbLHAEYxuPxfumsCBW6xApGyrwBC6ssBpgP3AJFCHwFpLsMD0oxJBOQQVQUTh+MA5zmzAPZ13QPC34MDU0dPALeRgwPOk88AWotDAVGDiPlZ9GT/sp6/APL/jv2eKwsBLciZBZaudwH1ICL/frKxAOY+3wB+yl0AlQLg+2he/v7VB9UA+9eNArK3OP8v50sAg6+E/EdrTwOqV8j8xMvM/ZkAaPmUco8CLFz5AiFgSQZapuMAVWixBqtyPQMTeCkFbnZhADFpSvrFiv8Ca5NnAO1BGQDyh98Aun+RAk1lMP9M9IEB5bydB+BcrQDI76MAv3wbBF3XkQN91F0AdQKJAOFqVPxhtpMDa4cXA1bDDwFBOZkDMJy7ASi+PwMG408BxiPE/UQQwQBcEIb+l/LjA7GqHwE94FEDYquzA3cK4wEzzK0GRNa/AkawlQY4B9r8+JNLAROr8v15pH0ExI0xAPNijPwLT2b6ccwLBDJeHwIcg5cDK45Q+Rh8FwY3+y798akxALQOeQBLgJ0D9fUNB2l1IQQfNOcByxTFBgai3wByQl0DcuX1ALOnNQJubqsDnTD/Apq9zwM8y6sBAQMFAlWAEQbnex8BlowNBYp4FQGi9AkE1eC4/lgHnP2tL/8D9YzRB3FHrwHVHlEA=", - "encoding": "base64", - "path": [ - "y", - 30, - "data" - ] - }, - { - "data": "ObUiv+fUjUAGchPAXczdwGXeA8Hp6MtA/EsdPXDJJj8neuzAs/JmwNUrd8DzMq7A2wmUwNV9n8BZuENALP2Jvss4I0EYSSrAG/KcQA+L18Cn6+3AtC17QESBokAEJy5BF3+eQLd2nkCZKNPAp7fowMRNQ0BbCvzA1Q+YQNVOjcBQKJRAnsYFwRj8yL+lNtk/BSJJwD9ZyUAz0XRAedP7wNN41MCQwpbAEVCHwMAB6cDZwVVBpBBnQD5p0r+r43U/mQJswGMLzMDqiq7A6GzOwPOqHEBOswLB9r7SwKK/ML95d+jARiwCvu13zcBckSnApozbv66bQcDy3/HADlyEP3m5gcCmCfLAiES8wIPwv8BqX/g/HyoEwanQ+0AOVI5AdEYqPz+elD8WBZ5Ab9+Av2b6oEBaHVrAXZBHQC2Y0sDVxrVACQ5hwOxYf8BHPAHBWXb8v5RygMDWLOxAnmYCQfYQ1MCsiwnAYtWZQOM4ysDrvKTAi2DKwCEay8DkDs3Aq2kvwOloLsBS5G7A4e80PxMpi8CBMgNBgPrbwD+4lMDS4oBAzkX1wGqekj9hAyJATTPwPgn5yUDBJJVA8DBFv42EnMDTpu+/OvepwLZhw78l6G1A+iIswFVL28BP3A6/pbz7QN0IhsApAxlB3dqrPxnK2UBkBE9Ao/8UQPo96cDpX6PAUGg4vbgF2cCqwJNAD7Davyx3Jb9sQRRB/GqLPIz8yMD7qQXBWnyUQN4klECxtSBAYKjKv8hoYMA8WOvASd/RwG6cjz/ifqzAzCrgwPO54MDd2CS/fhZyvv2XAECiB/fA/ksRwOu1mkC1PuTA8AuOwBcwAkF3rMvAs4QRQdwwvT7QpY/A9p8LvTSiB0FQkw0/h80ywLb+B0C4xOnARKU0wMNK/cA7FD3A7T4bwY1c4z7W+ZtA+PkvQMmgiT73/CpBwSA0QXN4S77qrhxBF0zzwDa3LUBM4Uo/I6SLQNfEdsA59Z2/aePGwKhw0MD4n1tAYivyQISMk8C9/ZxAJlN/QMVT7UCoqTtAdukPwGI9zsDc7CdBkxvawGJRn0A=", - "encoding": "base64", - "path": [ - "y", - 31, - "data" - ] - }, - { - "data": "leyOwJJpPkAlGrvAJBDMwIFKE8Evhy5A7lZwwPyrSUAzQwnBJ8LWwCNeysDz3ejAaKk1wG3CR8BIYZBA6MZ8wHYp9EDrxWu/LX8LQIpjvMD+YeLAflDJP5chykBrsQpBtSUnQHRW+D8Wue3A2T3pwApV2r5a4AXBcjumQO3eAMCxmExACiAPweT4osA5o6K+DJ9lv96KsUDl13w/QuDewIpcp8AHmTTAFvzXwGf4C8GE0z1BCSW4P2HUjMANAPW/DySQv+SVuMANPl/AYgz3wD4SjUB96vDAnZH2wIV2BkDeoezAKbkXQEoX8sCTJp/AGDGAwASqDb/8PvPAMUlbQIPCwMBIUv3AaIyBwOs1c8D2I4NADRoPwWfArUAn+VY/NrhYQK1fQUAftMU/DzCOwHj9/j+rZG6/LueYQPAK48AUO1VAHkeivw549b9hpuDAvxgAP/Ax/78/h6JAWH/PQJf3m8CiXMe+nJNTQHf6ncDm3kTAZ2n5wIi3iMD/yqbAd5mvwCutssC1GsS/mGhFQMS+DMB0qa5Ao9v0wIVD98AKORdAtU0FwYApJcBVuoJAPq0XQKnRkkDqrew/UpdDwFzFMMAocKTAU45ZwA4Gl8BRQoVA0XKcwKSL8cCSWYDA8iLEQIsdEMAayfxAvG8AwN9wj0B6Gro/v2SLQNcb5cDniDHA0A9LwNhApMAPQNs/NB97wMjJbMDa9vBAP5sowGQ+kMBKBurABG3QP3XXn0BtFJy+X/aDwB1Mub/j5+LA4Oa3wP7ivr8vkuDAsL8EwUe8x8Afn0bAM2tMwEyPhkArFgTBcoOAvbZ2yUCxvbvArDAlwG/9nUBpib7A5cXoQCDFJUB3yP2/yXzyP/xz0EAenAjASHfKwOeTiEB55LLAPTKOv94W68BnNrXAMDUcwR1qGUDnLIZAaNifPnunB8DwRQdB3vEWQdaUIEAp7/5ArPYAwSDY5D4Z1hzA3zP4P91L9L/n+SY/aFzwwA15ncBn+A0/FQDQQAYxGsBvhZI/8dmBQNmOyUA7pItAwZq8wKeyicC4WRRBXZerwA/2KUA=", - "encoding": "base64", - "path": [ - "y", - 32, - "data" - ] - }, - { - "data": "uRLxwKJcMj5j4QfB+0aiwKbWEcFaHKK/2qzbwKgPiEAMewjBc0QLwdCe78CkofjAi+hFv6wqb782KFhAAWvewIAGjEBoMmU/hUE7v38kicBV/LbAYJJyv1TrrUBiYrlAil8ePSd1oL+N6uDAE4bIwNhDdcBWf/XAbKA1QGtlFD/4BIS+oUgHwQUs+sAMYxLAYJi2P343IECL1Pi/TsmnwGWvT8DLER+/WRUCwVkEDsEcShxB5I1cv0Pk0sAvf5DA5n/IP5rni8DPVpK/IBf5wKb9iEDcbsLAIDP1wLSmjkDba9LAmMOKQNb078B2ldTAJCW1wOXR+z++5NXAQiiTQCc+4cBoGObAkmLkv339lr/E535AUccIwSrlKUAr8TfAqhGpQMD6g0A4Xv6/VmPhwLqBn7+6ctE/jOmdQOPxz8AtrmC+SyuNP4Bhuz5cwKTAHC86QPxtgj4lBRZAo6eKQE2nK8BkorM/p9kMv/MERsBKSDG//ED7wPym3r8U3FnAMEvpwO356sCQaFc/96mbQErcHz6MXRNAESPtwEZQFMFukPk+bJn+wFfjvMBaEVhA7Tl4QGouIkDejY+/NiqdwK1KzL6XEO/A/CWTv8vh5cArmPM/89zCwOpC5sBMcN3Arch7QICP8711EblAgb6fwMQq6D88kea+z2qMQCe5wMCKgwO+gm+7wARdQMDEta2/XOStwL3UxMCoL6hAgqOdwN73EMCNobLAkn7Mv0AdKUA/nkTAbnjCwKRlQz85ELnAP+aGwECYdsCifvDABIYGwXcZl8BfCqbAoje5wOV5lkDK2PfAu5cJQCLVr0CsjH7AN//nvhiipz/9uZbAYnKcQHPKg0CZ9j4/Ib5SQJl2hEBipJHA9FUKwRdXm0CNRFXA4+Q0P43EucDPx+3A+CIOwZdna0AVIo8/IrwJwCvggcBSNrJAyArhQAPDkUAd07RAykjuwNdC7r9weazAd4sqv8zAcj59RxxA+aL4wA20NMCMbRfAkj2iQOcZij1k2i7AUKChPyaomUBNLkdAhcQIwRc637/COvNADQBXwBn9V78=", - "encoding": "base64", - "path": [ - "y", - 33, - "data" - ] - }, - { - "data": "HmEXwZdOLcDdHh/B5YtVwAJNA8ERd5/ABocLwapZE0Dw2O/A/DMWwf908MBlZeTAQ6GuP3JrrD9Ewlw+qeQNwTeOHD8NcyZAaV9jwFBYEcBMwnLA8mRVwOPUEkB4WRpAbschwPcAicA50brAME+UwLnr08Ao0MbAHpgkv15ZR0BYLXDA5m/mwPBZGcH/DnzAgDJnQAp4qr9TYJTAxE1CwKp0c7/7Y9I/hLMHwUhrAMFHyeJAPitDwJ4h/8Be88zAf6xwQL54IsDm8qk/gOHgwDpCwz8Sg4LA8fDWwDvKpkC/9aTANUWHQAn2zsCWxu7APDHPwATob0BPqqXAnMtFQO5m4cB3YLjA0wYoPyJtyD8GQNM/xT/swMQnnb5PZMDAoXyfQAlmJkAtzajAOc4HwYT+iMAHY35A0iQOQNbApcAJWnHAUbJXQHH3JUA69DDAkwSdQCbWHUAgXyO/Qk/mP3CPYb4gGkNAyuSMwKN5d7/XweA/9AfdwE4neD/aIqO//A/9wMXL9cBvoEVAO32iQGDUHkBuq4e/EgLPwGk0FsFbkLe/PpfbwB1vBMHgKPE+VxSDQKl5hz4m3nzAzg3BwAX2/j9dlAvBQL2aPxiuCcH1MqC/eTHLwGPxwMAQkA3B/vyuP5fDAECMfFBAd8HkwLjSgr9CXBPA+1/cP2gfisB1ZSFAyI71wCnkFr/tJYfA9wXCwIaO78AariFAMczQwLIeSz5V8VbAbziRwJMVG7+baqzAt3blwBXXOEBzlXjApDESwBelscCUteHABXX0wA0UMMA8YdLAxEf1wKdMKUADyNHAEZKEQBsrKEBRgdu/7dHbP5W0HMDyZz/AwAADQDyqQED9L1BA+CtCQDHduj8ZvsrArMYYwYkoI0Dvika/HHEcQOVBa8DFJQPB3fXpwAiKLkCGvxfAmkmLwGa5qMCfpAxA2A+DQPCGh0CtBTtA1NHEwMJOfcADovLANJ5LwOqgFkDCp29A3MXlwBmu477NuZ7AITVSQMiPIUAVS8TA9c0GwD5kOkBQPhY9CEYgwV20gD8de69Ar7mGvzYVh8A=", - "encoding": "base64", - "path": [ - "y", - 34, - "data" - ] - }, - { - "data": "nK0jwTNFp8DT7yLBwE+vvyKv1sAcA/TAUfkSwa3aGr8aOLrA7DQOwZxx2cAuabnAu4dUQO6wW0ABqUXAs6Uawd0pTsD1qXRAg8K8wIwUir02e8e/fHanwGr1zr+5HZu/eU6XwHXT1cCsyIXA8+wpwCnKBMFkf4jA3bWBwPg2qkDbL9bA8q+twMnUJsEVoKHAC2WsQAIEnsBdwdbAUO4Tv8Kjtj9jTWlA2+EAwVse0cDG73hAK/eYwA2DB8Hc/ejAIqVjQDOd+r5gy2NAgkm3wEBz5L/DXd6/cRSmwEzzVkAYTlbA35DIPzO1msBgs+zA45LOwMLZHEDfB1PAWA65Pq6LxcDya3jAX+9AQP/+gkDEmJG/hw22wD3MTsDJcQDBLq0iQPi6TL/coPrA7DcNwfqS0MAYErBAEvvFv+5oW8DBHtfADnepQALgi0DQpvW9FUi+QI05ikCDUGDA+ldpv3yHD0AkyYhArGTxwFJ4oD97UX9Ak3GrwEFlY0BeK3Y/29jtwEsd2sCVA5dAnHE+QI+xjEAj2YjACYqhwGaXCMF9WUvAXFeowIX9FsFp4ynAt+fDPxiMAcAsg8bA0p/JwPgcg0A+/w/BOJxaQCP5DsEUJofAyKG8wD+QisA7/BjBUVetvz0vb0BGOeY+X2EFweRRbcBNa3fA+v3Jv1K6EsDNDZhAh28GwS6y8D/GjcvAEBq8wFN88MCijOi+EQrowHNIKEBEJVO/6l7WwIMlcsBLCd3AavDqwAPElEDpedW/KPEovozezMAbDL7A0O7IwBgnCr8GK+HAJAkJwWAFhL7I95zAsuKzQGsHer+WXzQ/PuhoQHM+usDFFYK/c9eCv57fXb2AeHJAWSihP7ZTrL9RcOfAoH4TwWoRSr/NLuw/Lup2QO7fm792MQHBud+mwJQcJj7Pxq/Aei6/wDSluMD6+rG/KFdDPyNh5T/Y4I29SxeNwDNissBz9ArBjnqnwEQFhkBb+WpA2eW/wKp//D/F19bAePaZPzOXkUBRVQXBREalwGegMT9WDkjAENMlwb69YUCKeT5AEASsP+XJ3sA=", - "encoding": "base64", - "path": [ - "y", - 35, - "data" - ] - }, - { - "data": "MvQfwUTF4sDgRRbB1vQtPzojmcAfUQ7BBpwIwSPYXMClD2/ALT3ywIj/ssBU5oDA+kuVQPBQmUD9hr/AXeIXwQIdzMB2QVBAKEzswN+mCEB89Uk/FcrMwOnBp8C0ppXADkbFwKEfAcHcBhDAtLkAv3kVC8HTmAHAs6PdwE+R2UDQqQzBAKtTwM/4JsEQSbHAvOnIQGTf98C9H/zAac71P9eWaEAmb5hArI3iwBefk8Dc/Kg+PVy3wCTYAcEvNuPAwFa4PwAYzD9ZBJhAk9+BwDTxmsB7L0E/iKxSwJhT5z7h2qe/EH3Pvx6JNcAWAdHAeTu3wKQfkr4zvJm/Q0AewO3DlsCQkd2/U62dQNIfvEB1VXLAW9ZowHrbuMDHYg3BzKYHvz3Hg8CH5xPBZ2EFwWwL8cChhJ5AXVWiwMv6tr+6OArBgFzRQOYmnEDv0SFAFJ2kQCSgqUCwXbfA1ZVgwFYxfEAp3Y1AIhMbwaLKUEDdtbJALt1bwGevskCPOkZAmBzHwPnDp8DvOJVANTqEvSl+nkDr0NrANiJTwG/T4cBww4/Ag4NTwCB/FsGFna3A2LLyv1sRgcDHK+7AdwG5wEXhpUAiYgjBvG6iQDipBMFq89TADyOfwAfoEsC7OhHBsWl2wG34YUB1SRnAO8gJwX+tuMCWfpzAw+yUwN1M/73pw7hAbAQBwWAPfUDSIuzAZqqhwBA9z8DT1FfAwgHjwOhnlUD71+Q/SJX8wOJ/zsD1JfDA5MjVwAaos0AJkyo/JMr6Pw1EzsD+/4zA0WGQwF9s2z8RXNHAPXcGwUm1ScCGlDzAHEXBQPK/jcCE9kFAn5uYQC7YAsG1voQ/qNJ7wEpyTMBosNI/0XBWvzkZfsB38OXAUMYAwUUPgcBTcIdAVF6QQHHaqz8tlefAwU0vwAtTIMDdDfzArUvZwOrntMAWwZnAuYYpwLzVjL9PEkLAtbIYwDlF0MB4gAnBP17PwCvPq0BQhdU/qRiNwKJ9gUBgs+fAKICAv25wrECM1w/BMT7zwK6ozr9ccrzAZb4cwcPfk0CMSFc+qOdkQGaiC8E=", - "encoding": "base64", - "path": [ - "y", - 36, - "data" - ] - }, - { - "data": "5HEQwSxK/sAF7vvARJEqQLCIJMDrgw/BtYDlwLuivMBxP7W/jBq3wFkpgsDWMwHAIeiPQAnZh0CHgwPBiL4JwV/qBcEx0CQ+oID6wCcdhEB+vkNAce7YwJSqAMGGgPDA8ozUwPNABcE21T++PePWP64bAMGkMbI+eWkPwf1b2kAkbxzBDbl7v83fG8EI5K3AooanQFAaFcHuwQDBe7SGQG0hqUDHgnZASmW2wMCfGsCpxU/Az8e5wDFx4MBz1sLACnCBv+Y8YUBlEWBAc5UJwJj96cCAX0lA2QqXvwTrI8CBZ1E/zB2TwD9dJb/jkaHAzQyQwPKRQcDqTHk/kGygwDF9OcCLTQk/WsG2QNNyv0AHUsDA+USvvz/178BwMwrBTxVjwLUb3cDZuhXBFwjpwAIy68A/HQtAypz9wNP/Kj/HpRDBo4nPQH+3PkD8MZtA0yAeQB1CkUBGFN/A6Pq0wCFEQ0DFh/Y/MbQpwVecikCR87dAct2mv6GhyUBs0JtAnbaRwMcGUcADiw5AmD5IwBvlL0AO0gTBdh+sv9XvpMChpabAD1eQv2AFB8FF/fLA2EyhwNOjrcCeye/A83eUwPYbZkBTVvDAeX6uQFhx3cCN5wTB9jZvwML6tL3BTvbAIuW1wJ+8Gj8Li5vAv70BwQZn2sD1jafAOhblwIF/AkCoRI1ACancwMAQjUBMXOjA+AR0wFbdmcBaI7vAJOHFwEmvs0Az64FAVL8Cwc2NBMFEiefAd9qrwJ2Zn0Av/ztAcjJ4QPGNusAZ9ibAMn0ewOGmcEBg5KfA3rjowIehtcAIek6/mSKFQAag5sCMjZtAicB6QEgjE8Fs+z5A1t7HwPckvsAk9IC/R6E1wHq3vsDH58nARzfKwHGR2MCce7xAmjJjQMqGcEAJm7zA+CUtvW+Vm8BUSxPBtpvXwHo5osDaMfPAWQyywBGzd8BMQK/AHapcvrHp1cD2ou/AO2TZwK46p0BEFmW/6G4jwJ5tnUBhDdLAlwJFwLpwgECOHAbBeBYTwYNaasCBLwDB5AIJwQMqREAXMyTAZ12nQIFREsE=", - "encoding": "base64", - "path": [ - "y", - 37, - "data" - ] - }, - { - "data": "8vTwwOFL58CBKbvAdc6MQP3mR77fswPB/7iqwIDL9sBAb30/MFtiwGQUFcC2SM89/ogQQDdK1D8gJhnB6h/nwD1aE8F2sknARlDpwJW6s0BNgaBASxPOwL5CGsHJWBbBSFnHwOpW88CLlPE/oNFvQHsG1MBtwyxAZ7kdwS9fjECYIxTBi5izP8zpB8Ei8pnAp3/jPwgZFMH6a+nAHge9QJiatECeV6Q/q6yAwLrOnr1qPcfApxWkwLiCq8Dd4ZHAAgRXwCJfoEBiaEU/0mLrvZEVD8FLAKBA1OSAPxEWqcDo2jhAHOfhwCJQyz+Ah0vAt989wHbTrcBj3kRAzVrgwNwcZr+LMjFAZJGHQPxxcEBGEvLAMbJ7P17EAMHn9PfAnw7FwNCoD8EF5QXBDoa6wHssy8ADTpq/QY0dwTM6LkAHRurA5AiCQL5e9r0JD8tA9ppPv+UY+T/K1+fArtPiwFXJPj/TGvK/7B8fwTnbSkAGAGlAvHtnP5kSlkA687pAL8omwClFir/2G3a/Mei5wIkRGb9UzQjB2CwyP291PsC/gKnA8s2QPyLg2sBGMg/BKCzzwFrowMDGddHAMNpGwHiAkT4rNMPA/sprQP4QosDJgQ7BYs8SwExMCEBKW7fAKSzVwARbKcDMINDAbODgwAR72sBoqp3AcGgNwUUzgUAgIrg/EjumwLH+HEDC+MnAjLMUwHpxMsDZx/LApWKYwLpgh0CdaKBAEV32wLU4DsHC/cjAEW5pwOoeE0DGHZ5AWJSoQOx3mMDNayq/wgqXvmvKpUCcQl3ABImuwJRZ8sBHbrE/BLguPstUDsHxWatA8XuTP8WLD8HdIJJAvlv2wCxdAcHQTmPAYjWRwEFA3sCB45vA9e+GwC2cC8HIIbxAwNB4P2RftkB2fIbAw2IpQMOe1sAr7BDB2Lq8wK8AhcDLKRfBZZLuwEXnx8AgA97AtRb8P72FxMCQS7fAJz/IwAjDQUD8W1bA2sMLv7W4V0APNqPAeraXwFf1mj8zMuDA0swawVOlpcA9ZhTBK8/awMmdCj+Hf57AahytQESm9MA=", - "encoding": "base64", - "path": [ - "y", - 38, - "data" - ] - }, - { - "data": "kcG0wPptgMCtPV/ALgeyQAdIDEABmN7AB5hMwDqACsE6aFVAc8CUv05r8r6/3A1A5vErvxUftL/kDBzBbzevwDAWEsHD0sHAVTHBwLcGwkDdlclAoI+xwLq8HMHpmiPBvZ2kwBZRx8AvSXZAzfuwQBGumcANR5tA0IwSweq+4j4P9tXARe5rQKnU2cBbVHLA/7wTwLiE8MAQ2bvAuFvJQP97cEBoR86/uo4IwAHyEECWNAHBCgZ9wCLbVcBc4i3AUsSswOM/skCU6gnAf5H2PynfFsEjb6xA90BIQNaG7sC0bZZA74EMwaAGbkCtwoy/i16gv5ii6sCOz5xAk2oDwfvUkz+MNJlAnCGUP7KP8z7CJwLBSidRQBGy7MClQMzAnDUBwXNkIsHZLNXA3fqCwAGtm8CXC47AHC4pwfxjkkDsZWfA9hYKPa7gT8DO1chAPuN/wGiClr+WNNjAX9X2wIJh3b/+3azAAaDswJeOPj/CTsU+Vs9DQOEfwz/yAKZAqcQDvwamlT+W3IDASZf6wOIaecB24vnAot0rQEv9JL+rv5rAFJtSQL8imsD5jxPBjlIWwdtevMDp0p/AIoyuvywdSsCmr4zAjVg0P2yVOcCENQDB4Cs6vxSShUD6E1nAcf/awE7sscA5vuXATMGwwP8SwcDMpoLAzz4WwY7itEDtWO+/zHVKwKG0bb4Qr5vAmgozv++xGL+gywfBROlAwDVnlD8hiWxAPx7WwNb79MDI2pvAYBfYvxrvjb9KiMxA5V+vQAbOWcDwPag/P7XzP5bHpECuerS/2G1OwIvyCMEXHF5AlXB/wCowEsGJH2BAtqr7vzCN/MD3CapAE2wEwXUTF8ETFLjA+3+4wHBz3MCH2kXAUzLxv7L5GcEhn2VAHFj0v23d1ECPIRLApN+bQKRu+8DdO9zAwTeQwL2BQMAE0yPBhtwDwS5EAME7herA9kmAQCbWn8B/bmTAZUCkwMycUL5O+63AqF+/P2boEz8y+U3AJFS6wAKq7r+ID6XAT8MJweoEw8DBFhbBYQ+YwNPDBcBsEtLAWgtIQFJjfcA=", - "encoding": "base64", - "path": [ - "y", - 39, - "data" - ] - }, - { - "data": "rO5fwKOZeD+ASW+/yDqtQJlvjEC99qnAkPtjv6FqBcEWRq5AgvGiP+0KtD+Cs4ZAHxdiwPh9icAsDwTBt4VewLitBsGx7gXBBA+LwCxekED0H8hAOyCJwHEHCMEDHiHBddlpwHEjjsCOR7FABx/ZQLhGLcDrE9JAeXDLwE/VacDL+gjAHmW0QBjVmMDu+x/AdB/CwLw6iMBYuYDA+n+MQLC2FD981InA5mgEviIojkBfrgvBhPsfwJV/jr8aJDa/jtTewMC5h0DmYZrAGYV0QM5nBMEz1GFAf56gQHXsDMHSLb5AOQYYwWFsskAIUIY/9U0IPx74CMF3TsNA4QsEwYIPSUA/C8tAWE4NwHC3OsD7nuTA8BipQCeOvMBAzpXAYogPwTXlIsHgOJDAINoKwDPWRcAy8eXAAW8bwdx0wECMZpE/srKCwC4Yv8AIsopAgDTXwLCshMCnnbjAJE7ywMf1gMDR8wPBPUVCwO+t7L8gkT7AbXKgQER4/L/C6htA3lvNP8KvVkA4XdPA6JgOwTzE18CKD87AAL6NQFUw3D878HvAo/OhQAebIcAOwP3AFuojwUm8pMCAP0bAhGTsPkhkx8CvKx/AS/IbwBeWEb93bpvAQhJhPyvDuUAQh1q/hSPMwJ6O/cA9SODAL8ttwMNimMAESTjAxHIFwfCv0EC1Ip7AhOxzvxNkOsCDzUfA56t2P8iZ0D+rcAnBD2GKvx8IDcDeiKs/bKKpwNmuicDCnUrAPMO9Ptvfi8BsDdpADDNeQJRk7b8rw01A/G19QLI/QUBNnjo/t3xJv4QVA8G9P6ZAuunxwL2d+8AcvvQ+3IaawFW7yMAecolAf0oBwVtnHMFZJu7AXL/JwOb6wMAk6Y+/ebMMP/iDEMHcYKg+LJmRwOi4u0CO13e+b96vQBwKAcHjczDAzhoywL5m2b9PbSDBT90BwUnfDsHqM9vAb2S1QKZ5XMA+Gpm/GltpwLhlXMAQdN/A4RhbQLjLFsBNxJC/n7vJwFK5lsCCkUHAkZuxwNTvzsBk7vjAy+AawLN8kMBlDenABHpuviZffz8=", - "encoding": "base64", - "path": [ - "y", - 40, - "data" - ] - }, - { - "data": "gZeXv7z+tkB41dU/zC4zQLePwkDwn1rATR27P2XqwMDxF+NA/ONoQCrCTEB/Ar5AIqfAwN7y1sD+4JDAQD2pv7wZ6MBBex/BeXkZwD6Hoj/tH4JAH6UxwPhaucAZzxHBPvH3vykOGsDwg9dAJXbjQG/F8b42ge5Am/3fv3+b6MAHTU1AwHbcQB+jH8C4oYe/nCMSwXIumT1ep/a/UQ+IP+2zL8AtC9HAy5bwP+StxkDMbQfBs9Jmv2p9lz/H2ao/xl/7wMCfmT95jt/AeIGqQKChosA6LzA/Hl7OQAimD8E3FsJA3MIMwVXB3UBXo0hAu2ISQGlADsHwd8BAACXNwKPPnUBtkuFAOaGpwHzevsB/xWnAkjDXQAqXesCcIzDAAjwFwS85CsFT8wXAhFUVvslplL+ZRxPBhZrawMb41kBhsbFAmcT0wFCfAMETvLw/v6YLwR1A1MBqkI7A157YwNhVv8C0OiTBF2IXQDnyh8BCwb/AiBTSQJFrp8Ccr4S/aapoQAMDq0DPGQfBvp0KwRLiDsFElZXAazmzQMamfkA6Py/A9L68QGrbyL0x44jAWAYewawrgMCx4YK/UswQQPxBC8GfI+q+JM6pwPux5T8E51A+JmcbQAK61UAW490/oqWuwE5uGcEC28bAXmXavzIQTcBZbr2/382qwBZWvkAvXe7AcJunP7PMqcDKr5u/c6AkQNc4cUBY7v/A83hqP6WTqcBsi52/0+powH/+6z7cBKW/iywaQHaj48C2lq1AGSjfPfIWVr6bcZxAqz20QOCAsDxr7TRA54TZP28utcBEgcJAC8kjwewhpMAboSrAEyvlwMveicCK4r0/zFbpwAa5CsHp8QbBx8e4wIwrlsDa+Wc/G8o8QEiMzMCYyEDA9B3XwIm1UkCD4ec/x+JsQFT328B/XxVA4aZhv1Tnl75yxw/BTA/swE9zCcElK7rAgBHRQBq91L/tOp8/giD5v+WryMBXsfnAo7+gQKTioMA/coI/AebHwJAG4cDCvT2/pZQ2v0fhy8Du9XTA/LUtPak20cDgp+bAJU9mwMHBtEA=", - "encoding": "base64", - "path": [ - "y", - 41, - "data" - ] - }, - { - "data": "rhCYP5UXEUFga4VAR1txvzzs10BZ+K6/PcRuQPNOxb+4Yf5A/iW5QKHUl0CQguZA9yb+wP1HB8HrzVE/orBkP7xAuMAZRCvBCBynvmw1E8BNnxw/XFiPv9BX6b9GqPLAVlPuvUMjgL5UX+FAYL66QLq15D/vQtxA2ANcQLA+IcEK9etAaNnaQAa9jb09c+I+Nc00wfJ1ikAcMo4+dvEfwEhJuMB1FAHBY09uQICP5EAGXvPAwjY+P2LIWUCOf1NAojP4wPvZCsDPnwbB5Py/QJjrcL72AhLAoCfiQK+p6cC3h4xA9r++wBsq7kATpqBAt595QPwa/cDL7nVA09IIwBrEy0CyTslAgX76wNzXBcH/07w/ob/iQAoZ2b9kzjC/xjKtwLsbm8DU2Nw+LRnxPzLKUz+e8CPBH/UHwFtaxUCTbwZBxNwlwVFkE8H2x82/9eUbwUtUBsHRWTvACxavwPak7cAN3zTBQ1LUQCpeyMBpQgbB4nXsQKbQ/cCvdIzA6TyuQENS30AfWRTBkv7NwKcQJMHN0SrAYi2zQMoJvkADQa+/FRefQAlUFUAB0ZA/gOf4wPC7J8D+kI0/Ov57QLdaJsFYJMw/2y31wOZ0gUBAxKhAfA5yQB5nykA/9YZABl2HwDtBJsFlr6DAtGvMPv8Fvr9Yj6A7OFMov4r/UUBzwBHBWwNgQDxh58BkZT8/QK+AQGtMtkCssdvAP902QNvp+sCrDmzAGzfmv1Mmo0A/mic/0smJQNWkEcHh5xBAFmRVwBo6uT+RysNABTLQQFDIQMBrbJhAqtSCQKiugL88AKZAcxg9wa0Cmb/bqLDAzBcMwYrFCMAP5d2/fprCwA+orMDWEwfBs/RUwL3GRMD5zDhATr+kQBci7L8jVsHATkoEwagW0Dx6vG9AG7N4PzTlWMCwLdNA8kSJP4WFjz+jYOvA2DLHwJwyx8BwHI7AfW26QJCkYz6HfmdAUrwTvnYtB8HFLfTASY+9QDyY5sBUuUdAGYa3wN8qCcEB5sk/um6NQLNAvMDY8tE/seUfQBQS/8D0B9HACT/SwGlIC0E=", - "encoding": "base64", - "path": [ - "y", - 42, - "data" - ] - }, - { - "data": "bFdfQFUCKUEUe8tAPtWSwK+HuECwej4/PSq4QMVmaUB0GfBAi4zwQGp4uECBDvZAAdMRwSZuFMFdgb1Ao9hDQICygMCWziXB+XnhP9EQs8CPkD/Aa+kXP3GyKkCkvrTAK/naP7ed9T+KnrhAcigyQMDefEAGy4xAlfHyQOZ6PcH+IRdBTdOdQOCuFkD0efU/hPhFwV194UBZ6B1A7CO5wGhYA8G0awrBqeiiQJcr0EDHFcvAHpYWQOsRrEBvN6JAwaC+wLLxqMBlCg3BzH2gQKkWl0A18qDAwEPLQLW8U8DqxcI/TjaMv1TE00CSg9FARnenQMMMmsDU7ws/bQ5DQPaU50D4UnRAPOsYwaNuHcFw4sdAi4y3QNjLHD/IybM/rFA0vzIWRz8/xTtAkTJzQE6kMUC1Xh/BNZVSQHMHe0CEphFBPn9AwU/FEsHq5ZDALN0WwV7rEsHyx6K/qu51wHD6AsGKkDLBKuQKQcxK98BvJR/BUE/dQOkCHcHW0ejAzm3bQDqWAEGVAQvBBLEMwMo/J8GdPAq/FdJ2QCwR6UBQzpo9+P8mQHjak0AVgcdA0gJYwLEyjb+FmktABg6sQKy0McHFX2JA2tcUweE8wEDdhQ9B1pGWQAaTjkDJnM1ApyczwKQ0IcHixmTAGWceQDcEmz5sxr4/qh2JQIzXpb6QWBnBAICvQNgPCMGeVCtAKIulQGh06EDJL6vA9YCTQLGpGcFjwLrAhloHPpvOBEF2CCRADZG9QDjtIcGNNLW/RMbMwGciQUDfTNFAwwS8QLKAt8C4N81A0XzHQCCagkDXZSBA1U5BwUBqREARUfvA9QEWwZxIBT6L35fARDeSwDgKub0ED9zAcMRiP4Xppr9dhpZAr9fcQH1EWECNUAjB5FsQwSwaUcDCG6xAuAT0v0aH3j8R4w5BK709QBQVHUCVEqrADTWZwBNbzL8yYTbAZSZNQBYIBkD1ILlAGiXVPz9uHMHzG7/AVoyvQKj7CsECVKJA9I6bwMdMEMFWcHRAlJ4AQfOiosA1ndNATEKYQMUOCcFEqq7AXsQOwTuuGUE=", - "encoding": "base64", - "path": [ - "y", - 43, - "data" - ] - }, - { - "data": "3WqxQAm0I0Guaf5A0ZL4wBO+XEDLLjRA2sDpQOBv+EBFIapAMLoIQfwOtkASQttABMEUwal1DcFCfBZB7hShQLnFB8BhlwjBRwJxQHt5BcFnt8jAMoYRQE7ywUD9JVzA7iJdQLZwf0ByCSpAcFVmv5Y7vEAM2XE/I1MdQXwQRcHNCB1BmgH0P7uLkUBTVVFA7bhBwZDmAUG9hpBAx3sIwZBNHsGmGfzASraqQPmIe0A7+ZnA0md2QHzA3ECk9M5AUnzBvynp+8D66fXATAsaQME+A0EIJuvAzUCBQNTq7j+l3M6/jWGHQKNshUC7pfBAVwnDQKh/sj6TCjjAQY3vQOGG50B8RxI/lbUjwaOkIMGTQBtBdytAQHI8OUD9fVpAt8CIQFFExUCpB6lAJsOtQBrLkkB4u/jAkhfyQNzYQT94SQFBZ95GwWPu68DQ0+DA2OPowEpaCsFFCuA+yH4AwCqm/sCUihfBeUUSQdtOB8FRUSbBjNOPQKN2KcES3RfBCKHzQBi6AkEKjMDA3hIwQDZmEcGYd84/1TaXP7dj7UASJsI/KEhJvhVJ0kC1Dh1BzTwXQMRa7j45LaNAqk/OQL9gKMEJHaVA2wcgwYML7kAA3SxBpzeXQBRQ3D/OOQJBUlWfv614AsGLfPy/qgqLQGPuBEDryDlAovL5QLUUe8DxewXB4QzjQGITDsFYP49AsGu6QDtUBEHTamTA5DPAQDleJcE2G/DADGgDQEUKGkGkRIpAd+XiQGZJHsFT3J3A794NwZAljEC1MrJA+uVgQHsF/sDlQfRARyX/QHdyA0FztDK/0UsrwZVGyEBtfhfBqZwKwXkJGUDydunASlM2wJ3tqkAwkTjAX7GeQJJOBj+6E8dAXcL5QMQU8UC30iPBbSUMwZFxx8Bync1AGhWUwOFszUAUQhhB2LCVQCTFYkBwUEDAofxJwKfnbEBzh5G/OegLvtv8dUD/2PJAUfNYQARgIMFARw7AN1JWQDpnE8F8n9hAf5NuwIMG/MAYe7tAftMcQch5gcCuMB9B453QQMN8/MBoz4PAf2wnwX4xC0E=", - "encoding": "base64", - "path": [ - "y", - 44, - "data" - ] - }, - { - "data": "inniQJ5RBkE9QghBMxAlwVvUID8D3JZAjSEAQS54IkHbwAFAIeMGQX0ZbkBnZoRAzKsBwaEa0cBdcC9B2SXTQKj9Br7K8I7A75qyQKG6JcGhuw/BWEd0QB3O+0CmIIm/HMSgQDQBu0CCtYq/FyWQwGyw7ED+zirAXUUkQaMJM8EaRg5BYFazv0DAw0DqT4xA3YEiwRn6/EAmEMlAKJQowYFqKcGJ+KHAQ5pxQDAVBT9j0EXAH8akQKp39kBvzOhA36ZzQC10HMHUUYfA6pUuv1DIHUGp/RDBhQRwP1EJ00AeqpPAcFUGQffEYj9LKvZA36bGQHVasEAuS8HAJvMnQRsfv0DYdzHAwK8XwT3+BsFW7jdB+G5NvgGYoUC4VKVAV9kEQUUnHUE5cOpA/3rPQBqUxEDw92HAoRccQaz3IsB8j7lAJks0wTVhVsAn+w3Bv5JSwM7ex8C3HwhAZMKRvVGpwsBgO7bAKvgGQS16AsG3mRXBK/9rP+TZHcF0wC3BA/zpQMcq2kCgaK6/GvzhQINLssDbXWxANLPWv/z+rkAdRzhAKzBAwKYW/UC4cDhBWF/rQBXjAECrzNdAuyHfQIrOAsF0sMJAhfMWwSfB/0D9DixBkghMQKQvoL9v/xBB0Py5Pjdxf8CVaJW+M1O3QNmJcEAnaYVAbUMZQSmj5MAaRJ3AurcBQWut/cDMEsFAuTe1QKepBkHnqM+/GGDaQOatGsGb3QfBJmt1QDKwFkEQE7lA42PyQHjn/8DJIP/AHTIpwU1Oq0Cv+z9Aeu3oPnMfF8Hr5wNBhMURQd0kLUHFpnbAcTzwwGi+/kDqJyLBjK2/wHA+kUCFdxPBvj+AvyyjFEFCASFAbfgBQQw6FUCSk+hA6qLlQNkCHUFaYy/BBSDjwOIqCsHjBs5AlaXgwAKAHEHEKAxBIHPCQDwYg0CRigy/laWzv+TjAUHJDh8/6K5fwDZAq0B2Mg1BEqydQP6RDcFeQB1Am4/tPgXuBcG5WAFBxLwawJr+kcANAvFAbHMiQWFxNcANMTZBzJLoQMD3oMDr2CbAi2wvwaagz0A=", - "encoding": "base64", - "path": [ - "y", - 45, - "data" - ] - }, - { - "data": "e0f0QE2EqUD4P/BAythBwbwgEcC/nsdAlxXoQOHZLkHEq8e/QcXTQH/VJT9BzcI+kZmcwETbCcDrli9BC7/sQJtL7j+M37c/17jiQPmRN8GpQS/BQsiiQKalBkHgZ6w/i8nJQH1H6kDORpfA9CP3wFWOA0Ebs8HAXA0VQQWjBcHcDd1A1S2TwM+uzkCuaaNArUHNwD+c1ECx5fJAy6o5weiUH8E+BfS+SgqjP6kCP8CE66C/jaHEQLd070B+ReVAqnYEQYBfLcHyPl4/BUxuwBNvIUHIiR/BWnATwH4BIEGioejA/F0sQe93IsBVWtlAfhqnQJuSE0FTMwzBo8U8QRcWV0C/Z7zAGSDYwGOKmMB8FzhB5N1ZwJtq30BKHcxAB7ksQb/+N0HgCQ5B3RzOQCDn6ECA5+I/sDAjQczos8DaHyhAHkEFwVRh6z+cKR3Bu/zGP+kRAsBnl21ADSjvPyb9zr9aw9q9XOnYQJ3Px8CXLcrAwwk1wHH648CzvTLB+4KuQOfAa0BfYHJAsv4fQeR5lr7aAbNAwe+MwJfjAEDoqIJALviywOBhA0G40jdBwmEpQYAxXkAmAv9AEN7WQIdNesBAKbVAsbXhwFPa5kD5HBNBrH8uP0/ig8AvtwxBYh36Pw7f4j8qNbM/OE7FQNg1qEDgoqZAW4YfQWvnHMHY2ii9bzgDQYL2mMC+VuZAfxKJQI7G50CIOsw+YXPYQPdq4MBPFQjBMgOpQPqo/kCvA9hA1XviQNx7hsAsgyXBLpY1wVr4tEA4nkO+IZwrwIfJIMGvPgBBjm8WQYAuOkEcGdfA5Q8twJSYBkGiLBjBsHavvwc6zkA/oyXBrNhjP3gONkEBHOdAa0oiQZBLgUDXmvNATr6SQHIxJ0F5jiXBIsJhwJRWJMGBH55ARSsPwetKOUHvqdxAzrLfQNqGaEC4bfc/cwHOPvrqMEHprxZAoGTSwA1Vz0CSdxNB8MbEQBUeucCjDtJAnj0gwLBercCKjA1BeACAv7dcQz4KgglBqrEVQX1swL9NsDNBs1zKQMhiw7xPj36/kjshwe9eVUA=", - "encoding": "base64", - "path": [ - "y", - 46, - "data" - ] - }, - { - "data": "GsDSQMC1nD9ISp1APp5QwYRUoMCQweBAhymUQGgLJkE2maDAFVFXQETaI8C4YF7AMP3yvLeCPkDzrRtBiQPcQJSxb0D3S91Ar90BQQShN8HXOEDBz428QCxo/UAedGxAtOzkQHxPA0Gxhv/ASkQmwXTz/UCP/A/BrcznQI5CgMAM+IBAoWbvwNe5p0BRiqdA6fWbvzpHkEA2QQNBB503wRbP8MCrXYpA77S0v0UayMDtMB8/fifWQIJmwEDS6rZAwUA3Qc5uLcG6YrlAkLzPwBdAEkE0rRzBtmyrwDKHO0ESJhfBO7k2QYjRt8CM1ZVAV29DQCBONEFhsS7B34M1Qdw6Dz59YwnBMMgOwMhaNz4TRh9Be77LwLlVCUE35NBARL83QTV9OUGF3BpBXp+WQGiM90BfVtRAQnMVQaxuBMFTG4C/6sR0wFXU0UC3qBjBHyPCQKV9MkCDsqJArTxtQGa1cEBhGLFA7Q6KQH2uB8BJYtS/yn7KwPiWJ8An+SHBsScXQBOmer7r7P9ATVMzQbUrpECC2eVAu7vawAEs5r+rEKFAkXb6wPGf3UC1fyBBjl8+Qb1cmED3LAlByZKsQA91zj8e/WlAAaMswBh0nEDKaM1AZtL6v33S1cBz8d1A4YVcQLXt3kBkSEJAgjKkQFmXzkChWr1A7WoTQVSCPMGBNJxA1PveQOCQsT4Q4vdAsk3nP1sTjEAzjxlAMTmwQPRcG8C4it/AATrCQCA9rkC9zt1AqDqqQGCpNj8qRD7BczwvwcgbnEAH0ljAY7uzwNU3F8Fpi9VAPvMIQYT/K0EvoRLBdys2QLpg+UAY9d/AUrlvQGrj/UDXHCjBMwgvQBpHPkGogSdBcfQtQfYmskDAc95AUx+FP+J7HEEfUvvArtqdPxGWLsFS0xNAtkMkwVgxO0G/G4NAXE3mQLYiBEAg7olAOzMMQJ39REEPNX9AWHsTwS6/4UC5WAZBECLcQPwblr+4FhhBufiowJtgDL+G5wxBSF/sPjQ8nkAsSwpBWL/xQNT7170bThxBVKd5QHJspEDxvSc/IKLnwJ4Xvb4=", - "encoding": "base64", - "path": [ - "y", - 47, - "data" - ] - }, - { - "data": "omyAQJlxRcBkicg/z6NOwe157sD64MtAZCyIP+6qCkFn2AHBkXXUvqb1scCk7ODAz1edQG7I7ECFLO1A2ySWQHLpqkCFBixBtkAHQSLZIMGxPT/BRqW+QMuG0ECGabpApWTrQOzyAkGeZyvBvUlGwfkxwEDR1jXBRESIQOzmnT/Ou/I+nYsewQuiSEDVxJFAmbGJQC531z+QFvpAyvUbwdyxR8BgOgNBKNx/wCPAEcE5ch5AmovSQHh4YkBYWUBAh+BSQQiXF8GYQxhBWr8NwTk25UCFeQDBVJcAwU8DPEGbdjDB6b0qQe96CMH8iOY/MZevPkHcPkGkVEbBeDwWQVe2R8C4ySvBSo07QIB1o0Ds/eFAMAcPwXCYG0FEUp1AH7YoQb2zJkGv6hVBDHXyP32n4kCydiFBgdjtQNkWJsHqwYjAQWvIP+z9HUH6ZPHAmaYWQaeV30D2k8JAyEyqQK/mBEHV0BdBag+ZP4AoOEBFJV1AO/IVwT2YJUCX1efAX/SNv1awhcCZoClBse4pQS3XE0GHbQRBv70Nwfq0rsA5ebNAom0ZwVykg0CxAOxABB86QZIkuUBCJwRB2og8QFTf00Cg6ns/xSseQCDV2j/SYyxANyqOwCWFDMFULHVAQGKXQDISJ0GhPpFAGWI7QCwe5kAQUsVAAQHuQMQ0T8GwyAtBt9SJQMrgr0DFOepAZQV/v1EeEz+vlohA6FlLQF9hOUD3zUvA7gO2QHQ9BUD8or5AlCAhQCPirkCRGEfBn9UPwbZSOECSdcrAPyIDwXVt5MCzFoNA2jnLQOQnB0G3MjHBujnsQJBCx0DZLx3A49D+QMTmC0GiGRbBUkGNQGTjMUEbBkJBjh8iQTHi2UDRf6BAzooqwBYAAEEkc1rAL+62QNoAJMFrgim/K4wsweMaJEFOOhY/UIvNQK64zT1glc1AxBR4QAUVQEHBxa1AWfQ0wVLj20BohcFA4nrbQALWcUDQLTFB1A/3wBmAkkB6bvJAyk3zP1YYC0HjN+BARxCbQN3dpT+F4eVAyHhnP9ySFEE33BFAM9ocwFTyeMA=", - "encoding": "base64", - "path": [ - "y", - 48, - "data" - ] - }, - { - "data": "PbBTP6vXr8CTM/u/JY03wSCfF8GtB3BA3YYqwIrFvEBSLivBEZmFwItOA8G8miHBLOcNQYjHJkHGUIVAJ4bSP+xpykBRTExBeRD5QM2g2cB+RCfBqsaeQFvuiUCpaPFAZ0LTQMl02kBK/0zBhuJZwX3MMEB/cFDBN6QdP0x7w0Dn+kLA/0Q8wVcUMz+X8j9ANpsIQUJgvL8Yo8NA5THCwGjhC0Bk1ipB9Q/LwGXlNsHhDodAwAmwQDFUID+4H0++dZhVQTfVyMA9kDpBj6grwRKTiEDnFoTAbXEjwRV/JUEpPz7BHsMLQTIkLMGgQae/SjMbwCFoNkExDlHBGEPFQFMfxMA3eEPB5DntQNl3D0HJa0NAQhMwwTC6I0EjVANAHf4DQcePAkH9X/BAHSSYv4AsmEBvAzxBZRqVQPkdPcHpNrPAPpHPQEXaNkEB73LASrAyQUn6HUGH3c1AjtfRQNgmOUEaEDZBEV0IwA0X6EAA7/lAS109wZaD5kBd9iXAQ6+PwPvY98DecDVBgBQJQYtjOEF+nQlB6wImwU/aC8FAxrRAkyEswQC0Jj9wwG1AM4YhQbQ3zUBjcdNAoN35vD38HkF8due/+2njQNPj17/pHsW/U3jUwOWeJMGa2lM+0tO0QOpGQkGEBbpAPmmfPul45kDm2rhASVeXQJOkUsF4Oi9BFuNvP4UnGUEDIK1AKuFtwEnmVcBsqLtAsPbGPvrV8EB6nOg/L5V2QKKc2r/2CW5AlLsnvx10EEEIZDzBvmGhwAyxrj5A6g3B4u0kwTmcOcBfrFI/ZhZHQKEjn0AAi0XBPVIcQRaDdEA3oDdAScIqQS4qB0HBKM/AAkS4QEVrE0HQPEZBnGr6QOX480DU0glAvhvFwPHvp0D8Nvw/138RQSQR+8Ch1mXAkCkjwcCS70DFEz3ALF+PQATb8b+tEgFBhfeqQCqlJUEx7dFAi+lLwdNHt0A5ZShApaC3QJ16/EB2PDJBiZEbwcjIC0FdOZdAiGFPQKdEL0F6Y2RAfpOsPxObJ0AOrGhAtU8MwJwLQUFgqnNA4XZGQF9Yr8A=", - "encoding": "base64", - "path": [ - "y", - 49, - "data" - ] - }, - { - "data": "PboPP6g74T6Bw9W+XkQkv/ehD765aQ4/ukzFPdOAiT4rzde+SuYTvwswnT5cVha/KKCbvpSJC75D5t4+GzEivpQPmj9oSL8/89PDvthWdb8lWVU+S9FJv5r/Tz9egHm/zUuvvdWAFz/D05S9I92RPo/ruT2X6e4+7MHrvqZUcz598OA+3UqivpN2hj/tpgrAwhjIvcJ0SD4v/bO/jdv+vqBKYL6nDmE/UX+SvgEydz/Mmbw/4MUHv1bZ/j7eB8O/9XtNvnbJlL5i//E+B5kKP/FrtD45IT6+P0VHP7KrnT8//9g+5k/RPdgSXz+lQ00/SThPPz9gjD/ke4Y+4iMSv8qlSD6lMje9rMc/P4pKhD48NNU+MwSlvqIIrj+j9Nm+UEFRPwcIsT+ydSa/93DKvngCl78Td1S/1+cOP4tUpr6+stS+PHqYvwAZHb5lBwI/7nA3P8GNTr++ITi/G+uKv/nwAb/itxm/R8aHP/azNL6vSAA+/2YjPpXh6j5B60K+NWoPP/6AeD1FPUq9ZffVvpQ7Y77m9uS+eU2VPoMfSD+j+me/bgoPPbhUwL3m3Mg+kld1P9vvBr8WNZG/UqnyPm+uNzxeNYO8e80jP2pKij5UV6o+H/prvlStJL/dUm+8VkVwvo/OOz5Xn9E+tesTP0f4lL8mQFe/1wwrP1jl9T7GP7a+sIeiPQa7UL7TbV++lBNyPwyJ2L4bSaa/0xXCPcGkuL3GRDS/fW4dP0owq75lcCk/mWw1P5IdSL7Qizi+IszXvh1s2j7IoFO+6VmQPuaMjr4qzBu/OkBWvcMrm77tek49zsShvnV/PL7mr4i++Lm4PaiKxL46NoY+P8UCvxVCFL4zOGM/1E4Gv7v4Lj92UJY8BVmWPv2tg755FRU/sx0BPx86Fz8Dnl8+KRsVQOr2dz2I7/k+C6lwv62EWj69M6K+QJ0Xvw6HSL9yFZ4+9JWCvnQ4kr/N8Tg/KGOhv4qJgTxmXLs+yIjzPu76lj4hb1m/131vv9Qp4b5SIoa/o9fAPUpJxL94DJ++ZM9Yv2KK2T4RSJw+lzg6vsOstj4=", - "encoding": "base64", - "path": [ - "z", - 0, - "data" - ] - }, - { - "data": "6lU7QHccRkCWsjBAC1wuQPflSkCPjVhAnFIvQEJCXkA/yy1A1RU6QEB4d0AjbENAIFFfQNPaP0DXg1VAU9ZNQPYPjEDe6JFAnE46QJIvJEBMvVlAdzkWQEPzb0A76ihA4XBCQL4uU0B/LD5AzVdXQGT1OUBE9UVA1PstQBr9YEBdf0ZA3tpCQMWZcUAL1Zs/FI41QLaiTUBk2Pc/r5gsQCGnVEBhiotAG5JAQG4gfkBs+JhA8AgmQOKvRECK+N8/FFweQDkZWkBn42FAgj9bQITMdkCCnSZAKPpvQC4/b0C7cVFAWI5qQNBBZkDbPWJAk1BnQK+sVEBxbEpAr9I7QPhYWEBCS1RAiMxtQK4tTUBIoUpAMFZFQM1CmUCv1zVA7rBLQKXRjEB0+zlATQZcQD4r+T9f+SNAlhGBQA7qMkAF0VNATkH4P1aJWEAj3GFAtZM/QIGvMUB7wTVAHYEVQDF6KkD+qCtAavdtQNgUJ0BKTV9AZYJKQDi4N0DeKE1AuSRsQK3aLkCKc1ZAKpY1QEPrQ0BQ9ytAsadmQEi+jkCyDSxAPWdgQNBtRUD1LldAIYqBQDtaMkAKWwFAqpI9QGfDYUCm+E5ACmp7QC2aWUDwXlxAh/EdQNecLED0qRdAJyw1QF4EdUA6xUZAKAZeQJHI+z+WVDBAs1OCQBtGV0AiJTRA1KQyQEsUW0C7rRlAFuVgQC9HFkDvvBFAJ18wQHzlQkAxog5AdbpCQCrKTkDuFGdAv6pjQNxDW0CsUytA7rYuQPCsSEBbcyNAObhPQB4oWEDAyQ5AK2UxQFjfNEDqd1dA6VU3QHsCOEBlc0FAE/g1QOmfR0CQsDxAbTQzQA9DB0DC2oNAVh8AQDc3gkD5siVAGRODQMqeUkC1sXZAvi5BQFTqckALTG5AKz2lQNuQQkDOB1ZA/zZaQIEDZkARokxAdms9QOj6GUCl/lVAwWRCQJYeKkAzhFlAZWP+PyFsZ0CkPUpA9WhPQGRYQkA3gjhAqtwtQIbTO0C0fChAPww6QI3Q4D9ptSNAyTQOQKTlWkDxYD5AbkpcQJ+ocUA=", - "encoding": "base64", - "path": [ - "z", - 1, - "data" - ] - }, - { - "data": "aj+gQPmvpUDyBrJAuEK5QDc7ukCh5a5ADx6iQF3quEB4ybhATKa/QFsZ0EBuscRAmsnQQATutUDhP7BA/ZO9QFUz2EA0UtlA/DC8QLeAu0ASYrRAY2mmQGkuvEDgXrtA2xm2QEkYqUCNbrFAUOe2QBDyqECdCalAajCmQESjvUCtLaRAZJa9QAxku0CUCI5A+bCoQP9SskCmJqZAOMa4QE4Kv0DhVeJA6Vq5QFf5u0DC6OlAYYCpQAEfpkD5QZdAYtKbQArLxUCvVrBAw76sQBSEzkAT1qxA0xWzQDD3qUA056xAqRzRQG1nqkD08bJAFmeuQFCom0AO0q9Asjm/QPAQtkBMCrtA3DC2QM4gskAQC6xAzN69QCvG60DjZ7JACxOgQAhQ00BuC8BAI07KQO9Hm0BEg7ZAUIPQQAHTtUDcUMdAPWWYQMVdv0BHaLpACFWbQLeexEC8scBAAxOtQBWCrEDWvrFAnV+zQH6TokC398BA4S6yQOLKoUB9ub1AWEi3QNceokC/AbxAhs62QCs0u0CsFLRA7ba5QEfx50CUUbtAH2q8QN61tkDsOrBAWJXJQEaotUBkr6NAahahQF5fykAoVrpAaVHGQG1XtEC7DLpAIKSfQMNoukBCyJRAbTivQCcy1UDxvKlAZi22QH2Rn0Ah9LxAFNDQQOwerUBARLRAZjasQHbTxUCgHaFARM2pQBmInECXQbVAMeafQKBqt0C0tZxAxmGhQEOQwkBRILNAYYK3QE0Wx0DrQLBADMe6QMQ3q0D73KhAE0awQEjtw0AwF5hA6oumQFharUAic7lAT7+1QAgNqkD6artAe1yrQBrPwEB/EqxADUK8QAV3hUB288tAn8eIQF0i1UB5maJA7CbcQE06x0B8OcJATs6hQHHqv0DyiMVAYQvmQFTDrEB8yK5AvITeQJaTykCwHMZAtG2+QHbLnkAhB7hAu527QLdWyEBDtadA5mqfQI7iyUA/JqtAmFirQH1hqECuY8NAmMK+QP3vvkDkAb9A/BuhQAp+mECu5ptAp52hQFgzuECYHadAMb7CQOpuzEA=", - "encoding": "base64", - "path": [ - "z", - 2, - "data" - ] - }, - { - "data": "/9zaQF331kBJ6/VAeMr9QHk570ARrd1AxRfeQEBY40C8Ef5AwvQAQdJ2AUGw9AFB+d8HQSuw8kCOH9dAn8PzQMZQBEHnygBBUdsAQZaKAkEGE+ZARQjzQNzv4kDbTwRBrJb2QCsF2kBJlvFAmZvpQFZN6EDrhOlAkkzVQByZ7kAYR85AyqP3QPkT6EDBkOdA6S7fQPKa4kCOwgBBexj9QI376kA9WA1BGQf3QFec2UDxSw9B9UbvQC7g10BKMOdAbZTQQCwF9EBeb99AIqneQJT390C+t/pALWDZQNsTzEDlKudA0wMGQYce10AoXd9AbEDXQGqOwkAld+tAFSL8QHy65kAnKetALrreQAnF60BRSOBAXxXyQP4NEEEbqPJAeOLPQGht90CJwANBKn39QBaf6ECSYf9A5sr8QFbc+kCqCQBBfNPcQE/b6kAixupA3vrMQFQlBkE2BAFBZuT8QAA57UBBi/JAAl/VQB2w4UDqMvZAjHvoQA7G4EAVovBAac3dQNhy3UAgeuhA8V34QJ2F80BAyP5AREzjQL+YD0GaQQVB5/XlQHvR8EBVodtAWTzyQBz1+0AfhPxADkDXQHUi/kByDe5AodLrQCil40BPPelATN7gQFI/AUF7ANNAsYrwQDJgB0G/UuFAmZrnQGM+9EAtlQRBVnT3QDp15EApTfZAgYLzQLLa/UBoRO9Agm3UQKuR20B9EQVBmiPXQGaQ8kBrtN5Acw7YQPsM9EArPd5AKGPmQFrn9UCFVPtAA3v+QDsz6EAcdPNAovjoQGT570C0H9hAYM3fQNls5EDp3OpA86X3QKdv3EBpd/RAOdPtQMDf/UCYSfJAgfoCQak1tkBgn+tA/wfBQGTNBkEkE+hA2XYIQSaiAUHiselAr9zSQJ7c6EBGX/FA5iQEQWEJ4EDMvtlAQCUVQSHMA0HyuQZBZ8/5QENnz0A+3+9Ah1DzQId2DUHldtlAhkTyQFr390Cab91APCTZQG3Y3EB3qgJB0sUHQebF/UCAcARB6+XGQCuV50Dcp8pA4U3qQL/Z6UC1iulA8LDuQChH/0A=", - "encoding": "base64", - "path": [ - "z", - 3, - "data" - ] - }, - { - "data": "MFUBQV5j7kAmNQpBbMcMQbZWAkEHK/RAZjIDQX1j8EDIuQlB0Q4PQWvBB0GVxg1BbyUSQYhSBkHuJdRA93YCQdkhDUEZxQJBoI8RQTU3D0EEnAJBd5IPQbXc6kAlnBhB5EEPQShc/UDG7QhBC4kBQfrwCEEl+QhB8i/ZQBHL/kAC3NpAZWcEQazm+kC/wxNBwBP2QCoF8UCR0hhBwPgIQZGV+0CC5xZBZCgGQc/m50B4YhlB+QwMQYKM80DNDA9B7C7fQEVL/EC9xQBBerMBQafI9kBiFQ9BKpnxQFf42kCrqQZBSLMMQa+d9UCuUfZA3tPwQKev0kCDIwZBQ+QFQWdn+kAE7/9AGzn4QIoHBUH5B/VAXhcBQaPXGUFm6ghBYSjoQM7t9EDMvhRB428CQRflDEHrgw1BBZsAQTIEDEFkcAhBeGgAQeiT+UD9CgBBGEPpQHgYFEHAqA5B/yQbQaBfB0GlsgdBWErdQGEFBEEMUgVBCbkAQbPYA0F96wBBWkT1QERFAUHVTvpArzsJQanLAkG/mRFBo4X7QL0eF0GH/h5BrJ76QF9cBUFQCOZAn2r5QPu7EkG6XhZBN+D4QE5uAkFvuABBLtL0QNVb+EDHC/hAhQcDQZ48EEFozvtAzLEMQZ9uD0G7pQBBbUH/QBODEkF5iBpBaVf1QJ1BBUHt3whB/oUNQTOXCUGujQ9BIO/vQGAXAEGL8xtBdrf8QFlHBEE1pgJB6Oj4QDx3/0BOoflAL2n8QAJp/EAfTw1BaB0IQQ8aBkGQSA5BTCMFQSIf+kC71AJBLbr9QIEy9UBveQFB8c4JQVOC60CxTQNBOi0JQVTpCkG3sQpB4TEXQWinyUAr2+tAwA/hQGu5FEH+ngpBezsPQQddB0F0vPVAMcLrQBWi+UDbhv9AnD4EQXFB+UBjNulAvh0pQTYdEkFKkRtBeI4JQUiEz0BpQQdBb4wCQcDiI0GUZP1AkT4SQZgg/kDnqPVA3IHvQIpM90Bqig5BNK0gQdq6B0G2hxNBU1bBQHQ7DkHk0NFATqMKQTYUAUEXhApBa276QDM8BUE=", - "encoding": "base64", - "path": [ - "z", - 4, - "data" - ] - }, - { - "data": "+EoAQXvo2UBOQP9AARcCQYAd8UC52ORAY8YAQdv7z0BAZe9At00DQQkD60B/Y/1APqT9QI4U9kBIbZBACR3rQLGsAEG4zN9AIjgHQUkHAUFXk/pARl0KQRiryEDO4RRBVBkRQf5b+0AN1v9AUazyQDcUBEHbdQBBz3CeQGgm4UBbILdAW+3rQHWn5UBzeRdBi2jgQMoH0UBgZBZBXknyQFWx7UCmKAZBu5LyQJNR1EA3Jg1BRA0JQaAy70BHtw9BPqmuQFfS4kCquf1A423/QM/6zkAT8wFBrZvmQOrBwkDaIv9AKQ7rQGzw70Bnuu1ARnnqQM8guEBtMPpAPePmQM1X40DYPu9AeJ7uQA99+kC9q9ZA+OPsQA/+DkFuRAFBAKbRQHZmykCwKQpB+HniQLSmCEG0u/9A3hbeQPTZ/UAIkO1A27LyQGYT6UAZcutAilfZQIYHBUGLgwRB7wgnQVk5+0BtcvtA3VO9QNlg/kDoMPFAcCzxQPW+/kAvb+xA43PtQCjh+0AjF+tAalf4QIWC6UA54ghBypPxQJ2NBEF7xSRB89bwQOmh9UDaL7tA1WrdQNCzEUE0DRJByQv0QA2C4EAkUOhAji/YQKRx5EBrSdhA4VL/QH2dAkG9k/lA0BEOQV8L80C/r/lAm8TuQBm9DUGzOxlBGSnQQBIeAEEepvxAFX8FQfzd+EAjhglBrsXoQAk0+kBivhlBQgX+QPwO7kBOcP9A+PjwQNMy20BIXPJA4aPsQGSN3ECZHv1AC0zqQIPjAUFWVgVBHTr8QAas5ECs7ARBXpH0QARJzUCWUPJAA+v6QFHeyUAAruxAyq//QAgL/EDAzPpA5HMTQWJqp0D/38RA3d/WQAMoD0ETEQZB2t37QNRB5UC7vtpAJ8LdQM9X6UCxZeZAfMzeQAj55kDiEtJAxiUnQVqQCUHEXxxB0VMAQaTpiUBmsANB/yPuQHEcI0FP2/xAfBwQQZao3UCFvOZAvsrfQN+o6EBrnQNB628jQe9r60CGWQhBrypsQKvrDkF3T5lAeWcDQWWu8ECSxAdB3uTlQP4j4UA=", - "encoding": "base64", - "path": [ - "z", - 5, - "data" - ] - }, - { - "data": "66m2QNsUiECU3qdAFrGxQOP+pkA+OJ5A/Cu4QHl7XUAGw5RAk4uqQEn6k0ArXpxAAu2WQNYLpEB5khO+NO+dQOo6rUBbsIFA2ue2QJrzqkCW5KtAVpPJQN2qXkBIrO5AkbT1QBzwtkBeMapAp7moQAY7ukAIU6ZATaZWPyxnjUB7ARNAu62bQN/JlEAW8PpAZrmVQJ8Ac0B8H/BAq7qaQAZsrECx8adAnQOjQOu9jUBXw8ZAjEDSQFYJtkC6xOJApiXCP/LZl0DyLrNA/yW2QF5lXEBpj6FAo+2mQCuLYkAk8qZAbyiCQP5xr0CvZbBAmx+wQJ6hNEBf5KNA2qCBQDcMmEBm6adA40CuQNoeq0C/fGhAna+kQJJy1kDv87RALwh5QPo7NUBctL1AwSqRQBCiyUCw9KJAvPKGQGsZn0A4e5BAZ9WoQADTpUByd5dAPOeMQFG3o0CYybdAnJ8dQSXUpECNTKxAgkkxQJwss0BH05tA0dipQLuRr0ARLKRAJ8KwQIQmuECHuahAe7qgQGkWmEBihrtA/SStQK8oqEDRJRJBGY2vQCPgoUBBWwZAjEmIQLxJ6UBdGt1Au+m3QCPch0BHS5pAn0KHQMQumkDaYGpAOMa+QOWUqUAGWbVAbyzqQETmhkCLAbdA3LijQAEW0kAzEvhAOkxrQNGbq0Bz2qxANRu0QKWBoECnuMNAsUitQPYYtkD9PPlAXnK+QC9Zm0DrsLNAiFWrQCBceUC6yq9A9haoQBbeiUAkZppAOZmTQCLzuUB4GbFAHYWrQMHynkBGVNBAUBuzQDGNQEBeRKVAsN+lQBzrXkC0c55AHnynQLW8pEBHh5xAxjjkQLID2z+U1T9A2WOOQHqF30D+J75ASgGeQH5CiEDykYdAuOmcQBhuokA8e5hAgLdzQHr5kUAIg4VAdxMMQXLYxUBa3wVBcKeyQFAsQz2gyMpA84yiQD+fCEFHcrdAa+XdQOnuikDOyaNAa4+bQIUXokD8vb1AlyAMQQkDkUBVMb1ASwyZv3to4EDkZfI+Wv20QOjDnUAidsdAls+hQLtvcEA=", - "encoding": "base64", - "path": [ - "z", - 6, - "data" - ] - }, - { - "data": "DGZ0P2TzkL4yiKg+wIAqPy6TVj961SI/7S2FPyQHw79ctak+MO+LPmDlqj4Yu+A8ygYVvrL1Mj8bwqHAZWA9P2jXCj+O+Jy/bnJtP1TVMD/kNhk/4dH0P569i78ysoBA0N2MQEl2kD/mROM+5jJEPzg8fD8SD4A+AquBwF4yVj7jHD7A4ffgPiD/Rz6KvItAUZklP07rHb9B93NAthX/PnaVhj9ZghI+sHRaP8skGz+8t68/XiUdQFUeAkAhK0ZAP6dkwJBsLj8Gh2k/ZItpP6+Atb/w0+c8T0WJPxzgLL+Zqqs+jwt7v0Guiz85zuI/vgC3P/E2AcDgzcE+ZMZ3v/cvUj9Y01M/NOGPP9g0Dz/45au/mEVSP4b4KEAItGE/qIXvvu6VNcCLz6U/INTEPvFG9j8SnYI+MPw0v64OpT1IzPa8vXuFP1iLZD9Ai/C7+8SePoDaAr7CLF0/H7X1QPgxEz5uaDM/GuIowOiEgz+UN38+ftdtP8R1Ej+ftl0/u6ewP1qv2z8waHA/hDflPhO1sz718l4/qExqPzlBWT6YX8dAeuWOP24J/z6L21PA/1JSv4ztYECwpidAckntP9AQl76ZhUE/3inCPcqTUz8Mr9i/eaXgPz8L5D4iy6U/g7puQOMTm7/2dLA/pD1FP8srBEBLLIBA2V5pv3FuuD6vMz4/7l1RP47KfT6ofbA/Wly3P4uGyT+n5opAQ97qP98ZAj9u4mE/9qZdPygjS79jKIg/WayoP85nMD6Y2j09BMLfPjYAiz88Huc+Rb4nPyvfVD9kKDBAirnTPxDhA8BQ1TI/HBg3P9AZcL9k6AQ/JaWoPso6/D4/A4c+3xxHQDQVUMDYGPi/wt9GPn78PEB4RbU/AKY4PZS9bL4nY2a+GD2PP8cYgj/zyA8/q+a5vzzGFr8kChu+jvSpQPlzuz/R2KxAoDVbP54OkMAf3BBAEsc0P0bApkDh8qQ/s7IvQKjCOz6bjng/NaVAP6G6Sz855eo/tUGzQI5A0r1oT5A/il21wPieUEDTVJDAyVU+P8rzwz2pcOY/FW51PyB3zb8=", - "encoding": "base64", - "path": [ - "z", - 7, - "data" - ] - }, - { - "data": "nPCQwHhBkcC/HpTAnGiVwI9Hh8B3doTAaxGPwPORtsBEcHvAcdOZwHo+gcDgAZfAp4WRwEJOg8BSJQXBlQ59wOi8lMBbkL3AMluKwDMei8BdIY/AiTBSwNOansCHgbW+ICKivsDrhsDOTpPAPEyIwIdckcBLRZDAqzPtwOgBf8DBOtjAw/eFwGUriMBltYO+6q5vwFpFkMBFK4C/i1mAwI5PhcA1d5nA1I58wB60ZsA5uYjAoR01wHivG8CIIQjAZxPuwNE8d8B6xIzAxf+RwD6kr8Ceg5PAICx+wKJDjMB9To7AfhmtwB6RhMC0EDDAfghlwNVevcCbZ4vAeTSswJkBZMAKx4jAJg+AwOBkkcCQ4rLAy9WFwBWGHcCpzJHAXKaMwMXF4sAk4HfADVB1wDuvXcC6YY/AtxWnwNqHlsAhCI3AyDdzwLSahsDWupXA4hN2wDB3oMBIt5bAZWyEQBm6nsCRvY3AUm3SwPCUhsCBsYzA87eFwMHclcDSZYHAm+RowAKmRsDnbojAurGFwDUqhsCKL5PAzBiKwFV3m8Aslf8/OmyHwBcWicAE+ufAdCuwwKdguL+3IjHAGIE8wJ8ej8Af5XLA4gZ5wKVWaMBcEcTAd4NfwC2YkcAya3DAAZuXvzu8v8C4Jm3AmPl/wKssYcCqZn2/Xa+cwJ/ck8DLfI7AWNWMwKork8CYJ4rAk8ZjwIP5U8BEZ2+9jTRLwHpIgsCE4IzA9U6JwFvinMC+kIHA+P9QwI2RdMCqe4vAoXZ1wH/Li8B6UJbAf/CMwHQXgcDqMAXA8ElCwJ1HxcDj34bAsZ+DwFsTl8Cw9IXAl1CSwMx+jMBe4YTAPtb0vyb+3MAISr/AGE6FwPVJGMB3CXXAvkqUwNMZi8Do5onADiBZwPA1ccDpQnrABD3BwAC4rsDxkYrA4V8QP613hMCQ2qw/9UeSwENH+cCSuT/AZqOFwN8gPT+7FHjApIAlwNy1dsAnKnPA6XR4wOXqgsBXP0XAKSSrPyUJjcAQRIrAbnkIwbPTr78tOP3Atk2UwCvfl8BlxFzAEOR+wJovwMA=", - "encoding": "base64", - "path": [ - "z", - 8, - "data" - ] - }, - { - "data": "AqYLwRN37sC1mwfB/cgMwXmgBMEpPgHBe6YNwXdtCMH8pu7AdKQMwdW58sD6TwTBxl31wCk+AcGu0yPBjN71wPz6DcHhKRTBfJwLwZGeBMHuQQPBc777wAXH7cCP95bA056iwNhWC8ErSQnBvNgCwdGsEMFf/P7AdG4Wwe7S5sCo2xDB5l37wKR3+sCtRJ3A/SvkwMMs4cC8DLTA6o73wBIzCMHRhAjB0N0AwYnv58CagBDBWZrzwJMJzcB1odvAugUiwST6+cAFYQnBDAgLwUkwA8HqQf/AsMQCwdbU4MBEL/7AvGkHwQcABsHeFdfAeij+wEWDCcF2t/7AS94GwTKn58BwUAXBZwEFwcVjBsFypQfBOREEwWnS38ApDw7B427lwPReHcHMTQPBmeTpwEvoA8EAa//A7u0DwXeRAsEbROrAOBH0wEGwBsHBfgPBqvvnwB4kB8HYJRTB+FO0vpXFC8FZPQXBru0OwUp7BcEpC/3ACy0FwZ4nCsGROQPB+N0AwaGj58CeTAjBDFrzwMkU8sDWtBHBtLEGweDGB8ErwjbAqUoJwUEbA8HCNhzBL/ELwZG/xMA06/LAU4TlwJPJ7sDeoPfA0kLhwGtX7MBYOBDBZQ4AwQbRA8HLJwDBu0O9wAUEFsGL9wHB0VUAwdsFCcF1wrrApdDywEXvAcGy7QjBRkoLwUGzA8GQ6BDBdGz8wHtU78DRr5DAXQ3zwIrU+sCSRgnBpN0JwT2k9MA/UwbBbPbmwAGG5MDYfPTANoDuwOdwDsHh4wbBHMQDwWThAsHnV87AmaXiwBPIDsFBQwHBBWL9wPuc5cDE2/3ALzcFwXBwBsEmyPTAdmvSwPJbFcEe+wvBdpDuwNus5sC28wXBHgwDwTRs58D8jOvA+gbjwE5e/sB23PHAkaQWwcORDcFpw+XAwq+OwEIyDcFV7UbAaAYRwdiwHsEA2PbAUcECwYSrgMD5bgTBlunswPZq5MAjlvDAvDjxwFITAsHDvOnApw9UwHPk8MDQIwvB0kMhwY2nucCExx/BjCkKwXJPA8GmfAHBpzQDwQl+C8E=", - "encoding": "base64", - "path": [ - "z", - 9, - "data" - ] - }, - { - "data": "Jw06wRJUEcF+kTTBZOQ6wUCMMcE01TLBz6k/wc6fIcFqnCTBNo06wSw6J8E46yrBIR4fwSqCMcGlOi7B+mwnwZyWQ8F4VTbBXlZCwUFpMsE6JSzBlUE5wQRPCsGunAfB7doQwZrQQsEp2TbBbgMvwQxARsHgfifBjT0hwfGhGMF56x/B0CsrwY+4KMEN/g3BLZQXwZA3BMHTJRfBG3crwWHeN8EbxDLBCrkywSJiIsHs4kzBHr05wRzYGcFsoCrBEwE6wZTiLsESUTbBGEs2wRLJGsEPkybBMn4zwXWuDcGkRyjBEyckwVn9NMHKeh7BZmo2wQG3IsGbMCrBTDsjwYrDIcGlPDLBurc3wQtFMMGVbyHBHwMywSQJK8G0i0LBbKUQwf5ZNMEkDznB5jkgwWfnPsFspCTBUN0ewbu/J8HHMwzBHZAkwYqmNsFi6ivBf0UawfOsKsFtw0zBeTeawAf2M8FumjDBLskeweFTNMG72ybBOdE0wczUNMHHqTPBUog3wU8FKMGL0jfBQoscwbZwHsG/OUnB/z4zwaoZL8FEa+bAs2w4wehaM8GBVS/BWi4rwVLVIcEszjfBu2kpwQ3gF8GiYy/BOCsWwe5lJcG+qyfBQdw3wXblLMGDbzTBaWEewUowOMGs+jvB0XgzwVEbR8HcgB7BRUMSwayMKMGROjfBz+4+wSsQK8HvoUjBnd40wWChLcGCpwbBFg8ywXcQLcG97DbB/JlAwTfEEcG+DT3Br+olwadDHMH+gCPBaUAnwc6iRcHcBy/B6LAtwUKQM8FSyx/BUrokwR4YJsEW5y3BxYgpwbSkBsHWryzBEqAvwQXEOMFi1ifBNccnwSDPKcEvvSTBp+kawWVeM8EYQj7BLF0twUAZEMFaehnBIy8dwf3UMcHJxCXBhYw7wckILsHETgzBdcYKwXBXRcGx/OHAUS5KwZTYLcFgkTnB58MwwWXUAcFWeTrBFyo1wVfGGsGBJyHBOdMjwYL6McEm/CzBSfPvwFgvH8GWpz3BgzgmwQNFGsFCxSzBZXw3wcjfJ8GzDz/BNtw0werfHcE=", - "encoding": "base64", - "path": [ - "z", - 10, - "data" - ] - }, - { - "data": "ap1Wwf9bFsHCplHB3JVVwXVxS8EwnFfB4PZfwRJfKMHW7UXByJpWwS1ISMHXI0PBX/A2wfTYUMGTkyTBffVFwZYqbMEXrEbBxH1pwbvJT8HbS0bB1uhlwRWJCsFhuTjB0zRDwXEIasFuhVHBXp5JwXhPasGxREPB1Q4XwVp0LsFw9BnBM+hJwXw9RsFqf0DBE9wswRomA8FDRUbBG31MwapdUsH5tEzBxvNTwedRQsED6HrBySZowSO+P8GaM1fBYTc/wbaIT8FLv0/Bu5pOwWyJH8EFEkLBPoxQwdc5G8FAOkXBpQ0uwY2lT8Fm/EPBf9FcwR+CLMHrXUfBEKsrwdFkQsF2TUzBfbpVwd8SSMFIPyfBF75MwQ7xV8HQBWjBGvYcwd6jN8FJ9F7BINA+wXaiZ8EUFjfBSKElwazOP8EZhgvBV9g8wTbTUcHrhUTBtv4tweGuP8EHn3bBrcMKwV+0ScHqXUrBhh4awTCPUMEECD/B7UpSwfuKS8EzFFHBDYdZwRYGTsE1/VLBBwErwfCqNMEdDXHBmq5LwfqnR8E0By3B7GxSwcFbVcE34S3B/BQ3wTibVMFt8GPBAARSwTnUKcHjqVLByxguwbc4R8GSJCnBqB9ewQm+RsFxBVjBWJpRwW77R8GwamnBkxxZwWN2c8FKIlLBoVwZwYBzQsEmHFHBsw9hwVnfQsG0RG/BoolbwVIKVMFGUzrBm7xawbaoTcENPlDB4RNpwUO0FMHDjmTBWbpKwcFBOMGNj0DBjYZLwfpNbMF5MUbBvXtHwfjfT8GyfUvBgilKwTPHKMGSiUrB7gFDwfkWB8GRYEvBr45JwQ3JXcGs7EjBDqNZwQNILMG71y/B/kEswXRyZMHpfGTBEv1JwYagGsEczy/BsHI4wYtnUsFoAkXB/AVRwfjEOcFJkxHBHmk/wab2bMFhliXBt811wf4LKsHlT2nBhAlMwcdTNsG7XF7BOd1jwQPANcH+/jbBZYlAwTZvUMG1t1bBDw4xwTv1OMEw6F/BNlQXwZBSTcFVriXBXIxUwXTUO8HT1W/BeTRSwQAjGME=", - "encoding": "base64", - "path": [ - "z", - 11, - "data" - ] - }, - { - "data": "bZBiwexWBMFxE1/B12ZdwVx3VMES+G/BokFwwTgDHMFFelnBd4dgwYCyWcETVk3B3rxAwSW4XcFPzgXBXERWwRYlhMGpp0XBTNiAwVimXMHt31LBLdSBwR4k78C1LV7BXxBoweLXgMESGFnB5fJTwWIBfsER2lHB1lDtwARHNMGhOvzAMWBYwZAqVcG4KmXByBEywXR12cDg3WbBVRhcwd2DWcFcs1bBnYRkwTBVUsGv2I3B7iCDwcdHV8E1rXLBgJ4xwV8sXcEYS1fB3k9WwfWyEMEuqlDBVhlcwc90FsGiKFXBkd0kwTbsWMHsHlvBGpVxwWmiJsHy61XBIyYfwdZRVcFTJFXB66lgwQARUMFlxRfBc/RVwW1FdsH8Tn/Bnk4VwUdKJ8ESKXXBvhhRwf5jgMF4CTfBiUwYwTo+SsE/O+TALY1DwQD3WMHtqUzBZ/wtwe1mR8EhU4nB4QU9wWnMTcHQWlPBmbcAwXuPWsGRP0bBJmFewZdIUcF/nlvBK4towaPIYsHsxVrBxjMkweSmO8ElGoXBXodTwcM0UsG6IVrBLppZwfAcacGyFRfBkc8vwbVlesHqo37BvIRrwXj/LMEsGGTBvVU3wYglW8FgARTBAelywVYGUsE3GWrBkDB4wemARsESS4XBlv1wwdkliMEDcHfBOpgNwfuCUMHNRFfBXEJywdcZS8FfPYPBba1xwTlQacG4jmLBQ99ywbp+XcHbIVjBXb+BwRK8AcEx4nzBVR1hwfRiRMF2mE/BJP1ewZGigcGEfE/Bep9SwdLOWMH8A2fBt4dgwVihFcHIpFfB7thLwWH15sBtjlnBaQlUwaLxdcG7OlrBj5x+wYoVHMEWEizBumEpwVdug8GrVXnB7Q9ZwTglEsGQ/jfB6mpCwej4YMFaT1bBQQZYwZWYMMEdgQHBKZpkwe+WgsHklU7BxFiKwQb2EcG2tIXBbfVVwarCXMGEfnDB90GBwUyzQcFcKjnBUgZPwWDTXcEbH3HBLEhfwSP7Q8EEvXPBOjjmwNx0dcG4RgnBQvJhwQHmPsGLDYrBVUxcwXq188A=", - "encoding": "base64", - "path": [ - "z", - 12, - "data" - ] - }, - { - "data": "pRlewa2DrsB+pFzB5rRSwREUTsGPB3zB+FdxwYdI9MCxrVrBno5YwdWlWsFTvUjBFYs6wW6jV8Gv8J3AEVJWwXQbjMGb6DLBP7iFwYquV8HOflHBdjaJwT0OocA8i3fBAkR/wW8whcHV2U/BPCtOwRoYgcHXOVLBKhR1wCumKcFrQJPAcjtVwWR+VMFQPXvBzdEmwUDmfcDxjnjBOoVZwfHCTsE9vFDB3g5kwSJ9UcFK+5fBDaGKwWpPX8HLKn3B9fgOwXshWMFMTE7Bw0JOwRgZ2MANOVDBbQVXwdmT+MBwMFXBouUGwcoRUsEmQWHBkRh1waWqDsEsdlTBwlX2wJa8WMEEdU7B90BZwVmmSMHk49/A2lRPwQxdg8FhW4TBj6rtwG72AcHxL3zBy8ZVwU/BhcG+tCPBOWPrwNsVRsEhWHjAsgM5wZanTsFjMUPBVwEZwVdSQcGVq5DBQQljwee+P8HEyUvBCU+hwFkWUsF+sTvBXNVYwaIsSMH09lLBrtRlwapxZsFiYFDB4IQGweRmMsHxsorB8jdMwauiTsEP5HnBKs1PwfpxbsFN19DAAFUUwR2UicFJy4TB8EB1wZldIMERNGPBQFYwwRGHYMEE28vAgsV2wYJTTsEEPmrBSROJwYcwNMHu2o/B6q16wQdcj8GGFIfBZR/ZwMNMUcEqG0zB8hRzwe+XQsF/lIfBn1Z3wd2bbsGZy37BizR6wXI+WsFNy07B6+yHwTkmrMA1CoPBlxdowVljP8FFoE/Btj9ewWRthcFM3UvBRAtPwcl3UMEubXDBL75mwdq+08BywVTBkmREwaIHlcDUnlXBgRpPwZ+9gMEOrVjB2U2LwbaZ7cDhbBbBf24Pwfq+jcFxj33BhFJawYXI6MCu2zDBlPA5wbMoXcFs61jBAHZQwbrvEMGEy7LAYe95wXMch8FxbGvBiqeTwZBYxMAhRJDBuuJPwWxhdMHKCnLBTdSIwV4yPcE8SibB0f9OwWvaWcHj/nzBoQKBwa/DPsGG8XnByRxXwIweicFtm6jAM3hfwZnDL8EOEZbBvLhTwXVwgsA=", - "encoding": "base64", - "path": [ - "z", - 13, - "data" - ] - }, - { - "data": "2qtIwYec/L4lyUnBsGQ2wdhCOcENoHvBvF1jwcoheMC0JUfBMmY/wUV4SsHWpDTBmPkhwWmTPsE+dKs+kRZEwVP0jcGi1AzBwXyDwZ4kP8GNTz/BeAOJwS3fnb/xM4LBHGOEwcg1gsFxkjbBe343wehKd8EssEHB4nS1P6/cDcHJUgg/5gw/wQOzQsG5AIHBbQwKwfSXwT7mF3vB9sdDwW0INcGyizrBgaVRwZ29PsFZDZzBuNOKwVZFVsFNF3fBp9GkwItiQMGhqDbBFw43wUrwNMA6ID/Bl7tAwc1QkMA9DkLBq4KhwF+eOsEKvVTBMHFnwTvMwMBqfkDBrURswNEhSsF84zjBzQM/wSnHMMGLxCfAsGE5wVvzhMHNEoLB0th1wBtXiMBifHTBXppHwasnhMFy4fbAaxZswO0pMsGey4Y/hxwdwfoFNcHMeibBDNnawB/2K8FuapHBljN8wby7HcFSYzPBqGquvhEuNsGpRx7Bqn5AwcQ+L8HZ2zjB7ZdRwW7MWcEqLjbBc6SewGAtF8FNgInBbXk1wRNKPMHs5oXBxzY2wbr2ZMGWEeS/2tzDwGRqj8F814LBsgJvwQ30AcHpRk/BkOMWwQN/VsHxy9C/BddpwdhoOsG++VjBDrSPwX6yD8HpapTBpXt1waujj8HFJovB3elGwIaIQcGvTzDBbsFjwWOhJ8Hd2oTBHX1swYB6ZMG8QofBxIpwwWqKQcGI+DLBSfCGwe/YVL9iAIDBCsJewfwUKMGDYj/BIIJIwX92gcFSWjnBmRA8wZpEOMHPEGnBhrdcwbHjAsDORUDBCIAswUpaKb9U8z7B6sc5wcU0gMF34UHBprmQwa3tXMBL69XASeGywPltkcGCfHHB6h9NwZ3+dMBupRjBS1YdwbrkRcEniUvBwkU5wcw7rsA0yqK/ey9/wRLjg8E3oXvBxuiWwQq4pb8+g5TBdnA6wUuYfMFPt2PBJNWIwQGtJsGGpvfAW4I/wRcgQ8Eo33rBA1yMwTOfJ8E2zXLBgpQHQJWWkcHwje+8rUpMwcXzC8H1ApzB6i05wZLzlT8=", - "encoding": "base64", - "path": [ - "z", - 14, - "data" - ] - }, - { - "data": "+w4hwaJRl0DupSXBUgkKwQ96FME3Rm7B6fVFwZtB5T8TUB3BwfsUwfkBKMG/DhDB6RrowNrUEcFzvqJAjpEdwV6GicGtR5/AW0J0wRRqEsHlJxnBiQqBwQ6hSEAVI4LBiTiCwfXRb8EVlQzBFH4OwZ1ZXcHlzBvBit6wQHCPv8D5AZ9APHUVwRmLHcFvr3jBDpWzwGBlikDgP27B3oIYwbyGDMFaBxLBnswrwToVGMEiHZrB4MGDwQ/KOsFNoWDB5DNFP/cOFcF2qg7BDbkQwZx6JUCBoxrBRGIXwZ9pLD9tARnBjuhLPt4rEcG25TXB2ilIwTTomL+rlRfBTy0JQBGeKMEDKxPBhNAQwTK1BsH3ClFAFesSwQAQgMFNIXHBgbjAP9hhtj+dPl7BMeojwX45d8F5l27Ag2zKPxHIDMEJ56VAAHnewGy4DMEptejA6D8mwILsBMFceIvBLvuDwdIgyMCm2gnBScGIQFH+BMGcGdnA9M4TwVK8BME/Ug7BL3Erwc/7PMHsywzB/g5/PhxWzsBqi4HBYMwOwV7vGcGIrofB46YNwXYHTMHYZ3tAao2Yv+aajsFdUXPB/ntYwXZjnMCX+ybBf0nQwDX5O8ECZH9A/m9LwY4aFMHN2jbBPdiPwZ30qsBH5pLBrVpgwSYRicE83YfBKSENQG7HHMFNyQLBYCdEwU/l7sDzI3bB0ZlQwdn7SsFuk4jBjZhVweFwE8HuLgLBFf58wa3ThEDFQGrBCnNEwbAb+sDmJBvBlXEcwXTuasGs+BXBbfIWwQKMEMExZlHBeJdCwfbIaUAqWxfB2IcDwdM6Z0AFvRTBMHYSwXiDcsFI+xXBKmaPweBZFEArUQjA4Br6PL6UjsGyFlXBSGQwwdUmtz95c9nAkhzUwPI8GsEZKizBpEsQwTclaj4ck3FAxT90wdL/cMEotH7BARCUwVCdiEBwepLBrB4UwXnudME0v0XBSE6BwXuY+MAGs1XAK7cewaE1F8F68GrBv2ORwbz6+MCcOl7BJ023QC7Qk8GSs59AofUmwb8wnsB42JvB5XsOwb8frkA=", - "encoding": "base64", - "path": [ - "z", - 15, - "data" - ] - }, - { - "data": "1wbLwFwl7UBHhd7AIpmZwMqYuMBqHVPBK1YYwR0fvUDFbrXA2A6xwPoa48AhG7PA+FA0wKEZoMAm2eZAjGHBwGP8fMGyTzo/TwZTwUlEocDBdLjAsPthwWhJsEAmh3bBVeNxwXBTTMEslaHAyNuiwKgONMGUzrvAlWPpQJoS8L/5PNdAMWKwwMKrw8BFV17BYJ+YvwPlw0B7tlHBHqWswPpbo8A0SajAtNrgwCuNtsBNGJLBo5RqwdNIDMFNpznBHki/QGM9qsDmKKTANAuwwBbpwEAV8rvAvsewwBaqq0AzYrHAi9WiQE3IqMB/tQTBhWMWwfLMikA56q/AJanOQNcE58CiILTAJnGbwCkokMAFWeBANeWxwPeCacHJwk7Bo8m7QK7itUBVcDnBoMnRwMjuV8H6bds/bSuwQKydp8Bnl+JA1Kk5wKYIp8DB8irAdv0uQHf3ksB1KX3B/NmCwSgBPr9G1ZrAMm7AQFPzbcAPGBTAvKumwPCYjMCoFKPAnEHlwJyeD8ERk6HAl2OmQMJX7781eWXBLLKuwO0+y8DC+IHByzepwHbAIsHoPeJAUKSJQOHuhsEUjlLBAQ4xwdRaLj305s/A/QgFwIDCD8EsVuJA5O0ZwZ5FsMAjEgTBhD2JwSReiz1mGovBTcw5wQ8hd8ELFHrBraO4QJABvsAw44LA2+kTwbHeNsDvIFTByJMiwWvSIcEg/ILB7PoowWCzocA2e2HADD9cwfl82UBFKkTBcn0Ywb6fcsCR1b3Ag6GxwL7mQcHMU77AU/m5wJEurcDpfinBA2sYwU2e5kDmV7DA59yQwI0OvUAx46vAlYatwJVPV8HdMKvABAyHwQdMxkBubW5AP/eyQJkphcFiJCjBuYwCwWwusEBYiybAHA/lv7hcscApf/DAazGjwMqKsEBk181AWfZYwcl0SMGWDXTB3e2KwSXI8ECpD4rB8RiywH3vXMFiIBjBc0xkwSz8b8AKVipAdfvSwEYbqsAKFk3B4ryPwRifbMBT0zvB9jDdQL5bj8GqMexAH9PawG66SD8WbJXBJ0ilwLLT5kA=", - "encoding": "base64", - "path": [ - "z", - 16, - "data" - ] - }, - { - "data": "jjumv76PAkFODxnABDQGPrguS78qyyjBqNmywD/q9ECETCC9VBkcv2n3FMDaj3S/GQU3QCxZ/T6luO9A67NMvzWoWMHPUrJAX9oiwfS4wT5rCtC+Yu0wweQ6uUD/YlrBTHdQwYWGGcEL3i2+4N19vKTV9cDc7L2+LHboQDdbPUC9NtNAM0HAvjgJOr9W4zHBHgRvQAqPwEDKGSXBPK/WPXZWl73IdL498nTlv/gV9r4My4PBWFE+wabelcAV3AHB5jcMQUBQEbtheS0+cFMhv1j950BpLtC+1q5bvpwmAEHKzxK+iGPvQEYyb75C9oLAaX6iwDC35kBsCF69yH8IQffPKcB0vxC/MGYPP3rMRD/0GApBAQ39vhACRsFVoxvBFVwDQShX6kAz/gXBL/ulv33GKcEtycBAvKHfQFTarr7B6+BAExMIQBhUhb6p6jxAxzPWQL5d7T48o1TBIq90waPfokBMzAk/xku3QPi0FEBAUUJAuGKjvIK5Uj9wQ129CYoawH79ocCAEvU9U9b/QNJXZ0AEwjnBK8Iuv/ZZ5r/svGjBEIT3vuNC0MBBjwFBQfTkQKIecMGCQiPBOunvwGWcmEDKJm2/rU5RQPqsocBVmP9A1hWlwJZndL5lBYLA0vR2wYQVokBxZHnBWa7/wAjTTcEayVTBBTLkQLFXxr5HX50/rpClwMkeQ0AkDyPBRM/BwL3z0MAwFWzBUubUwDOtpT51liNAuEMqwWrf7kBF6QzBw5y0wHuovz8UMga/iMPaPMx9BsG5BYq/tHtAv4xSrr4U3+LAwPW8wHYnC0FVAk6+ZjvIPp9ryEAgH4i9/h1tvgoRLsGSbp2934RuwYq1+kD2TOVADOgMQRoFasHYANXATEuDwI0g6kBFhy1AnrN4QEqjhj14DTbAyAMNP6K5AkGnNuJAnRgtwRPuC8F/9lrBiFd2wfNNDkHBCnbBtGq2vl4pNMFI77XAzk82wXymyD/AG+BAjDfavwsPOz6k8iDBqvGGwXum1T9v5wrBCrXPQLShg8E7Hf1AElHuv7RhvEB1eojBxzwPvnK43kA=", - "encoding": "base64", - "path": [ - "z", - 17, - "data" - ] - }, - { - "data": "0QOIQOgB7UBEFTpAGOKXQOjIlkA5ptrAzcIKvz+j+EB2s6tAwfaPQFaWVUCGuINAGXrgQFWfrkBBE85ATFyZQOV3JMHKuPpAmdLGwM6sq0CX/qFAY03cwI6MkECF8C7BuUcfwRVArsBJFJVAWUGaQMq1RsAkl6dAxx28QPnsxkD8YaRAQoaaQOi/pEBYweTA9wzVQD6PjkDpb9DA2G2pQLJQmUDJXaZAkj+IQCRhnEDquV3BjQcCwfDN2j42/WTA38kdQdd2o0AiyaVAIpaRQOD+3EBxQaVAERSjQM8rEEE4UaNAfLQAQfWLmkAWE4c/YDfPPifvBEHmyqRAoZ0OQTj2MEDliJpABMCrQDycrEDomQpBKhSaQOt5FcFtwavABjgOQdx06EDISojAc9CSQBWo18BmBgNBUNzWQEXOlUDG3axAmn27QFZxlkCIrulApzEMQfCXpECdHxzB2QZUwZcrB0E6SKZADqeDQJT23UAUAt1APXagQELZq0AKKphAGFNGQOyVWb0eIqBAk58OQdPz3kAL4f7Avr6OQKS7XkB4xzzBQTqRQPpx3r+VxfNA7zsAQXYHQ8Grm8rAi/IzwOOg6ECG66ZA4HTkQHBQZzx5JepAbn1VP7Euo0AWL38/w+xLwWVi6kA3Yk7BaDZCwDuLFcEgKx/BXwveQPquqEBFMbdAtFPevbuU6ED5U8TAgJMrv4PN9b/ibkLBbTPWv/0tpUBu5eZAzavKwGbW00Di6ofAAjsqvy/xu0AFiqNARUqnQIy3XcAzqYxAOJGXQJulmkC/0CfARdSwv8uDCUGMSaJAosaXQIhTo0BdPqFAauKcQDOo68BHAp9Aavo+wY67/kBOXQtB9FYjQYCvO8E5/+a/bbmSP54j70BnM9ZA9ib0QBj2rUBOLThAvcK2QBUYD0G1u8ZAXzHhwHD5YcBfoDLB6YhIwXpiDUFX70nBcmyfQDjS9MDk+XS/C2LwwFo9v0AlJhNBBYWBQNPMqUCDEczAeN1swUkmw0CfQpXAyl6dQOGtX8H7kuJAbVh1QANkDEFXPmnBWRKYQGtNpUA=", - "encoding": "base64", - "path": [ - "z", - 18, - "data" - ] - }, - { - "data": "FEMHQbyVrEA1OudARcr1QBKcCUFqOfK/zziUQLYQ1UBliQ1Bix4DQd5c8UB5qPZAsxkUQZrGA0GAx4tAHOUOQQ5hvMC3vAZBXpOpv3TDBUG6pghB6evOv8NJCkBFuebABMi6wOKqu747qP1AUfz/QGGVD0C44AxB1dZbQPGd8UB3yipAEhIEQWUwGUGlZgDAIbT2QKT75j/HzN6/7ysGQad8+kD1cgNBICEMQYfDBkHomiXBbzJVwH6BrEAGGug/eIcaQXCQBUFepAFBZWcDQfBVrEC8jApBKooLQYu8CkFYMgdB0xroQAUTBUGv/7pA4BC2QJRdAkG1hAVB1iz+QGuP5UBsFAdBZLQBQS+t/0D87uxA3yIGQffMr8Df5XU+7QsDQf4WwEA2JCY/UwoOQV/K6r8B3AlBGXWlQGXLAUHO5CBAVDnvQAoQ9UCBuh5BBrMSQYqv/0BKPqTAYs4iwdaaH0FJeudAPVjKP3M8FkEinw1BxTkFQfdy/0CpPvpAiGztQGiym0Av3fhAwOoEQTdIBUHaLVnAHpcBQcXW6ED/Tv7ABwcBQZkhZECw9L5AuBDvQGx8BcHKLMm/2S8pQIEgAkFPahhBQLUUQV5qoUBSAa1AWaXJQOz9C0HrBLZAVc8PwU7C+UC/4xPB7lA6QNIym8D1kbHAR16yQPoTDUGrpQJBLxyeQAKCGEFxX4m/sa2dQEd8T0Ag+QfBDC1xQA7x/UAwvh5BKrRGv9oxkkCfxaQ/02mQQE0KBEGyVQtBnPwFQRurHUDRUQZBd64JQTs5A0Hdex5Am35fQCs75kCPmwhBH13ZQE7mM0DNFQJBmhn8QGwyN8CvZQNBu2/8wPol3kAfgg5BNzQiQRk5/cCPFmFACje6QP+6y0AXzg9Bvw8XQXyYDEFyCvFAYbwMQQjIBEEJ4IVA4TMRwDDxOEDfsfTAJPsKwcDI80CvuQ7BmecHQQPHQcCIQYBAHw0owI1xB0GqmBtBu4QDQQd5BUELpOG/Jw47webGCUGOkKM+tVIeQJ7vJcH6zKVAhkQDQTnGH0FRqDLBUDf4QBw9DEA=", - "encoding": "base64", - "path": [ - "z", - 19, - "data" - ] - }, - { - "data": "BlIzQQvyEUC3KCJB2MARQYl3K0EDmW1AVZwEQf+7kUAOOClBFDwmQQh7IUGFjhxBs/keQSCWEkEKYb8/NIA5QXGQaL7V5vlA5gl5QDvNGUEXXSNBVAuDQNuWXr/OxR7AcAksvwhxmEDkMxtBwFEaQa0s2ECCPyhBbgg1Pu/L6kCiFwi/yXQhQSt1SUHqlW1AzM7rQAV7vb/ahF5AnEgcQXD+FUEbjhZBeWM3QQFrJEFn77vANAgRQBZyE0EP4NBAXdAFQWenHkHq7BRBJ/IjQckPPEBV1CVBj24qQe7Q5UAqGiJBRZKsQGCSI0HMnRZB2ngYQeuF30CKjR1BKIi6QIMIIUG8hCVBfXUQQW1cEEH+QKFAmkEkQQOqX78MoLRAt+rJQI7vdECsialAKDc3QeqlZUA2EPZAPUUrQGDXH0Ee6J+/PETrQDinDUFcty5Bo+gCQd6LE0FnXRw/t+LAwKMNIkEXCO9A4gm6v1CMIkGMahJBcWkfQSGPEEEwORZBmBkhQabuAUFuCgxBlNnNQCq1A0HGY/Y/RWYjQY3PF0HkRD/ADIggQWmj9kDfQVdAKza7QMXuWsBEOGRA2B/nQFpO+UALFkJB6KwfQfRCDEGjWh9AMHMdQSSBLEHBchFBJPCBwCIQ4kB/EJHA8Ob4QEG/GD/ljye+kcBRQNpoJ0GD1A5BFkULQfA0JEGOcohAIvYPQcPN5kBEa3HAfCACQcWxEEGBHjFBqm6gQCQZxT+61MpAmOwHQd0NDkHT+yZBZJAdQU1B7kCwiyxBqvoqQRQoH0FLCdpAGcfuQIk5lkD7aSNBbuDfQJ4Jkb6A1xlBlkkPQdzhGEDHWx5BBREuwEXVn0C/cgBB/HcMQTw9ScBjXvpAB2YOQSDDh0BZ3x1BencbQdybJkH2bytBCwMmQajxz0A9q5w/o4VDQFIHAUGx1kjAkOVvwIcdrUCafobA5/kjQbFmEkBfQPxAJfM5QF1HFEF3cg5BNDgtQe3qGUHyQVRAU2XuwAaYFkGkFaJANrUZv6nWr8BELRpA+RoxQd4JHkE9C9jAlDgTQQU2w78=", - "encoding": "base64", - "path": [ - "z", - 20, - "data" - ] - }, - { - "data": "GJNLQdNc0L/jqDtBF50UQWTSNUGFXPpAnNYlQRXtzz8VqS5BL8I0QfJyNEH9FCpBiGMVQcFCCkEiyee/P01QQamqrUB0dshA10MAQX71F0F0LChBYUwKQatTZcC8xDdAoBKVQN0JCkFZ8SNBuEQgQSiAG0EG2CtBb6VGwDdqvkA46F3AUZkqQaVvZkF/YQZBrUW/QCiChcC0b/dAdVEeQXyIGkEsIhJB3w1MQTZFLUGkqb++Q1vhQMx3PEH8uBtBNG7DQL75IUEf9hJBiw4uQS6tab4oTSpBE5UxQQOVlUAXHihBSlAqQILpK0H9njpBpUY+Qfgcn0D49iBBTT4uQLvDOEHAWC1BZiAIQWAcDEGyq9k/hkwsQVcne0AEyBVB8UJZQMaycT87dQtBmwlKQZgF9kB16rVAvAMAvxVKKEG6Eo3AWy6+QCb9CUElTSdBPOnAQAO0EEGkkcBARNNev7GZEkHOoM5Azzt9wGCoGUHZIwJBRnkkQTsSDUGneRtBUtszQTEPG0FwuQRB/4RfQIYx4ECMoNFAZNsuQdEnJ0EcDC5ArBgqQcRJJkEs8YC8InVXQJDbFUDBdPNAwC0mQQkR0EDG6VZBquIWQev1MUFYEZS/dRE9QS+TNkE9FjFB/Uv1P24KrUCJnJg/rMIxQUtGt0DcFKdAWOZxPod4KkE3wwVBvV4wQZUcHEHthQNBtkM4QbvyGEElXuc/o+EwQRUEDUGzmS5BB8wUQdTaAMAEzB9Bd94xQQ6DAUFvnCtBmBwhQdY5LUF+XTxBuGk1QenIJEF15BxB77giQZdloD8TjCdBFzy8QN/1T8D3aB1BdMUIQSp710As6iRBW0NLQFIREUCUeMdAw6DHQL3IFkCqTytB9ygpQdxZpD95NxlBrN0LQfCvKkFhsklBpessQbyxbUBnUwrAJC/wQMy6N0HrJwZA1HQKQASyFUCCGbw/FPwoQRu23kBKgyVBqeTvQIAnC0FH5t1ARoJBQZ/lGEEpd+dAOzsFwNSeDUHtEQRBY49ZwGGJIT8AV4G/NVRKQRCpCkGGq6a/OYEWQQ92ksA=", - "encoding": "base64", - "path": [ - "z", - 21, - "data" - ] - }, - { - "data": "+k9TQTlNkcAFAENBMKIHQYIlLUGefSVBpxEyQQCq5b+TfSJBS1UyQZQSNUGFmydB1A71QG533kA5kIzAPsFWQcNJFkESVn1A7XQrQal+BEGVpBtB7Yg7QRJ8rMAIAu1A62wKQZYqMEHi4BxB47gVQRcUM0FarxxBBvOowB0na0CBx6XAuh8jQTTRckEHZjtBFYRxQBCEtMB0IipBQr4PQWhiDUHF8/NAnlNPQQe2JUHOlKRAY2YkQecvUkHldDZBx4U+QLJVE0FNPP1AvU4mQRRVT8BJhBxB7EMlQbSEoD/gPh1BRmU9v0BbIUHf00pBXExPQT16DUALNhRBYBmVv80jPUH1fCJBD/7ZQPT76kBLvQzAFD0iQXK69EB4sDhBQK3Nvn3uDMD4WCtBCVhLQan+IUGcKTRAxttcwOpGHkHDoMDAvghmQA5L5kBvDw1B8xA6QF/A80Bp/hxBLouQQMnc50AxiZBA34yqwAvr/kCPdMFA7UAZQcsS8EAIvw9B+SIzQXKBHkFSfdRAQWKfvqzvm0A4YBtBFLQnQZ+wJkHbFPRAiqkhQZclPEHroFPAqkhDPh/g6UB7vCFBLuhCQVIPjkCoDFtBwLD6QNsdREGFLYfAvONIQddULUFIxztBsLPkQDwgQkDMNM1Ai25RQXYMFUGKhBVBRIY1wEstG0E2u9NAbHlAQRbdA0EHHylB8XZLQXFFJ0H599pAgzZJQZKA7kAw3xlBaN9AQcS2lMBTYUNBuptHQVtBxUAytB1Bj3sUQSQxTEHuXzpB1PEtQUuFF0G7MTZBcVQ5Qca4JcCrURpB9bRzQPMZqMD5TA9BGUTeQCNDGUEJMhpBuiQBQZuVhr9+D2hA/bkkQMMJ4ED5GkNBZKQxQWUUBcCi6QRBFOPWQASKHEE1XlZBs7AkQZRhtT3mQ5LA+1wpQepVV0ELyNZAWEnlQAfEr7+rHNBAfZUbQU+BJkGA/TZBekQpQZ+m30Bbv31AkiVEQVfiBUE85xhBYeB1QMta40B8HB5BTL2hwIrK0EAXlHvAxUpSQcMn0EDGbI9AVjMJQSHGw8A=", - "encoding": "base64", - "path": [ - "z", - 22, - "data" - ] - }, - { - "data": "RBZNQdTSo8Aw1zpBGhXcQOSaFEG5xDlBDG4tQegbi8DTIQhB7vEhQTFkJ0E77BdByjehQGBJiUDfa63A335PQTq6PUH6HYM/XRdBQXuIxUDUvgBBrtJWQaaGvMDR+ypBpaAyQUvKQEGH1QhBUa37QGnUNkH8s/1Abla0wGaePj+unZrAonUNQSiXcEHyMVtBniVzP3sArMCO+UJByybmQP1J4UB7n6FAj0tEQbSwEEGIlxFBlXRAQWhMVkE/9TtBD+9pv6y960ByebNAeiYQQfcCocA1tf5Ajm0JQXZUJMAnRARB+vxwwA//BkFYWUlBuo9OQQ4gkr9p9vRA9aOMwDIUMUEw2AdBvAOFQP9nnUAw/pzADg0JQWX9HkEY6kdBc1N6wCBHkcCEMTZBh5o+QbyAMkHvLzO/TluqwP62BEGkHrDATRwVP716l0D2X8ZAJlFvv7k2o0DclkFBAHwNQaOmj0AyQu8/aFKbwNRcrUBFFEVAEQABQW4xp0AfNOpAq1kiQVQVEUFSZX1AVk56wBht/z+rlDZB0C4RQYNnGUEoTDNBxUYKQeAkQEHgZqfAV1Q/wOVeLUFQUjJBiXpMQZ/q3T/wSFFB8dKpQJldRUFoX7PA9JxEQdtnE0EdgDRBKo0tQWF6zT3rOiJBL75eQUZFNUHlmUBBNFaYwEYt+kBPvHZApLQ+QWYBu0DKwThBOQJNQaXfIkEviSpBkLdNQdVWpEDj/utA/TlYQQNPr8Bu5FJB55pLQXs4U0BUUwBB4I30QAfGV0Hu8ilBwuUXQa1u9EBZGztB7/88QbFCp8BS3f5AqJCEP+IHu8DpPeNAuF+LQFkBMUHh3QBB0Uk4QYr7dMCqso0+gO/5v/CQIUHmT0dBwyUrQRBfkMCH18VAI4tyQFOC/UBC4lNBP0oPQW7KXcCKSaTAkA9EQaENZEF7ESJBa3coQen9i8CPDB9BTir/QNKZSEFagDVBhzBDQWpqikBuXQI+be03QewIxkCnNSdBBscMQaXTiUBCFCRB1ISWwMAAMUEY5ajA/pFLQZMhX0Ce3w9BN/PaQE6ursA=", - "encoding": "base64", - "path": [ - "z", - 23, - "data" - ] - }, - { - "data": "8dk6QacyP8CKZyVBNaaUQBII3UB2QT5Bzx4bQfMAnsDxdMRAuwUGQWItDkHHiPpAxurLP9kbVD9m/3vAcIQ8Qa9OUkFdgQrAUWNEQQm4VkAUcrNAWCFfQW8YksDduEtBgxhGQThvP0Ek4tNANcm1QNuRKkE/PqtAT9dhwI38F8CT1Na/AcTWQFQ4YUE452dBC/UGwB5gO8AlmkhB7suUQKtSjECKVcg/fgQtQfLG4EDG1TdBGrhIQeyQSkHd4y9BTkeGwKKFmEBc2xdAfFDcQKVOl8DWvqlAGIvCQDgvo8BLf75AVVurwJfdv0D5UDhBWqA+QTgmdMCzRKxAbU61wJgpF0FPyb9AN5o+P5ezzz+GcKfAsyvGQBzFLUEIN0dBU8W4wByNqMDhUS9BlUsmQeRcMUE4hXrAVmatwJezvEDe0irAtPokwLN0sD8v0i9Am0WMwK0q0z8LqlJBwU0+QSmTdT8DBJ2/7PnGvz6cBUAG7Q2/qXS8QNAVB0BOzJpAK6QEQXyT7EAuoNI+YpHCwAXRsL9GMT5BZXrbQCJ6AUFobldBKEvMQKoeNUE005jAMxmhwHL9T0GRjC9BLKFFQfwWsr9MnDtB/D/5P1j8N0Gay4zAd9syQVFB1kAcKR5BFaZSQWLlM8BXjkdBbkNcQcG2QEENr1ZBM8uUwAF4pkD+Mn0+4+4tQRTHJ0AO2zZBiZ0/QcmOD0FepFNBfCZBQdQ9AUC5E4lA+E9eQRuxdcDDS1FBVS9AQYD4kL76LaxAwqioQNwRU0GJdw1BUWjrQAeInkDmni5BcTAwQZgDtsCBFrNApAIBwJDdkMA9fYxA/ox0P1oTN0HKE7ZAWxdaQRkgncDHpkPAMMymwFbeO0Ga5zpBECUYQV31osBjnVFAmG/nPasRp0AcGkRBPAfcQO9jrcCpuEfAAlxKQY/SYEEA+ERBiwFIQTUcr8Cqmj5BMhywQJ/jVkH/NiRBli9JQaTiYD/mCWrAb8AeQZGQSECXTCNBKMRHQd0MGz8ahRpBkhTCv1SlZEEzuYHAoh44QXe/nr7tlEBBR+OJQPrvD8A=", - "encoding": "base64", - "path": [ - "z", - 24, - "data" - ] - }, - { - "data": "7iYeQWa3ZT9MlgRBRhv1P9VDc0BO4zVBV1L7QCqMLcBqQExAIkLBQLDR1kCsAbNAvK8SwB27NsAB95I9xWIfQdDDV0H4FZDAA4A4QVCDBjwxriJAdThXQeRQgL8+5VpBjFZIQdNQL0H4BYRAKSM6QJxpEUHFYg5A4aIpPyWPm8DeSjtAhrF5QITPRUHBr2NBNh+RwD59rD8gvz1BB7e9P7j/fT80vxjAZf4KQfw9jUAUHkpBkNNAQYGmMEEqbxVBVLyowIpUyD/Bisa/QOmEQK1E4L80F/c/oPo9QOrzrMDwD0BAaFGSwGxnPEDduxlBxqAhQdXzi8DelyRAgE+KwKJa40AUgDRA6fI2wGKXCcCR0jzAA7FJQJp9KkG9TzlBoASrwIQTU8Al/hlB7k0EQTVPIkHaDb7AmNM9wP8dN0AaNt0/KG6jwOCpGcB7Raa/1NXQwB8UE8AV+1NB5IpbQXcgNMAlWHjATLdTQAOt4L/VwXzA3G1MQLACyb8T3NQ/WJq5QA8/okBgT07A2QfEwGv0hcCMCDZB5pF9QB07wUDClmhBXxVcQM5mHUG/bM2/lLCfwKcHYEHTYR1BWrowQQmKfMCTihtBiG74vw3mHUGu0DS/1oQVQbY8W0AayfZA5l1lQcphmcArilpBPPFLQeqvO0HGs1pBl8Xwv5JxAUCF6FjACKQQQVhdor9+9yZBp2wlQQLW4EBJn2pBQAMmQZ/pzb8ygdo+D8RVQcqjCL0KIkFB6GMnQXr2bcAvjQZAY3cRQLt9QEFEiM1AxbOSQPK7xz/LoxNB/2AVQRyYaMB0ICtAUQSPwJsnjL+eR3E/Q3gtwFH0LkHaAStAAbFpQZDdTsDxoZbAgL67wP1BQ0GAkSBBtSP1QLmHRsCdvaK+B7hhwGzZ6D8HeChBBJuDQIxol8C6+nw/KRQ/QRy6T0E72VVB9PNVQXWBf8B7Z0tBa3QeQDt4U0GLAAZBbLo+QdZrM8Cs57vA2gv0QB9aJb9mKBFBPFhvQR9jUMDz4ARB95NDQGT1gkFr8qa+nnwZQZMPdcAj9FxBmF6JP5XiHUA=", - "encoding": "base64", - "path": [ - "z", - 25, - "data" - ] - }, - { - "data": "e5nwQCfqjkCtPrRAWgKQv+kXzz1SxSJB30+uQER/tz8kCz6+RqdOQOBmgUA1MDlA8ZemwL3Tr8DQHolA7NXyQAixUEGSU6DAFx4gQWwTU8BgF3e/qGpBQf/vWkCZ0lpBlkg8QUwiE0FJr5Y/C/movuLc20C4mJ+/l1WVQMEKycB7+MtAv7cEP+Y+H0HDclBBUyG5wOTMn0CC8CRBJnUAwPIKKsBhXqrAB+O+QEpcqT9f1kxBM7crQf4lCkF2rN5AJaZlwBAg+L99MpXAJHhxP5oFJkDkn/G/i+0Qv3voW8DurOe+btSgv+NPCL+AE99AbtryQHAd+r/KHyW/smluv5V5hUCGClW/qmmywDSmocDRC2w/Lt7SvsvxGEFjPiBBJ/QzwL/Jkz86K/JA+Gu0QKQuCEF1jMLAWPPGP3g0Ib8HFKxA54/TwB3Ho8ActZzAAYjZwDK6qcAmUUhBbzhnQaxApcDxnqzAPNfYQKHXm8CH9cbAApHlPQ0Ck8AH3vO/Ge40QNpPEUAfJ7HABYx4wN8wscBsOiFB1R8DPyA8YUClGWlB47qXvebp9UCqhy9AbToKwNB0YEFNRv5AT9EPQVuGosAarORA2uSfwFaZ8UD8kWZAsCncQCxT1r4FUJ1Au7hoQWN+n8DYhl5BR00vQfSMKUEgYE9BkUwWQGh9vb9n7rjAbhTSQNQwj8DE3AtBrTIAQflFkED7nHFB4yb9QM3Mk8B8217ALJlAQRODfUBSiSRB4QwDQbWRwcCf7Ma/EXyVv8H1IUEf7V1A9ymmP4xvDMDuttlAXevdQPUCOz4EvSi/ELS6wCyMSkCHii/A2LirwN9UG0GxZVS/w9VpQRBYMj8MumHA20iFwOKWO0GwafVAZCGoQM1eXz/+umzAU8C8wIxF/b8GLwJBwr04P+uCxb/6EpdAuu4kQVBOMkGy7FZBFMZVQdZVDr8KSElBf/Nuv7WHQEFH7LpAkb4mQd/bsMDlt7XAwd6VQJNSgsBQ6edAaMWCQeKEusDHnctASGjPQEuTi0G/xHRAvPzhQDZoscBglGhBEjYcwMhXxUA=", - "encoding": "base64", - "path": [ - "z", - 26, - "data" - ] - }, - { - "data": "zRCVQAAu3kB+JB9AyupywHRiaMCrfwZByRsmQGHVoUByZGDAuyaPPRwBej+YNyS+dx7HwJSsycClwOpAnrGXQHvyPkGJbyrAGQz7QEYSu8AeNITAI7AfQRIqz0D/iE1B60YkQShh2kDVb/2/J7xdwEK7hECP9YvAgnfvQOZ8xMA8sghBcGk/wHyn3EAl2y9Bt0qmwCEr6UCmdwBBZfaawNKyqsD7D8vAXDMuQF0hAMCpK0NBbMMLQXNzsUBzLoBA4t8fvgVqnMBt6bjACvgbwBEQv0BuGqDAbpV9wHhubjxuHXHA6N8/QGBxeMBP/G5AQZqPQFhy/j/mjWrAMA5DQG/CSD9FGIfAOkfZwAT8ycDtBJBAOHN3wKKi+EDlQ/tAdwh+P7Ecp0CuRp5AiBomQKN0ykBWE3nAWViuQMfSfMC6j/VAVXvTwK2Eu8B16OjAejmfwHve0cAzwjFBbWljQeYVncDvBZ3AugIOQfgsyMB0/dfAtYc+wDTtw8Cu+JnASbrzvvCmVL8a3LbAdNKcPKNzksA4SgJBKCVDwLFAIT9YBVtBlpRkwK0kn0AOOcVAq1oPQK6lU0EDLq9Ak4HJQA6hecC/YoJAxhzKwJmklEAVetlA7Hh3QJNvhMClS9M/O/teQdNcFMASCVZBlJwHQabnDEEUAzdBor+1QOUUkcD6kcfAuOJkQASftsDkj89AgA+jQEwTyT/9hWpBJRCaQByXxsDh67/A7GggQXR82UCKu/pAHNWpQL461cCrgJfASDyGwKI38kAay7Q9omYOwMgLp8AhWnNAQTF9QOkfgUDV/HLAi+CvwOuFxkDf+KzAmNvGwICm/EAieYHAN7RcQUH6jkDq2Ru+f7h/vyTcJ0G/IJdAstEYQGDxkUBAo7fAs/LGwHAPpcBMv6RAO4M0wGcyKEDEo+dACNf8QKbGCUGSQUpBmvNJQdaLUkByEjtBOTCCwEkoIEHaMDRALLADQdGM08AYgEvADFeWP0XGvsBdjJxAkCiGQUt2zMBw5n1A6D0LQVwUjUFjotxAM7h/QD6LlcDvVWZBsLWfwPmtB0E=", - "encoding": "base64", - "path": [ - "z", - 27, - "data" - ] - }, - { - "data": "lNqxP+ZXA0HBJH+/R0SywITb0MD1vsRAuTQRv2KS80DSWMbAc45FwDFvD8AOJUrA8zmdwI2UlsDl6RNB3DjAP5buI0H9yc8/znqlQAXI5MBoMcnApZnnQAQmA0FzwjRBWD8CQQw9fkBHPZbAGd+6wKTWhj+GGtTALXURQXSLfsD2QBdBuuK3wPPtT0CpdQNBMxIWwKcbBEFP9aRAT9jLwDp8ycB6ep/Ak6Fsv6Ghm8CTbC9BjffFQOfW8j/E3iI/iT5eQBmk1sBg64zAQ+iowNkmA0GxEtLAmnXVwPRXY0DCr8bAjWjJQCSI0sAmiD49kaFrP0g9qEAYrLvA6uzEQHKiLsBCdtXAxT29wHTMr8CjIONAnVjPwKp7rkDlxqVApi6PQBi9AUF1RPQ/1F49vyVtbUDoegI+KpABQeEr0MB3jwhBpsiRwLXNhcCAnP7Aj4W5v0sNtMC98RFB9fVRQb21DsAn38+/1yobQdKIpcAkNKTAoqqxwDVttMAGp8rAgw9swEAkcsC3jF/ATHyAQNftob/dobZAbFG8wFvNFsAXHEBBIHbGwI2J6D/wrAdBmy67QMF+O0E3tiRAAZNFQDLw+L5rPRg/SzGvwEc2oj+AtAxBOnTLPnBs38Dg8Oy/FN9JQXH7DkC090JBDCOsQGSxz0DGlhNBJ3D8QC1F08C8no7A+V5ZPjTNjMAbonJA1tzYPz/Fyr/L91ZB882dP25LtsAKi8nAsSPtQEurBkEEwppAggH3P+Fyo8CJP9vAYXrCwK/2jkA0z1HAmzOnwHxy2cB+xcY+BXwOP+MK3UBdOsPA8soywAum/kA+CsjA/paUwM1ks0BDusfATAlEQXJW50ALYF9A2qUnQGlnCkHhbqs/wcBOvwZQ5UAcF7rAxDyHwIyh4sAKwtI/+jCmwFxrv0BYbAhBbNibQNh0rkCHpTFB/lE0QQ9cyUA56CJBctjKwHC86EAxzgm/tGyvQFrdscCIzDU/AEIkwHd2scCLYAlAHaiCQVARl8ACkp4/sQwcQUsoiEF11g1BQcz6Pjja4790alhBLwe4wMjNFUE=", - "encoding": "base64", - "path": [ - "z", - 28, - "data" - ] - }, - { - "data": "b/oEwEdnAUFvhIjAlqe5wMBd/sB2V15AXlNnwBs9EUE79/rAnNS4wAq4n8DDcLLAmKDlv4WVib8Yxx9B2Sn4v4TFAEHT2qtAZdgGQKDj1MDvsdzAfgJ+QL/OCkE/ARJB08mvQK4ERT8vWM/AZ+ndwL+nC8AyrPDAbvsWQZTgGD1MuxBBZVnkwPPLX79vwJlAvOP3P5Pg/ECpZ+k/2JzAwJpzo8Aiw9a/vPyIwICd18BhWRNBlvNMQP6iA8A/9DTAZrHKQDaE2cB7IpO/6EnhwFVKFEEdZr/ACx8EwU1JyECLMOXAs0IIQWmdA8HlXmjAI40ywHhk80B03NTAXo0DQTIAuMDhuPTAh1o3wF/1MsASnQlBisn1wNvqL0DctQVAql/gQGLRHUFzSK6/IzN7wEhCRj+QJ4dAyZIYQZ0p+sC+L/tAoXDTvi+kI79BntfAUG8wQGO4MMDChNRALXs0QX2Gyz/F6EFAsMwTQR7B+r98TdG/pTjnwGpJTsATx7vAl9/MwBWax8B3itM+kYHgQCiCOkDoxDhAV7DrwPbQm8Dk6xlBQ2rowABNzL8vVRpBCioGQTeQGUGKERq/r7z/vuHQWUCDlj3AyTM1wFwnFMDaThhBdGVHwNJJB8HPqaHAbsIqQeWav0BN0CZBDHvgP+PLcECSzM1Aw5IPQRt+5sD0Vme/piRLwLcVob+r2UU/zBz8vyWcj8D+VDhBd20iwKe7PsAba43Aec+IQAXiC0FeqrM/esvdv7qdzb9/FO3AdlXEwH/1bD8x0b7AujPkwEQ+ysBySEXACU87wPvpCkHkcd7AkcfhPw1DB0FcLJvAf5R+vyouPEA53djAaEYhQRCxD0GHg8lAyo+xQJhBykDb0Q7AT8BzwJOhCkGaAn3Ao9IUv0UA6cBugAjANYOuwB7qBEFOSAhB+EavPwsw3z/Hsw5BE04WQdqNBUFzdwJB5J3lwGz+fEAtIXPAZoUTQNxeIsASI41AXhaxwPYfOsCvTFe/5+FxQdFzq780mdK/rYQZQeCqekF2/xpBqR9FwLts/D/JhUBB2YKIwLR0C0E=", - "encoding": "base64", - "path": [ - "z", - 29, - "data" - ] - }, - { - "data": "VLK2wP2OskCsLenA+ZpHwDXw5MAr6Xq+ldLSwGl5FEFh+fnAR9T9wPqt3sBrdOLAq288QAFegUAjpBJBM0SzwHIkmEBL8AlBq1T2v1z1TcCzKqHAPdoOv5ox80C50LdAIBDZPzg+T8DbztHAkJW6wGQStsChXsTARrT+QArWnkBZGdBAS4TLwI3zrcAK+1u9WPHGQIB3skBmJSLAfQA+wJDCor9qdFNAwDzbwPG928AmWM9As0FavxGbyMCKp87AJWgKQUsEgMA4m2BATp/ZwH2BDkFT2yrAin0AwcvrA0HUjbTAjVobQWIsA8Fb5ujA7irSwOJEE0ESyJ7Aw2ASQcYcA8F7z8jADcUgQICY9j+chAtB9JDVwOJXYr/xHQHAe+8JQesdJ0G4R6LAKZ/ewPIdOsA4HfxAsrsZQfCZ4cD8T5RAfKqfQONEg0BSFUTAQ+LZQNWpCUBoYENANSMCQfSPs0AWTulAM1nYQH8YRUCAymJAsHnqwF1YrD8KAyfASwQJwU3wAcHHD59AkhcSQRiO2kA2V2e/BGHQwB111MB/77tA6Di3wHo6qsCEjhVBpSYgQbtnyUAjuorAS7aVwOAO3kA8Ss3AVV/aP6ChwMDOHgdBDW3JwKl2/MBRSAHBQHHxQLMiEkE0g/NAko0/wFzqwTz6shhAUdEKQcFGq8AprH1AjCPVwJ05UkDVk0DAgya6wMx66MD1iwVBELfQwCKzBED/FIi+6lgCvr7U5EDAO0DAqIW2wAvLZkAt1a/AgvhQwD2MYcAp0PDA1DrkwP9bP8BvvdbAj8jSwFN6EkExj6bALp7KQJtv6kC4eUa/09uDQDo0Lb9hH5HAk6vVQJTgGkGJnAhBwYv6QI4aPUBvJ8PARHbPwEZGDkHsAF499HqGQDWkocA+k77AxIw9wEDUGUEXP9BAsAFIwEjmRsBHGrBAjLPPQJ3UFkEhEqNAcf+vwHD3LL9jM+TAtLfzv4k3IEDM2PZAXYbhwDzD9j/wkInAZcxKQbIQYECf0JrAx/DxQL9DUUGqXQ9BvfXPwIeBuUCirBdBllYqvslBsUA=", - "encoding": "base64", - "path": [ - "z", - 30, - "data" - ] - }, - { - "data": "w8fywFSsaD/aTAfBtexaP+I6l8D+IE/AgVP+wJ1P/kAuYb3APaAEwWou1MAv48/AlSDDQJ0/5kB8vdpA6JXywEvA0z80DyNBPLiewKQOmT/FP9y/i2WFwNs1qkDHjSBAT2nUvxnDwsBmro/AZVQ/wNWs+sA21kXAVnadQBin+UBk3RNAhFl8wNUC+cD0z4DAfUkJQTHB/z8LmLbAT19hPzOUJ0B01s9AF/7awMfHnMCxuXdAjHuBwM5BCsFiigjBdOUWQdZHBj6SYM1AYjyLwH6q4UDvC5o/9vq7wPGUCUGWCCHAWAUVQSCGx8CCyxHBWqMHwdYdFkFtzN6/S6cFQdazCsEJ61DArk3GQLI0qEC42eJAPBSCwB6McMBJUJ/AohEIQd5jGEHkDfHAqHYCwTi4sMCXqhpB8J8CQbZ9jMCwYR2+qvgBQTwJ3kAwfYM/XAIPQfElskDacVm+smmeQK2b/0BBXxhB9kY1QLs+zkAqkttACDSrwJcImEDEK6w//IEOwfqYBMG06PFAv5YWQe6uDkF9D3nAju1wwLZLy8AkFRFAzzokwGbT78BD0+1AObYgQYj/R0C7Bd3AhmXqwAnwDEEuMfnATi2gQDNn/sATIrNAKLTjwKeAscC/KhfB3feOQITvKEHcaZtA5dfEwD4dQ8AH756/W4LdQN7C9b9jDt1AfSsJwSSjx0DsZbbApoD5wDpbCMG0l6VANrcMwX1htEBNqllAF9BswGyceEBmUcPA5OT/wKi73ECO8APA2p47Pzhbz8BI0NnA1E+hwIraiz+LEQ3BFc4LwWh8/EBlSeq/agUMQV0enUCpf0dAb63nQLWUYsASZkq/BzpZQIjeDkEy7hRBaWEFQRnRqr0LFgfBEHXowG748kDW1l5Afw7mQM2r2L8jgvXAZR2qPge/E0GFvDZA41bKwD0ox8D75A5AQmZtQFQ1D0En2A5AG90JwKJni8D1vw/B4zyiwMJnvkA75hNBWCnEwHw8rEDKQdTAbKEfQTRO0UDMx9vAozWBQKEkJEGsT9VAgmD7wJDy/0DXndxAjkNgQGSXHD8=", - "encoding": "base64", - "path": [ - "z", - 31, - "data" - ] - }, - { - "data": "h6X+wMR2kcCihAHBecaTQAjupb/RULTAI8P7wBfZnEA6aCvAF7bhwDcuiMA614TADLIFQUR3FEEuMiNAYrwBwe9W1L/E6itBeE7uwFZVqEAJUhJA7dvkwARL1j/PYoG/1oqXwCT3A8EZeHi/gAtnPxJ3D8GCA3o/aW4Vvn0VGUG+XVbAvnQMvwPkBcE8gujAueEeQacwJ8AIpwLBl7SPQNuLukCYUgpBWTecwGt1xb+3mYA/T4LXwGjZGsFWtBbBJUYQQZkcikAtVgVBkLMCv/oAXECOdJhAuqoUwJ5V8kCFoL0/1BvvQEjKMsCQLxnBdMoNwWEzBkG0GgpATzW5QOK178CJCUI/jiwNQRRe9ECPCVdAJtrvvpJkycA0uuHAlobaQAu140CiYRPBDMD0wN0z78C9wyRBOgSkQOg65b5LTJnAu98hQRVJC0E3DZtASfIdQWBd/0CO4VrAsn2qPy9DF0HCjipBK9gtwLdVDkHUYRJB9TLiv3Ol6EAhPJ1ASRvzwPmg2cCcNxBBRNkCQRxiH0GEC8/AmwmzPQBIh8BScdG//xK5P6IdB8E7wGFAmiIMQRLVtL7hrAzBJIsNwTXSG0Fa5enA75XvQOBQB8Fa98A+I1y6wFpu/b/c0hfBGQKBP63iLkHEX+M/o43/wMVguMDqBpXAPvhdQJkkE0A4FQxB0R0Uwd9sBUEzSPfAY9ICwcSAB8FQnMo/mn8cwZCKA0E4Ac1AbjbSwD/Csr8bJgXBZSYQwf/eEUEA1AtAfnqRQAmDBMGq2YvA1+HPv0AEnEAEKh3BPTkdwdKal0D48Q9AKqkgQb8ghT9Cc8hA7GsUQRsTv8BAyFdAfu5rvup410AF0Q9Bc6HnQL9vRsADABvBqnvKwEP8lEB6AcdAOV8TQcvFD0CmF/XA+7tlQAvF50BjtyDA38cLwdIK+MBFIqe/4gQkP4723kBmF1m/IBcBQNSL7cBitxvB5C/0wDC/BkHLwhhBDCttwNyg/UDyIATBieXWQGNeCEE5AwHBjUHLvzsu20Bs1BNAmTjvwL8CFEEF83tAeLHMQHUYlsA=", - "encoding": "base64", - "path": [ - "z", - 32, - "data" - ] - }, - { - "data": "bnrUwDpY98AKE8bAD2XyQGcJH0BKx93AN7DBwOezAb/+g6Y/gQGKwB5w+b479hO/KoAZQfAfI0G8Y1bAQJ7dwEUblMBO5iJBDFQRwXwcBkGsxLZAaHURwQZOMcAaHovAdjPlwIk5FsH2vj5ABw+UQHFCC8GzTZtAHR2hwGwGJEH28dXAGVhDQLXs6cBuBhXBlM0jQeY9sMB4PRnBcbzpQG+TAkE/4BlB+HnVvzUAF0CaWfu/q0sJwY2kE8FRPQzBlaziQJRl80As3BFBp2hmQPlhBsAvB/JAL8T1P1XImUADqaVAaLlyQEMwvT8XlAjBy5nxwNs8vUACd7JAtxhiP663mcBKHJVASgUlQYEAD0EkPCPAKwlUQIrYBMGPnfXAZyhOQK95LkCxDB3B1fyqwK87BsFLahpB3C+1PUuUbkApMunAyaQvQV9rFEG1tvpAJWwXQT3qE0FEqcPAmgQewA0jHkG2lCpB1xPAwExTJUHSBSVB12IgQMyTDEGNnPRAjdSUwIWnZsALKRNBOCSkQFf3HUGzGAbB4heAQKJSQ78jRafACLqlQDNh+sBVXyPAuh67QPAccMBvJhvBfAIOwYWjGkFrvKPAkj4QQVvN68AOtqTA3O43wLa1CUA2RADB2mklwGyKIkEQlL+/6NEAwYET+8AZp+7AaLXyvy2fvkBXEBZBnb0GwQGCF0HWqAvB+CfYwP3+2MCksg3AHU0Twe7qG0H4oQlBChQDwfXRtMAV0BPBcrUHwXHPIkGZF7xAJEvwQC8FB8GxolK/o0oUQOMO+kCuIBfBCrAZwQoJO7/FQ7tAFCQjQfqPVcBnRghBKCsiQfho9cDmA9hAlmxywEyDJEA54OpAlyl7QK2yuMAlJxjBnDNxwECbvr56OgJBvV8iQbJXtEDh8cDAXgfJQAesQ0D8VMLA/XUgwTzr58DqxZPAj98fwEZvP0Cw7HLALje4QBaCGMHjexHBauwTwYEBHUEHCwZBAgHQvl8mF0HOoQ3BkA4+QPKtFEHiiwDBmM26wNciOkANbWfAkHuvwERkFkFmoTA/0qcGQUK/9MA=", - "encoding": "base64", - "path": [ - "z", - 33, - "data" - ] - }, - { - "data": "YYt+wP5uEcGRJEbANFMbQcI9vEB749DATQQvwCe3r8A3BaFADi4Mv/ynYkDwjlBAWXkaQXLVHEEwAOPA0D+KwAR318DC3wRBNGAYwfQOKEGWRgVBXi8ZwehOq8DywOLAaakIwX9/EsGWY8xAxa/2QBQm2cCsGwFBym/1wCwGHUEsEv7AoTbGQAp/osBfER3B9OwWQWUTysArCRrBKb4TQQccGEEYtBNB+wsCQMxAukBj6ZXA390SwfAR7cDdcs7AFMA+QIPXHkEnGglBTwHkQG6RwcDByhdBd1u5QNNXA75BggNBZGr/v1hHrkDiy8TA3tGZwOlVoD8EMwVBDc6XwJQfir9P1f1A/zQpQWxNEEF/p93A8afTQBz+GMFf0c3AFMMMwE25W8DX/xDBDPfhvyv8+cAX/PBAQBycwO2d6ECihPzAwtMqQeV8B0G3Vx1Be8bwQDwkE0GbzPvALC+7wAU5EUGWrBZBY3TgwKcEKkGD7CNB/3fIQCLREkERKhdBTLMNv+uzQz/l/vxAaCuTvNbpB0H9yhTBHlvrQFvPQkCwcQDBMYQEQfpAtMBs5d3AFe8zPx1408CMjRTBPa/pwD1rB0GhoOm/vQsXQYntnMB7zATBCtNsPx/gu0BIIqTARSi2wNLmAEFW35DA7BLOwIUxD8HjThTBi4m4wAUnDUGH0AlBgs7BwNuEF0GLdQTBarF4wMo6YMCjFbTAKWriwP28IUEUlR1Bk2cBwYwq+MDlygjBNEjPwCVmH0HBuwtBnt8YQbdL2sC4xEBAAy67QJLUHEFczPHAGxz/wC2ouMC2iQxBa4ASQT87ucAJVBxB/tYaQRr9A8FqkxNBZvnXwHTNVcDxrndAmkPuv/Pm+sB2i/jApGsrvpqcocD1/hFBrH8dQXVhA0FPaVHA/lEFQeVBTsDe4vDAc2kewYv/ocBC/+nAQj6owGEhN8A3HMnAZ+sMQaDNJcEqZN7A630YwSgPIEFUhqpAEetCQKD1HEEDpgDBhs2Pv951CkE4Y8zAVXn4wK5Btr8FHuvAYV8ZwKpCA0FyOyjA3ZYXQUD/CcE=", - "encoding": "base64", - "path": [ - "z", - 34, - "data" - ] - }, - { - "data": "HC0Dv5DxDsHGQS8/CeQvQXePC0GMPInADFK0P0xtAsE1qAJBcgVbQDeV4ECbOtJA7PgEQR76+0Bgdw3BSvtYv4gI68AlzZZAjZ0HwZAvOUGQFSFBCmkGwdBHucABrw3BwT4HwanK6sAJTRJBhyIhQZZOWMDcrihBpV8IwcTOAkEAZvXAHx0MQQTeB8D8lwvBjE7sQLi3rsC+jgLBTzsjQfHlG0Ea9+ZA8vesQA+tCkG4V9zAdpUCwffikMBjtzHANgNQwFODM0F49stAFYwfQVc/+8CwyyZBPRIQQaueocDFQChBneHMwIa5C0EqMDHAIM+Qv52CjcDbgiVBgDcEwSi2PUCCkSdBdoYXQWM59kDIrBXBPw0VQfbEHMEeA2XA+rnMwGRK6cBjItrAJDYUQNPjrsD7WWhAvbftwEoPIUE/utzAojwSQQOVv0AYLStBRup0QI6m80BqewLBQGkGwYqa1UCXXNZAhMTPwKdDGUG/iwxBOyMVQSl8BEFlvCNBMxZxQCKzn0CHz5lArEOmwLxjsUCftA3BPacgQdF9ykAiyBnBvI4qQf93EcAY0hPB20SewIg+CMEGRunAsMOMwGknvUDXHvU/sAIJQRhgwb9j/xnBUT+SQLSADkFGhZu/A/n5wDc7h0BR8N3A4SVpwDxPCsERTxvBbpjvwE2ILUG29cZAqN8gwKF5AUErlsPAMCEbvs7bUD9MpAPBDYdtwIeoEkGuoR9BQB/IwN64AsGL9MnASqNWwDcEBUED5ipBQ9spQQTxdMD3V8xAZo8MQdm/K0G7RorAgyCiwCBPDMEI3S9BkjbZQKmTyMC4TR5BM5f1QE0d6sBWcitBMJUKwc8e48Cr//+/Zp/WwLSND8EI35TAuFZjQOeE78BOghBB9O4AQYOHHUHJGfQ9paIaQR2/9MDapOzARZkDwf8c7b/qkRDBQQXowAe04sCbBP/AHtAxQeeaG8EzcGDA9ycDwf8/DUHaJ8K9a0rCQHwQDUFOgbLAX1KfwPilykAkh0bAJHUBwZ5TrMAeaBLBmZadP+Gyp0CQybLAhkoXQWll/8A=", - "encoding": "base64", - "path": [ - "z", - 35, - "data" - ] - }, - { - "data": "Ac1GQBYf7cCceItAuys2Qf9sLkHuh1G/N/GoQH1/EsEPySlBTF/cQMXvHUE2VRRBo7emQLSEgUAVkRHBeng2QNuZwcBJ36W/8GW9wD5POEEykC1BN6m4wJDuk8DGxhTB2ZXWwPEcg8B+OjNBHm06QcH/bj+GWENBI3n+wAGKpkD9W8XA1HYqQY49lz9G3snA0Z93QOHrVcAOSqrAY7MhQf8pC0HmZUtAdGsEQWJdLUHONAPBNCGwwEmBc78iidE/4Xn3wK5lNkFJ3QFAn0pBQeF2AcGytCNBeWs3QYUyAcHOsz9BjZQLwfTsM0HtU5U/eHk1QEPN9MASLDlB27Ygwc5B0UBNLUNBjCXZQNXxlkBzhSPB0U81QZ14C8GjjVY+Jb4MwSYvEsEvMFHA7B3BQFvm1b+wKQPAxccCwb2fQEHM5ZDAWWrHQHNNtD8bSyRBcGvFv5yZhkC+XNTAkL8bwcg3+z9pogFAkVOawEOe20AMd7ZAEg06QSwNvECqDh5B8XnwQKHsB0E83O6+s/AGwcqDCz+13NnACK0/QVscEEEmlhrBeKBDQV201D/JgR/BMu8CwcllEMHCR3LAL3ojv+MyzD8+AaxAtivDQM3tD0DHPRfBVjH2QFgpMkEbdEJAUG8GwbDz778pZATBI0krvmrN08BewwjByTD1wCizP0EZnvI/ccHRP2TPnED3OR/A59JqQC6An0A7qBnBuA/RPsb51UAQzQtBxbRLwF9R5sARazvAhWHePoi6n0AmiDpBfJUpQfQS37z04BJBlbowQXWeJ0GV3iu+4hGfv6inIcG4wEZBYRA2QJx/psAPKQtBaTZwQL3UmMDUITJBwSERwQhUD8HXIdDAK1ccwU8fDMFXQR2/5BzYQM/eA8HfFPVAx5aNQLONJkHwVGFAr9siQZ8TIsGZXr/AD4qlwNCX5D9wUhfBcIn+wNyCF8GPPgbBwv5JQRdr9cBRfEE/LNSpwAF+wUBshbLAdvMIQYqpxEBwJtm/2XEAwbKIAEBn+Zo/g8flwL+8A8ELqBfB7VGVQGXWAb7Mp/rA/+sCQWklvsA=", - "encoding": "base64", - "path": [ - "z", - 36, - "data" - ] - }, - { - "data": "Qf/KQLFQksA/CfFAFdwsQWYgRUFB1T1AmZ0IQbNsDcF8uURB49UbQZLtQEE/DjVBAKjFvGmb57+c9QHBNwvGQLSJTsASt8rA80ENwOWUI0FlDylB3jcJwMtSFcBlEQTB9TJlwDhVhz1pOkhBPSxGQb6pokDjD1BBqpvFwFKSPT8nTGfAs8E8QTupikAmMj7AXQikvzq0lr6hcMG/UMAMQaOXw0BlminAqCgpQTw+REE8MwLBzZTTv47/NEAeu7dAsNwmwf56JUFC6mzANU1WQXrX4sBJEgtBCoBRQah3GMFtUkhBF6EXwR6TTkHIC51ABo3MQGo0E8Fm4j5BtswlwbHUF0E5clBBgFwPQDYTtb3ydBvBy0dJQTC3xMBiW4BA8q0awTtNGMHQ9Yk/+HYTQVq7LEBi89DALzzxwGm4UUFHUnm/RpzgP2cFhMABrAVBfZzDwOLwjL9CpWbAEGwZwcMTicDzanvAZIwPwFcV+T9PG0U/IlNSQV8R3D9xOwNB0kcpQTmRM0HKxq7AloQfwYfemcDGO1XAtmtRQS+2MEE5yQLBDC9OQcvmqUAd9RXB+rUawQZI/MAd1TY/EoNTQFucbMCK9QVBbUzcP+oYtUB/cP7A7IIjQWIcR0GYp9lAMGPnwM9m0MBBBwHBShNYQJB+RMC8zr3AEwfUwFubQkFVg2LAZziwQJCzKb8j0O8/a5/gQGSlB0EsxxfBY0yPQGyxFUAgo7dAqzoOP7q/oMDZbYk/9laFQH8KUb5SXDlBMbIVQWbQdEB3LDVB/vBIQb9IDUE/WoJARlE5QJIZIMHCGVBBtOIgwNaoPsDpZrxA2c8IwAZTh79jdCVBwAb6wFiqFsEXiBDBbPw0wQJV3MCXEGdAT64VQW6d9cApDZdAPyGjv78FHEFe69BAWaEbQcD+MMHeaF7ArVKUv6gVpUCM1AbBtWncwFZFJsHAwuPA53xUQchEj8BKeZxAISqovyxJsj8SoRHBr7UmQT72qj/XyzFApNwcwdG9YMBE3qhAiJqnwApBF8HA9AjBRqL0QBCwscA1uQ7Btd6rQFB/KsA=", - "encoding": "base64", - "path": [ - "z", - 37, - "data" - ] - }, - { - "data": "L5ARQfES1r52qiFBPbARQfrhTUGFoslAGfUxQerm68CqUFJB67s+QUuVWEEMlkpB7XWqwBDs08De9MHAQ90QQXIT0T6j4xLBaSMDQDRQ8EBLOhFBMZr3P4DYLD+XsLzAOnC6PgigiECZYlBBcQxDQWDjCUGMlE1BlNJVwMJ1gcBRxRG+1lpBQUjg40A+018/SSmwwO8hN0BvsSpAVcDBQN8G1j8xQOPAm5pDQes3TkGzscnAyv0pQLMyx0CDFBNBpi07wbo/+0CskfPAM2xdQYj+oMDtZq9APBNdQTVNGsE6L0BB8AAPwbWHWkHZ4AFBgwsWQYW8F8GM1DRBDrQVwaKhO0Fg401BPzhgwP2Nm8Dfr/3AWnNPQcEFEsBOZupAaAsTwXonC8HYSKdAT8g8QcPT0kApWRHB5bC4wDUAU0EF8T1AUCJkwMv69sAotJhAMP8OwagjusAb05Q+atT/wEwYCMHGle/Anf9+P39XiMA4W5PAlzVdQUKbWcAdCJ5AfHBOQaxKUkGM7gbBllsgwc9i/8CL0X4/zkhUQU56RkEOoq7AIj1IQRGMBkFFTPLA7o8cwdSAqcDXLaNAxZLZQMWS3MBOUy1BRZhrwH+OCEEea6bArVNBQVtyS0HAbB5BCpqUwNp4D8GacsXAEtfQQOkiqj9TdBLAEXeSwDOuNEGnEenAScEMQaRWvcDFl7xAoqIcQburM0FKxv3AORcAQSI6VMCO8wY/gjaHQK/747+2DZ1Anm3tQGusqMAmmyVB7t3UQD0a50A1+UtBW+VTQXVBsEAanvdAzYnSQHOYCcEwW0pBPbHEwKVSnD1HM4w/ZEHZwMsdQUB8EQJB+xSmwFhjC8GtGiLBuz03wedkYMDgmupAPtU0QaOtv8BYV+e8PmnJwGHf9UCdmxBB9kMBQSYeKsECiAS9IupJQB4QAUFfAsPAmGGFwBPZIMHjmobALvBPQfVJC78NsgZBnOBCQEz8gcBv0S/BBeY4Qc6GjMCbO9dAEG0gwX+S7cBn4ApBP0QZwLk4EMEEddDAIDwhQbpHEMGlywbBWAQlP3+Lxz8=", - "encoding": "base64", - "path": [ - "z", - 38, - "data" - ] - }, - { - "data": "Kcc0QfuDcUBx6T9Bp37BQACDRkHfmhFBIsdPQdb9msC2O1FBExFWQVUIZEEtGFRBrLsMwdvHF8FWEkDAhRI2QaRrgEDSBijBThO/QKaNSEDufMVAHU+3QAzqW0AVmyfAJfKIQFPE/UBHc0pBkj8vQaNiN0EsPjpBTqPPPrD23cD/D1JARy42QaUOF0FR+pJAk7z2wK4coUCt681AKnXPP9prb8DWphvBo31SQSHhSUFZWzvA45PRQLYIEUE/Yj5Bp2k7wZv3aEBebxzBohJVQUfpAsAYVok+XbNYQUvGCMF6sCRByT7owO1+VkF9sypBwB07QVwbC8FQXRhBcKjiwBnRUkHemTlBWf3xwDZ8/MC3upvAoPJFQXwqD0AYLyFBaPruwO/j2cC/IAxBbbRbQSxfHUFeDSHB7IFCwOXEQkFjM69AdUbgwLD0GMEkbuG+NekiwREDDMHQxIVAqQmowLWIMMHIRxLBHO5uQJVnCcGJmgLBqbBZQcfv3sBytSC+/uxmQf2gY0FKqxvBG54LwUd5F8G6D6VAQSJGQX+wUEE2UPe/ig0vQcUDLkEYz5PAc5gLwe+d4b+6VQ1BtFcbQZLlBcGyDktBrO/wwLp2LEG4Yp2/DGRTQQsOPUHmBERB8k2av1TKHsFvJkHALq0SQV/zr0DpPus/BrbTv1aOE0ExTxTBka82QY45FMESzhRBaFk+QQ44U0G+bKjAxMYtQZjW6cBAhqTAfKPuQEsbB0CE0wNBdTEhQUcPB8EukvlAGVQJQBzgIEE9ClZBVPFPQaRRcD4XKCtBMAMaQarwvcAFQzNBvXz2wFC3RUBG7ozAfccXwVvn00Ak7oVAJtLZv24A38A0wCDBn5gjwSvrRj+VjyZBZatIQcc+VMBnrpnA7rIXwXFigEC+WC9BnHubQNutDsHprVRAR8XfQO2dJkFBvTTALarkvr/nCMGoKIK+rmg6QY+lYUBF2zNBLjfeQJFS+cBRNTfBN6o9QTuQA8H2oR9BM5kMwScAGsFiHTZBBf6TPz556cAkqlnAUSs+QSr5LsE668nAPXWQwN8Xm0A=", - "encoding": "base64", - "path": [ - "z", - 39, - "data" - ] - }, - { - "data": "rRxOQQlar0BbDVJBso+dP445LEHTLTVBIFthQQujpb802j9BePhgQdEQYkG+elBBbj0rwYXfK8GAOXA/3rBRQX9A5kB5nCnB6yUVQdx0KcByes8/LxgQQdsZqkAWpJE/olf2QNkxL0FXpjRBRUkIQesQWUFs1xNB3uZ1QBMeAcHPZp9AbIAYQdINM0G1OvtAutQFwUMft0BVnBlB4WhrwOB38MDgxizBmC9UQUlNNUH24qA/aZwdQYuGM0EawFxB6bIowfC9DcC7vCfBrv06QfRezD+8naXABJBCQQTjycDmsORAYKmQwNPcQEGdV0dBlhVUQRC73cBVOstAVoBiwH0gXEGSIhFBud0cwV97FcHYcfq+TlkqQcYCy0DFPkNBX8qRwNlPe8DDUTlB6WFvQWJrRkEYfBvB9XP/Pm/JHkHcJbpA4twIwSnyHsHPWK/ALFQgwROSIcGRivNAEFvgv/zzQsG6ZRbB+ISdQBURM8H7nSDBZ1VGQeiEDsEfiaXAAuVxQVj0ZkHEjhnBDBnFwNrfGcGG8gtBewIkQUlaTkELPvk/baT9QExGSkHvGwW/OuXSwCmyCUCzcz1BoBg/QWUTCcH2CF5BTu0cwXXpREHvsUxAajxYQTeMGUEOjVxBO0wgQDAgG8G+Yko//j4zQQ9JEUElHbZADWnnP2+Xt0Cz7RvBMtFUQdNzMcHKnkBBQypUQQnAZUEpvvC/GCZPQVdAGMFEJhHBFoIiQdoPmkD5bi9B655AQU0JH8HWkG9AcHRiwNvaQ0FIzFFBLNw6Qeb8psBp8k1BWgc/QbBiAcD0dQdBGIX3wJdFpUCTwQHBRFwpwf1SGkFG+cu/3C4IQKD8h8Ddag7BjnLywDdWnkDiLExBazJQQWLDbT7R4/3ANfkxwWYcl79vNENBdv27vnVXvcAItqBAptMiQbK9QUFaLXU/7IxcQBg/vsBAR3VAABsRQYyQ5EAFtlRB4ZYjQY9vHcHKgSnBwo0yQR/wJcG77kdBwcLNwLUxJcF14FVBeHqAQI1Ll8Am4Dc/J9FPQX+wOMH4jkHAdOr5wCMnvUA=", - "encoding": "base64", - "path": [ - "z", - 40, - "data" - ] - }, - { - "data": "8nBcQVrnkkBXxFZBE0CJwNY590DF8k5BgM5lQZNgLUCVKxxBd2deQSXvUEEDOD5B/Rw0wWDBKcFncIZAWbNiQSFIHkFIGBrBUWdAQVZ/48Ag7m/A3KQ6QfuGvUB4hZdAuX4oQc1JVEG5cAxB7BWWQGhCbkF0fK9AteavQEIR+sDr331AQ9bJQFoaREERNyhBXhP6wJ2ljEB0G0FBFXLswJKzGsG7syfBsGxGQYrUDUEa2qdAGONHQTczSUE2OW1BnAgDwdxG3cCtLh7B6uULQUiBikDOJw7BaGkYQS3rPMAF0RZAsv5Gvw2pF0EZQVZB8nVfQQM0h8AAgMA//yicP7AXVkHZlKNAQT0owR21FsEKRnxAb0jzQC67HEEQhFpBX+v9vtKgs72AZ1pBX8d2QZ0ZZEFfFwPBVi9tQNu1yECVF3dA9MwJwVIcEMEBdBDBj0gJwXiNIMH4HyhBsgMEQIjJQcFiOAjBQoNfQGioRcGvjCfBvh4hQUYwF8GDmQbBtExuQXBeW0E24ALBK/wXwMALCsEgFDtBVtvTQA8OPkEqILJAqOBMQH9CWkGRp2lArodbwC7buEDuUWFBlcJWQbSV98DL5WRBU5ArwcN+UEFkb7FAidZNQTB3vUD/BWdBofq8QOcSB8He6Y9A5I1IQSZAQEFbdBBBAuuJQB2GHT9+KQ7BqiRmQYTfOcGGKWFBAJ5cQaqaakFENeg/N8xiQVXvI8Fv7TfBwvBDQQ/5p0CZD1BBP5lTQSwmIMEHG92/FmPxwFk3W0H9ID1BtZsRQWI8DsEvLWNBnylXQe9VK0AneIRA/SXTwIg+u0AQSiPB4ukkwf+4QEEy09DAMu21QK6lE79LzNfA1ABXwNcdCUHzBmVBJCBKQb2EYkDsDRrBNrU2wYLUusD7d0pBFR2vwAGYx78IiYZAC7VJQaDEUEGbRZNAmIzdQIn9DcAbPO5Aj32gQM1pIkFqcWhBgPpMQUgWJ8GOSAfB/iYUQUaUMcGuLmRBPktVwEqkGsE14WlBvHOZQIw707/7pYZAy6JUQUVTL8EiOV0/S5MYwYJijkA=", - "encoding": "base64", - "path": [ - "z", - 41, - "data" - ] - }, - { - "data": "ImleQTEh/D89fkxBiff7wOzgR0A1Nl5Bu/VbQRlXnEBsEshAxwtNQRoMLkE0MBtBVU8pwTpvE8HVcqRAG+NnQfbzQEGAY/XA7nRgQTN8HMEzVfLArfJZQdvYl0D4/PxADnZLQYVibUETxZxAROwbv68zdkF+pZY+9IyVQIeEzsDpnRk/AevHP2v4R0E9ZkdB6DPJwD4aYz9DQVxBBDQYwbYkJ8Ee4Q3BvOclQU8woED3pwtBJcxmQfkmUEFSum5BR4eSwE7RHMGl9gDB5OGGQLBcnEDtVjHBM+WvQOqDsT/L1V3A29dLQIjVsUAL1VVB+H9bQf9dEr9es4PAeICfQFnsPkHqbJi+uFYewRM7BMGKNrtAYOhEQIS2SEGR+WVBRBRrQMc6ZkAovm5B3olwQfvndUGU9LLAY7+nQLdQjz8uqSQ+DYvvwIHS28AZwTHBJI++wLjJCsFGJE1BNIazQIILLsFiH9TA1i4Ov5meQ8GKIRrBH7jOQKY+DMHq4yHBeMhaQVCZP0HIwrHAfeMQQJi108ArSl9BKkOkP73EHUGoewtBh4g3wPPAXEFyXa5AX7w0P7UED0HldHhBxv1gQTT4wMCd3l1BBZomwR6aTUF7XaVANEExQbAVTz84XGJBOeINQSoUyMDWNvlArcZQQblLZEEUETxBlaSWQFAbmsAZnNnADZJpQXJJL8Fd3XVBWOBVQdDjYEEkNalA9EBnQbgxG8HwnknBvWJaQXMKUEBNe2RBBqJYQVwWDcFSdcvAvJ0dwfaGZUFrJBVBXt+gQLHFL8Fq4GlB5WFhQTPNtEC+rOa/HMWQwDbBlEAg/C7BXHMMweikXEEVhhrBus4MQW7dTED+aWTAgxoUQN5AOUHgAnBB9bY0QY5joUCXZyHBh7wnwcDGD8Ew+0JBiuQOwXlMWkDH8Ig/GUBjQYqUUUGy4vlA15EeQdl1E0A2KihBmUolv0wIR0EgO25B6lpqQeFHHMHUZaDAmL27QMffKMHKBHRBL5M3PjNb98Als3FBgggwQD5O0j9WVqZAWapKQY2gE8Fpn5RA9H4fwSitij8=", - "encoding": "base64", - "path": [ - "z", - 42, - "data" - ] - }, - { - "data": "CEpSQfMxwr8dWjFBIucdweQeKMCmCmJBTT5CQe+gh0AMTrU/UzsrQcAM60DZHMlA1NMLwSbx08Cns1pA9bRfQdBuWkHtlJfA8op0QfFCL8FpPh3B5qlsQTAkqz/n5ChB5y5jQZOueUEa0Pi+W9qzwBjtb0FsuKDA76/dPzBjhsA45lLAFBR4wMfBO0H8Q1lBrWt8wI/jVcDV7GlB9Nckwbg0IMHE0r/A44LbQBx1s77ilDpBDId5QWNcRkGS9F9BODjePn3SMsH7vqDAWY7vv570MkCYoj/BdtOUPbNemECaxADBROanQBzXlD5jW0RB8BFGQbBPSkAnowPBtZDEQAqHFEHS+LLAWUkBwZ1fv8DqCKlAQTAkwEUZaUEZTWRBaBS9QMzGn0CVrnVBZtNaQdooe0G8Uf+/FZGHQKxTkMCxqm3AVWSswJZkZMAQPj3BkAoPwJvWwsDAFGhB1ysLQZytB8GnQ3XAKZaQwEUfLsF0dPTAd/S0P9ZC38AQYSjBAJs1QZ3xEUGJkuK/pmKzQN7VacBSDXhByKOVwCRH1UDzrDRBo8L7wLxEUEEW+JFABeOGQCH1OEGSKYFBtj9cQcJGY8ACh0ZB0WEPwfJOOkGpvTNA3S38QIKPlMC9WE1Blho1QcnHSsC4hClB7J5JQXXlfEHRrlxBklEdQJQxCcGgjmTAa9BdQQxnEsGvCH5BopA9QUFoR0HdrAVBGt9aQdUOAMEZ7UfB/W1kQWLAwr4tWmtBTgROQYxvz8BLZRXBT1ssweoFYUG/faxAOO4cv22BO8Ex/2BB6qdcQauDwkBtPd7ArQ3Yv9wlqT8jSyfBCRfCwLaObUFrgDTB6D02Qaspm0CJPCc/+tHGQPj+XkEt52tBKJ8NQXMkfkA9LxfBdfwFwaZ0K8E57ilBKvMwwTudvkCBITbAsT1uQYtKQUGfnidBMtpFQSpRqEB81E9BPXPAwHucXkEqJWVBpM96Qe2O/cC7Ele+N0JEP3kMDcEY7nZBOqZrQEEbksAQsWxBpMSOvzyqmEATLmdAhlUvQVrcysA2VABBOXQUwT/8OcA=", - "encoding": "base64", - "path": [ - "z", - 43, - "data" - ] - }, - { - "data": "+841QUdJj8BYPwNB/B4qwawB8cBjJ1lB9ZQWQT16wz9Y63zAIRTuQDiNCUA8TL0/1Pm3wJ6ON8BUFeA86SBIQe3kaUEeQFG/7tN7QfS/LcELDyzBXUpxQRtSScB5wklBDbFuQW87eEHzR7TA3wASwesqWkHxdw7BCXgKwBgCnr9UKsbAoc4Bwf2lG0Hlt1tBGRRsv9R4ycCs6GhBiBkfwX2TB8GtsO+/BOfEP9bvscCaRWBBGR9/QezDKUGPTD9B3EaZQERANMGmgUK/taDlwPDUeL/WFjvBIYOswNn9uUBf9TLBynqUQKHhosBnGiBBW6IcQc9OkEA6US7Bmy2jQJsOqkC0pBfBECalwITSKcAFNUVAS57qwCSdfUHKslNB5D+6QMVEYkCJdG5Box4zQZnpckFaIg9Ayvl0PxYVDMEOc87AX0kfwJqyUD/WYzTBd0ANQAJoFcD0G3hBOY0zQR8am8De+D6+01zowGJrBcFdfJLAINqGwCSqhcA7kxzB+HT5QAvuoEDi7ypA0zbVQCV6Rz6bY4JBzIwTwXh7BUBeHFNB+2g2wUX0MkF9uPc/jnemQOU6WUEROn5BYLFGQWxExr7MgRtBeErNwJ5iFEEc2yu/JFU6QMHxDcFJrCZB9B9TQbCMQj/z601BYhkwQZK2hEGyJXFBcqq1vwljLcFnlC4/OVdBQZchxsDDvnhBF6EQQQ2aHEEiri5BmM47Qei1p8CilzPB20xgQSuqe8A7FGNB8MkxQYk6RsC81C3BpCQowUdsS0FMrKC9tcbAwN2oM8HlXEdBDelHQU0CkEDlVCjBLgrOP3zLPcAMqQ3BFBkNwATLckF/0DnBrx5WQXGJa0AXfoRAki7yQPXZeUG3R1dBEvejQGjfUz+5pfnAPYajwISlMsHNjvdATSJBwbd8vEC4gbnAIGFpQbrNG0GrZEhBbQxkQTIjtEDVlm1BWQkdwfmoZ0HqGUxBC019QV6kn8CRrI9AEr2YwHoQvcAJLWxBehvcQCpGZb6m6FlBMVmTwCW38kDy3fA+9r/+QGXKDsDjui5BQkrywE12vsA=", - "encoding": "base64", - "path": [ - "z", - 44, - "data" - ] - }, - { - "data": "ZRgGQVbszcBbXoFAPgkmwfCfMsFWuUFB4yatQEEgAMAcmALB+XM8QKMygcBjbHzA5gbOv9yT6j+HZV/A/n0eQSJGbkEth1JAKlB1QTl2GsGoiyjB4QlmQevKycBQ9l9Bzs5sQZDbZ0FA9RPBilw0wXxOM0EOXzbB6B2rwI3TA0Dh9P/A2w8xweSGxkA4XExBnRMWQDe8/cDs1ldBgQAJwb6tvMCW8DxAaLySwFgeFcEcVHxB1F52QU6M8UC29ApBKo/JQClyI8F/A25A8/cuwRJjjcDy4STB1ScYwRJNlkBAuVDBjHcCQDYpEsEMz89AkJ+5QM8fQEDMmkXBpIAnQPYSiD0jGUDB+M+cv/5mvj+thsu9N5UswQX2gkHkqTFBUWx5QGkrpT7zIVhBQDrsQCPXW0HrpqlAxs1AwKcSOcG0sPvAwGl+P5pTkkB9UBjBQeqyQNe3DkBcLnxBsW9RQRIDMD6x/VhAYC0NwSr4kcBLCQu/EbQGwRIk7b7GIwDBieY6QIx2qb5DLLFAAuWyQOJvckDHXIJB7vdFwX7fVsDAPmVBFitawYmpAkGgqMC/09ZnQMvTbkH9O2tBwTUeQbtnNUC7GrFAJFwzwAGfs0DuQ3zA5PVYwCByPMF/j9pAwNxmQX5YgUAjHGlBlHQAQaCHhEELM3hBWN6YwEisPcHd5Y5ASXUSQWpNAcC3vmRB68eXQNd/vUDSP05BHkYIQdiCvb/ungzBhatLQZx6z8AauUlBIvMBQc3wkz/0ZzLBlAMTwdfJIUETmrHAIysgwQ6ZGcEDxxtBSCAiQda4zz+XYEzBNmeIQCVpwsCwwcXAjEIbQF91a0FspyzBN0drQVe6Nz9an5lAymXjQFmhhEF1jDBBCEWgPKsUOcB7kqbAaJ8yv4ciJ8Fcw1VADXpBwcijg0CjI/TAKTlTQfNOt0DbFl5Bi4d4QeT4f0C8boBB5NNDwQmfYEHU6yFBAIlwQWINhb+jY9hADKoPwdYW6r/Xt1JBQowaQRDwgkDwAzhByWjjwO7WH0Fp5j3AIhxfQA4kLkAjsVRB0kydwAc2+cA=", - "encoding": "base64", - "path": [ - "z", - 45, - "data" - ] - }, - { - "data": "jb+AQDUa48DAmJ2/eMETwXOzWcF+HRlBZtqpPSecncCfEzHB2XkdwOyhDMEQoADBmStGQPtvrED2wsXALnG/QDEiZkEKZqJAO8RfQU9W7sBywBTBCL9IQZAFAsFOTWpBIwhcQaEZR0FtTjjBzSREwZjz8kCu10rBTXXwwN6WlUCLxwnBz+1NwfC1ij/xkShBq66XQCMJBMFCNjVBkP7HwFdXFcCaUMJALzAVwdI4PMGBIodBZ7VdQfr2TkBoX4NAUY63QNDxAcE2MsBAnNNVwVqR3MDzKPvAPXdEwRKFCEARWVzBJUXBvwf0PMF5E+Y/9hrhPtzDi705GUzB63g0vwjypsBqM1XBgj5GQFvRmkAIeVHAnItQwQbHgEGcifVASQ5IPyUoSsCgozFB9bkDQAseNEHcksVAowXCwB6gUcE3efjALHSCQLhpwkBx1tPA163gQFvtskCT6nJBMV1jQSwTl0AgeqFAYs0SwSK6/T7KVWdAxrMywUKaVkDcdajAYh84wA1RsMC/8L5AsrQ+QGkrrUCb6nZB8r1kwUKe8MCpXWlBbW5rwZXadkDmzI/AxHAIPxuceEF/JUhB5NXBQPwHmEBUKIK+ki3XP7YMLz+EbsrAJ6sHwa/pVsG3JQZAQAhvQfWFmEA9TnpBG/RdQIitekGjW3BBvwLkwBLoPMG74clAAtefQKgAOkBlWUBBGyt7v5SOUz/+AmNBE5h+QPynMEDTpqTArnYjQb6h/MC1CR1BlCJ2QC7RmECwoiXB+47cwMO0wUC0NBrBIRtLwWw23MBL/rpAnHHVQIrn7L+ZV17BwYSuQBPY/MBBmR3ARqGzQAtaVkF8Xw7BLGR0Qf3pK8D44ElAl7mqQH5AhkH1jexAUwijwCEruMCaOdu/vrl4QE9CCsGnxA/A2SUzwd1loz+M3APBVUUqQVye4r3Fe2dBp0GBQXA7lT/YdoRBA9pXwVTeR0HqYctAQOdSQf73TkDaGNhAq94+wWZCOkCCKylBsd0+Qe3uzkC0OQVB4CcJwT5DPkEAGLXAqTUMwMZKuEDJeHFBXW2uv5IsA8E=", - "encoding": "base64", - "path": [ - "z", - 46, - "data" - ] - }, - { - "data": "ZTjIvzX6wMCR+8LAukjpwEhVb8GOPLdAY46owOZF38AtZEzBiF/hwLp6QcGxWizBqC3CQJb60UBSZf3AcOMpP3R0T0F2/IJAwbQ5QSWLisDZR+TA2v4WQQYrC8EwZ2dB63E6QcZKFEHBpErBd75DwV7XLUDNR07B0IQIwafqv0DHI/vAsVRawbxGkcD3dNxAS6WvQJdb58AiUv9A0x9FwDrk+D8ehtlA9NZLwSg1UcH8uYpBniQzQY6n+b/SIcu/JvZ4QPOmocDkDbxASlRqwUUiBcEpoIrA+TFdwSY4mb+4dlfBzyiTwDnUU8G2hFzAxq6jwC9GTsA+h0PBRrtzwF5wFMHK/VjBEDq/QC5MykBIWLXAAypjwb3db0Fujy1Am54qwP4qvMBc6/NAHhaCwBO58kAGWppABCABwVELWMGLsLzARiC9QEloqEBAMynAHnPMQJQI2kB0cFpBu71nQQ9IzkBpkHlAIjYDweKZoED+McdAFd5KwUs3t0CFFc+/anT3wENTE8He/IlADlQVv48zkEBME1pB2/Bxwe1sJMFlel1B6cVrwbbax7+zf9TAhnQ3wDUwdUESixNBbpJzP73Ui0DsQMDAPFGmQAd1kMD1t/LAX1hCwfDJXsEJ3k/AdAFqQX7jNEDaR4BB99AUwOjDXEFE11dBJKkGwQ8HLcHiJ71ArG2cvjs1vECXaQlB9+PLwFKhkcCIdWtBGOvNv9BYs0DcuWe+shzIQJTA/8ArJ7ZAQMy8vwH90EA0XQnBCWhrwM/s+z5DEUfBabljwYTIRsDgw1o/IGEKQJT1mMBESGDBxyqMQCSJB8F5VAJAJm3LQJ3fMUEvk7/AuNZvQZHqrMB5FJk+mO0lQHBPgUGk3iFAd2QNwRkd9MCbqhNAUzfPQEstusCPyuPAgLUWweBB/78Swu7A5dzaQOqhwMCPM2NB53uAQXkGB8CSZ4JBxW1bwYLtG0G4sr8/QX8iQWFywECQZqRA9VFcwfQ5vUBNwdtASXtZQcdS00A6NX5A234OwcTxUkFI/u3AasPkwCRayED8IoJBg1EnQAws3MA=", - "encoding": "base64", - "path": [ - "z", - 47, - "data" - ] - }, - { - "data": "njPUwFuJIsAZWBzB4T+TwP7KdMHIfLo+4dITwcszAMG3kFbBt14lwQ0NY8FwlEXBfavWQOeZsUC86wjBXjCewDxUJ0Ennb4/vJIBQY/5yb6XyYPA/RueQD3XAMHbolVBDMAFQdc8nEB2eU3B6eM0wRwHQMDMgULBOIQDwY/frUAHrqvAmrJXwVELEsFz8fA/DPd9QLeimMCs7ltAEk1SPzETpkCgBbJAgTpwwRdRVsEngIhB4tfoQALk08DwhtfARtOdP2czib8pvYBAr4FuwfxlCcHY+mg+tE9kwSB8hcB9M0PBNAzbwJTmWMHQ7vrAlvYXwfrptcA+Cy3BSsLCwKA0QcG/B03BHMPUQMeytkBhsN/ApAFmwTECUEFkv1PAWvaswFAZ98DTrENAir0PwewyJUBdovY/dioPwdYZTsGUnfu/2Ki5QBX6M0C7HgZAyGGDQMcMv0ArLjBBXr9cQU8bwkBQM0M/aJu0wN9n4UDP8tVAehZSwdLNwUDF2CBAkW4zwXrUN8F6OqU/UeJ9wCWt4z+1lyxBLv5uwVXkPcGvRj9BRjZcwQg3zsDyhvfA2XGywLHNYkEDephAOe+PwJB02D+RJyfBwhLUQI7lCcEPx+zAf5RpwSBTVcHYavbAZqFVQQdcAr9pqHpBrdDswCtQLUF1mCxB4eUIwTBiD8Flnm1AEfqvwHqpy0AWXXdASWgnwce3CcHv1WVBLNTWwPqNxkC4RJNAQTtAP31M0MDAPpU+nQnLwMx7wkC8G77AVG7DPuHcqcC652HBGfJrwUN/xz/vm4zAOuE6wFC42MA5jVPBd4WCP5fB+MBi5KtAz2mfQL0M+EA7FwbAaJFbQXt36cDXRi/A+tRQv7JRakEq/kPAv8M0wb10BsH2BaZA6CzYQMJTA8CQ1CzBtH3YwKjvlsA6YJ/AoQDsP0GCKcGkqU9BK35yQWY+m8CjMHNBFSpQweN9uEBYNXPALSi7QBZs1EAL5htAYsBpwWyMz0CNpf0/AbhoQbnNnUDY6b+/urP9wIPbW0FS5AHBbfEtwSJdoEAjE4ZB0YanQAV7WMA=", - "encoding": "base64", - "path": [ - "z", - 48, - "data" - ] - }, - { - "data": "ycAnwRiqPUDGYETBGOWbv7X7asHS26XA0RM+wZso+sD1T1HBtMRGwQEUdMECCE/BeBGwQLuFQkB5tfvAm88VwcRA00C0EN+/XmhaQOnTZUDsGKy+Q5dKv7E9xcAZHjNB2T5wQIqkIL9Dj0LBVeAYwR0u+MCg6ijB+SrJwJzXMkDILQW/SgxHwfw3SsE4QW/AWNwJP5v1Pb/iU/+/duqIQCLyy0DFgD5AWzGCwesnTcHOs39BkJABQNBiJMGh8ijBaqziv4wGTUCYR4o/eLhjwRfF78D7H5BAWGVbwegQy8AYVSDBHIIBwXjsTcGG5zHBzn1KwXyT68D4aAnB+YznwL9TW8GUgjLBFkSnQP5PWkAxStvA1TpawUL3IEEpmgPBRBblwGC4CMF/dxLA+jNJwRGMU8DCp9q/adYIwSMlNcF6iE5AMydeQPf8Gb9Vpb1A9900PxUXZUC4oeFApVNAQRELjEAdvjfAbK10v3V43EDtR6VAiHtKwfNkjkBmk65AWb5WwcTzSMGBnxDAZyjPwFIv4L9NcdlAm9RcwUPBR8HjbgxB4Vg9wRRQIcHnZe/AFfDtwBY5P0FB6Ui/Zs4NwZCiAMD2zVrBV/zAQN++OMH0BqjAErx/wd6JO8ENuC7BfAgvQQzcb8Ah+mZBF1c0wZLf00AjitlAVs/rwKr3ycC+Qa4+vzoYwfxwo0Dgaf2/3SRVwR5INME0EVBBVjIqwc7DlkCqJOVAw0KjwKYFQcCFc6fAM10hwTwOdEAhhiDASS+EQGjgHcE0s2zBwB9lwQAPq0DhUgnB6NfnwOOt8MAuBTnB3yZGwGwEuMDOYc9A4vIMQPHoS0BzQRtA4P40QSy+A8GN66XAyiN6wC7jQUGRB/rA1XlKwcwi/cBmncJAYPCoQAM0E0DmDFbBCd9NwPeu0MDPcpy+EpFswF0KX8FvIStBlCNVQf1N2cALRFJBJi03wdLRLz9toAHBxFCVPhvKqECDdWu/2VNowfURpUBQbGLAlJ1qQdlaAEB4qcrAzUypwFRrVkE4kO3AtzpXwb0aKkAW9INBZjG0QMlUDUA=", - "encoding": "base64", - "path": [ - "z", - 49, - "data" - ] - } - ], - "model_module": "ipyvolume", - "model_module_version": "^0.5.0-beta.1", - "model_name": "ScatterModel", - "state": { - "geo": "arrow", - "line_material": "IPY_MODEL_e8566485affb45f8bd994182350ee604", - "material": "IPY_MODEL_3e8cee824d0f4b68ad7f23b1717c261e", - "selected": null, - "sequence_index": 17, - "size": 7, - "size_selected": 26, - "texture": null, - "visible": true, - "vx": [ - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - } - ], - "vy": [ - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - } - ], - "vz": [ - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - } - ], - "x": [ - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - } - ], - "y": [ - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - } - ], - "z": [ - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - }, - { - "dtype": "float32", - "shape": [ - 200 - ] - } - ] - } - }, - "c641231c68b14e8292677203201fa6b0": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.1.0", - "model_name": "LayoutModel", - "state": {} - }, - "c70fb21381d94e9f8d203c17d13aa7fc": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.4.0", - "model_name": "VBoxModel", - "state": { - "children": [ - "IPY_MODEL_8dbf31d0ae3648cbabe83f95f9b7e3b5" - ], - "layout": "IPY_MODEL_3ddf7e481aec4de694577c019c98cfaf" - } - }, - "ca43709a8b204164a304b73735979e94": { - "model_module": "jupyter-threejs", - "model_module_version": "~1.0.0", - "model_name": "SceneModel", - "state": { - "_model_module_version": "~1.0.0", - "_view_module": null, - "_view_module_version": "", - "background": null - } - }, - "ca841fd5477640649d0cd0bc7e980b61": { - "model_module": "ipyvolume", - "model_module_version": "^0.5.0-beta.1", - "model_name": "FigureModel", - "state": { - "ambient_coefficient": 0.5, - "animation": 200, - "camera": "IPY_MODEL_c0d781a560654bd5bcdddd6a44889c19", - "capture_fps": null, - "diffuse_coefficient": 0.8, - "height": 500, - "layout": "IPY_MODEL_8cd7b3c022054937a9d9fc5778faa430", - "matrix_projection": [ - 2.9448154572796907, - 0, - 0, - 0, - 0, - 2.3558523658237527, - 0, - 0, - 0, - 0, - -1.00010000500025, - -1, - 0, - 0, - -0.200010000500025, - 0 - ], - "matrix_world": [ - 0.05, - 0, - 0, - 0, - 0, - 0.16666666666666666, - 1.020538999289461e-17, - 0, - 0, - -3.061616997868383e-18, - 0.05, - 0, - 0, - 0, - -2, - 1 - ], - "meshes": [], - "scatters": [ - "IPY_MODEL_ff6eb48719bb46c89367ccf844932fed" - ], - "scene": "IPY_MODEL_9909dfc27b8445c9b2c0b0e34b75bbad", - "specular_coefficient": 0.5, - "specular_exponent": 5, - "volumes": [], - "width": 400, - "xlim": [ - -10, - 10 - ], - "ylim": [ - -3, - 3 - ], - "zlim": [ - -10, - 10 - ] - } - }, - "cc7835a92f184cba990381766ff7a5d9": { - "model_module": "ipyvolume", - "model_module_version": "^0.5.0-beta.1", - "model_name": "FigureModel", - "state": { - "ambient_coefficient": 0.5, - "animation": 200, - "camera": "IPY_MODEL_4d7a6daf02e04c048401fe27f6e9411b", - "capture_fps": null, - "diffuse_coefficient": 0.8, - "height": 500, - "layout": "IPY_MODEL_25277f48e0c34a6682c66c20e00a34e7", - "matrix_projection": [ - 2.9448154572796907, - 0, - 0, - 0, - 0, - 2.3558523658237527, - 0, - 0, - 0, - 0, - -1.00010000500025, - -1, - 0, - 0, - -0.200010000500025, - 0 - ], - "matrix_world": [ - 0.5, - 0, - 0, - 0, - 0, - 0.5, - 3.061616997868383e-17, - 0, - 0, - -3.061616997868383e-17, - 0.5, - 0, - 0, - 0, - -2, - 1 - ], - "meshes": [], - "scatters": [ - "IPY_MODEL_6cbccad5b7db418eb20315cbbe3ea8be" - ], - "scene": "IPY_MODEL_197353e08a2a47d896802d935ab84101", - "specular_coefficient": 0.5, - "specular_exponent": 5, - "volumes": [], - "width": 400, - "xlim": [ - -1, - 1 - ], - "ylim": [ - -1, - 1 - ], - "zlim": [ - -1, - 1 - ] - } - }, - "ce132e4bd9694a83834a81a60daea3ee": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.4.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_d3251110850a4dda956417d360076caa", - "IPY_MODEL_ea561674d7254c89aacdac5c4bf4815a" - ], - "layout": "IPY_MODEL_abf85081062f4e82888c09171f55ee72" - } - }, - "cfb2da5a977640d4af4ec44890f9a747": { - "model_module": "jupyter-threejs", - "model_module_version": "~1.0.0", - "model_name": "PerspectiveCameraModel", - "state": { - "_model_module_version": "~1.0.0", - "_view_module": null, - "_view_module_version": "", - "fov": 46, - "position": [ - 0, - 0, - 2 - ], - "projectionMatrix": [ - 2.3558523658237527, - 0, - 0, - 0, - 0, - 2.3558523658237527, - 0, - 0, - 0, - 0, - -1.00010000500025, - -1, - 0, - 0, - -0.200010000500025, - 0 - ] - } - }, - "cfb85996953142479439894fb4c96c1a": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.4.0", - "model_name": "FloatSliderModel", - "state": { - "layout": "IPY_MODEL_d081f58788c84a87b245ddc053e78377", - "max": 14, - "style": "IPY_MODEL_0b15901ef7b34307971333d2fde5913e", - "value": 14 - } - }, - "d081f58788c84a87b245ddc053e78377": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.1.0", - "model_name": "LayoutModel", - "state": {} - }, - "d1bb401a114241488e3f386d31f21d8e": { - "model_module": "@jupyter-widgets/output", - "model_module_version": "1.0.0", - "model_name": "OutputModel", - "state": { - "layout": "IPY_MODEL_5a2ace988cc0485f8d31dd37b76a4365", - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": "convert -delay 5.0 -loop 0 /var/folders/4h/rklzvjwj08170p1nlsntfdkw0000gn/T/tmpyxtyf5fp/frame-*.png wave.gif\n" - } - ] - } - }, - "d3251110850a4dda956417d360076caa": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.4.0", - "model_name": "PlayModel", - "state": { - "interval": 200, - "layout": "IPY_MODEL_15ae0e209e304a3b9bb24fe0fea70351", - "max": 14, - "style": "IPY_MODEL_fa7852dab7a74edda19d766352adbb66", - "value": 14 - } - }, - "d4522e05191c44e59e373863e22cab61": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.4.0", - "model_name": "PlayModel", - "state": { - "interval": 200, - "layout": "IPY_MODEL_a10382301480402aa1ddd69c44656e92", - "max": 2, - "style": "IPY_MODEL_4163df1232f24aeb85117381a8944736", - "value": 1 - } - }, - "d79017ea773b4b6f9d66a60a706b6668": { - "model_module": "ipyvolume", - "model_module_version": "^0.5.0-beta.1", - "model_name": "FigureModel", - "state": { - "ambient_coefficient": 0.5, - "animation": 200, - "camera": "IPY_MODEL_245072663ea94bb096b2321d43813961", - "capture_fps": null, - "diffuse_coefficient": 0.8, - "height": 500, - "layout": "IPY_MODEL_ee12cdc16e854395840290d35c74b46f", - "matrix_projection": [ - 2.9448154572796907, - 0, - 0, - 0, - 0, - 2.3558523658237527, - 0, - 0, - 0, - 0, - -1.00010000500025, - -1, - 0, - 0, - -0.200010000500025, - 0 - ], - "matrix_world": [ - 0.05, - 0, - 0, - 0, - 0, - 0.16666666666666666, - 1.020538999289461e-17, - 0, - 0, - -3.061616997868383e-18, - 0.05, - 0, - 0, - 0, - -2, - 1 - ], - "meshes": [], - "scatters": [ - "IPY_MODEL_0b44784ed5904895a8c2cc1e5f71c18c" - ], - "scene": "IPY_MODEL_e8757e3650794e76b697b1f1df0f6fcc", - "specular_coefficient": 0.5, - "specular_exponent": 5, - "volumes": [], - "width": 400, - "xlim": [ - -10, - 10 - ], - "ylim": [ - -3, - 3 - ], - "zlim": [ - -10, - 10 - ] - } - }, - "dab1ee01ae48430abf2f36fdef09580e": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.4.0", - "model_name": "SliderStyleModel", - "state": { - "description_width": "" - } - }, - "dc41199297ca477eb7746db122b34869": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.4.0", - "model_name": "VBoxModel", - "state": { - "children": [ - "IPY_MODEL_ca841fd5477640649d0cd0bc7e980b61", - "IPY_MODEL_ce132e4bd9694a83834a81a60daea3ee" - ], - "layout": "IPY_MODEL_42dbcaf6de244359ae06cf249b1762fa" - } - }, - "e13c3dfe59994790b9a7b82c10c980a6": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.4.0", - "model_name": "FloatSliderModel", - "state": { - "layout": "IPY_MODEL_b05fab60e7a440729bd5414b8c187821", - "max": 2, - "style": "IPY_MODEL_dab1ee01ae48430abf2f36fdef09580e", - "value": 1 - } - }, - "e492fbd963294c17a8e32f74283216e9": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.1.0", - "model_name": "LayoutModel", - "state": {} - }, - "e5a7217eef0b4574bf0bc5c2f102a3ee": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.4.0", - "model_name": "LinkModel", - "state": { - "source": [ - "IPY_MODEL_d3251110850a4dda956417d360076caa", - "value" - ], - "target": [ - "IPY_MODEL_ea561674d7254c89aacdac5c4bf4815a", - "value" - ] - } - }, - "e8566485affb45f8bd994182350ee604": { - "model_module": "jupyter-threejs", - "model_module_version": "~1.0.0", - "model_name": "ShaderMaterialModel", - "state": { - "_model_module_version": "~1.0.0", - "_view_module": null, - "_view_module_version": "" - } - }, - "e8757e3650794e76b697b1f1df0f6fcc": { - "model_module": "jupyter-threejs", - "model_module_version": "~1.0.0", - "model_name": "SceneModel", - "state": { - "_model_module_version": "~1.0.0", - "_view_module": null, - "_view_module_version": "", - "background": null - } - }, - "ea561674d7254c89aacdac5c4bf4815a": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.4.0", - "model_name": "FloatSliderModel", - "state": { - "layout": "IPY_MODEL_ed0a30f9ef184d1e8baa5fa562891b1c", - "max": 14, - "style": "IPY_MODEL_3bd5bd6b326b48749588ca49278a6f8a", - "value": 14 - } - }, - "ed0a30f9ef184d1e8baa5fa562891b1c": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.1.0", - "model_name": "LayoutModel", - "state": {} - }, - "edbdc0ff545b4bddb8d1bd00dd7ee5a7": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.4.0", - "model_name": "DescriptionStyleModel", - "state": { - "description_width": "" - } - }, - "ee12cdc16e854395840290d35c74b46f": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.1.0", - "model_name": "LayoutModel", - "state": {} - }, - "f1e04a722ad847569876e85392fab858": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.1.0", - "model_name": "LayoutModel", - "state": {} - }, - "f864ec653a9b4f7fb057ccc1baba8ac9": { - "buffers": [ - { - "data": "AACAv83MTL8=", - "encoding": "base64", - "path": [ - "x", - 0, - "data" - ] - }, - { - "data": "AACAP83MzL0=", - "encoding": "base64", - "path": [ - "x", - 1, - "data" - ] - }, - { - "data": "AAAAAAAAAD8=", - "encoding": "base64", - "path": [ - "x", - 2, - "data" - ] - }, - { - "data": "AAAAAAAAAAA=", - "encoding": "base64", - "path": [ - "y", - 0, - "data" - ] - }, - { - "data": "AAAAAAAAAAA=", - "encoding": "base64", - "path": [ - "z", - 0, - "data" - ] - } - ], - "model_module": "ipyvolume", - "model_module_version": "^0.5.0-beta.1", - "model_name": "ScatterModel", - "state": { - "line_material": "IPY_MODEL_8f267d3de871489e9d9f86652fb27317", - "material": "IPY_MODEL_75202cde091f4ea7889b666f63fc7bfb", - "selected": null, - "sequence_index": 1, - "size": 2, - "size_selected": 2.6, - "texture": null, - "visible": true, - "vx": null, - "vy": null, - "vz": null, - "x": [ - { - "dtype": "float32", - "shape": [ - 2 - ] - }, - { - "dtype": "float32", - "shape": [ - 2 - ] - }, - { - "dtype": "float32", - "shape": [ - 2 - ] - } - ], - "y": [ - { - "dtype": "float32", - "shape": [ - 2 - ] - } - ], - "z": [ - { - "dtype": "float32", - "shape": [ - 2 - ] - } - ] - } - }, - "fa7852dab7a74edda19d766352adbb66": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.4.0", - "model_name": "DescriptionStyleModel", - "state": { - "description_width": "" - } - }, - "fc3eca8b4090422bbff25ef37b9707c6": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.4.0", - "model_name": "SliderStyleModel", - "state": { - "description_width": "" - } - }, - "fd44c9c13f624c51a0b923236f832f36": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.4.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_992acf7dd9a44c028b851bd16b142ffc", - "IPY_MODEL_cfb85996953142479439894fb4c96c1a" - ], - "layout": "IPY_MODEL_22f0f8cc309d4401b5cdc4e70e771051" - } - }, - "ff6eb48719bb46c89367ccf844932fed": { - "buffers": [ - { - "data": "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", - "encoding": "base64", - "path": [ - "color", - 0, - "data" - ] - }, - { - "data": "EXDgvgJeeT/NzMw9AACAP5mg+j0L7H0/zczMPQAAgD/sOh8/uDZ0P83MzD0AAIA/woFtPxeBbD/NzMw9AACAP6u+fj+3+Wg/zczMPQAAgD/DgFs/UVRqP83MzD0AAIA/tY4XP0bNbz/NzMw9AACAP8y3kD7stXc/zczMPQAAgD9tr7+7cNF/P83MzD0AAIA/h2xyvppJeD/NzMw9AACAP8eKy74AmnI/zczMPQAAgD/14/q+3yNvP83MzD0AAIA/fRoFv4X8bT/NzMw9AACAP/Xj+r7fI28/zczMPQAAgD/Hisu+AJpyP83MzD0AAIA/h2xyvppJeD/NzMw9AACAP22vv7tw0X8/zczMPQAAgD/Mt5A+7LV3P83MzD0AAIA/tY4XP0bNbz/NzMw9AACAP8OAWz9RVGo/zczMPQAAgD+rvn4/t/loP83MzD0AAIA/woFtPxeBbD/NzMw9AACAP+w6Hz+4NnQ/zczMPQAAgD+ZoPo9C+x9P83MzD0AAIA/EXDgvgJeeT/NzMw9AACAP5mg+j0L7H0/zczMPQAAgD+rtik/gE1zP83MzD0AAIA/Wqt2P4tLaz/NzMw9AACAP/F4dj9x7mg/zczMPQAAgD9aczU/KzJtP83MzD0AAIA/6lugPpPfdj/NzMw9AACAP2jt1r3lq3w/zczMPQAAgD+sU+u+fUtwP83MzD0AAIA/Y102vxUTZj/NzMw9AACAPwF2Xb/W4l4/zczMPQAAgD8fQ3G/tpFaP83MzD0AAIA/tlh5v09vWD/NzMw9AACAPxpce78L0Fc/zczMPQAAgD+2WHm/T29YP83MzD0AAIA/H0Nxv7aRWj/NzMw9AACAPwF2Xb/W4l4/zczMPQAAgD9jXTa/FRNmP83MzD0AAIA/rFPrvn1LcD/NzMw9AACAP2jt1r3lq3w/zczMPQAAgD/qW6A+k992P83MzD0AAIA/WnM1PysybT/NzMw9AACAP/F4dj9x7mg/zczMPQAAgD9aq3Y/i0trP83MzD0AAIA/q7YpP4BNcz/NzMw9AACAP5mg+j0L7H0/zczMPQAAgD/sOh8/uDZ0P83MzD0AAIA/Wqt2P4tLaz/NzMw9AACAP277cT94FWk/zczMPQAAgD/T4R0/8DpvP83MzD0AAIA/poj/PYA4fD/NzMw9AACAP9pcu74qwHM/zczMPQAAgD+opzy/BP1kP83MzD0AAIA/H0Nxv7aRWj/NzMw9AACAP/z/f79GeVU/zczMPQAAgD+bVHa/JcRUP83MzD0AAIA/K1pjv/NzVj/NzMw9AACAPxohU7/0c1g/zczMPQAAgD9r7ky/IUtZP83MzD0AAIA/GiFTv/RzWD/NzMw9AACAPytaY7/zc1Y/zczMPQAAgD+bVHa/JcRUP83MzD0AAIA//P9/v0Z5VT/NzMw9AACAPx9Dcb+2kVo/zczMPQAAgD+opzy/BP1kP83MzD0AAIA/2ly7virAcz/NzMw9AACAP6aI/z2AOHw/zczMPQAAgD/T4R0/8DpvP83MzD0AAIA/bvtxP3gVaT/NzMw9AACAP1qrdj+LS2s/zczMPQAAgD/sOh8/uDZ0P83MzD0AAIA/woFtPxeBbD/NzMw9AACAP/F4dj9x7mg/zczMPQAAgD/T4R0/8DpvP83MzD0AAIA/F+d0PUkqfj/NzMw9AACAP/Xj+r7fI28/zczMPQAAgD8Bdl2/1uJeP83MzD0AAIA/8NB/v8LUVT/NzMw9AACAP/4obL8kilU/zczMPQAAgD/vCDi/g1pcP83MzD0AAIA/F7L1vqe5Zj/NzMw9AACAP59ljL4+5nA/zczMPQAAgD+U4A++RAx4P83MzD0AAIA/IeXBvY+Xej/NzMw9AACAP5TgD75EDHg/zczMPQAAgD+fZYy+PuZwP83MzD0AAIA/F7L1vqe5Zj/NzMw9AACAP+8IOL+DWlw/zczMPQAAgD/+KGy/JIpVP83MzD0AAIA/8NB/v8LUVT/NzMw9AACAPwF2Xb/W4l4/zczMPQAAgD/14/q+3yNvP83MzD0AAIA/F+d0PUkqfj/NzMw9AACAP9PhHT/wOm8/zczMPQAAgD/xeHY/ce5oP83MzD0AAIA/woFtPxeBbD/NzMw9AACAP6u+fj+3+Wg/zczMPQAAgD9aczU/KzJtP83MzD0AAIA/poj/PYA4fD/NzMw9AACAP/Xj+r7fI28/zczMPQAAgD9iR2a//w5dP83MzD0AAIA/7jt+v8rEVD/NzMw9AACAP2vuTL8hS1k/zczMPQAAgD8DruG+L5RoP83MzD0AAIA/bhNGvUE2fT/NzMw9AACAP3QKkD5CqW4/zczMPQAAgD9OJwI/PRJfP83MzD0AAIA/w0kiP7SpVT/NzMw9AACAP0RWLD+NklI/zczMPQAAgD/DSSI/tKlVP83MzD0AAIA/TicCPz0SXz/NzMw9AACAP3QKkD5CqW4/zczMPQAAgD9uE0a9QTZ9P83MzD0AAIA/A67hvi+UaD/NzMw9AACAP2vuTL8hS1k/zczMPQAAgD/uO36/ysRUP83MzD0AAIA/Ykdmv/8OXT/NzMw9AACAP/Xj+r7fI28/zczMPQAAgD+miP89gDh8P83MzD0AAIA/WnM1PysybT/NzMw9AACAP6u+fj+3+Wg/zczMPQAAgD/DgFs/UVRqP83MzD0AAIA/6lugPpPfdj/NzMw9AACAP9pcu74qwHM/zczMPQAAgD8Bdl2/1uJeP83MzD0AAIA/7jt+v8rEVD/NzMw9AACAP8ZgP78nPls/zczMPQAAgD+fZYy+PuZwP83MzD0AAIA/rwBwPtOxcT/NzMw9AACAP8NJIj+0qVU/zczMPQAAgD8nKV8/BUlBP83MzD0AAIA/lR55Pzr2NT/NzMw9AACAPyeRfz9LWjE/zczMPQAAgD/3/38/5EcwP83MzD0AAIA/J5F/P0taMT/NzMw9AACAP5UeeT869jU/zczMPQAAgD8nKV8/BUlBP83MzD0AAIA/w0kiP7SpVT/NzMw9AACAP68AcD7TsXE/zczMPQAAgD+fZYy+PuZwP83MzD0AAIA/xmA/vyc+Wz/NzMw9AACAP+47fr/KxFQ/zczMPQAAgD8Bdl2/1uJeP83MzD0AAIA/2ly7virAcz/NzMw9AACAP+pboD6T33Y/zczMPQAAgD/DgFs/UVRqP83MzD0AAIA/tY4XP0bNbz/NzMw9AACAP2jt1r3lq3w/zczMPQAAgD+opzy/BP1kP83MzD0AAIA/8NB/v8LUVT/NzMw9AACAP2vuTL8hS1k/zczMPQAAgD+fZYy+PuZwP83MzD0AAIA/2eanPhOXaz/NzMw9AACAP//+Rz92lkk/zczMPQAAgD+SGHw/5TU0P83MzD0AAIA/W2d4P5jKLj/NzMw9AACAP7JcWD+RmDQ/zczMPQAAgD+PmTg/EwU9P83MzD0AAIA/G/ArP2G/QD/NzMw9AACAP4+ZOD8TBT0/zczMPQAAgD+yXFg/kZg0P83MzD0AAIA/W2d4P5jKLj/NzMw9AACAP5IYfD/lNTQ/zczMPQAAgD///kc/dpZJP83MzD0AAIA/2eanPhOXaz/NzMw9AACAP59ljL4+5nA/zczMPQAAgD9r7ky/IUtZP83MzD0AAIA/8NB/v8LUVT/NzMw9AACAP6inPL8E/WQ/zczMPQAAgD9o7da95at8P83MzD0AAIA/tY4XP0bNbz/NzMw9AACAP8y3kD7stXc/zczMPQAAgD+sU+u+fUtwP83MzD0AAIA/H0Nxv7aRWj/NzMw9AACAP/4obL8kilU/zczMPQAAgD8DruG+L5RoP83MzD0AAIA/rwBwPtOxcT/NzMw9AACAP//+Rz92lkk/zczMPQAAgD8nkX8/S1oxP83MzD0AAIA/5tlgPyuoMj/NzMw9AACAP56aDz9UqUk/zczMPQAAgD+FgmM+b9FoP83MzD0AAIA/rQlsvGRsfj/NzMw9AACAPzswxr3EO3U/zczMPQAAgD+tCWy8ZGx+P83MzD0AAIA/hYJjPm/RaD/NzMw9AACAP56aDz9UqUk/zczMPQAAgD/m2WA/K6gyP83MzD0AAIA/J5F/P0taMT/NzMw9AACAP//+Rz92lkk/zczMPQAAgD+vAHA+07FxP83MzD0AAIA/A67hvi+UaD/NzMw9AACAP/4obL8kilU/zczMPQAAgD8fQ3G/tpFaP83MzD0AAIA/rFPrvn1LcD/NzMw9AACAP8y3kD7stXc/zczMPQAAgD9tr7+7cNF/P83MzD0AAIA/Y102vxUTZj/NzMw9AACAP/z/f79GeVU/zczMPQAAgD/vCDi/g1pcP83MzD0AAIA/bhNGvUE2fT/NzMw9AACAP8NJIj+0qVU/zczMPQAAgD+SGHw/5TU0P83MzD0AAIA/5tlgPyuoMj/NzMw9AACAP4Xp3j6TlVQ/zczMPQAAgD87MMa9xDt1P83MzD0AAIA/8OoCv/neQT/NzMw9AACAP9SBPL/HLiE/zczMPQAAgD8FQU2/fZ4WP83MzD0AAIA/1IE8v8cuIT/NzMw9AACAP/DqAr/53kE/zczMPQAAgD87MMa9xDt1P83MzD0AAIA/henePpOVVD/NzMw9AACAP+bZYD8rqDI/zczMPQAAgD+SGHw/5TU0P83MzD0AAIA/w0kiP7SpVT/NzMw9AACAP24TRr1BNn0/zczMPQAAgD/vCDi/g1pcP83MzD0AAIA//P9/v0Z5VT/NzMw9AACAP2NdNr8VE2Y/zczMPQAAgD9tr7+7cNF/P83MzD0AAIA/h2xyvppJeD/NzMw9AACAPwF2Xb/W4l4/zczMPQAAgD+bVHa/JcRUP83MzD0AAIA/F7L1vqe5Zj/NzMw9AACAP3QKkD5CqW4/zczMPQAAgD8nKV8/BUlBP83MzD0AAIA/W2d4P5jKLj/NzMw9AACAP56aDz9UqUk/zczMPQAAgD87MMa9xDt1P83MzD0AAIA/9Vgqv8oBLD/NzMw9AACAP2Wnc7+hzvQ+zczMPQAAgD91k3+/UD7SPs3MzD0AAIA/zUF7v7Y1zz7NzMw9AACAP3WTf79QPtI+zczMPQAAgD9lp3O/oc70Ps3MzD0AAIA/9Vgqv8oBLD/NzMw9AACAPzswxr3EO3U/zczMPQAAgD+emg8/VKlJP83MzD0AAIA/W2d4P5jKLj/NzMw9AACAPycpXz8FSUE/zczMPQAAgD90CpA+QqluP83MzD0AAIA/F7L1vqe5Zj/NzMw9AACAP5tUdr8lxFQ/zczMPQAAgD8Bdl2/1uJeP83MzD0AAIA/h2xyvppJeD/NzMw9AACAP8eKy74AmnI/zczMPQAAgD8fQ3G/tpFaP83MzD0AAIA/K1pjv/NzVj/NzMw9AACAP59ljL4+5nA/zczMPQAAgD9OJwI/PRJfP83MzD0AAIA/lR55Pzr2NT/NzMw9AACAP7JcWD+RmDQ/zczMPQAAgD+FgmM+b9FoP83MzD0AAIA/8OoCv/neQT/NzMw9AACAP2Wnc7+hzvQ+zczMPQAAgD8+tHG/+krSPs3MzD0AAIA/feEsv5jnCD/NzMw9AACAP4OkBL8Y9SA/zczMPQAAgD994Sy/mOcIP83MzD0AAIA/PrRxv/pK0j7NzMw9AACAP2Wnc7+hzvQ+zczMPQAAgD/w6gK/+d5BP83MzD0AAIA/hYJjPm/RaD/NzMw9AACAP7JcWD+RmDQ/zczMPQAAgD+VHnk/OvY1P83MzD0AAIA/TicCPz0SXz/NzMw9AACAP59ljL4+5nA/zczMPQAAgD8rWmO/83NWP83MzD0AAIA/H0Nxv7aRWj/NzMw9AACAP8eKy74AmnI/zczMPQAAgD/14/q+3yNvP83MzD0AAIA/tlh5v09vWD/NzMw9AACAPxohU7/0c1g/zczMPQAAgD+U4A++RAx4P83MzD0AAIA/w0kiP7SpVT/NzMw9AACAPyeRfz9LWjE/zczMPQAAgD+PmTg/EwU9P83MzD0AAIA/rQlsvGRsfj/NzMw9AACAP9SBPL/HLiE/zczMPQAAgD91k3+/UD7SPs3MzD0AAIA/feEsv5jnCD/NzMw9AACAP5tbZ72Uk3Q/zczMPQAAgD+AwJE+009CP83MzD0AAIA/m1tnvZSTdD/NzMw9AACAP33hLL+Y5wg/zczMPQAAgD91k3+/UD7SPs3MzD0AAIA/1IE8v8cuIT/NzMw9AACAP60JbLxkbH4/zczMPQAAgD+PmTg/EwU9P83MzD0AAIA/J5F/P0taMT/NzMw9AACAP8NJIj+0qVU/zczMPQAAgD+U4A++RAx4P83MzD0AAIA/GiFTv/RzWD/NzMw9AACAP7ZYeb9Pb1g/zczMPQAAgD/14/q+3yNvP83MzD0AAIA/fRoFv4X8bT/NzMw9AACAPxpce78L0Fc/zczMPQAAgD9r7ky/IUtZP83MzD0AAIA/IeXBvY+Xej/NzMw9AACAP0RWLD+NklI/zczMPQAAgD/3/38/5EcwP83MzD0AAIA/G/ArP2G/QD/NzMw9AACAPzswxr3EO3U/zczMPQAAgD8FQU2/fZ4WP83MzD0AAIA/zUF7v7Y1zz7NzMw9AACAP4OkBL8Y9SA/zczMPQAAgD+AwJE+009CP83MzD0AAIA/5aVmP9bQyj3NzMw9AACAP4DAkT7TT0I/zczMPQAAgD+DpAS/GPUgP83MzD0AAIA/zUF7v7Y1zz7NzMw9AACAPwVBTb99nhY/zczMPQAAgD87MMa9xDt1P83MzD0AAIA/G/ArP2G/QD/NzMw9AACAP/f/fz/kRzA/zczMPQAAgD9EViw/jZJSP83MzD0AAIA/IeXBvY+Xej/NzMw9AACAP2vuTL8hS1k/zczMPQAAgD8aXHu/C9BXP83MzD0AAIA/fRoFv4X8bT/NzMw9AACAP/Xj+r7fI28/zczMPQAAgD+2WHm/T29YP83MzD0AAIA/GiFTv/RzWD/NzMw9AACAP5TgD75EDHg/zczMPQAAgD/DSSI/tKlVP83MzD0AAIA/J5F/P0taMT/NzMw9AACAP4+ZOD8TBT0/zczMPQAAgD+tCWy8ZGx+P83MzD0AAIA/1IE8v8cuIT/NzMw9AACAP3WTf79QPtI+zczMPQAAgD994Sy/mOcIP83MzD0AAIA/m1tnvZSTdD/NzMw9AACAP4DAkT7TT0I/zczMPQAAgD+bW2e9lJN0P83MzD0AAIA/feEsv5jnCD/NzMw9AACAP3WTf79QPtI+zczMPQAAgD/UgTy/xy4hP83MzD0AAIA/rQlsvGRsfj/NzMw9AACAP4+ZOD8TBT0/zczMPQAAgD8nkX8/S1oxP83MzD0AAIA/w0kiP7SpVT/NzMw9AACAP5TgD75EDHg/zczMPQAAgD8aIVO/9HNYP83MzD0AAIA/tlh5v09vWD/NzMw9AACAP/Xj+r7fI28/zczMPQAAgD/Hisu+AJpyP83MzD0AAIA/H0Nxv7aRWj/NzMw9AACAPytaY7/zc1Y/zczMPQAAgD+fZYy+PuZwP83MzD0AAIA/TicCPz0SXz/NzMw9AACAP5UeeT869jU/zczMPQAAgD+yXFg/kZg0P83MzD0AAIA/hYJjPm/RaD/NzMw9AACAP/DqAr/53kE/zczMPQAAgD9lp3O/oc70Ps3MzD0AAIA/PrRxv/pK0j7NzMw9AACAP33hLL+Y5wg/zczMPQAAgD+DpAS/GPUgP83MzD0AAIA/feEsv5jnCD/NzMw9AACAPz60cb/6StI+zczMPQAAgD9lp3O/oc70Ps3MzD0AAIA/8OoCv/neQT/NzMw9AACAP4WCYz5v0Wg/zczMPQAAgD+yXFg/kZg0P83MzD0AAIA/lR55Pzr2NT/NzMw9AACAP04nAj89El8/zczMPQAAgD+fZYy+PuZwP83MzD0AAIA/K1pjv/NzVj/NzMw9AACAPx9Dcb+2kVo/zczMPQAAgD/Hisu+AJpyP83MzD0AAIA/h2xyvppJeD/NzMw9AACAPwF2Xb/W4l4/zczMPQAAgD+bVHa/JcRUP83MzD0AAIA/F7L1vqe5Zj/NzMw9AACAP3QKkD5CqW4/zczMPQAAgD8nKV8/BUlBP83MzD0AAIA/W2d4P5jKLj/NzMw9AACAP56aDz9UqUk/zczMPQAAgD87MMa9xDt1P83MzD0AAIA/9Vgqv8oBLD/NzMw9AACAP2Wnc7+hzvQ+zczMPQAAgD91k3+/UD7SPs3MzD0AAIA/zUF7v7Y1zz7NzMw9AACAP3WTf79QPtI+zczMPQAAgD9lp3O/oc70Ps3MzD0AAIA/9Vgqv8oBLD/NzMw9AACAPzswxr3EO3U/zczMPQAAgD+emg8/VKlJP83MzD0AAIA/W2d4P5jKLj/NzMw9AACAPycpXz8FSUE/zczMPQAAgD90CpA+QqluP83MzD0AAIA/F7L1vqe5Zj/NzMw9AACAP5tUdr8lxFQ/zczMPQAAgD8Bdl2/1uJeP83MzD0AAIA/h2xyvppJeD/NzMw9AACAP22vv7tw0X8/zczMPQAAgD9jXTa/FRNmP83MzD0AAIA//P9/v0Z5VT/NzMw9AACAP+8IOL+DWlw/zczMPQAAgD9uE0a9QTZ9P83MzD0AAIA/w0kiP7SpVT/NzMw9AACAP5IYfD/lNTQ/zczMPQAAgD/m2WA/K6gyP83MzD0AAIA/henePpOVVD/NzMw9AACAPzswxr3EO3U/zczMPQAAgD/w6gK/+d5BP83MzD0AAIA/1IE8v8cuIT/NzMw9AACAPwVBTb99nhY/zczMPQAAgD/UgTy/xy4hP83MzD0AAIA/8OoCv/neQT/NzMw9AACAPzswxr3EO3U/zczMPQAAgD+F6d4+k5VUP83MzD0AAIA/5tlgPyuoMj/NzMw9AACAP5IYfD/lNTQ/zczMPQAAgD/DSSI/tKlVP83MzD0AAIA/bhNGvUE2fT/NzMw9AACAP+8IOL+DWlw/zczMPQAAgD/8/3+/RnlVP83MzD0AAIA/Y102vxUTZj/NzMw9AACAP22vv7tw0X8/zczMPQAAgD/Mt5A+7LV3P83MzD0AAIA/rFPrvn1LcD/NzMw9AACAPx9Dcb+2kVo/zczMPQAAgD/+KGy/JIpVP83MzD0AAIA/A67hvi+UaD/NzMw9AACAP68AcD7TsXE/zczMPQAAgD///kc/dpZJP83MzD0AAIA/J5F/P0taMT/NzMw9AACAP+bZYD8rqDI/zczMPQAAgD+emg8/VKlJP83MzD0AAIA/hYJjPm/RaD/NzMw9AACAP60JbLxkbH4/zczMPQAAgD87MMa9xDt1P83MzD0AAIA/rQlsvGRsfj/NzMw9AACAP4WCYz5v0Wg/zczMPQAAgD+emg8/VKlJP83MzD0AAIA/5tlgPyuoMj/NzMw9AACAPyeRfz9LWjE/zczMPQAAgD///kc/dpZJP83MzD0AAIA/rwBwPtOxcT/NzMw9AACAPwOu4b4vlGg/zczMPQAAgD/+KGy/JIpVP83MzD0AAIA/H0Nxv7aRWj/NzMw9AACAP6xT6759S3A/zczMPQAAgD/Mt5A+7LV3P83MzD0AAIA/tY4XP0bNbz/NzMw9AACAP2jt1r3lq3w/zczMPQAAgD+opzy/BP1kP83MzD0AAIA/8NB/v8LUVT/NzMw9AACAP2vuTL8hS1k/zczMPQAAgD+fZYy+PuZwP83MzD0AAIA/2eanPhOXaz/NzMw9AACAP//+Rz92lkk/zczMPQAAgD+SGHw/5TU0P83MzD0AAIA/W2d4P5jKLj/NzMw9AACAP7JcWD+RmDQ/zczMPQAAgD+PmTg/EwU9P83MzD0AAIA/G/ArP2G/QD/NzMw9AACAP4+ZOD8TBT0/zczMPQAAgD+yXFg/kZg0P83MzD0AAIA/W2d4P5jKLj/NzMw9AACAP5IYfD/lNTQ/zczMPQAAgD///kc/dpZJP83MzD0AAIA/2eanPhOXaz/NzMw9AACAP59ljL4+5nA/zczMPQAAgD9r7ky/IUtZP83MzD0AAIA/8NB/v8LUVT/NzMw9AACAP6inPL8E/WQ/zczMPQAAgD9o7da95at8P83MzD0AAIA/tY4XP0bNbz/NzMw9AACAP8OAWz9RVGo/zczMPQAAgD/qW6A+k992P83MzD0AAIA/2ly7virAcz/NzMw9AACAPwF2Xb/W4l4/zczMPQAAgD/uO36/ysRUP83MzD0AAIA/xmA/vyc+Wz/NzMw9AACAP59ljL4+5nA/zczMPQAAgD+vAHA+07FxP83MzD0AAIA/w0kiP7SpVT/NzMw9AACAPycpXz8FSUE/zczMPQAAgD+VHnk/OvY1P83MzD0AAIA/J5F/P0taMT/NzMw9AACAP/f/fz/kRzA/zczMPQAAgD8nkX8/S1oxP83MzD0AAIA/lR55Pzr2NT/NzMw9AACAPycpXz8FSUE/zczMPQAAgD/DSSI/tKlVP83MzD0AAIA/rwBwPtOxcT/NzMw9AACAP59ljL4+5nA/zczMPQAAgD/GYD+/Jz5bP83MzD0AAIA/7jt+v8rEVD/NzMw9AACAPwF2Xb/W4l4/zczMPQAAgD/aXLu+KsBzP83MzD0AAIA/6lugPpPfdj/NzMw9AACAP8OAWz9RVGo/zczMPQAAgD+rvn4/t/loP83MzD0AAIA/WnM1PysybT/NzMw9AACAP6aI/z2AOHw/zczMPQAAgD/14/q+3yNvP83MzD0AAIA/Ykdmv/8OXT/NzMw9AACAP+47fr/KxFQ/zczMPQAAgD9r7ky/IUtZP83MzD0AAIA/A67hvi+UaD/NzMw9AACAP24TRr1BNn0/zczMPQAAgD90CpA+QqluP83MzD0AAIA/TicCPz0SXz/NzMw9AACAP8NJIj+0qVU/zczMPQAAgD9EViw/jZJSP83MzD0AAIA/w0kiP7SpVT/NzMw9AACAP04nAj89El8/zczMPQAAgD90CpA+QqluP83MzD0AAIA/bhNGvUE2fT/NzMw9AACAPwOu4b4vlGg/zczMPQAAgD9r7ky/IUtZP83MzD0AAIA/7jt+v8rEVD/NzMw9AACAP2JHZr//Dl0/zczMPQAAgD/14/q+3yNvP83MzD0AAIA/poj/PYA4fD/NzMw9AACAP1pzNT8rMm0/zczMPQAAgD+rvn4/t/loP83MzD0AAIA/woFtPxeBbD/NzMw9AACAP/F4dj9x7mg/zczMPQAAgD/T4R0/8DpvP83MzD0AAIA/F+d0PUkqfj/NzMw9AACAP/Xj+r7fI28/zczMPQAAgD8Bdl2/1uJeP83MzD0AAIA/8NB/v8LUVT/NzMw9AACAP/4obL8kilU/zczMPQAAgD/vCDi/g1pcP83MzD0AAIA/F7L1vqe5Zj/NzMw9AACAP59ljL4+5nA/zczMPQAAgD+U4A++RAx4P83MzD0AAIA/IeXBvY+Xej/NzMw9AACAP5TgD75EDHg/zczMPQAAgD+fZYy+PuZwP83MzD0AAIA/F7L1vqe5Zj/NzMw9AACAP+8IOL+DWlw/zczMPQAAgD/+KGy/JIpVP83MzD0AAIA/8NB/v8LUVT/NzMw9AACAPwF2Xb/W4l4/zczMPQAAgD/14/q+3yNvP83MzD0AAIA/F+d0PUkqfj/NzMw9AACAP9PhHT/wOm8/zczMPQAAgD/xeHY/ce5oP83MzD0AAIA/woFtPxeBbD/NzMw9AACAP+w6Hz+4NnQ/zczMPQAAgD9aq3Y/i0trP83MzD0AAIA/bvtxP3gVaT/NzMw9AACAP9PhHT/wOm8/zczMPQAAgD+miP89gDh8P83MzD0AAIA/2ly7virAcz/NzMw9AACAP6inPL8E/WQ/zczMPQAAgD8fQ3G/tpFaP83MzD0AAIA//P9/v0Z5VT/NzMw9AACAP5tUdr8lxFQ/zczMPQAAgD8rWmO/83NWP83MzD0AAIA/GiFTv/RzWD/NzMw9AACAP2vuTL8hS1k/zczMPQAAgD8aIVO/9HNYP83MzD0AAIA/K1pjv/NzVj/NzMw9AACAP5tUdr8lxFQ/zczMPQAAgD/8/3+/RnlVP83MzD0AAIA/H0Nxv7aRWj/NzMw9AACAP6inPL8E/WQ/zczMPQAAgD/aXLu+KsBzP83MzD0AAIA/poj/PYA4fD/NzMw9AACAP9PhHT/wOm8/zczMPQAAgD9u+3E/eBVpP83MzD0AAIA/Wqt2P4tLaz/NzMw9AACAP+w6Hz+4NnQ/zczMPQAAgD+ZoPo9C+x9P83MzD0AAIA/q7YpP4BNcz/NzMw9AACAP1qrdj+LS2s/zczMPQAAgD/xeHY/ce5oP83MzD0AAIA/WnM1PysybT/NzMw9AACAP+pboD6T33Y/zczMPQAAgD9o7da95at8P83MzD0AAIA/rFPrvn1LcD/NzMw9AACAP2NdNr8VE2Y/zczMPQAAgD8Bdl2/1uJeP83MzD0AAIA/H0Nxv7aRWj/NzMw9AACAP7ZYeb9Pb1g/zczMPQAAgD8aXHu/C9BXP83MzD0AAIA/tlh5v09vWD/NzMw9AACAPx9Dcb+2kVo/zczMPQAAgD8Bdl2/1uJeP83MzD0AAIA/Y102vxUTZj/NzMw9AACAP6xT6759S3A/zczMPQAAgD9o7da95at8P83MzD0AAIA/6lugPpPfdj/NzMw9AACAP1pzNT8rMm0/zczMPQAAgD/xeHY/ce5oP83MzD0AAIA/Wqt2P4tLaz/NzMw9AACAP6u2KT+ATXM/zczMPQAAgD+ZoPo9C+x9P83MzD0AAIA/EXDgvgJeeT/NzMw9AACAP5mg+j0L7H0/zczMPQAAgD/sOh8/uDZ0P83MzD0AAIA/woFtPxeBbD/NzMw9AACAP6u+fj+3+Wg/zczMPQAAgD/DgFs/UVRqP83MzD0AAIA/tY4XP0bNbz/NzMw9AACAP8y3kD7stXc/zczMPQAAgD9tr7+7cNF/P83MzD0AAIA/h2xyvppJeD/NzMw9AACAP8eKy74AmnI/zczMPQAAgD/14/q+3yNvP83MzD0AAIA/fRoFv4X8bT/NzMw9AACAP/Xj+r7fI28/zczMPQAAgD/Hisu+AJpyP83MzD0AAIA/h2xyvppJeD/NzMw9AACAP22vv7tw0X8/zczMPQAAgD/Mt5A+7LV3P83MzD0AAIA/tY4XP0bNbz/NzMw9AACAP8OAWz9RVGo/zczMPQAAgD+rvn4/t/loP83MzD0AAIA/woFtPxeBbD/NzMw9AACAP+w6Hz+4NnQ/zczMPQAAgD+ZoPo9C+x9P83MzD0AAIA/EXDgvgJeeT/NzMw9AACAPw==", - "encoding": "base64", - "path": [ - "color", - 1, - "data" - ] - }, - { - "data": "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", - "encoding": "base64", - "path": [ - "color", - 2, - "data" - ] - }, - { - "data": "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", - "encoding": "base64", - "path": [ - "color", - 3, - "data" - ] - }, - { - "data": "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", - "encoding": "base64", - "path": [ - "color", - 4, - "data" - ] - }, - { - "data": "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", - "encoding": "base64", - "path": [ - "color", - 5, - "data" - ] - }, - { - "data": "jdrbvrCAeT/NzMw9AACAP2wtWr9Vh3E/zczMPQAAgD/h/3+/BQ1tP83MzD0AAIA/CMZev7G2bT/NzMw9AACAP/QIC78Cb3M/zczMPQAAgD8Acwe+K6h8P83MzD0AAIA/rZ6FPgjceD/NzMw9AACAP0jfEj+rLG8/zczMPQAAgD9CFEk/yZNnP83MzD0AAIA/ED9oP/lxYj/NzMw9AACAP0Mbdz++d18/zczMPQAAgD+Pr3w/+QleP83MzD0AAIA/+fR9P3OhXT/NzMw9AACAP4+vfD/5CV4/zczMPQAAgD9DG3c/vndfP83MzD0AAIA/ED9oP/lxYj/NzMw9AACAP0IUST/Jk2c/zczMPQAAgD9I3xI/qyxvP83MzD0AAIA/rZ6FPgjceD/NzMw9AACAPwBzB74rqHw/zczMPQAAgD/0CAu/Am9zP83MzD0AAIA/CMZev7G2bT/NzMw9AACAP+H/f78FDW0/zczMPQAAgD9sLVq/VYdxP83MzD0AAIA/jdrbvrCAeT/NzMw9AACAP2wtWr9Vh3E/zczMPQAAgD/1qH+/Yd9sP83MzD0AAIA/+1ZPv6qYbj/NzMw9AACAP70nx74XrnY/zczMPQAAgD/EcuA9rhd9P83MzD0AAIA/bhYMP9sNcD/NzMw9AACAP1XLVz+sQ2U/zczMPQAAgD/0HXs/b3teP83MzD0AAIA/Xit+P9ndWz/NzMw9AACAP796bj9lV1w/zczMPQAAgD/RWlk/QEdeP83MzD0AAIA/w8xIP1IjYD/NzMw9AACAP8KnQj/p4GA/zczMPQAAgD/DzEg/UiNgP83MzD0AAIA/0VpZP0BHXj/NzMw9AACAP796bj9lV1w/zczMPQAAgD9eK34/2d1bP83MzD0AAIA/9B17P297Xj/NzMw9AACAP1XLVz+sQ2U/zczMPQAAgD9uFgw/2w1wP83MzD0AAIA/xHLgPa4XfT/NzMw9AACAP70nx74XrnY/zczMPQAAgD/7Vk+/qphuP83MzD0AAIA/9ah/v2HfbD/NzMw9AACAP2wtWr9Vh3E/zczMPQAAgD/h/3+/BQ1tP83MzD0AAIA/+1ZPv6qYbj/NzMw9AACAPzkaq77t5Xc/zczMPQAAgD92dWw+lLh5P83MzD0AAIA/YKsyPy/caj/NzMw9AACAP+WsdD/hAWA/zczMPQAAgD8L63w/gMlbP83MzD0AAIA/0VpZP0BHXj/NzMw9AACAP+54Hz87gmU/zczMPQAAgD/UMMY+jptuP83MzD0AAIA/PgFHPobodj/NzMw9AACAP6uQkz1/i3w/zczMPQAAgD/KP/o834V+P83MzD0AAIA/q5CTPX+LfD/NzMw9AACAPz4BRz6G6HY/zczMPQAAgD/UMMY+jptuP83MzD0AAIA/7ngfPzuCZT/NzMw9AACAP9FaWT9AR14/zczMPQAAgD8L63w/gMlbP83MzD0AAIA/5ax0P+EBYD/NzMw9AACAP2CrMj8v3Go/zczMPQAAgD92dWw+lLh5P83MzD0AAIA/ORqrvu3ldz/NzMw9AACAP/tWT7+qmG4/zczMPQAAgD/h/3+/BQ1tP83MzD0AAIA/CMZev7G2bT/NzMw9AACAP70nx74XrnY/zczMPQAAgD92dWw+lLh5P83MzD0AAIA/VT8+P8YxaT/NzMw9AACAP4+vfD/5CV4/zczMPQAAgD+/em4/ZVdcP83MzD0AAIA/GhUnP0B1ZD/NzMw9AACAPzr5iz6vanM/zczMPQAAgD/DFMO92UZ7P83MzD0AAIA/4gHGvoShaz/NzMw9AACAP3y1FL/AAmA/zczMPQAAgD+kvC+/6iVZP83MzD0AAIA/bSM4v8bpVj/NzMw9AACAP6S8L7/qJVk/zczMPQAAgD98tRS/wAJgP83MzD0AAIA/4gHGvoShaz/NzMw9AACAP8MUw73ZRns/zczMPQAAgD86+Ys+r2pzP83MzD0AAIA/GhUnP0B1ZD/NzMw9AACAP796bj9lV1w/zczMPQAAgD+Pr3w/+QleP83MzD0AAIA/VT8+P8YxaT/NzMw9AACAP3Z1bD6UuHk/zczMPQAAgD+9J8e+F652P83MzD0AAIA/CMZev7G2bT/NzMw9AACAP/QIC78Cb3M/zczMPQAAgD/EcuA9rhd9P83MzD0AAIA/YKsyPy/caj/NzMw9AACAP4+vfD/5CV4/zczMPQAAgD/DA2c/avJcP83MzD0AAIA/TgsHP1EJaT/NzMw9AACAP8o/+jzfhX4/zczMPQAAgD+qmtq+K1BpP83MzD0AAIA/MDJAvxC3VD/NzMw9AACAPxX4bL8w80Y/zczMPQAAgD8XgH2/Vt0/P83MzD0AAIA/Fvp/v8Q4PT/NzMw9AACAP0B0f7+8qTw/zczMPQAAgD8W+n+/xDg9P83MzD0AAIA/F4B9v1bdPz/NzMw9AACAPxX4bL8w80Y/zczMPQAAgD8wMkC/ELdUP83MzD0AAIA/qpravitQaT/NzMw9AACAP8o/+jzfhX4/zczMPQAAgD9OCwc/UQlpP83MzD0AAIA/wwNnP2ryXD/NzMw9AACAP4+vfD/5CV4/zczMPQAAgD9gqzI/L9xqP83MzD0AAIA/xHLgPa4XfT/NzMw9AACAP/QIC78Cb3M/zczMPQAAgD8Acwe+K6h8P83MzD0AAIA/bhYMP9sNcD/NzMw9AACAP+WsdD/hAWA/zczMPQAAgD+/em4/ZVdcP83MzD0AAIA/TgsHP1EJaT/NzMw9AACAP3nPWb2oYn0/zczMPQAAgD98tRS/wAJgP83MzD0AAIA/0Ptnv8CwSD/NzMw9AACAPxb6f7/EOD0/zczMPQAAgD8vNm2/JlY9P83MzD0AAIA/PWpJv7sjRD/NzMw9AACAP8P6Kr8jYks/zczMPQAAgD8NZx+/jlxOP83MzD0AAIA/w/oqvyNiSz/NzMw9AACAPz1qSb+7I0Q/zczMPQAAgD8vNm2/JlY9P83MzD0AAIA/Fvp/v8Q4PT/NzMw9AACAP9D7Z7/AsEg/zczMPQAAgD98tRS/wAJgP83MzD0AAIA/ec9ZvahifT/NzMw9AACAP04LBz9RCWk/zczMPQAAgD+/em4/ZVdcP83MzD0AAIA/5ax0P+EBYD/NzMw9AACAP24WDD/bDXA/zczMPQAAgD8Acwe+K6h8P83MzD0AAIA/rZ6FPgjceD/NzMw9AACAP1XLVz+sQ2U/zczMPQAAgD8L63w/gMlbP83MzD0AAIA/GhUnP0B1ZD/NzMw9AACAP8o/+jzfhX4/zczMPQAAgD98tRS/wAJgP83MzD0AAIA/YGxxv1NORT/NzMw9AACAP8yieb8YFTw/zczMPQAAgD8XAEC/C0dGP83MzD0AAIA/x/bUvk8wXT/NzMw9AACAP4lZ370lRXY/zczMPQAAgD/lmLw9OXJ3P83MzD0AAIA/t1ckPqzicD/NzMw9AACAP+WYvD05cnc/zczMPQAAgD+JWd+9JUV2P83MzD0AAIA/x/bUvk8wXT/NzMw9AACAPxcAQL8LR0Y/zczMPQAAgD/Monm/GBU8P83MzD0AAIA/YGxxv1NORT/NzMw9AACAP3y1FL/AAmA/zczMPQAAgD/KP/o834V+P83MzD0AAIA/GhUnP0B1ZD/NzMw9AACAPwvrfD+AyVs/zczMPQAAgD9Vy1c/rENlP83MzD0AAIA/rZ6FPgjceD/NzMw9AACAP0jfEj+rLG8/zczMPQAAgD/0HXs/b3teP83MzD0AAIA/0VpZP0BHXj/NzMw9AACAPzr5iz6vanM/zczMPQAAgD+qmtq+K1BpP83MzD0AAIA/0Ptnv8CwSD/NzMw9AACAP8yieb8YFTw/zczMPQAAgD/D+iq/I2JLP83MzD0AAIA/mAgyvrSwcD/NzMw9AACAP3ZQmD7KLmM/zczMPQAAgD8Srx8/quo+P83MzD0AAIA/dm1KPx13KT/NzMw9AACAP9GnVj8KtiI/zczMPQAAgD92bUo/HXcpP83MzD0AAIA/Eq8fP6rqPj/NzMw9AACAP3ZQmD7KLmM/zczMPQAAgD+YCDK+tLBwP83MzD0AAIA/w/oqvyNiSz/NzMw9AACAP8yieb8YFTw/zczMPQAAgD/Q+2e/wLBIP83MzD0AAIA/qpravitQaT/NzMw9AACAPzr5iz6vanM/zczMPQAAgD/RWlk/QEdeP83MzD0AAIA/9B17P297Xj/NzMw9AACAP0jfEj+rLG8/zczMPQAAgD9CFEk/yZNnP83MzD0AAIA/Xit+P9ndWz/NzMw9AACAP+54Hz87gmU/zczMPQAAgD/DFMO92UZ7P83MzD0AAIA/MDJAvxC3VD/NzMw9AACAPxb6f7/EOD0/zczMPQAAgD8XAEC/C0dGP83MzD0AAIA/mAgyvrSwcD/NzMw9AACAP1hi3T7D4VQ/zczMPQAAgD/Rp1Y/CrYiP83MzD0AAIA/Z599P7WjBz/NzMw9AACAP63zfD+FxAA/zczMPQAAgD+flnc/R+IAP83MzD0AAIA/rfN8P4XEAD/NzMw9AACAP2effT+1owc/zczMPQAAgD/Rp1Y/CrYiP83MzD0AAIA/WGLdPsPhVD/NzMw9AACAP5gIMr60sHA/zczMPQAAgD8XAEC/C0dGP83MzD0AAIA/Fvp/v8Q4PT/NzMw9AACAPzAyQL8Qt1Q/zczMPQAAgD/DFMO92UZ7P83MzD0AAIA/7ngfPzuCZT/NzMw9AACAP14rfj/Z3Vs/zczMPQAAgD9CFEk/yZNnP83MzD0AAIA/ED9oP/lxYj/NzMw9AACAP796bj9lV1w/zczMPQAAgD/UMMY+jptuP83MzD0AAIA/4gHGvoShaz/NzMw9AACAPxX4bL8w80Y/zczMPQAAgD8vNm2/JlY9P83MzD0AAIA/x/bUvk8wXT/NzMw9AACAP3ZQmD7KLmM/zczMPQAAgD/Rp1Y/CrYiP83MzD0AAIA/ap1/P9z2AT/NzMw9AACAP29SVT/gCAs/zczMPQAAgD+Y1RM/ALooP83MzD0AAIA/Xp3sPjM+OD/NzMw9AACAP5jVEz8Auig/zczMPQAAgD9vUlU/4AgLP83MzD0AAIA/ap1/P9z2AT/NzMw9AACAP9GnVj8KtiI/zczMPQAAgD92UJg+yi5jP83MzD0AAIA/x/bUvk8wXT/NzMw9AACAPy82bb8mVj0/zczMPQAAgD8V+Gy/MPNGP83MzD0AAIA/4gHGvoShaz/NzMw9AACAP9Qwxj6Om24/zczMPQAAgD+/em4/ZVdcP83MzD0AAIA/ED9oP/lxYj/NzMw9AACAP0Mbdz++d18/zczMPQAAgD/RWlk/QEdeP83MzD0AAIA/PgFHPobodj/NzMw9AACAP3y1FL/AAmA/zczMPQAAgD8XgH2/Vt0/P83MzD0AAIA/PWpJv7sjRD/NzMw9AACAP4lZ370lRXY/zczMPQAAgD8Srx8/quo+P83MzD0AAIA/Z599P7WjBz/NzMw9AACAP29SVT/gCAs/zczMPQAAgD/GgKk+vhpLP83MzD0AAIA/9k0fvnaQZD/NzMw9AACAP7L4sL7imEA/zczMPQAAgD/2TR++dpBkP83MzD0AAIA/xoCpPr4aSz/NzMw9AACAP29SVT/gCAs/zczMPQAAgD9nn30/taMHP83MzD0AAIA/Eq8fP6rqPj/NzMw9AACAP4lZ370lRXY/zczMPQAAgD89akm/uyNEP83MzD0AAIA/F4B9v1bdPz/NzMw9AACAP3y1FL/AAmA/zczMPQAAgD8+AUc+huh2P83MzD0AAIA/0VpZP0BHXj/NzMw9AACAP0Mbdz++d18/zczMPQAAgD+Pr3w/+QleP83MzD0AAIA/w8xIP1IjYD/NzMw9AACAP6uQkz1/i3w/zczMPQAAgD+kvC+/6iVZP83MzD0AAIA/Fvp/v8Q4PT/NzMw9AACAP8P6Kr8jYks/zczMPQAAgD/lmLw9OXJ3P83MzD0AAIA/dm1KPx13KT/NzMw9AACAP63zfD+FxAA/zczMPQAAgD+Y1RM/ALooP83MzD0AAIA/9k0fvnaQZD/NzMw9AACAP1LQPr8bgtI+zczMPQAAgD8eTm2/jYBcPs3MzD0AAIA/UtA+vxuC0j7NzMw9AACAP/ZNH752kGQ/zczMPQAAgD+Y1RM/ALooP83MzD0AAIA/rfN8P4XEAD/NzMw9AACAP3ZtSj8ddyk/zczMPQAAgD/lmLw9OXJ3P83MzD0AAIA/w/oqvyNiSz/NzMw9AACAPxb6f7/EOD0/zczMPQAAgD+kvC+/6iVZP83MzD0AAIA/q5CTPX+LfD/NzMw9AACAP8PMSD9SI2A/zczMPQAAgD+Pr3w/+QleP83MzD0AAIA/+fR9P3OhXT/NzMw9AACAP8KnQj/p4GA/zczMPQAAgD/KP/o834V+P83MzD0AAIA/bSM4v8bpVj/NzMw9AACAP0B0f7+8qTw/zczMPQAAgD8NZx+/jlxOP83MzD0AAIA/t1ckPqzicD/NzMw9AACAP9GnVj8KtiI/zczMPQAAgD+flnc/R+IAP83MzD0AAIA/Xp3sPjM+OD/NzMw9AACAP7L4sL7imEA/zczMPQAAgD8eTm2/jYBcPs3MzD0AAIA/5aVmv9bQyj3NzMw9AACAPx5Obb+NgFw+zczMPQAAgD+y+LC+4phAP83MzD0AAIA/Xp3sPjM+OD/NzMw9AACAP5+Wdz9H4gA/zczMPQAAgD/Rp1Y/CrYiP83MzD0AAIA/t1ckPqzicD/NzMw9AACAPw1nH7+OXE4/zczMPQAAgD9AdH+/vKk8P83MzD0AAIA/bSM4v8bpVj/NzMw9AACAP8o/+jzfhX4/zczMPQAAgD/Cp0I/6eBgP83MzD0AAIA/+fR9P3OhXT/NzMw9AACAP4+vfD/5CV4/zczMPQAAgD/DzEg/UiNgP83MzD0AAIA/q5CTPX+LfD/NzMw9AACAP6S8L7/qJVk/zczMPQAAgD8W+n+/xDg9P83MzD0AAIA/w/oqvyNiSz/NzMw9AACAP+WYvD05cnc/zczMPQAAgD92bUo/HXcpP83MzD0AAIA/rfN8P4XEAD/NzMw9AACAP5jVEz8Auig/zczMPQAAgD/2TR++dpBkP83MzD0AAIA/UtA+vxuC0j7NzMw9AACAPx5Obb+NgFw+zczMPQAAgD9S0D6/G4LSPs3MzD0AAIA/9k0fvnaQZD/NzMw9AACAP5jVEz8Auig/zczMPQAAgD+t83w/hcQAP83MzD0AAIA/dm1KPx13KT/NzMw9AACAP+WYvD05cnc/zczMPQAAgD/D+iq/I2JLP83MzD0AAIA/Fvp/v8Q4PT/NzMw9AACAP6S8L7/qJVk/zczMPQAAgD+rkJM9f4t8P83MzD0AAIA/w8xIP1IjYD/NzMw9AACAP4+vfD/5CV4/zczMPQAAgD9DG3c/vndfP83MzD0AAIA/0VpZP0BHXj/NzMw9AACAPz4BRz6G6HY/zczMPQAAgD98tRS/wAJgP83MzD0AAIA/F4B9v1bdPz/NzMw9AACAPz1qSb+7I0Q/zczMPQAAgD+JWd+9JUV2P83MzD0AAIA/Eq8fP6rqPj/NzMw9AACAP2effT+1owc/zczMPQAAgD9vUlU/4AgLP83MzD0AAIA/xoCpPr4aSz/NzMw9AACAP/ZNH752kGQ/zczMPQAAgD+y+LC+4phAP83MzD0AAIA/9k0fvnaQZD/NzMw9AACAP8aAqT6+Gks/zczMPQAAgD9vUlU/4AgLP83MzD0AAIA/Z599P7WjBz/NzMw9AACAPxKvHz+q6j4/zczMPQAAgD+JWd+9JUV2P83MzD0AAIA/PWpJv7sjRD/NzMw9AACAPxeAfb9W3T8/zczMPQAAgD98tRS/wAJgP83MzD0AAIA/PgFHPobodj/NzMw9AACAP9FaWT9AR14/zczMPQAAgD9DG3c/vndfP83MzD0AAIA/ED9oP/lxYj/NzMw9AACAP796bj9lV1w/zczMPQAAgD/UMMY+jptuP83MzD0AAIA/4gHGvoShaz/NzMw9AACAPxX4bL8w80Y/zczMPQAAgD8vNm2/JlY9P83MzD0AAIA/x/bUvk8wXT/NzMw9AACAP3ZQmD7KLmM/zczMPQAAgD/Rp1Y/CrYiP83MzD0AAIA/ap1/P9z2AT/NzMw9AACAP29SVT/gCAs/zczMPQAAgD+Y1RM/ALooP83MzD0AAIA/Xp3sPjM+OD/NzMw9AACAP5jVEz8Auig/zczMPQAAgD9vUlU/4AgLP83MzD0AAIA/ap1/P9z2AT/NzMw9AACAP9GnVj8KtiI/zczMPQAAgD92UJg+yi5jP83MzD0AAIA/x/bUvk8wXT/NzMw9AACAPy82bb8mVj0/zczMPQAAgD8V+Gy/MPNGP83MzD0AAIA/4gHGvoShaz/NzMw9AACAP9Qwxj6Om24/zczMPQAAgD+/em4/ZVdcP83MzD0AAIA/ED9oP/lxYj/NzMw9AACAP0IUST/Jk2c/zczMPQAAgD9eK34/2d1bP83MzD0AAIA/7ngfPzuCZT/NzMw9AACAP8MUw73ZRns/zczMPQAAgD8wMkC/ELdUP83MzD0AAIA/Fvp/v8Q4PT/NzMw9AACAPxcAQL8LR0Y/zczMPQAAgD+YCDK+tLBwP83MzD0AAIA/WGLdPsPhVD/NzMw9AACAP9GnVj8KtiI/zczMPQAAgD9nn30/taMHP83MzD0AAIA/rfN8P4XEAD/NzMw9AACAP5+Wdz9H4gA/zczMPQAAgD+t83w/hcQAP83MzD0AAIA/Z599P7WjBz/NzMw9AACAP9GnVj8KtiI/zczMPQAAgD9YYt0+w+FUP83MzD0AAIA/mAgyvrSwcD/NzMw9AACAPxcAQL8LR0Y/zczMPQAAgD8W+n+/xDg9P83MzD0AAIA/MDJAvxC3VD/NzMw9AACAP8MUw73ZRns/zczMPQAAgD/ueB8/O4JlP83MzD0AAIA/Xit+P9ndWz/NzMw9AACAP0IUST/Jk2c/zczMPQAAgD9I3xI/qyxvP83MzD0AAIA/9B17P297Xj/NzMw9AACAP9FaWT9AR14/zczMPQAAgD86+Ys+r2pzP83MzD0AAIA/qpravitQaT/NzMw9AACAP9D7Z7/AsEg/zczMPQAAgD/Monm/GBU8P83MzD0AAIA/w/oqvyNiSz/NzMw9AACAP5gIMr60sHA/zczMPQAAgD92UJg+yi5jP83MzD0AAIA/Eq8fP6rqPj/NzMw9AACAP3ZtSj8ddyk/zczMPQAAgD/Rp1Y/CrYiP83MzD0AAIA/dm1KPx13KT/NzMw9AACAPxKvHz+q6j4/zczMPQAAgD92UJg+yi5jP83MzD0AAIA/mAgyvrSwcD/NzMw9AACAP8P6Kr8jYks/zczMPQAAgD/Monm/GBU8P83MzD0AAIA/0Ptnv8CwSD/NzMw9AACAP6qa2r4rUGk/zczMPQAAgD86+Ys+r2pzP83MzD0AAIA/0VpZP0BHXj/NzMw9AACAP/Qdez9ve14/zczMPQAAgD9I3xI/qyxvP83MzD0AAIA/rZ6FPgjceD/NzMw9AACAP1XLVz+sQ2U/zczMPQAAgD8L63w/gMlbP83MzD0AAIA/GhUnP0B1ZD/NzMw9AACAP8o/+jzfhX4/zczMPQAAgD98tRS/wAJgP83MzD0AAIA/YGxxv1NORT/NzMw9AACAP8yieb8YFTw/zczMPQAAgD8XAEC/C0dGP83MzD0AAIA/x/bUvk8wXT/NzMw9AACAP4lZ370lRXY/zczMPQAAgD/lmLw9OXJ3P83MzD0AAIA/t1ckPqzicD/NzMw9AACAP+WYvD05cnc/zczMPQAAgD+JWd+9JUV2P83MzD0AAIA/x/bUvk8wXT/NzMw9AACAPxcAQL8LR0Y/zczMPQAAgD/Monm/GBU8P83MzD0AAIA/YGxxv1NORT/NzMw9AACAP3y1FL/AAmA/zczMPQAAgD/KP/o834V+P83MzD0AAIA/GhUnP0B1ZD/NzMw9AACAPwvrfD+AyVs/zczMPQAAgD9Vy1c/rENlP83MzD0AAIA/rZ6FPgjceD/NzMw9AACAPwBzB74rqHw/zczMPQAAgD9uFgw/2w1wP83MzD0AAIA/5ax0P+EBYD/NzMw9AACAP796bj9lV1w/zczMPQAAgD9OCwc/UQlpP83MzD0AAIA/ec9ZvahifT/NzMw9AACAP3y1FL/AAmA/zczMPQAAgD/Q+2e/wLBIP83MzD0AAIA/Fvp/v8Q4PT/NzMw9AACAPy82bb8mVj0/zczMPQAAgD89akm/uyNEP83MzD0AAIA/w/oqvyNiSz/NzMw9AACAPw1nH7+OXE4/zczMPQAAgD/D+iq/I2JLP83MzD0AAIA/PWpJv7sjRD/NzMw9AACAPy82bb8mVj0/zczMPQAAgD8W+n+/xDg9P83MzD0AAIA/0Ptnv8CwSD/NzMw9AACAP3y1FL/AAmA/zczMPQAAgD95z1m9qGJ9P83MzD0AAIA/TgsHP1EJaT/NzMw9AACAP796bj9lV1w/zczMPQAAgD/lrHQ/4QFgP83MzD0AAIA/bhYMP9sNcD/NzMw9AACAPwBzB74rqHw/zczMPQAAgD/0CAu/Am9zP83MzD0AAIA/xHLgPa4XfT/NzMw9AACAP2CrMj8v3Go/zczMPQAAgD+Pr3w/+QleP83MzD0AAIA/wwNnP2ryXD/NzMw9AACAP04LBz9RCWk/zczMPQAAgD/KP/o834V+P83MzD0AAIA/qpravitQaT/NzMw9AACAPzAyQL8Qt1Q/zczMPQAAgD8V+Gy/MPNGP83MzD0AAIA/F4B9v1bdPz/NzMw9AACAPxb6f7/EOD0/zczMPQAAgD9AdH+/vKk8P83MzD0AAIA/Fvp/v8Q4PT/NzMw9AACAPxeAfb9W3T8/zczMPQAAgD8V+Gy/MPNGP83MzD0AAIA/MDJAvxC3VD/NzMw9AACAP6qa2r4rUGk/zczMPQAAgD/KP/o834V+P83MzD0AAIA/TgsHP1EJaT/NzMw9AACAP8MDZz9q8lw/zczMPQAAgD+Pr3w/+QleP83MzD0AAIA/YKsyPy/caj/NzMw9AACAP8Ry4D2uF30/zczMPQAAgD/0CAu/Am9zP83MzD0AAIA/CMZev7G2bT/NzMw9AACAP70nx74XrnY/zczMPQAAgD92dWw+lLh5P83MzD0AAIA/VT8+P8YxaT/NzMw9AACAP4+vfD/5CV4/zczMPQAAgD+/em4/ZVdcP83MzD0AAIA/GhUnP0B1ZD/NzMw9AACAPzr5iz6vanM/zczMPQAAgD/DFMO92UZ7P83MzD0AAIA/4gHGvoShaz/NzMw9AACAP3y1FL/AAmA/zczMPQAAgD+kvC+/6iVZP83MzD0AAIA/bSM4v8bpVj/NzMw9AACAP6S8L7/qJVk/zczMPQAAgD98tRS/wAJgP83MzD0AAIA/4gHGvoShaz/NzMw9AACAP8MUw73ZRns/zczMPQAAgD86+Ys+r2pzP83MzD0AAIA/GhUnP0B1ZD/NzMw9AACAP796bj9lV1w/zczMPQAAgD+Pr3w/+QleP83MzD0AAIA/VT8+P8YxaT/NzMw9AACAP3Z1bD6UuHk/zczMPQAAgD+9J8e+F652P83MzD0AAIA/CMZev7G2bT/NzMw9AACAP+H/f78FDW0/zczMPQAAgD/7Vk+/qphuP83MzD0AAIA/ORqrvu3ldz/NzMw9AACAP3Z1bD6UuHk/zczMPQAAgD9gqzI/L9xqP83MzD0AAIA/5ax0P+EBYD/NzMw9AACAPwvrfD+AyVs/zczMPQAAgD/RWlk/QEdeP83MzD0AAIA/7ngfPzuCZT/NzMw9AACAP9Qwxj6Om24/zczMPQAAgD8+AUc+huh2P83MzD0AAIA/q5CTPX+LfD/NzMw9AACAP8o/+jzfhX4/zczMPQAAgD+rkJM9f4t8P83MzD0AAIA/PgFHPobodj/NzMw9AACAP9Qwxj6Om24/zczMPQAAgD/ueB8/O4JlP83MzD0AAIA/0VpZP0BHXj/NzMw9AACAPwvrfD+AyVs/zczMPQAAgD/lrHQ/4QFgP83MzD0AAIA/YKsyPy/caj/NzMw9AACAP3Z1bD6UuHk/zczMPQAAgD85Gqu+7eV3P83MzD0AAIA/+1ZPv6qYbj/NzMw9AACAP+H/f78FDW0/zczMPQAAgD9sLVq/VYdxP83MzD0AAIA/9ah/v2HfbD/NzMw9AACAP/tWT7+qmG4/zczMPQAAgD+9J8e+F652P83MzD0AAIA/xHLgPa4XfT/NzMw9AACAP24WDD/bDXA/zczMPQAAgD9Vy1c/rENlP83MzD0AAIA/9B17P297Xj/NzMw9AACAP14rfj/Z3Vs/zczMPQAAgD+/em4/ZVdcP83MzD0AAIA/0VpZP0BHXj/NzMw9AACAP8PMSD9SI2A/zczMPQAAgD/Cp0I/6eBgP83MzD0AAIA/w8xIP1IjYD/NzMw9AACAP9FaWT9AR14/zczMPQAAgD+/em4/ZVdcP83MzD0AAIA/Xit+P9ndWz/NzMw9AACAP/Qdez9ve14/zczMPQAAgD9Vy1c/rENlP83MzD0AAIA/bhYMP9sNcD/NzMw9AACAP8Ry4D2uF30/zczMPQAAgD+9J8e+F652P83MzD0AAIA/+1ZPv6qYbj/NzMw9AACAP/Wof79h32w/zczMPQAAgD9sLVq/VYdxP83MzD0AAIA/jdrbvrCAeT/NzMw9AACAP2wtWr9Vh3E/zczMPQAAgD/h/3+/BQ1tP83MzD0AAIA/CMZev7G2bT/NzMw9AACAP/QIC78Cb3M/zczMPQAAgD8Acwe+K6h8P83MzD0AAIA/rZ6FPgjceD/NzMw9AACAP0jfEj+rLG8/zczMPQAAgD9CFEk/yZNnP83MzD0AAIA/ED9oP/lxYj/NzMw9AACAP0Mbdz++d18/zczMPQAAgD+Pr3w/+QleP83MzD0AAIA/+fR9P3OhXT/NzMw9AACAP4+vfD/5CV4/zczMPQAAgD9DG3c/vndfP83MzD0AAIA/ED9oP/lxYj/NzMw9AACAP0IUST/Jk2c/zczMPQAAgD9I3xI/qyxvP83MzD0AAIA/rZ6FPgjceD/NzMw9AACAPwBzB74rqHw/zczMPQAAgD/0CAu/Am9zP83MzD0AAIA/CMZev7G2bT/NzMw9AACAP+H/f78FDW0/zczMPQAAgD9sLVq/VYdxP83MzD0AAIA/jdrbvrCAeT/NzMw9AACAPw==", - "encoding": "base64", - "path": [ - "color", - 6, - "data" - ] - }, - { - "data": "KdCiO8Hsfz/NzMw9AACAPx53Cr/Z0HY/zczMPQAAgD9jb2a/cfFuP83MzD0AAIA/tW9/v1IIaz/NzMw9AACAPwKIWr+fP2w/zczMPQAAgD9smwy/UR5yP83MzD0AAIA/FSA8vjD5ej/NzMw9AACAPyhoJT5HQ3s/zczMPQAAgD/Z1+A+cVhyP83MzD0AAIA/UoUiP3dRaz/NzMw9AACAP8icQT+pgmY/zczMPQAAgD/N2FE/6MtjP83MzD0AAIA/ZM1WP//tYj/NzMw9AACAP83YUT/oy2M/zczMPQAAgD/InEE/qYJmP83MzD0AAIA/UoUiP3dRaz/NzMw9AACAP9nX4D5xWHI/zczMPQAAgD8oaCU+R0N7P83MzD0AAIA/FSA8vjD5ej/NzMw9AACAP2ybDL9RHnI/zczMPQAAgD8CiFq/nz9sP83MzD0AAIA/tW9/v1IIaz/NzMw9AACAP2NvZr9x8W4/zczMPQAAgD8edwq/2dB2P83MzD0AAIA/KdCiO8Hsfz/NzMw9AACAPx53Cr/Z0HY/zczMPQAAgD+DEGy/sFZuP83MzD0AAIA/wPR7v/HZaj/NzMw9AACAPxQLQL+VBm4/zczMPQAAgD9PQaq+ly13P83MzD0AAIA/Z/wEPjM3fD/NzMw9AACAP4+qBj/NUG8/zczMPQAAgD9fqEw/7q5kP83MzD0AAIA/GkJyP1ePXT/NzMw9AACAP2g/fz+J1Vk/zczMPQAAgD9hg34/a4NYP83MzD0AAIA/+c95P2JcWD/NzMw9AACAPwuFdz83bVg/zczMPQAAgD/5z3k/YlxYP83MzD0AAIA/YYN+P2uDWD/NzMw9AACAP2g/fz+J1Vk/zczMPQAAgD8aQnI/V49dP83MzD0AAIA/X6hMP+6uZD/NzMw9AACAP4+qBj/NUG8/zczMPQAAgD9n/AQ+Mzd8P83MzD0AAIA/T0Gqvpctdz/NzMw9AACAPxQLQL+VBm4/zczMPQAAgD/A9Hu/8dlqP83MzD0AAIA/gxBsv7BWbj/NzMw9AACAPx53Cr/Z0HY/zczMPQAAgD9jb2a/cfFuP83MzD0AAIA/wPR7v/HZaj/NzMw9AACAP27ENb9MyW4/zczMPQAAgD9DP1u+lS16P83MzD0AAIA/ANuiPpdddj/NzMw9AACAPxnGOz+Scmc/zczMPQAAgD/3DXU/u+lcP83MzD0AAIA/YYN+P2uDWD/NzMw9AACAP9qRZj+5slk/zczMPQAAgD9nsj8/4lpeP83MzD0AAIA/48cZP8nlYz/NzMw9AACAPxjP/j63Img/zczMPQAAgD/wIuw+JrNpP83MzD0AAIA/GM/+PrciaD/NzMw9AACAP+PHGT/J5WM/zczMPQAAgD9nsj8/4lpeP83MzD0AAIA/2pFmP7myWT/NzMw9AACAP2GDfj9rg1g/zczMPQAAgD/3DXU/u+lcP83MzD0AAIA/GcY7P5JyZz/NzMw9AACAPwDboj6XXXY/zczMPQAAgD9DP1u+lS16P83MzD0AAIA/bsQ1v0zJbj/NzMw9AACAP8D0e7/x2Wo/zczMPQAAgD9jb2a/cfFuP83MzD0AAIA/tW9/v1IIaz/NzMw9AACAPxQLQL+VBm4/zczMPQAAgD9DP1u+lS16P83MzD0AAIA/eivCPrRcdD/NzMw9AACAP83YUT/oy2M/zczMPQAAgD9oP38/idVZP83MzD0AAIA/57BqPzlQWT/NzMw9AACAPxLmKT/9c2E/zczMPQAAgD+nMrE+xNZuP83MzD0AAIA/V7hTPQ1HfT/NzMw9AACAP7FHLr6loHY/zczMPQAAgD9aIZu+FtpuP83MzD0AAIA/L3qxviIzbD/NzMw9AACAP1ohm74W2m4/zczMPQAAgD+xRy6+paB2P83MzD0AAIA/V7hTPQ1HfT/NzMw9AACAP6cysT7E1m4/zczMPQAAgD8S5ik//XNhP83MzD0AAIA/57BqPzlQWT/NzMw9AACAP2g/fz+J1Vk/zczMPQAAgD/N2FE/6MtjP83MzD0AAIA/eivCPrRcdD/NzMw9AACAP0M/W76VLXo/zczMPQAAgD8UC0C/lQZuP83MzD0AAIA/tW9/v1IIaz/NzMw9AACAPwKIWr+fP2w/zczMPQAAgD9PQaq+ly13P83MzD0AAIA/ANuiPpdddj/NzMw9AACAP83YUT/oy2M/zczMPQAAgD+k/38/7ydZP83MzD0AAIA/fAhYP71DWz/NzMw9AACAP/Ai7D4ms2k/zczMPQAAgD8zTvs7rZd/P83MzD0AAIA/v5THvqWGaT/NzMw9AACAP+p5K7+gt1Y/zczMPQAAgD9v6VS/KiJKP83MzD0AAIA/nB5ovw9yQz/NzMw9AACAP/hnbb+ha0E/zczMPQAAgD+cHmi/D3JDP83MzD0AAIA/b+lUvyoiSj/NzMw9AACAP+p5K7+gt1Y/zczMPQAAgD+/lMe+pYZpP83MzD0AAIA/M077O62Xfz/NzMw9AACAP/Ai7D4ms2k/zczMPQAAgD98CFg/vUNbP83MzD0AAIA/pP9/P+8nWT/NzMw9AACAP83YUT/oy2M/zczMPQAAgD8A26I+l112P83MzD0AAIA/T0Gqvpctdz/NzMw9AACAPwKIWr+fP2w/zczMPQAAgD9smwy/UR5yP83MzD0AAIA/Z/wEPjM3fD/NzMw9AACAPxnGOz+Scmc/zczMPQAAgD9oP38/idVZP83MzD0AAIA/fAhYP71DWz/NzMw9AACAP9pNxT5jDW0/zczMPQAAgD+xRy6+paB2P83MzD0AAIA/AAoiv9tdWT/NzMw9AACAP5weaL8PckM/zczMPQAAgD/HfH+/UzM4P83MzD0AAIA/Gwd6vx+xNT/NzMw9AACAPym3bL9tJzc/zczMPQAAgD/sh2a/QTY4P83MzD0AAIA/Kbdsv20nNz/NzMw9AACAPxsHer8fsTU/zczMPQAAgD/HfH+/UzM4P83MzD0AAIA/nB5ovw9yQz/NzMw9AACAPwAKIr/bXVk/zczMPQAAgD+xRy6+paB2P83MzD0AAIA/2k3FPmMNbT/NzMw9AACAP3wIWD+9Q1s/zczMPQAAgD9oP38/idVZP83MzD0AAIA/GcY7P5JyZz/NzMw9AACAP2f8BD4zN3w/zczMPQAAgD9smwy/UR5yP83MzD0AAIA/FSA8vjD5ej/NzMw9AACAP4+qBj/NUG8/zczMPQAAgD/3DXU/u+lcP83MzD0AAIA/57BqPzlQWT/NzMw9AACAP/Ai7D4ms2k/zczMPQAAgD+xRy6+paB2P83MzD0AAIA/rpE0v8MZVD/NzMw9AACAP+WGeb+vHDw/zczMPQAAgD9ydHa/Deg1P83MzD0AAIA/XPJEvyKdPz/NzMw9AACAP82QB78VwVA/zczMPQAAgD93ubK+aZNfP83MzD0AAIA/LDyRvhdJZT/NzMw9AACAP3e5sr5pk18/zczMPQAAgD/NkAe/FcFQP83MzD0AAIA/XPJEvyKdPz/NzMw9AACAP3J0dr8N6DU/zczMPQAAgD/lhnm/rxw8P83MzD0AAIA/rpE0v8MZVD/NzMw9AACAP7FHLr6loHY/zczMPQAAgD/wIuw+JrNpP83MzD0AAIA/57BqPzlQWT/NzMw9AACAP/cNdT+76Vw/zczMPQAAgD+PqgY/zVBvP83MzD0AAIA/FSA8vjD5ej/NzMw9AACAPyhoJT5HQ3s/zczMPQAAgD9fqEw/7q5kP83MzD0AAIA/YYN+P2uDWD/NzMw9AACAPxLmKT/9c2E/zczMPQAAgD8zTvs7rZd/P83MzD0AAIA/AAoiv9tdWT/NzMw9AACAP+WGeb+vHDw/zczMPQAAgD8pt2y/bSc3P83MzD0AAIA/uHsVv+CUTD/NzMw9AACAP324Fb401nE/zczMPQAAgD+HNmQ+GL9oP83MzD0AAIA/acXkPhcaTz/NzMw9AACAP4XfBD/rQEY/zczMPQAAgD9pxeQ+FxpPP83MzD0AAIA/hzZkPhi/aD/NzMw9AACAP324Fb401nE/zczMPQAAgD+4exW/4JRMP83MzD0AAIA/Kbdsv20nNz/NzMw9AACAP+WGeb+vHDw/zczMPQAAgD8ACiK/211ZP83MzD0AAIA/M077O62Xfz/NzMw9AACAPxLmKT/9c2E/zczMPQAAgD9hg34/a4NYP83MzD0AAIA/X6hMP+6uZD/NzMw9AACAPyhoJT5HQ3s/zczMPQAAgD/Z1+A+cVhyP83MzD0AAIA/GkJyP1ePXT/NzMw9AACAP9qRZj+5slk/zczMPQAAgD+nMrE+xNZuP83MzD0AAIA/v5THvqWGaT/NzMw9AACAP5weaL8PckM/zczMPQAAgD9ydHa/Deg1P83MzD0AAIA/uHsVv+CUTD/NzMw9AACAP8AV2bq41X8/zczMPQAAgD+F3wQ/60BGP83MzD0AAIA/YGdVP9i5Gj/NzMw9AACAP8P9dD+SxQQ/zczMPQAAgD/9Tns/ovL9Ps3MzD0AAIA/w/10P5LFBD/NzMw9AACAP2BnVT/YuRo/zczMPQAAgD+F3wQ/60BGP83MzD0AAIA/wBXZurjVfz/NzMw9AACAP7h7Fb/glEw/zczMPQAAgD9ydHa/Deg1P83MzD0AAIA/nB5ovw9yQz/NzMw9AACAP7+Ux76lhmk/zczMPQAAgD+nMrE+xNZuP83MzD0AAIA/2pFmP7myWT/NzMw9AACAPxpCcj9Xj10/zczMPQAAgD/Z1+A+cVhyP83MzD0AAIA/UoUiP3dRaz/NzMw9AACAP2g/fz+J1Vk/zczMPQAAgD9nsj8/4lpeP83MzD0AAIA/V7hTPQ1HfT/NzMw9AACAP+p5K7+gt1Y/zczMPQAAgD/HfH+/UzM4P83MzD0AAIA/XPJEvyKdPz/NzMw9AACAP324Fb401nE/zczMPQAAgD+F3wQ/60BGP83MzD0AAIA/K2RsP19xCz/NzMw9AACAPz2afT++5ek+zczMPQAAgD844F8/6Kv3Ps3MzD0AAIA/vxdNP96aAz/NzMw9AACAPzjgXz/oq/c+zczMPQAAgD89mn0/vuXpPs3MzD0AAIA/K2RsP19xCz/NzMw9AACAP4XfBD/rQEY/zczMPQAAgD99uBW+NNZxP83MzD0AAIA/XPJEvyKdPz/NzMw9AACAP8d8f79TMzg/zczMPQAAgD/qeSu/oLdWP83MzD0AAIA/V7hTPQ1HfT/NzMw9AACAP2eyPz/iWl4/zczMPQAAgD9oP38/idVZP83MzD0AAIA/UoUiP3dRaz/NzMw9AACAP8icQT+pgmY/zczMPQAAgD9hg34/a4NYP83MzD0AAIA/48cZP8nlYz/NzMw9AACAP7FHLr6loHY/zczMPQAAgD9v6VS/KiJKP83MzD0AAIA/Gwd6vx+xNT/NzMw9AACAP82QB78VwVA/zczMPQAAgD+HNmQ+GL9oP83MzD0AAIA/YGdVP9i5Gj/NzMw9AACAPz2afT++5ek+zczMPQAAgD9PKzU/g+0OP83MzD0AAIA/962TPvshTT/NzMw9AACAP7UKxD31cG4/zczMPQAAgD/3rZM++yFNP83MzD0AAIA/Tys1P4PtDj/NzMw9AACAPz2afT++5ek+zczMPQAAgD9gZ1U/2LkaP83MzD0AAIA/hzZkPhi/aD/NzMw9AACAP82QB78VwVA/zczMPQAAgD8bB3q/H7E1P83MzD0AAIA/b+lUvyoiSj/NzMw9AACAP7FHLr6loHY/zczMPQAAgD/jxxk/yeVjP83MzD0AAIA/YYN+P2uDWD/NzMw9AACAP8icQT+pgmY/zczMPQAAgD/N2FE/6MtjP83MzD0AAIA/+c95P2JcWD/NzMw9AACAPxjP/j63Img/zczMPQAAgD9aIZu+FtpuP83MzD0AAIA/nB5ovw9yQz/NzMw9AACAPym3bL9tJzc/zczMPQAAgD93ubK+aZNfP83MzD0AAIA/acXkPhcaTz/NzMw9AACAP8P9dD+SxQQ/zczMPQAAgD844F8/6Kv3Ps3MzD0AAIA/962TPvshTT/NzMw9AACAP/C8w76SrjI/zczMPQAAgD81Iyy/05PcPs3MzD0AAIA/8LzDvpKuMj/NzMw9AACAP/etkz77IU0/zczMPQAAgD844F8/6Kv3Ps3MzD0AAIA/w/10P5LFBD/NzMw9AACAP2nF5D4XGk8/zczMPQAAgD93ubK+aZNfP83MzD0AAIA/Kbdsv20nNz/NzMw9AACAP5weaL8PckM/zczMPQAAgD9aIZu+FtpuP83MzD0AAIA/GM/+PrciaD/NzMw9AACAP/nPeT9iXFg/zczMPQAAgD/N2FE/6MtjP83MzD0AAIA/ZM1WP//tYj/NzMw9AACAPwuFdz83bVg/zczMPQAAgD/wIuw+JrNpP83MzD0AAIA/L3qxviIzbD/NzMw9AACAP/hnbb+ha0E/zczMPQAAgD/sh2a/QTY4P83MzD0AAIA/LDyRvhdJZT/NzMw9AACAP4XfBD/rQEY/zczMPQAAgD/9Tns/ovL9Ps3MzD0AAIA/vxdNP96aAz/NzMw9AACAP7UKxD31cG4/zczMPQAAgD81Iyy/05PcPs3MzD0AAIA/AACAvwAAAADNzMw9AACAPzUjLL/Tk9w+zczMPQAAgD+1CsQ99XBuP83MzD0AAIA/vxdNP96aAz/NzMw9AACAP/1Oez+i8v0+zczMPQAAgD+F3wQ/60BGP83MzD0AAIA/LDyRvhdJZT/NzMw9AACAP+yHZr9BNjg/zczMPQAAgD/4Z22/oWtBP83MzD0AAIA/L3qxviIzbD/NzMw9AACAP/Ai7D4ms2k/zczMPQAAgD8LhXc/N21YP83MzD0AAIA/ZM1WP//tYj/NzMw9AACAP83YUT/oy2M/zczMPQAAgD/5z3k/YlxYP83MzD0AAIA/GM/+PrciaD/NzMw9AACAP1ohm74W2m4/zczMPQAAgD+cHmi/D3JDP83MzD0AAIA/Kbdsv20nNz/NzMw9AACAP3e5sr5pk18/zczMPQAAgD9pxeQ+FxpPP83MzD0AAIA/w/10P5LFBD/NzMw9AACAPzjgXz/oq/c+zczMPQAAgD/3rZM++yFNP83MzD0AAIA/8LzDvpKuMj/NzMw9AACAPzUjLL/Tk9w+zczMPQAAgD/wvMO+kq4yP83MzD0AAIA/962TPvshTT/NzMw9AACAPzjgXz/oq/c+zczMPQAAgD/D/XQ/ksUEP83MzD0AAIA/acXkPhcaTz/NzMw9AACAP3e5sr5pk18/zczMPQAAgD8pt2y/bSc3P83MzD0AAIA/nB5ovw9yQz/NzMw9AACAP1ohm74W2m4/zczMPQAAgD8Yz/4+tyJoP83MzD0AAIA/+c95P2JcWD/NzMw9AACAP83YUT/oy2M/zczMPQAAgD/InEE/qYJmP83MzD0AAIA/YYN+P2uDWD/NzMw9AACAP+PHGT/J5WM/zczMPQAAgD+xRy6+paB2P83MzD0AAIA/b+lUvyoiSj/NzMw9AACAPxsHer8fsTU/zczMPQAAgD/NkAe/FcFQP83MzD0AAIA/hzZkPhi/aD/NzMw9AACAP2BnVT/YuRo/zczMPQAAgD89mn0/vuXpPs3MzD0AAIA/Tys1P4PtDj/NzMw9AACAP/etkz77IU0/zczMPQAAgD+1CsQ99XBuP83MzD0AAIA/962TPvshTT/NzMw9AACAP08rNT+D7Q4/zczMPQAAgD89mn0/vuXpPs3MzD0AAIA/YGdVP9i5Gj/NzMw9AACAP4c2ZD4Yv2g/zczMPQAAgD/NkAe/FcFQP83MzD0AAIA/Gwd6vx+xNT/NzMw9AACAP2/pVL8qIko/zczMPQAAgD+xRy6+paB2P83MzD0AAIA/48cZP8nlYz/NzMw9AACAP2GDfj9rg1g/zczMPQAAgD/InEE/qYJmP83MzD0AAIA/UoUiP3dRaz/NzMw9AACAP2g/fz+J1Vk/zczMPQAAgD9nsj8/4lpeP83MzD0AAIA/V7hTPQ1HfT/NzMw9AACAP+p5K7+gt1Y/zczMPQAAgD/HfH+/UzM4P83MzD0AAIA/XPJEvyKdPz/NzMw9AACAP324Fb401nE/zczMPQAAgD+F3wQ/60BGP83MzD0AAIA/K2RsP19xCz/NzMw9AACAPz2afT++5ek+zczMPQAAgD844F8/6Kv3Ps3MzD0AAIA/vxdNP96aAz/NzMw9AACAPzjgXz/oq/c+zczMPQAAgD89mn0/vuXpPs3MzD0AAIA/K2RsP19xCz/NzMw9AACAP4XfBD/rQEY/zczMPQAAgD99uBW+NNZxP83MzD0AAIA/XPJEvyKdPz/NzMw9AACAP8d8f79TMzg/zczMPQAAgD/qeSu/oLdWP83MzD0AAIA/V7hTPQ1HfT/NzMw9AACAP2eyPz/iWl4/zczMPQAAgD9oP38/idVZP83MzD0AAIA/UoUiP3dRaz/NzMw9AACAP9nX4D5xWHI/zczMPQAAgD8aQnI/V49dP83MzD0AAIA/2pFmP7myWT/NzMw9AACAP6cysT7E1m4/zczMPQAAgD+/lMe+pYZpP83MzD0AAIA/nB5ovw9yQz/NzMw9AACAP3J0dr8N6DU/zczMPQAAgD+4exW/4JRMP83MzD0AAIA/wBXZurjVfz/NzMw9AACAP4XfBD/rQEY/zczMPQAAgD9gZ1U/2LkaP83MzD0AAIA/w/10P5LFBD/NzMw9AACAP/1Oez+i8v0+zczMPQAAgD/D/XQ/ksUEP83MzD0AAIA/YGdVP9i5Gj/NzMw9AACAP4XfBD/rQEY/zczMPQAAgD/AFdm6uNV/P83MzD0AAIA/uHsVv+CUTD/NzMw9AACAP3J0dr8N6DU/zczMPQAAgD+cHmi/D3JDP83MzD0AAIA/v5THvqWGaT/NzMw9AACAP6cysT7E1m4/zczMPQAAgD/akWY/ubJZP83MzD0AAIA/GkJyP1ePXT/NzMw9AACAP9nX4D5xWHI/zczMPQAAgD8oaCU+R0N7P83MzD0AAIA/X6hMP+6uZD/NzMw9AACAP2GDfj9rg1g/zczMPQAAgD8S5ik//XNhP83MzD0AAIA/M077O62Xfz/NzMw9AACAPwAKIr/bXVk/zczMPQAAgD/lhnm/rxw8P83MzD0AAIA/Kbdsv20nNz/NzMw9AACAP7h7Fb/glEw/zczMPQAAgD99uBW+NNZxP83MzD0AAIA/hzZkPhi/aD/NzMw9AACAP2nF5D4XGk8/zczMPQAAgD+F3wQ/60BGP83MzD0AAIA/acXkPhcaTz/NzMw9AACAP4c2ZD4Yv2g/zczMPQAAgD99uBW+NNZxP83MzD0AAIA/uHsVv+CUTD/NzMw9AACAPym3bL9tJzc/zczMPQAAgD/lhnm/rxw8P83MzD0AAIA/AAoiv9tdWT/NzMw9AACAPzNO+zutl38/zczMPQAAgD8S5ik//XNhP83MzD0AAIA/YYN+P2uDWD/NzMw9AACAP1+oTD/urmQ/zczMPQAAgD8oaCU+R0N7P83MzD0AAIA/FSA8vjD5ej/NzMw9AACAP4+qBj/NUG8/zczMPQAAgD/3DXU/u+lcP83MzD0AAIA/57BqPzlQWT/NzMw9AACAP/Ai7D4ms2k/zczMPQAAgD+xRy6+paB2P83MzD0AAIA/rpE0v8MZVD/NzMw9AACAP+WGeb+vHDw/zczMPQAAgD9ydHa/Deg1P83MzD0AAIA/XPJEvyKdPz/NzMw9AACAP82QB78VwVA/zczMPQAAgD93ubK+aZNfP83MzD0AAIA/LDyRvhdJZT/NzMw9AACAP3e5sr5pk18/zczMPQAAgD/NkAe/FcFQP83MzD0AAIA/XPJEvyKdPz/NzMw9AACAP3J0dr8N6DU/zczMPQAAgD/lhnm/rxw8P83MzD0AAIA/rpE0v8MZVD/NzMw9AACAP7FHLr6loHY/zczMPQAAgD/wIuw+JrNpP83MzD0AAIA/57BqPzlQWT/NzMw9AACAP/cNdT+76Vw/zczMPQAAgD+PqgY/zVBvP83MzD0AAIA/FSA8vjD5ej/NzMw9AACAP2ybDL9RHnI/zczMPQAAgD9n/AQ+Mzd8P83MzD0AAIA/GcY7P5JyZz/NzMw9AACAP2g/fz+J1Vk/zczMPQAAgD98CFg/vUNbP83MzD0AAIA/2k3FPmMNbT/NzMw9AACAP7FHLr6loHY/zczMPQAAgD8ACiK/211ZP83MzD0AAIA/nB5ovw9yQz/NzMw9AACAP8d8f79TMzg/zczMPQAAgD8bB3q/H7E1P83MzD0AAIA/Kbdsv20nNz/NzMw9AACAP+yHZr9BNjg/zczMPQAAgD8pt2y/bSc3P83MzD0AAIA/Gwd6vx+xNT/NzMw9AACAP8d8f79TMzg/zczMPQAAgD+cHmi/D3JDP83MzD0AAIA/AAoiv9tdWT/NzMw9AACAP7FHLr6loHY/zczMPQAAgD/aTcU+Yw1tP83MzD0AAIA/fAhYP71DWz/NzMw9AACAP2g/fz+J1Vk/zczMPQAAgD8Zxjs/knJnP83MzD0AAIA/Z/wEPjM3fD/NzMw9AACAP2ybDL9RHnI/zczMPQAAgD8CiFq/nz9sP83MzD0AAIA/T0Gqvpctdz/NzMw9AACAPwDboj6XXXY/zczMPQAAgD/N2FE/6MtjP83MzD0AAIA/pP9/P+8nWT/NzMw9AACAP3wIWD+9Q1s/zczMPQAAgD/wIuw+JrNpP83MzD0AAIA/M077O62Xfz/NzMw9AACAP7+Ux76lhmk/zczMPQAAgD/qeSu/oLdWP83MzD0AAIA/b+lUvyoiSj/NzMw9AACAP5weaL8PckM/zczMPQAAgD/4Z22/oWtBP83MzD0AAIA/nB5ovw9yQz/NzMw9AACAP2/pVL8qIko/zczMPQAAgD/qeSu/oLdWP83MzD0AAIA/v5THvqWGaT/NzMw9AACAPzNO+zutl38/zczMPQAAgD/wIuw+JrNpP83MzD0AAIA/fAhYP71DWz/NzMw9AACAP6T/fz/vJ1k/zczMPQAAgD/N2FE/6MtjP83MzD0AAIA/ANuiPpdddj/NzMw9AACAP09Bqr6XLXc/zczMPQAAgD8CiFq/nz9sP83MzD0AAIA/tW9/v1IIaz/NzMw9AACAPxQLQL+VBm4/zczMPQAAgD9DP1u+lS16P83MzD0AAIA/eivCPrRcdD/NzMw9AACAP83YUT/oy2M/zczMPQAAgD9oP38/idVZP83MzD0AAIA/57BqPzlQWT/NzMw9AACAPxLmKT/9c2E/zczMPQAAgD+nMrE+xNZuP83MzD0AAIA/V7hTPQ1HfT/NzMw9AACAP7FHLr6loHY/zczMPQAAgD9aIZu+FtpuP83MzD0AAIA/L3qxviIzbD/NzMw9AACAP1ohm74W2m4/zczMPQAAgD+xRy6+paB2P83MzD0AAIA/V7hTPQ1HfT/NzMw9AACAP6cysT7E1m4/zczMPQAAgD8S5ik//XNhP83MzD0AAIA/57BqPzlQWT/NzMw9AACAP2g/fz+J1Vk/zczMPQAAgD/N2FE/6MtjP83MzD0AAIA/eivCPrRcdD/NzMw9AACAP0M/W76VLXo/zczMPQAAgD8UC0C/lQZuP83MzD0AAIA/tW9/v1IIaz/NzMw9AACAP2NvZr9x8W4/zczMPQAAgD/A9Hu/8dlqP83MzD0AAIA/bsQ1v0zJbj/NzMw9AACAP0M/W76VLXo/zczMPQAAgD8A26I+l112P83MzD0AAIA/GcY7P5JyZz/NzMw9AACAP/cNdT+76Vw/zczMPQAAgD9hg34/a4NYP83MzD0AAIA/2pFmP7myWT/NzMw9AACAP2eyPz/iWl4/zczMPQAAgD/jxxk/yeVjP83MzD0AAIA/GM/+PrciaD/NzMw9AACAP/Ai7D4ms2k/zczMPQAAgD8Yz/4+tyJoP83MzD0AAIA/48cZP8nlYz/NzMw9AACAP2eyPz/iWl4/zczMPQAAgD/akWY/ubJZP83MzD0AAIA/YYN+P2uDWD/NzMw9AACAP/cNdT+76Vw/zczMPQAAgD8Zxjs/knJnP83MzD0AAIA/ANuiPpdddj/NzMw9AACAP0M/W76VLXo/zczMPQAAgD9uxDW/TMluP83MzD0AAIA/wPR7v/HZaj/NzMw9AACAP2NvZr9x8W4/zczMPQAAgD8edwq/2dB2P83MzD0AAIA/gxBsv7BWbj/NzMw9AACAP8D0e7/x2Wo/zczMPQAAgD8UC0C/lQZuP83MzD0AAIA/T0Gqvpctdz/NzMw9AACAP2f8BD4zN3w/zczMPQAAgD+PqgY/zVBvP83MzD0AAIA/X6hMP+6uZD/NzMw9AACAPxpCcj9Xj10/zczMPQAAgD9oP38/idVZP83MzD0AAIA/YYN+P2uDWD/NzMw9AACAP/nPeT9iXFg/zczMPQAAgD8LhXc/N21YP83MzD0AAIA/+c95P2JcWD/NzMw9AACAP2GDfj9rg1g/zczMPQAAgD9oP38/idVZP83MzD0AAIA/GkJyP1ePXT/NzMw9AACAP1+oTD/urmQ/zczMPQAAgD+PqgY/zVBvP83MzD0AAIA/Z/wEPjM3fD/NzMw9AACAP09Bqr6XLXc/zczMPQAAgD8UC0C/lQZuP83MzD0AAIA/wPR7v/HZaj/NzMw9AACAP4MQbL+wVm4/zczMPQAAgD8edwq/2dB2P83MzD0AAIA/KdCiO8Hsfz/NzMw9AACAPx53Cr/Z0HY/zczMPQAAgD9jb2a/cfFuP83MzD0AAIA/tW9/v1IIaz/NzMw9AACAPwKIWr+fP2w/zczMPQAAgD9smwy/UR5yP83MzD0AAIA/FSA8vjD5ej/NzMw9AACAPyhoJT5HQ3s/zczMPQAAgD/Z1+A+cVhyP83MzD0AAIA/UoUiP3dRaz/NzMw9AACAP8icQT+pgmY/zczMPQAAgD/N2FE/6MtjP83MzD0AAIA/ZM1WP//tYj/NzMw9AACAP83YUT/oy2M/zczMPQAAgD/InEE/qYJmP83MzD0AAIA/UoUiP3dRaz/NzMw9AACAP9nX4D5xWHI/zczMPQAAgD8oaCU+R0N7P83MzD0AAIA/FSA8vjD5ej/NzMw9AACAP2ybDL9RHnI/zczMPQAAgD8CiFq/nz9sP83MzD0AAIA/tW9/v1IIaz/NzMw9AACAP2NvZr9x8W4/zczMPQAAgD8edwq/2dB2P83MzD0AAIA/KdCiO8Hsfz/NzMw9AACAPw==", - "encoding": "base64", - "path": [ - "color", - 7, - "data" - ] - }, - { - "data": "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", - "encoding": "base64", - "path": [ - "color", - 8, - "data" - ] - }, - { - "data": "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", - "encoding": "base64", - "path": [ - "color", - 9, - "data" - ] - }, - { - "data": "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", - "encoding": "base64", - "path": [ - "color", - 10, - "data" - ] - }, - { - "data": "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", - "encoding": "base64", - "path": [ - "color", - 11, - "data" - ] - }, - { - "data": "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", - "encoding": "base64", - "path": [ - "color", - 12, - "data" - ] - }, - { - "data": "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", - "encoding": "base64", - "path": [ - "color", - 13, - "data" - ] - }, - { - "data": "KdCiu8Hsfz/NzMw9AACAPx53Cj/Z0HY/zczMPQAAgD9jb2Y/cfFuP83MzD0AAIA/tW9/P1IIaz/NzMw9AACAPwKIWj+fP2w/zczMPQAAgD9smww/UR5yP83MzD0AAIA/FSA8PjD5ej/NzMw9AACAPyhoJb5HQ3s/zczMPQAAgD/Z1+C+cVhyP83MzD0AAIA/UoUiv3dRaz/NzMw9AACAP8icQb+pgmY/zczMPQAAgD/N2FG/6MtjP83MzD0AAIA/ZM1Wv//tYj/NzMw9AACAP83YUb/oy2M/zczMPQAAgD/InEG/qYJmP83MzD0AAIA/UoUiv3dRaz/NzMw9AACAP9nX4L5xWHI/zczMPQAAgD8oaCW+R0N7P83MzD0AAIA/FSA8PjD5ej/NzMw9AACAP2ybDD9RHnI/zczMPQAAgD8CiFo/nz9sP83MzD0AAIA/tW9/P1IIaz/NzMw9AACAP2NvZj9x8W4/zczMPQAAgD8edwo/2dB2P83MzD0AAIA/KdCiu8Hsfz/NzMw9AACAPx53Cj/Z0HY/zczMPQAAgD+DEGw/sFZuP83MzD0AAIA/wPR7P/HZaj/NzMw9AACAPxQLQD+VBm4/zczMPQAAgD9PQao+ly13P83MzD0AAIA/Z/wEvjM3fD/NzMw9AACAP4+qBr/NUG8/zczMPQAAgD9fqEy/7q5kP83MzD0AAIA/GkJyv1ePXT/NzMw9AACAP2g/f7+J1Vk/zczMPQAAgD9hg36/a4NYP83MzD0AAIA/+c95v2JcWD/NzMw9AACAPwuFd783bVg/zczMPQAAgD/5z3m/YlxYP83MzD0AAIA/YYN+v2uDWD/NzMw9AACAP2g/f7+J1Vk/zczMPQAAgD8aQnK/V49dP83MzD0AAIA/X6hMv+6uZD/NzMw9AACAP4+qBr/NUG8/zczMPQAAgD9n/AS+Mzd8P83MzD0AAIA/T0GqPpctdz/NzMw9AACAPxQLQD+VBm4/zczMPQAAgD/A9Hs/8dlqP83MzD0AAIA/gxBsP7BWbj/NzMw9AACAPx53Cj/Z0HY/zczMPQAAgD9jb2Y/cfFuP83MzD0AAIA/wPR7P/HZaj/NzMw9AACAP27ENT9MyW4/zczMPQAAgD9DP1s+lS16P83MzD0AAIA/ANuivpdddj/NzMw9AACAPxnGO7+Scmc/zczMPQAAgD/3DXW/u+lcP83MzD0AAIA/YYN+v2uDWD/NzMw9AACAP9qRZr+5slk/zczMPQAAgD9nsj+/4lpeP83MzD0AAIA/48cZv8nlYz/NzMw9AACAPxjP/r63Img/zczMPQAAgD/wIuy+JrNpP83MzD0AAIA/GM/+vrciaD/NzMw9AACAP+PHGb/J5WM/zczMPQAAgD9nsj+/4lpeP83MzD0AAIA/2pFmv7myWT/NzMw9AACAP2GDfr9rg1g/zczMPQAAgD/3DXW/u+lcP83MzD0AAIA/GcY7v5JyZz/NzMw9AACAPwDbor6XXXY/zczMPQAAgD9DP1s+lS16P83MzD0AAIA/bsQ1P0zJbj/NzMw9AACAP8D0ez/x2Wo/zczMPQAAgD9jb2Y/cfFuP83MzD0AAIA/tW9/P1IIaz/NzMw9AACAPxQLQD+VBm4/zczMPQAAgD9DP1s+lS16P83MzD0AAIA/eivCvrRcdD/NzMw9AACAP83YUb/oy2M/zczMPQAAgD9oP3+/idVZP83MzD0AAIA/57BqvzlQWT/NzMw9AACAPxLmKb/9c2E/zczMPQAAgD+nMrG+xNZuP83MzD0AAIA/V7hTvQ1HfT/NzMw9AACAP7FHLj6loHY/zczMPQAAgD9aIZs+FtpuP83MzD0AAIA/L3qxPiIzbD/NzMw9AACAP1ohmz4W2m4/zczMPQAAgD+xRy4+paB2P83MzD0AAIA/V7hTvQ1HfT/NzMw9AACAP6cysb7E1m4/zczMPQAAgD8S5im//XNhP83MzD0AAIA/57BqvzlQWT/NzMw9AACAP2g/f7+J1Vk/zczMPQAAgD/N2FG/6MtjP83MzD0AAIA/eivCvrRcdD/NzMw9AACAP0M/Wz6VLXo/zczMPQAAgD8UC0A/lQZuP83MzD0AAIA/tW9/P1IIaz/NzMw9AACAPwKIWj+fP2w/zczMPQAAgD9PQao+ly13P83MzD0AAIA/ANuivpdddj/NzMw9AACAP83YUb/oy2M/zczMPQAAgD+k/3+/7ydZP83MzD0AAIA/fAhYv71DWz/NzMw9AACAP/Ai7L4ms2k/zczMPQAAgD8zTvu7rZd/P83MzD0AAIA/v5THPqWGaT/NzMw9AACAP+p5Kz+gt1Y/zczMPQAAgD9v6VQ/KiJKP83MzD0AAIA/nB5oPw9yQz/NzMw9AACAP/hnbT+ha0E/zczMPQAAgD+cHmg/D3JDP83MzD0AAIA/b+lUPyoiSj/NzMw9AACAP+p5Kz+gt1Y/zczMPQAAgD+/lMc+pYZpP83MzD0AAIA/M077u62Xfz/NzMw9AACAP/Ai7L4ms2k/zczMPQAAgD98CFi/vUNbP83MzD0AAIA/pP9/v+8nWT/NzMw9AACAP83YUb/oy2M/zczMPQAAgD8A26K+l112P83MzD0AAIA/T0GqPpctdz/NzMw9AACAPwKIWj+fP2w/zczMPQAAgD9smww/UR5yP83MzD0AAIA/Z/wEvjM3fD/NzMw9AACAPxnGO7+Scmc/zczMPQAAgD9oP3+/idVZP83MzD0AAIA/fAhYv71DWz/NzMw9AACAP9pNxb5jDW0/zczMPQAAgD+xRy4+paB2P83MzD0AAIA/AAoiP9tdWT/NzMw9AACAP5weaD8PckM/zczMPQAAgD/HfH8/UzM4P83MzD0AAIA/Gwd6Px+xNT/NzMw9AACAPym3bD9tJzc/zczMPQAAgD/sh2Y/QTY4P83MzD0AAIA/KbdsP20nNz/NzMw9AACAPxsHej8fsTU/zczMPQAAgD/HfH8/UzM4P83MzD0AAIA/nB5oPw9yQz/NzMw9AACAPwAKIj/bXVk/zczMPQAAgD+xRy4+paB2P83MzD0AAIA/2k3FvmMNbT/NzMw9AACAP3wIWL+9Q1s/zczMPQAAgD9oP3+/idVZP83MzD0AAIA/GcY7v5JyZz/NzMw9AACAP2f8BL4zN3w/zczMPQAAgD9smww/UR5yP83MzD0AAIA/FSA8PjD5ej/NzMw9AACAP4+qBr/NUG8/zczMPQAAgD/3DXW/u+lcP83MzD0AAIA/57BqvzlQWT/NzMw9AACAP/Ai7L4ms2k/zczMPQAAgD+xRy4+paB2P83MzD0AAIA/rpE0P8MZVD/NzMw9AACAP+WGeT+vHDw/zczMPQAAgD9ydHY/Deg1P83MzD0AAIA/XPJEPyKdPz/NzMw9AACAP82QBz8VwVA/zczMPQAAgD93ubI+aZNfP83MzD0AAIA/LDyRPhdJZT/NzMw9AACAP3e5sj5pk18/zczMPQAAgD/NkAc/FcFQP83MzD0AAIA/XPJEPyKdPz/NzMw9AACAP3J0dj8N6DU/zczMPQAAgD/lhnk/rxw8P83MzD0AAIA/rpE0P8MZVD/NzMw9AACAP7FHLj6loHY/zczMPQAAgD/wIuy+JrNpP83MzD0AAIA/57BqvzlQWT/NzMw9AACAP/cNdb+76Vw/zczMPQAAgD+Pqga/zVBvP83MzD0AAIA/FSA8PjD5ej/NzMw9AACAPyhoJb5HQ3s/zczMPQAAgD9fqEy/7q5kP83MzD0AAIA/YYN+v2uDWD/NzMw9AACAPxLmKb/9c2E/zczMPQAAgD8zTvu7rZd/P83MzD0AAIA/AAoiP9tdWT/NzMw9AACAP+WGeT+vHDw/zczMPQAAgD8pt2w/bSc3P83MzD0AAIA/uHsVP+CUTD/NzMw9AACAP324FT401nE/zczMPQAAgD+HNmS+GL9oP83MzD0AAIA/acXkvhcaTz/NzMw9AACAP4XfBL/rQEY/zczMPQAAgD9pxeS+FxpPP83MzD0AAIA/hzZkvhi/aD/NzMw9AACAP324FT401nE/zczMPQAAgD+4exU/4JRMP83MzD0AAIA/KbdsP20nNz/NzMw9AACAP+WGeT+vHDw/zczMPQAAgD8ACiI/211ZP83MzD0AAIA/M077u62Xfz/NzMw9AACAPxLmKb/9c2E/zczMPQAAgD9hg36/a4NYP83MzD0AAIA/X6hMv+6uZD/NzMw9AACAPyhoJb5HQ3s/zczMPQAAgD/Z1+C+cVhyP83MzD0AAIA/GkJyv1ePXT/NzMw9AACAP9qRZr+5slk/zczMPQAAgD+nMrG+xNZuP83MzD0AAIA/v5THPqWGaT/NzMw9AACAP5weaD8PckM/zczMPQAAgD9ydHY/Deg1P83MzD0AAIA/uHsVP+CUTD/NzMw9AACAP8AV2Tq41X8/zczMPQAAgD+F3wS/60BGP83MzD0AAIA/YGdVv9i5Gj/NzMw9AACAP8P9dL+SxQQ/zczMPQAAgD/9Tnu/ovL9Ps3MzD0AAIA/w/10v5LFBD/NzMw9AACAP2BnVb/YuRo/zczMPQAAgD+F3wS/60BGP83MzD0AAIA/wBXZOrjVfz/NzMw9AACAP7h7FT/glEw/zczMPQAAgD9ydHY/Deg1P83MzD0AAIA/nB5oPw9yQz/NzMw9AACAP7+Uxz6lhmk/zczMPQAAgD+nMrG+xNZuP83MzD0AAIA/2pFmv7myWT/NzMw9AACAPxpCcr9Xj10/zczMPQAAgD/Z1+C+cVhyP83MzD0AAIA/UoUiv3dRaz/NzMw9AACAP2g/f7+J1Vk/zczMPQAAgD9nsj+/4lpeP83MzD0AAIA/V7hTvQ1HfT/NzMw9AACAP+p5Kz+gt1Y/zczMPQAAgD/HfH8/UzM4P83MzD0AAIA/XPJEPyKdPz/NzMw9AACAP324FT401nE/zczMPQAAgD+F3wS/60BGP83MzD0AAIA/K2Rsv19xCz/NzMw9AACAPz2afb++5ek+zczMPQAAgD844F+/6Kv3Ps3MzD0AAIA/vxdNv96aAz/NzMw9AACAPzjgX7/oq/c+zczMPQAAgD89mn2/vuXpPs3MzD0AAIA/K2Rsv19xCz/NzMw9AACAP4XfBL/rQEY/zczMPQAAgD99uBU+NNZxP83MzD0AAIA/XPJEPyKdPz/NzMw9AACAP8d8fz9TMzg/zczMPQAAgD/qeSs/oLdWP83MzD0AAIA/V7hTvQ1HfT/NzMw9AACAP2eyP7/iWl4/zczMPQAAgD9oP3+/idVZP83MzD0AAIA/UoUiv3dRaz/NzMw9AACAP8icQb+pgmY/zczMPQAAgD9hg36/a4NYP83MzD0AAIA/48cZv8nlYz/NzMw9AACAP7FHLj6loHY/zczMPQAAgD9v6VQ/KiJKP83MzD0AAIA/Gwd6Px+xNT/NzMw9AACAP82QBz8VwVA/zczMPQAAgD+HNmS+GL9oP83MzD0AAIA/YGdVv9i5Gj/NzMw9AACAPz2afb++5ek+zczMPQAAgD9PKzW/g+0OP83MzD0AAIA/962TvvshTT/NzMw9AACAP7UKxL31cG4/zczMPQAAgD/3rZO++yFNP83MzD0AAIA/Tys1v4PtDj/NzMw9AACAPz2afb++5ek+zczMPQAAgD9gZ1W/2LkaP83MzD0AAIA/hzZkvhi/aD/NzMw9AACAP82QBz8VwVA/zczMPQAAgD8bB3o/H7E1P83MzD0AAIA/b+lUPyoiSj/NzMw9AACAP7FHLj6loHY/zczMPQAAgD/jxxm/yeVjP83MzD0AAIA/YYN+v2uDWD/NzMw9AACAP8icQb+pgmY/zczMPQAAgD/N2FG/6MtjP83MzD0AAIA/+c95v2JcWD/NzMw9AACAPxjP/r63Img/zczMPQAAgD9aIZs+FtpuP83MzD0AAIA/nB5oPw9yQz/NzMw9AACAPym3bD9tJzc/zczMPQAAgD93ubI+aZNfP83MzD0AAIA/acXkvhcaTz/NzMw9AACAP8P9dL+SxQQ/zczMPQAAgD844F+/6Kv3Ps3MzD0AAIA/962TvvshTT/NzMw9AACAP/C8wz6SrjI/zczMPQAAgD81Iyw/05PcPs3MzD0AAIA/8LzDPpKuMj/NzMw9AACAP/etk777IU0/zczMPQAAgD844F+/6Kv3Ps3MzD0AAIA/w/10v5LFBD/NzMw9AACAP2nF5L4XGk8/zczMPQAAgD93ubI+aZNfP83MzD0AAIA/KbdsP20nNz/NzMw9AACAP5weaD8PckM/zczMPQAAgD9aIZs+FtpuP83MzD0AAIA/GM/+vrciaD/NzMw9AACAP/nPeb9iXFg/zczMPQAAgD/N2FG/6MtjP83MzD0AAIA/ZM1Wv//tYj/NzMw9AACAPwuFd783bVg/zczMPQAAgD/wIuy+JrNpP83MzD0AAIA/L3qxPiIzbD/NzMw9AACAP/hnbT+ha0E/zczMPQAAgD/sh2Y/QTY4P83MzD0AAIA/LDyRPhdJZT/NzMw9AACAP4XfBL/rQEY/zczMPQAAgD/9Tnu/ovL9Ps3MzD0AAIA/vxdNv96aAz/NzMw9AACAP7UKxL31cG4/zczMPQAAgD81Iyw/05PcPs3MzD0AAIA/AACAPwAAAADNzMw9AACAPzUjLD/Tk9w+zczMPQAAgD+1CsS99XBuP83MzD0AAIA/vxdNv96aAz/NzMw9AACAP/1Oe7+i8v0+zczMPQAAgD+F3wS/60BGP83MzD0AAIA/LDyRPhdJZT/NzMw9AACAP+yHZj9BNjg/zczMPQAAgD/4Z20/oWtBP83MzD0AAIA/L3qxPiIzbD/NzMw9AACAP/Ai7L4ms2k/zczMPQAAgD8LhXe/N21YP83MzD0AAIA/ZM1Wv//tYj/NzMw9AACAP83YUb/oy2M/zczMPQAAgD/5z3m/YlxYP83MzD0AAIA/GM/+vrciaD/NzMw9AACAP1ohmz4W2m4/zczMPQAAgD+cHmg/D3JDP83MzD0AAIA/KbdsP20nNz/NzMw9AACAP3e5sj5pk18/zczMPQAAgD9pxeS+FxpPP83MzD0AAIA/w/10v5LFBD/NzMw9AACAPzjgX7/oq/c+zczMPQAAgD/3rZO++yFNP83MzD0AAIA/8LzDPpKuMj/NzMw9AACAPzUjLD/Tk9w+zczMPQAAgD/wvMM+kq4yP83MzD0AAIA/962TvvshTT/NzMw9AACAPzjgX7/oq/c+zczMPQAAgD/D/XS/ksUEP83MzD0AAIA/acXkvhcaTz/NzMw9AACAP3e5sj5pk18/zczMPQAAgD8pt2w/bSc3P83MzD0AAIA/nB5oPw9yQz/NzMw9AACAP1ohmz4W2m4/zczMPQAAgD8Yz/6+tyJoP83MzD0AAIA/+c95v2JcWD/NzMw9AACAP83YUb/oy2M/zczMPQAAgD/InEG/qYJmP83MzD0AAIA/YYN+v2uDWD/NzMw9AACAP+PHGb/J5WM/zczMPQAAgD+xRy4+paB2P83MzD0AAIA/b+lUPyoiSj/NzMw9AACAPxsHej8fsTU/zczMPQAAgD/NkAc/FcFQP83MzD0AAIA/hzZkvhi/aD/NzMw9AACAP2BnVb/YuRo/zczMPQAAgD89mn2/vuXpPs3MzD0AAIA/Tys1v4PtDj/NzMw9AACAP/etk777IU0/zczMPQAAgD+1CsS99XBuP83MzD0AAIA/962TvvshTT/NzMw9AACAP08rNb+D7Q4/zczMPQAAgD89mn2/vuXpPs3MzD0AAIA/YGdVv9i5Gj/NzMw9AACAP4c2ZL4Yv2g/zczMPQAAgD/NkAc/FcFQP83MzD0AAIA/Gwd6Px+xNT/NzMw9AACAP2/pVD8qIko/zczMPQAAgD+xRy4+paB2P83MzD0AAIA/48cZv8nlYz/NzMw9AACAP2GDfr9rg1g/zczMPQAAgD/InEG/qYJmP83MzD0AAIA/UoUiv3dRaz/NzMw9AACAP2g/f7+J1Vk/zczMPQAAgD9nsj+/4lpeP83MzD0AAIA/V7hTvQ1HfT/NzMw9AACAP+p5Kz+gt1Y/zczMPQAAgD/HfH8/UzM4P83MzD0AAIA/XPJEPyKdPz/NzMw9AACAP324FT401nE/zczMPQAAgD+F3wS/60BGP83MzD0AAIA/K2Rsv19xCz/NzMw9AACAPz2afb++5ek+zczMPQAAgD844F+/6Kv3Ps3MzD0AAIA/vxdNv96aAz/NzMw9AACAPzjgX7/oq/c+zczMPQAAgD89mn2/vuXpPs3MzD0AAIA/K2Rsv19xCz/NzMw9AACAP4XfBL/rQEY/zczMPQAAgD99uBU+NNZxP83MzD0AAIA/XPJEPyKdPz/NzMw9AACAP8d8fz9TMzg/zczMPQAAgD/qeSs/oLdWP83MzD0AAIA/V7hTvQ1HfT/NzMw9AACAP2eyP7/iWl4/zczMPQAAgD9oP3+/idVZP83MzD0AAIA/UoUiv3dRaz/NzMw9AACAP9nX4L5xWHI/zczMPQAAgD8aQnK/V49dP83MzD0AAIA/2pFmv7myWT/NzMw9AACAP6cysb7E1m4/zczMPQAAgD+/lMc+pYZpP83MzD0AAIA/nB5oPw9yQz/NzMw9AACAP3J0dj8N6DU/zczMPQAAgD+4exU/4JRMP83MzD0AAIA/wBXZOrjVfz/NzMw9AACAP4XfBL/rQEY/zczMPQAAgD9gZ1W/2LkaP83MzD0AAIA/w/10v5LFBD/NzMw9AACAP/1Oe7+i8v0+zczMPQAAgD/D/XS/ksUEP83MzD0AAIA/YGdVv9i5Gj/NzMw9AACAP4XfBL/rQEY/zczMPQAAgD/AFdk6uNV/P83MzD0AAIA/uHsVP+CUTD/NzMw9AACAP3J0dj8N6DU/zczMPQAAgD+cHmg/D3JDP83MzD0AAIA/v5THPqWGaT/NzMw9AACAP6cysb7E1m4/zczMPQAAgD/akWa/ubJZP83MzD0AAIA/GkJyv1ePXT/NzMw9AACAP9nX4L5xWHI/zczMPQAAgD8oaCW+R0N7P83MzD0AAIA/X6hMv+6uZD/NzMw9AACAP2GDfr9rg1g/zczMPQAAgD8S5im//XNhP83MzD0AAIA/M077u62Xfz/NzMw9AACAPwAKIj/bXVk/zczMPQAAgD/lhnk/rxw8P83MzD0AAIA/KbdsP20nNz/NzMw9AACAP7h7FT/glEw/zczMPQAAgD99uBU+NNZxP83MzD0AAIA/hzZkvhi/aD/NzMw9AACAP2nF5L4XGk8/zczMPQAAgD+F3wS/60BGP83MzD0AAIA/acXkvhcaTz/NzMw9AACAP4c2ZL4Yv2g/zczMPQAAgD99uBU+NNZxP83MzD0AAIA/uHsVP+CUTD/NzMw9AACAPym3bD9tJzc/zczMPQAAgD/lhnk/rxw8P83MzD0AAIA/AAoiP9tdWT/NzMw9AACAPzNO+7utl38/zczMPQAAgD8S5im//XNhP83MzD0AAIA/YYN+v2uDWD/NzMw9AACAP1+oTL/urmQ/zczMPQAAgD8oaCW+R0N7P83MzD0AAIA/FSA8PjD5ej/NzMw9AACAP4+qBr/NUG8/zczMPQAAgD/3DXW/u+lcP83MzD0AAIA/57BqvzlQWT/NzMw9AACAP/Ai7L4ms2k/zczMPQAAgD+xRy4+paB2P83MzD0AAIA/rpE0P8MZVD/NzMw9AACAP+WGeT+vHDw/zczMPQAAgD9ydHY/Deg1P83MzD0AAIA/XPJEPyKdPz/NzMw9AACAP82QBz8VwVA/zczMPQAAgD93ubI+aZNfP83MzD0AAIA/LDyRPhdJZT/NzMw9AACAP3e5sj5pk18/zczMPQAAgD/NkAc/FcFQP83MzD0AAIA/XPJEPyKdPz/NzMw9AACAP3J0dj8N6DU/zczMPQAAgD/lhnk/rxw8P83MzD0AAIA/rpE0P8MZVD/NzMw9AACAP7FHLj6loHY/zczMPQAAgD/wIuy+JrNpP83MzD0AAIA/57BqvzlQWT/NzMw9AACAP/cNdb+76Vw/zczMPQAAgD+Pqga/zVBvP83MzD0AAIA/FSA8PjD5ej/NzMw9AACAP2ybDD9RHnI/zczMPQAAgD9n/AS+Mzd8P83MzD0AAIA/GcY7v5JyZz/NzMw9AACAP2g/f7+J1Vk/zczMPQAAgD98CFi/vUNbP83MzD0AAIA/2k3FvmMNbT/NzMw9AACAP7FHLj6loHY/zczMPQAAgD8ACiI/211ZP83MzD0AAIA/nB5oPw9yQz/NzMw9AACAP8d8fz9TMzg/zczMPQAAgD8bB3o/H7E1P83MzD0AAIA/KbdsP20nNz/NzMw9AACAP+yHZj9BNjg/zczMPQAAgD8pt2w/bSc3P83MzD0AAIA/Gwd6Px+xNT/NzMw9AACAP8d8fz9TMzg/zczMPQAAgD+cHmg/D3JDP83MzD0AAIA/AAoiP9tdWT/NzMw9AACAP7FHLj6loHY/zczMPQAAgD/aTcW+Yw1tP83MzD0AAIA/fAhYv71DWz/NzMw9AACAP2g/f7+J1Vk/zczMPQAAgD8Zxju/knJnP83MzD0AAIA/Z/wEvjM3fD/NzMw9AACAP2ybDD9RHnI/zczMPQAAgD8CiFo/nz9sP83MzD0AAIA/T0GqPpctdz/NzMw9AACAPwDbor6XXXY/zczMPQAAgD/N2FG/6MtjP83MzD0AAIA/pP9/v+8nWT/NzMw9AACAP3wIWL+9Q1s/zczMPQAAgD/wIuy+JrNpP83MzD0AAIA/M077u62Xfz/NzMw9AACAP7+Uxz6lhmk/zczMPQAAgD/qeSs/oLdWP83MzD0AAIA/b+lUPyoiSj/NzMw9AACAP5weaD8PckM/zczMPQAAgD/4Z20/oWtBP83MzD0AAIA/nB5oPw9yQz/NzMw9AACAP2/pVD8qIko/zczMPQAAgD/qeSs/oLdWP83MzD0AAIA/v5THPqWGaT/NzMw9AACAPzNO+7utl38/zczMPQAAgD/wIuy+JrNpP83MzD0AAIA/fAhYv71DWz/NzMw9AACAP6T/f7/vJ1k/zczMPQAAgD/N2FG/6MtjP83MzD0AAIA/ANuivpdddj/NzMw9AACAP09Bqj6XLXc/zczMPQAAgD8CiFo/nz9sP83MzD0AAIA/tW9/P1IIaz/NzMw9AACAPxQLQD+VBm4/zczMPQAAgD9DP1s+lS16P83MzD0AAIA/eivCvrRcdD/NzMw9AACAP83YUb/oy2M/zczMPQAAgD9oP3+/idVZP83MzD0AAIA/57BqvzlQWT/NzMw9AACAPxLmKb/9c2E/zczMPQAAgD+nMrG+xNZuP83MzD0AAIA/V7hTvQ1HfT/NzMw9AACAP7FHLj6loHY/zczMPQAAgD9aIZs+FtpuP83MzD0AAIA/L3qxPiIzbD/NzMw9AACAP1ohmz4W2m4/zczMPQAAgD+xRy4+paB2P83MzD0AAIA/V7hTvQ1HfT/NzMw9AACAP6cysb7E1m4/zczMPQAAgD8S5im//XNhP83MzD0AAIA/57BqvzlQWT/NzMw9AACAP2g/f7+J1Vk/zczMPQAAgD/N2FG/6MtjP83MzD0AAIA/eivCvrRcdD/NzMw9AACAP0M/Wz6VLXo/zczMPQAAgD8UC0A/lQZuP83MzD0AAIA/tW9/P1IIaz/NzMw9AACAP2NvZj9x8W4/zczMPQAAgD/A9Hs/8dlqP83MzD0AAIA/bsQ1P0zJbj/NzMw9AACAP0M/Wz6VLXo/zczMPQAAgD8A26K+l112P83MzD0AAIA/GcY7v5JyZz/NzMw9AACAP/cNdb+76Vw/zczMPQAAgD9hg36/a4NYP83MzD0AAIA/2pFmv7myWT/NzMw9AACAP2eyP7/iWl4/zczMPQAAgD/jxxm/yeVjP83MzD0AAIA/GM/+vrciaD/NzMw9AACAP/Ai7L4ms2k/zczMPQAAgD8Yz/6+tyJoP83MzD0AAIA/48cZv8nlYz/NzMw9AACAP2eyP7/iWl4/zczMPQAAgD/akWa/ubJZP83MzD0AAIA/YYN+v2uDWD/NzMw9AACAP/cNdb+76Vw/zczMPQAAgD8Zxju/knJnP83MzD0AAIA/ANuivpdddj/NzMw9AACAP0M/Wz6VLXo/zczMPQAAgD9uxDU/TMluP83MzD0AAIA/wPR7P/HZaj/NzMw9AACAP2NvZj9x8W4/zczMPQAAgD8edwo/2dB2P83MzD0AAIA/gxBsP7BWbj/NzMw9AACAP8D0ez/x2Wo/zczMPQAAgD8UC0A/lQZuP83MzD0AAIA/T0GqPpctdz/NzMw9AACAP2f8BL4zN3w/zczMPQAAgD+Pqga/zVBvP83MzD0AAIA/X6hMv+6uZD/NzMw9AACAPxpCcr9Xj10/zczMPQAAgD9oP3+/idVZP83MzD0AAIA/YYN+v2uDWD/NzMw9AACAP/nPeb9iXFg/zczMPQAAgD8LhXe/N21YP83MzD0AAIA/+c95v2JcWD/NzMw9AACAP2GDfr9rg1g/zczMPQAAgD9oP3+/idVZP83MzD0AAIA/GkJyv1ePXT/NzMw9AACAP1+oTL/urmQ/zczMPQAAgD+Pqga/zVBvP83MzD0AAIA/Z/wEvjM3fD/NzMw9AACAP09Bqj6XLXc/zczMPQAAgD8UC0A/lQZuP83MzD0AAIA/wPR7P/HZaj/NzMw9AACAP4MQbD+wVm4/zczMPQAAgD8edwo/2dB2P83MzD0AAIA/KdCiu8Hsfz/NzMw9AACAPx53Cj/Z0HY/zczMPQAAgD9jb2Y/cfFuP83MzD0AAIA/tW9/P1IIaz/NzMw9AACAPwKIWj+fP2w/zczMPQAAgD9smww/UR5yP83MzD0AAIA/FSA8PjD5ej/NzMw9AACAPyhoJb5HQ3s/zczMPQAAgD/Z1+C+cVhyP83MzD0AAIA/UoUiv3dRaz/NzMw9AACAP8icQb+pgmY/zczMPQAAgD/N2FG/6MtjP83MzD0AAIA/ZM1Wv//tYj/NzMw9AACAP83YUb/oy2M/zczMPQAAgD/InEG/qYJmP83MzD0AAIA/UoUiv3dRaz/NzMw9AACAP9nX4L5xWHI/zczMPQAAgD8oaCW+R0N7P83MzD0AAIA/FSA8PjD5ej/NzMw9AACAP2ybDD9RHnI/zczMPQAAgD8CiFo/nz9sP83MzD0AAIA/tW9/P1IIaz/NzMw9AACAP2NvZj9x8W4/zczMPQAAgD8edwo/2dB2P83MzD0AAIA/KdCiu8Hsfz/NzMw9AACAPw==", - "encoding": "base64", - "path": [ - "color", - 14, - "data" - ] - }, - { - "data": "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", - "encoding": "base64", - "path": [ - "size", - 0, - "data" - ] - }, - { - "data": "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", - "encoding": "base64", - "path": [ - "size", - 1, - "data" - ] - }, - { - "data": "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", - "encoding": "base64", - "path": [ - "size", - 2, - "data" - ] - }, - { - "data": "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", - "encoding": "base64", - "path": [ - "size", - 3, - "data" - ] - }, - { - "data": "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", - "encoding": "base64", - "path": [ - "size", - 4, - "data" - ] - }, - { - "data": "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", - "encoding": "base64", - "path": [ - "size", - 5, - "data" - ] - }, - { - "data": "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", - "encoding": "base64", - "path": [ - "size", - 6, - "data" - ] - }, - { - "data": "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", - "encoding": "base64", - "path": [ - "size", - 7, - "data" - ] - }, - { - "data": "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", - "encoding": "base64", - "path": [ - "size", - 8, - "data" - ] - }, - { - "data": "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", - "encoding": "base64", - "path": [ - "size", - 9, - "data" - ] - }, - { - "data": "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", - "encoding": "base64", - "path": [ - "size", - 10, - "data" - ] - }, - { - "data": "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", - "encoding": "base64", - "path": [ - "size", - 11, - "data" - ] - }, - { - "data": "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", - "encoding": "base64", - "path": [ - "size", - 12, - "data" - ] - }, - { - "data": "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", - "encoding": "base64", - "path": [ - "size", - 13, - "data" - ] - }, - { - "data": "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", - "encoding": "base64", - "path": [ - "size", - 14, - "data" - ] - }, - { - "data": "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", - "encoding": "base64", - "path": [ - "x", - 0, - "data" - ] - }, - { - "data": "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", - "encoding": "base64", - "path": [ - "y", - 0, - "data" - ] - }, - { - "data": "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", - "encoding": "base64", - "path": [ - "y", - 1, - "data" - ] - }, - { - "data": "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", - "encoding": "base64", - "path": [ - "y", - 2, - "data" - ] - }, - { - "data": "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", - "encoding": "base64", - "path": [ - "y", - 3, - "data" - ] - }, - { - "data": "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", - "encoding": "base64", - "path": [ - "y", - 4, - "data" - ] - }, - { - "data": "34Y8vXYjh73jtIi9A7w/vTscObzvcPs8mCWPPYimzD1X1PI95EsCPqOGBD4G+AM+u3EDPgb4Az6jhgQ+5EsCPlfU8j2Ipsw9mCWPPe9w+zw7HDm8A7w/veO0iL12I4e934Y8vXYjh73FcIa982IjvccTlzsH+mA9xpfHPdju+z1PUgQ+TFz1Pbe10D2+OKo9tjGOPUkLhD22MY49vjiqPbe10D1MXPU9T1IEPtju+z3Gl8c9B/pgPccTlzvzYiO9xXCGvXYjh73jtIi982IjvXxWJzwhF4k9x6rjPZ9iBD7IVPE9vjiqPcrwFj2ThRO8AoQ7vbkbjb3tG529uRuNvQKEO72ThRO8yvAWPb44qj3IVPE9n2IEPseq4z0hF4k9fFYnPPNiI73jtIi9A7w/vccTlzshF4k9lKbrPQb4Az63tdA9thMvPdvs+7xpYM29g7QdvqYUQb5DcVO+S/FYvkNxU76mFEG+g7Qdvmlgzb3b7Pu8thMvPbe10D0G+AM+lKbrPSEXiT3HE5c7A7w/vTscObwH+mA9x6rjPQb4Az44jsI9XJiUPO0bnb2yJiW+MxdevlsSdr5Ozna+bhpvvqAHa75uGm++Ts52vlsSdr4zF16+siYlvu0bnb1cmJQ8OI7CPQb4Az7HquM9B/pgPTscObzvcPs8xpfHPZ9iBD63tdA9XJiUPNhFvb2mFEG+xh90vm4ab761S0G+AjoGvjq6r70+Qo29OrqvvQI6Br61S0G+bhpvvsYfdL6mFEG+2EW9vVyYlDy3tdA9n2IEPsaXxz3vcPs8mCWPPdju+z3IVPE9thMvPe0bnb2mFEG+ZXR3vjv7Wb6oWe+9zUbUO2W07T2+WT8+zsxXPr5ZPz5ltO09zUbUO6hZ7707+1m+ZXR3vqYUQb7tG529thMvPchU8T3Y7vs9mCWPPYimzD1PUgQ+vjiqPdvs+7yyJiW+xh90vjv7Wb46uq+9Waa+PSUuhD6PC7w+axDWPnO13D5rENY+jwu8PiUuhD5Zpr49OrqvvTv7Wb7GH3S+siYlvtvs+7y+OKo9T1IEPoimzD1X1PI9TFz1PcrwFj1pYM29Mxdevm4ab76oWe+9Waa+Pf+4mz5ztdw+WzfnPrMS1D7zDsg+sxLUPls35z5ztdw+/7ibPlmmvj2oWe+9bhpvvjMXXr5pYM29yvAWPUxc9T1X1PI95EsCPre10D2ThRO8g7QdvlsSdr61S0G+zUbUOyUuhD5ztdw+ShrdPgptjz7Hxsg9cAOdPMfGyD0KbY8+ShrdPnO13D4lLoQ+zUbUO7VLQb5bEna+g7QdvpOFE7y3tdA95EsCPqOGBD6+OKo9AoQ7vaYUQb5Ozna+AjoGvmW07T2PC7w+WzfnPgptjz7gD469AZzIvoHOA78BnMi+4A+OvQptjz5bN+c+jwu8PmW07T0COga+Ts52vqYUQb4ChDu9vjiqPaOGBD4G+AM+tjGOPbkbjb1DcVO+bhpvvjq6r72+WT8+axDWPrMS1D7Hxsg9AZzIvg5RQr+DQFi/DlFCvwGcyL7Hxsg9sxLUPmsQ1j6+WT8+OrqvvW4ab75DcVO+uRuNvbYxjj0G+AM+u3EDPkkLhD3tG529S/FYvqAHa74+Qo29zsxXPnO13D7zDsg+cAOdPIHOA7+DQFi/B50fv4NAWL+BzgO/cAOdPPMOyD5ztdw+zsxXPj5Cjb2gB2u+S/FYvu0bnb1JC4Q9u3EDPgb4Az62MY49uRuNvUNxU75uGm++Orqvvb5ZPz5rENY+sxLUPsfGyD0BnMi+DlFCv4NAWL8OUUK/AZzIvsfGyD2zEtQ+axDWPr5ZPz46uq+9bhpvvkNxU765G429tjGOPQb4Az6jhgQ+vjiqPQKEO72mFEG+Ts52vgI6Br5ltO09jwu8Pls35z4KbY8+4A+OvQGcyL6BzgO/AZzIvuAPjr0KbY8+WzfnPo8LvD5ltO09AjoGvk7Odr6mFEG+AoQ7vb44qj2jhgQ+5EsCPre10D2ThRO8g7QdvlsSdr61S0G+zUbUOyUuhD5ztdw+ShrdPgptjz7Hxsg9cAOdPMfGyD0KbY8+ShrdPnO13D4lLoQ+zUbUO7VLQb5bEna+g7QdvpOFE7y3tdA95EsCPlfU8j1MXPU9yvAWPWlgzb0zF16+bhpvvqhZ771Zpr49/7ibPnO13D5bN+c+sxLUPvMOyD6zEtQ+WzfnPnO13D7/uJs+Waa+PahZ771uGm++Mxdevmlgzb3K8BY9TFz1PVfU8j2Ipsw9T1IEPr44qj3b7Pu8siYlvsYfdL47+1m+OrqvvVmmvj0lLoQ+jwu8PmsQ1j5ztdw+axDWPo8LvD4lLoQ+Waa+PTq6r707+1m+xh90vrImJb7b7Pu8vjiqPU9SBD6Ipsw9mCWPPdju+z3IVPE9thMvPe0bnb2mFEG+ZXR3vjv7Wb6oWe+9zUbUO2W07T2+WT8+zsxXPr5ZPz5ltO09zUbUO6hZ7707+1m+ZXR3vqYUQb7tG529thMvPchU8T3Y7vs9mCWPPe9w+zzGl8c9n2IEPre10D1cmJQ82EW9vaYUQb7GH3S+bhpvvrVLQb4COga+OrqvvT5Cjb06uq+9AjoGvrVLQb5uGm++xh90vqYUQb7YRb29XJiUPLe10D2fYgQ+xpfHPe9w+zw7HDm8B/pgPceq4z0G+AM+OI7CPVyYlDztG529siYlvjMXXr5bEna+Ts52vm4ab76gB2u+bhpvvk7Odr5bEna+MxdevrImJb7tG529XJiUPDiOwj0G+AM+x6rjPQf6YD07HDm8A7w/vccTlzshF4k9lKbrPQb4Az63tdA9thMvPdvs+7xpYM29g7QdvqYUQb5DcVO+S/FYvkNxU76mFEG+g7Qdvmlgzb3b7Pu8thMvPbe10D0G+AM+lKbrPSEXiT3HE5c7A7w/veO0iL3zYiO9fFYnPCEXiT3HquM9n2IEPshU8T2+OKo9yvAWPZOFE7wChDu9uRuNve0bnb25G429AoQ7vZOFE7zK8BY9vjiqPchU8T2fYgQ+x6rjPSEXiT18Vic882IjveO0iL12I4e9xXCGvfNiI73HE5c7B/pgPcaXxz3Y7vs9T1IEPkxc9T23tdA9vjiqPbYxjj1JC4Q9tjGOPb44qj23tdA9TFz1PU9SBD7Y7vs9xpfHPQf6YD3HE5c782IjvcVwhr12I4e934Y8vXYjh73jtIi9A7w/vTscObzvcPs8mCWPPYimzD1X1PI95EsCPqOGBD4G+AM+u3EDPgb4Az6jhgQ+5EsCPlfU8j2Ipsw9mCWPPe9w+zw7HDm8A7w/veO0iL12I4e934Y8vQ==", - "encoding": "base64", - "path": [ - "y", - 5, - "data" - ] - }, - { - "data": "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", - "encoding": "base64", - "path": [ - "y", - 6, - "data" - ] - }, - { - "data": "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", - "encoding": "base64", - "path": [ - "y", - 7, - "data" - ] - }, - { - "data": "vT/UPF/9BLyClDy9TPebvUsyuL16Xa29zZWBvTmhBL0EQTo6s8z2PAFgVj0J4YY92BuQPQnhhj0BYFY9s8z2PARBOjo5oQS9zZWBvXpdrb1LMri9TPebvYKUPL1f/QS8vT/UPF/9BLwHKEu9paOlvXaMuL2sbpa91AYSvakGVTwzSHs9W2fPPal0BD4ouRU+xUIePtW/ID7FQh4+KLkVPql0BD5bZ889M0h7PakGVTzUBhK9rG6WvXaMuL2lo6W9ByhLvV/9BLyClDy9paOlvUBUt71+KIa9BuBxvFv9Qz3kF9g9KLkVPukaKj5u7yw+NjAmPjIwHj580xo+MjAePjYwJj5u7yw+6RoqPii5FT7kF9g9W/1DPQbgcbx+KIa9QFS3vaWjpb2ClDy9TPebvXaMuL1+KIa9t9vquwnhhj2pdAQ++awoPnHXKT7ylQ4+xzLKPSWccT2Pd/48KQ6tPI93/jwlnHE9xzLKPfKVDj5x1yk++awoPql0BD4J4YY9t9vqu34ohr12jLi9TPebvUsyuL2sbpa9BuBxvAnhhj0DxAs+1+wsPnzTGj6EXrs9vW8yPPK1ir0MtwO+MFkpvsu1Nb4wWSm+DLcDvvK1ir29bzI8hF67PXzTGj7X7Cw+A8QLPgnhhj0G4HG8rG6WvUsyuL16Xa291AYSvVv9Qz2pdAQ+1+wsPmYHEz4lnHE9yeJkvTBZKb7r23q+jBOUvmtLnb45cJ++a0udvowTlL7r23q+MFkpvsniZL0lnHE9ZgcTPtfsLD6pdAQ+W/1DPdQGEr16Xa29zZWBvakGVTzkF9g9+awoPnzTGj4lnHE9ZkejvSemWb42lJe+0Gqivt7Olr7Z9YW+ewJ9vtn1hb7ezpa+0GqivjaUl74nplm+ZkejvSWccT180xo++awoPuQX2D2pBlU8zZWBvTmhBL0zSHs9KLkVPnHXKT6EXrs9yeJkvSemWb5rS52+qq+avq5aWb6HdLm9Hc7JO8BDLD0dzsk7h3S5va5aWb6qr5q+a0udviemWb7J4mS9hF67PXHXKT4ouRU+M0h7PTmhBL0EQTo6W2fPPekaKj7ylQ4+vW8yPDBZKb42lJe+qq+avrOpLb7AQyw9HIR4PnKivT4Hw9I+cqK9PhyEeD7AQyw9s6ktvqqvmr42lJe+MFkpvr1vMjzylQ4+6RoqPltnzz0EQTo6s8z2PKl0BD5u7yw+xzLKPfK1ir3r23q+0Gqivq5aWb7AQyw9bPynPq+YBT/Y4BY/JWUYP9jgFj+vmAU/bPynPsBDLD2uWlm+0Gqivuvber7ytYq9xzLKPW7vLD6pdAQ+s8z2PAFgVj0ouRU+NjAmPiWccT0MtwO+jBOUvt7Olr6HdLm9HIR4Pq+YBT+D2hY/0TDuPs8Vvj7RMO4+g9oWP6+YBT8chHg+h3S5vd7Olr6ME5S+DLcDviWccT02MCY+KLkVPgFgVj0J4YY9xUIePjIwHj6Pd/48MFkpvmtLnb7Z9YW+Hc7JO3KivT7Y4BY/0TDuPsDGNj20wHa+wMY2PdEw7j7Y4BY/cqK9Ph3OyTvZ9YW+a0udvjBZKb6Pd/48MjAePsVCHj4J4YY92BuQPdW/ID580xo+KQ6tPMu1Nb45cJ++ewJ9vsBDLD0Hw9I+JWUYP88Vvj60wHa+5aVmv7TAdr7PFb4+JWUYPwfD0j7AQyw9ewJ9vjlwn77LtTW+KQ6tPHzTGj7VvyA+2BuQPQnhhj3FQh4+MjAePo93/jwwWSm+a0udvtn1hb4dzsk7cqK9PtjgFj/RMO4+wMY2PbTAdr7AxjY90TDuPtjgFj9yor0+Hc7JO9n1hb5rS52+MFkpvo93/jwyMB4+xUIePgnhhj0BYFY9KLkVPjYwJj4lnHE9DLcDvowTlL7ezpa+h3S5vRyEeD6vmAU/g9oWP9Ew7j7PFb4+0TDuPoPaFj+vmAU/HIR4Pod0ub3ezpa+jBOUvgy3A74lnHE9NjAmPii5FT4BYFY9s8z2PKl0BD5u7yw+xzLKPfK1ir3r23q+0Gqivq5aWb7AQyw9bPynPq+YBT/Y4BY/JWUYP9jgFj+vmAU/bPynPsBDLD2uWlm+0Gqivuvber7ytYq9xzLKPW7vLD6pdAQ+s8z2PARBOjpbZ8896RoqPvKVDj69bzI8MFkpvjaUl76qr5q+s6ktvsBDLD0chHg+cqK9PgfD0j5yor0+HIR4PsBDLD2zqS2+qq+avjaUl74wWSm+vW8yPPKVDj7pGio+W2fPPQRBOjo5oQS9M0h7PSi5FT5x1yk+hF67PcniZL0nplm+a0udvqqvmr6uWlm+h3S5vR3OyTvAQyw9Hc7JO4d0ub2uWlm+qq+avmtLnb4nplm+yeJkvYReuz1x1yk+KLkVPjNIez05oQS9zZWBvakGVTzkF9g9+awoPnzTGj4lnHE9ZkejvSemWb42lJe+0Gqivt7Olr7Z9YW+ewJ9vtn1hb7ezpa+0GqivjaUl74nplm+ZkejvSWccT180xo++awoPuQX2D2pBlU8zZWBvXpdrb3UBhK9W/1DPal0BD7X7Cw+ZgcTPiWccT3J4mS9MFkpvuvber6ME5S+a0udvjlwn75rS52+jBOUvuvber4wWSm+yeJkvSWccT1mBxM+1+wsPql0BD5b/UM91AYSvXpdrb1LMri9rG6WvQbgcbwJ4YY9A8QLPtfsLD580xo+hF67Pb1vMjzytYq9DLcDvjBZKb7LtTW+MFkpvgy3A77ytYq9vW8yPIReuz180xo+1+wsPgPECz4J4YY9BuBxvKxulr1LMri9TPebvXaMuL1+KIa9t9vquwnhhj2pdAQ++awoPnHXKT7ylQ4+xzLKPSWccT2Pd/48KQ6tPI93/jwlnHE9xzLKPfKVDj5x1yk++awoPql0BD4J4YY9t9vqu34ohr12jLi9TPebvYKUPL2lo6W9QFS3vX4ohr0G4HG8W/1DPeQX2D0ouRU+6RoqPm7vLD42MCY+MjAePnzTGj4yMB4+NjAmPm7vLD7pGio+KLkVPuQX2D1b/UM9BuBxvH4ohr1AVLe9paOlvYKUPL1f/QS8ByhLvaWjpb12jLi9rG6WvdQGEr2pBlU8M0h7PVtnzz2pdAQ+KLkVPsVCHj7VvyA+xUIePii5FT6pdAQ+W2fPPTNIez2pBlU81AYSvaxulr12jLi9paOlvQcoS71f/QS8vT/UPF/9BLyClDy9TPebvUsyuL16Xa29zZWBvTmhBL0EQTo6s8z2PAFgVj0J4YY92BuQPQnhhj0BYFY9s8z2PARBOjo5oQS9zZWBvXpdrb1LMri9TPebvYKUPL1f/QS8vT/UPA==", - "encoding": "base64", - "path": [ - "y", - 8, - "data" - ] - }, - { - "data": "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", - "encoding": "base64", - "path": [ - "y", - 9, - "data" - ] - }, - { - "data": "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", - "encoding": "base64", - "path": [ - "y", - 10, - "data" - ] - }, - { - "data": "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", - "encoding": "base64", - "path": [ - "y", - 11, - "data" - ] - }, - { - "data": "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", - "encoding": "base64", - "path": [ - "y", - 12, - "data" - ] - }, - { - "data": "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", - "encoding": "base64", - "path": [ - "y", - 13, - "data" - ] - }, - { - "data": "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", - "encoding": "base64", - "path": [ - "y", - 14, - "data" - ] - }, - { - "data": "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", - "encoding": "base64", - "path": [ - "z", - 0, - "data" - ] - } - ], - "model_module": "ipyvolume", - "model_module_version": "^0.5.0-beta.1", - "model_name": "ScatterModel", - "state": { - "color": [ - { - "dtype": "float32", - "shape": [ - 625, - 4 - ] - }, - { - "dtype": "float32", - "shape": [ - 625, - 4 - ] - }, - { - "dtype": "float32", - "shape": [ - 625, - 4 - ] - }, - { - "dtype": "float32", - "shape": [ - 625, - 4 - ] - }, - { - "dtype": "float32", - "shape": [ - 625, - 4 - ] - }, - { - "dtype": "float32", - "shape": [ - 625, - 4 - ] - }, - { - "dtype": "float32", - "shape": [ - 625, - 4 - ] - }, - { - "dtype": "float32", - "shape": [ - 625, - 4 - ] - }, - { - "dtype": "float32", - "shape": [ - 625, - 4 - ] - }, - { - "dtype": "float32", - "shape": [ - 625, - 4 - ] - }, - { - "dtype": "float32", - "shape": [ - 625, - 4 - ] - }, - { - "dtype": "float32", - "shape": [ - 625, - 4 - ] - }, - { - "dtype": "float32", - "shape": [ - 625, - 4 - ] - }, - { - "dtype": "float32", - "shape": [ - 625, - 4 - ] - }, - { - "dtype": "float32", - "shape": [ - 625, - 4 - ] - } - ], - "geo": "sphere", - "line_material": "IPY_MODEL_0fa46a2814a34bd59ca3e501c5d8118a", - "material": "IPY_MODEL_bf169eb7e0d9407bbd19c23a12ca33fe", - "selected": null, - "sequence_index": 14, - "size": [ - { - "dtype": "float32", - "shape": [ - 625 - ] - }, - { - "dtype": "float32", - "shape": [ - 625 - ] - }, - { - "dtype": "float32", - "shape": [ - 625 - ] - }, - { - "dtype": "float32", - "shape": [ - 625 - ] - }, - { - "dtype": "float32", - "shape": [ - 625 - ] - }, - { - "dtype": "float32", - "shape": [ - 625 - ] - }, - { - "dtype": "float32", - "shape": [ - 625 - ] - }, - { - "dtype": "float32", - "shape": [ - 625 - ] - }, - { - "dtype": "float32", - "shape": [ - 625 - ] - }, - { - "dtype": "float32", - "shape": [ - 625 - ] - }, - { - "dtype": "float32", - "shape": [ - 625 - ] - }, - { - "dtype": "float32", - "shape": [ - 625 - ] - }, - { - "dtype": "float32", - "shape": [ - 625 - ] - }, - { - "dtype": "float32", - "shape": [ - 625 - ] - }, - { - "dtype": "float32", - "shape": [ - 625 - ] - } - ], - "size_selected": 2.6, - "texture": null, - "visible": true, - "vx": null, - "vy": null, - "vz": null, - "x": [ - { - "dtype": "float32", - "shape": [ - 625 - ] - } - ], - "y": [ - { - "dtype": "float32", - "shape": [ - 625 - ] - }, - { - "dtype": "float32", - "shape": [ - 625 - ] - }, - { - "dtype": "float32", - "shape": [ - 625 - ] - }, - { - "dtype": "float32", - "shape": [ - 625 - ] - }, - { - "dtype": "float32", - "shape": [ - 625 - ] - }, - { - "dtype": "float32", - "shape": [ - 625 - ] - }, - { - "dtype": "float32", - "shape": [ - 625 - ] - }, - { - "dtype": "float32", - "shape": [ - 625 - ] - }, - { - "dtype": "float32", - "shape": [ - 625 - ] - }, - { - "dtype": "float32", - "shape": [ - 625 - ] - }, - { - "dtype": "float32", - "shape": [ - 625 - ] - }, - { - "dtype": "float32", - "shape": [ - 625 - ] - }, - { - "dtype": "float32", - "shape": [ - 625 - ] - }, - { - "dtype": "float32", - "shape": [ - 625 - ] - }, - { - "dtype": "float32", - "shape": [ - 625 - ] - } - ], - "z": [ - { - "dtype": "float32", - "shape": [ - 625 - ] - } - ] - } - } - }, - "version_major": 2, - "version_minor": 0 - } - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/docs/source/bokeh.ipynb b/docs/source/bokeh.ipynb deleted file mode 100644 index fd6660be..00000000 --- a/docs/source/bokeh.ipynb +++ /dev/null @@ -1,780 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Mixing ipyvolume with Bokeh\n", - "This example shows how the selection from a ipyvolume quiver plot can be controlled with a bokeh scatter plot and it's selection tools." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Ipyvolume quiver plot\n", - "The 3d quiver plot is done using ipyvolume" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "import ipyvolume\n", - "import ipyvolume as ipv\n", - "import vaex" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We load some data from vaex, but only use the first 10 000 samples for performance reasons of Bokeh." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "ds = vaex.example()\n", - "N = 10000" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We make a quiver plot using ipyvolume's matplotlib's style api." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "39500cb0de6b4d3a9dce8709973cc26c", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "A Jupyter Widget" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "ipv.figure()\n", - "quiver = ipv.quiver(ds.data.x[:N], ds.data.y[:N], ds.data.z[:N],\n", - " ds.data.vx[:N], ds.data.vy[:N], ds.data.vz[:N],\n", - " size=1, size_selected=5, color_selected=\"grey\")\n", - "ipv.xyzlim(-30, 30)\n", - "ipv.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Bokeh scatter part\n", - "The 2d scatter plot is done using Bokeh." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "\n", - "
\n", - " \n", - " Loading BokehJS ...\n", - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/javascript": [ - "\n", - "(function(global) {\n", - " function now() {\n", - " return new Date();\n", - " }\n", - "\n", - " var force = true;\n", - "\n", - " if (typeof (window._bokeh_onload_callbacks) === \"undefined\" || force === true) {\n", - " window._bokeh_onload_callbacks = [];\n", - " window._bokeh_is_loading = undefined;\n", - " }\n", - "\n", - "\n", - " \n", - " if (typeof (window._bokeh_timeout) === \"undefined\" || force === true) {\n", - " window._bokeh_timeout = Date.now() + 5000;\n", - " window._bokeh_failed_load = false;\n", - " }\n", - "\n", - " var NB_LOAD_WARNING = {'data': {'text/html':\n", - " \"
\\n\"+\n", - " \"

\\n\"+\n", - " \"BokehJS does not appear to have successfully loaded. If loading BokehJS from CDN, this \\n\"+\n", - " \"may be due to a slow or bad network connection. Possible fixes:\\n\"+\n", - " \"

\\n\"+\n", - " \"
    \\n\"+\n", - " \"
  • re-rerun `output_notebook()` to attempt to load from CDN again, or
    • \\n\"+\n", - " \"
  • use INLINE resources instead, as so:
    • \\n\"+\n", - " \"
\\n\"+\n", - " \"\\n\"+\n", - " \"from bokeh.resources import INLINE\\n\"+\n", - " \"output_notebook(resources=INLINE)\\n\"+\n", - " \"\\n\"+\n", - " \"
\"}};\n", - "\n", - " function display_loaded() {\n", - " if (window.Bokeh !== undefined) {\n", - " document.getElementById(\"1a9e0d35-1003-482a-939e-38da3946c79b\").textContent = \"BokehJS successfully loaded.\";\n", - " } else if (Date.now() < window._bokeh_timeout) {\n", - " setTimeout(display_loaded, 100)\n", - " }\n", - " }\n", - "\n", - " function run_callbacks() {\n", - " window._bokeh_onload_callbacks.forEach(function(callback) { callback() });\n", - " delete window._bokeh_onload_callbacks\n", - " console.info(\"Bokeh: all callbacks have finished\");\n", - " }\n", - "\n", - " function load_libs(js_urls, callback) {\n", - " window._bokeh_onload_callbacks.push(callback);\n", - " if (window._bokeh_is_loading > 0) {\n", - " console.log(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n", - " return null;\n", - " }\n", - " if (js_urls == null || js_urls.length === 0) {\n", - " run_callbacks();\n", - " return null;\n", - " }\n", - " console.log(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n", - " window._bokeh_is_loading = js_urls.length;\n", - " for (var i = 0; i < js_urls.length; i++) {\n", - " var url = js_urls[i];\n", - " var s = document.createElement('script');\n", - " s.src = url;\n", - " s.async = false;\n", - " s.onreadystatechange = s.onload = function() {\n", - " window._bokeh_is_loading--;\n", - " if (window._bokeh_is_loading === 0) {\n", - " console.log(\"Bokeh: all BokehJS libraries loaded\");\n", - " run_callbacks()\n", - " }\n", - " };\n", - " s.onerror = function() {\n", - " console.warn(\"failed to load library \" + url);\n", - " };\n", - " console.log(\"Bokeh: injecting script tag for BokehJS library: \", url);\n", - " document.getElementsByTagName(\"head\")[0].appendChild(s);\n", - " }\n", - " };var element = document.getElementById(\"1a9e0d35-1003-482a-939e-38da3946c79b\");\n", - " if (element == null) {\n", - " console.log(\"Bokeh: ERROR: autoload.js configured with elementid '1a9e0d35-1003-482a-939e-38da3946c79b' but no matching script tag was found. \")\n", - " return false;\n", - " }\n", - "\n", - " var js_urls = [\"https://cdn.pydata.org/bokeh/release/bokeh-0.12.4.min.js\", \"https://cdn.pydata.org/bokeh/release/bokeh-widgets-0.12.4.min.js\"];\n", - "\n", - " var inline_js = [\n", - " function(Bokeh) {\n", - " Bokeh.set_log_level(\"info\");\n", - " },\n", - " \n", - " function(Bokeh) {\n", - " \n", - " document.getElementById(\"1a9e0d35-1003-482a-939e-38da3946c79b\").textContent = \"BokehJS is loading...\";\n", - " },\n", - " function(Bokeh) {\n", - " console.log(\"Bokeh: injecting CSS: https://cdn.pydata.org/bokeh/release/bokeh-0.12.4.min.css\");\n", - " Bokeh.embed.inject_css(\"https://cdn.pydata.org/bokeh/release/bokeh-0.12.4.min.css\");\n", - " console.log(\"Bokeh: injecting CSS: https://cdn.pydata.org/bokeh/release/bokeh-widgets-0.12.4.min.css\");\n", - " Bokeh.embed.inject_css(\"https://cdn.pydata.org/bokeh/release/bokeh-widgets-0.12.4.min.css\");\n", - " }\n", - " ];\n", - "\n", - " function run_inline_js() {\n", - " \n", - " if ((window.Bokeh !== undefined) || (force === true)) {\n", - " for (var i = 0; i < inline_js.length; i++) {\n", - " inline_js[i](window.Bokeh);\n", - " }if (force === true) {\n", - " display_loaded();\n", - " }} else if (Date.now() < window._bokeh_timeout) {\n", - " setTimeout(run_inline_js, 100);\n", - " } else if (!window._bokeh_failed_load) {\n", - " console.log(\"Bokeh: BokehJS failed to load within specified timeout.\");\n", - " window._bokeh_failed_load = true;\n", - " } else if (force !== true) {\n", - " var cell = $(document.getElementById(\"1a9e0d35-1003-482a-939e-38da3946c79b\")).parents('.cell').data().cell;\n", - " cell.output_area.append_execute_result(NB_LOAD_WARNING)\n", - " }\n", - "\n", - " }\n", - "\n", - " if (window._bokeh_is_loading === 0) {\n", - " console.log(\"Bokeh: BokehJS loaded, going straight to plotting\");\n", - " run_inline_js();\n", - " } else {\n", - " load_libs(js_urls, function() {\n", - " console.log(\"Bokeh: BokehJS plotting callback run at\", now());\n", - " run_inline_js();\n", - " });\n", - " }\n", - "}(this));" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "from bokeh.io import output_notebook, show\n", - "from bokeh.plotting import figure\n", - "import ipyvolume.bokeh\n", - "output_notebook()" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": { - "scrolled": false - }, - "outputs": [ - { - "data": { - "text/html": [ - "\n", - "\n", - "
\n", - "
\n", - "
\n", - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "tools = \"wheel_zoom,box_zoom,box_select,lasso_select,help,reset,\"\n", - "p = figure(title=\"E Lz space\", tools=tools, webgl=True, width=500, height=500)\n", - "r = p.circle(ds.data.Lz[:N], ds.data.E[:N],color=\"navy\", alpha=0.2)\n", - "# A 'trick' from ipyvolume to link the selection (one way traffic atm)\n", - "ipyvolume.bokeh.link_data_source_selection_to_widget(r.data_source, quiver, 'selected')\n", - "show(p)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now try doing a selection and see how the above 3d quiver plot reflects this selection." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "# this code is currently broken\n", - "# import ipywidgets\n", - "#out = ipywidgets.Output()\n", - "#with out:\n", - "# show(p)\n", - "#ipywidgets.HBox([out, ipv.gcc()])" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Embedding in html" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "A bit of a hack, but it is possible to embed the widget and the bokeh part into a single html file (use at own risk)." - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": { - "collapsed": true, - "run_control": { - "marked": false - } - }, - "outputs": [], - "source": [ - "from bokeh.resources import CDN\n", - "from bokeh.embed import components\n", - "\n", - "script, div = components((p))\n", - "template_options = dict(extra_script_head=script + CDN.render_js() + CDN.render_css(),\n", - " body_pre=\"

Do selections in 2d (bokeh)

\" + div + \"

And see the selection in ipyvolume

\")\n", - "ipyvolume.embed.embed_html(\"tmp/bokeh.html\",\n", - " [ipv.gcc(), ipyvolume.bokeh.wmh], all_states=True,\n", - " template_options=template_options)" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "!open tmp/bokeh.html" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [] - } - ], - "metadata": { - "anaconda-cloud": {}, - "kernelspec": { - "display_name": "Python [default]", - "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.5.2" - }, - "widgets": { - "application/vnd.jupyter.widget-state+json": { - "state": { - "09be19dce4ca4e84951953cfb8e077eb": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "39500cb0de6b4d3a9dce8709973cc26c": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.0.0", - "model_name": "VBoxModel", - "state": { - "children": [ - "IPY_MODEL_cf331857d7304e878d780756ff73d75f" - ], - "layout": "IPY_MODEL_5d5069112df047dab294247b40451d87" - } - }, - "3eb7aad0600449a494ba76a739f327d9": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "5d5069112df047dab294247b40451d87": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "86a92b4c1bd44ceba2e819a57513ac8d": { - "model_module": "ipyvolume", - "model_module_version": "~0.4.0-beta.1", - "model_name": "WidgetManagerHackModel", - "state": { - "_view_module": null, - "_view_module_version": "" - } - }, - "cf331857d7304e878d780756ff73d75f": { - "model_module": "ipyvolume", - "model_module_version": "~0.4.0-beta.1", - "model_name": "FigureModel", - "state": { - "data_max": 0, - "data_min": 0, - "height": 500, - "layout": "IPY_MODEL_09be19dce4ca4e84951953cfb8e077eb", - "matrix_projection": [ - 3.017766952966369, - 0, - 0, - 0, - 0, - 2.414213562373095, - 0, - 0, - 0, - 0, - -1.000002000002, - -1, - 0, - 0, - -0.02000002000002, - 0 - ], - "matrix_world": [ - 0.016666666666666666, - 0, - 0, - 0, - 0, - 0.016666666666666666, - 0, - 0, - 0, - 0, - 0.016666666666666666, - 0, - 0, - 0, - 0, - 1 - ], - "meshes": [], - "scatters": [ - "IPY_MODEL_ebd5bbce5b5c4fd89d6871bc5cfa4d28" - ], - "tf": null, - "volume_data": null, - "width": 400, - "xlim": [ - -30, - 30 - ], - "ylim": [ - -30, - 30 - ], - "zlim": [ - -30, - 30 - ] - } - }, - "ebd5bbce5b5c4fd89d6871bc5cfa4d28": { - "buffers": [ - { - "data": "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", - "encoding": "base64", - "path": [ - "y", - 0, - "buffer" - ] - }, - { - "data": "ooe+wpg/YcLIAgvCK+lrwvrSOkMCQxZDeSXgwO9fgMOg09JCghaxwe99cMNrg81CYpRawFQ/GMPMQQnCSlEhQzwFgEJCiizB8ValwhCaCkIwOAzBcTU0QSxPIcJqGMBCMPMPw9yPZ0MyS13CLjgnQuD7WkL8v9vBu4lEwjEXlMLiGW1CHUMxwYZgiULozCvDv1T8wj5ztELsL9FCHEJawy/C8sDkbbFCpjkTw2A/68KWVitDJVwswCLi1MLRqMLCQngYQc8ga0PaosLC7fw9wvhhG8IIVeNCIEunQuaCM8NiuB7DzL7YPz8KCsPJjAXDiNVOwhidEcKH2X1AePmXwJa41MLMGQFCFlAdQgAXjkCklTPD2iimwaMGWcJ375ZCWpI9w7quGsEIW2rDtK/VwTDFukGYUrTCNPcEwzgibcGUFirC3I9IQe49qsDk51nCPAvFQiMaC0IpearC08+ZQuTsOsFJhtlCYtS2wbc7t0KyNIjCquytwkrknsIUxPFA6sZFwvrIM8E9zvVBP5PfwjrTgMIwmvNBGhZAQ/or98I2aZ9DDkrxQNwm5UBnPwnCeti2wkqJx8JwfoRD0rUoQg5n0cFYwuJAII/jwL7dIkIc1czC9GUCw5Lt4cEWf4JDL0KHQkqR9cJe02/C/1lyQgzOg8KE405DajHYwqLFMcIhnL9CZhckQpeYnMIOpITCmBgTwlE2tsJA8LdA0upwQawYgUN20fJCgWeiwcrwusH6uxtDNOeHwWDyi8IAjcxCEK4Lw5LdyELsVmVBZm89Qp8ZQEI7ZoLCMfcDQvwHGcOqNDFCNOcvwnKuN0JyfIRDRnAVwd2EHEPWTgBD/gzuwSLSN0OY9hdCyonjQsZUmMLKIRFDXjAVQ/RnisEOWMjCVMwPwsKRScIkoALDWpsdQiaYYcJoz0PDlpQ/Qk9Cj0JQ+4RAokBzQtqAA0NMiUbCXP2OwptiXEN+eHTCKhl+QqPylD4jZYpBP0wCQ6W9PMBE541CQJmJQrLSGUKS+TzCytGUQrjKSUHDNCxCRY46QzBZKkNyjYhCW77UwUOUAkPgeCpC0h5LQ5EJl8MIgAbCvJdwwrxiFkK4Vv7Cg5w9wkK8okKnFzJCxvdgwssG9UJMKwLDYhJ0QkqMqsLRVZhC/uVow5KAOkP+JL1AZIL0wL55iUJeRzbCuiSPQi66f8LFTEnCPgYqQ4gqbEEMLqBBUZ6EQtgr5ELmn09DjVnNQurElEFWyEZCqsK3wmZ07ULYg4tAExgbQb54EkMl09xCskYIwcKFtMJK0jXDClsvw6/8+UGys5jC6CZzw6nVt0CGy55C8cwlwmzQnEJ3L9fCyhsIw4+KZEOKYKbCaF+IwjaJlkMcp8VC9lL+QYy/pcIINhpDnG1JQqedCsNq9/JChhQUQsTDqkGEAMvCcpu1wj9z1cAoYVTBJnYfwwJkYEPc9eZC3rRlw0aamsKwkDtDduIdw0rydcFyQL7CAOadwpjG5sEaKAJCxzwywRPikkICJAPDNNahwmJwT8NzEKvDvDJVQqQgHUPGQlxCtAt8wlFQq8GgmepBtxAcQbTJCsLI1k1BPkFgwl67KEMaBJTCrlqnwkZr+cLo09/B3XCAQnR40EDKYSzDQY4PwvZCycIgT1LCJuDLwWTtpkKszj9DYvWywheNa8O6S55CPN9VwlanJ8K4cRfDEQjYQmIkc8IEeC5DLsmXwsCKAb3S449ChmCIwlYBDcP2hBFDevXAQo60lcJ2JTzCJ8eIwv3Gz8IE+LvCIlKlwXpW3EIEGepBBlkuQ/I5hEIGxhvDJ/E5QRmLIsPsTVZCdSMeQ0goA0KftgdDNJSJQgPhFMIeR3bBgEGDQ28uokIoX/Q/WkYsQqlzCsMrrQ1C2XftwuJER0IzI57AoY+NQNbhM0IsZsFAh/tdQxTB8cK/QA5C1Qg0w5IIL8IEM/nCzqfUQfwhH0PtVbhBaf9pwjTaJ8FgqUJCtJa9wXg9OELLv45CiJotQvs+kUKa+lLCxvOOQslj+kKiPLvCcrgtQ64hHsPsRSdBOKYWQqaWLcPOTs3BpqwYQoCSUUIhg/VC3peswTC+50LnIldArog0wlSUlUJ6RhdBxE2NQvT+nkLk62nCwON9wj4/tsKQy/1BkjCmQl540ML+C0JC8HpqQysC1MKIFANClganQnY+ncI8JbjCisOuQQzudkK5rp5ClpwTw5rWesGHF+5CMKY2Qgo1jULhfRrDUptyQbLhqz9WjKlC2ELhwbp4zEKCGDlC7//Hwm9mtEIELInCUt8Gw8ggKUGS4ZlCv8L9QghrIsJDHxjCxl2YwULKXUOKFztDoH0Vwgt5qsJkz8rCicAIQj7XlsKakqRA0HMJQ9Cfd8JJEybCFwcjQ8Xo0sIGX6JC9n5mwyWGSMIw1hhBnCg0QVhnEMPBK4hCUhWQQcdXCEO8jo5AyB4hQurj7cKYR4VCq+kCw36yqUCsIMdBiWRKQZPFEkJrQuXCxKHTQb6dJUOGpSNCQmrYQuy2mUFI0epCDOKcQg57osLpDdTBQC2lwowAh8ICd4lC84alQDvAgMKM5pHCeewpQ+HPQ8C8n+pB+GlpQkj3RUO86a3BqrPhwh6E80D5qQBDzz5QQ6Nt9UFRozBDhi2Qw0V1RcP5PR7Dn88OwoKFkUFIelTCXqaUw94QLkPf3pHAJqMCQTYuDcPFIBRCPZvVQrKzesK+OT3ClVslQgKQvcESJMHBCFwnw7xlS8MAPC9Cz0kgwzbGEEOEQY/C4wbMv9yCaMO06bXBUgnqQk3LikHiCYZC2rWewWlhm0Gfsf1CvPzvQFBv5cGF0yzD2682wgXX+b/cgDHDVyRPw/x2XUN8oCzDOk0Uw0qKAsM4RN1BtsmxQl1Mx8IWnq4/dwoPQaJnMcOFh9FCeqjUwnIZCcMFiovDrIwGQ2CQ/8GEQAjC2IuYQoWAOsPaim3CWIx7wigx5UH+74S/IzsrwrB5n0KY0PjBJ68aQ9o5EcNl29FCd7powj9jE0JimEvDGqhxwtwir0KUxv/CDLEKQhDOWMJ25hbBQcH9P/JYAsK5PUZC0DMFQ90U20NIr3zCMoinQqA3KEOYhKbCyryawXS3UMK804pCbVVSwltQv8H17zLDMn4dw6awjkEqkUHCO/gBQlCNgUN00o3CV6htwuKaYMN2eSXDyObJQtit9cH2hkpDtjAFwju7r0KWqcbC1LcJQcqyYELoENVCuh/XwIB4/EL4+j1D0xA5wxS2lMBnOq3CwkPuwvz54UASka7A+DIgw6y+isKm/brCDC/6QXt4cMOu2o7CNKNnwKyHxcFMgyvCmHm+wszvjMLO0hxCLwSnQ5c/xsKsdzBCUs3SQA/enMGvIzbD9Gs5wnhM0kKj5KFCqHP7wk8Bt8G8H6TCv+yDQWrMbsKGdFBCDJkNwsihX8EYyg9DdpfvwgqRQMK+Ir1C0LcCQ7Z3fcM6baFCeq64wow/WUGv6ExB+s/5QZhI7MLu2hTCJKWSwlaTRMOOHK3C5DpSwmt9AcM/dbRB0q5DQvJj0UCoDdfCHK6LwfGrB8IR/ixDjPnkwiJgQkJ2S5DAhaVAwt4nwUJuf9dBhlhGw/OO9kGSO4lD8vU7Q9oQO8Lw2WVCzJ4twyy1dULg6nHCx82WQf9Xp8LZlILCHXigQh7eUEODg8pC9Y7OQpKvK0PA5BZDkD0UQk8D5UJiUoRDJ2pUwdoOekIEtvnCAGCMQwP7l0JAnqLCrovyvz+gJ0OK2zTDXl7mwb5OCsHeZAzDaygQQFQE2UK4GFRCRncqw1Fh/EJI3xhDXAIJQ1A59kL/5QlCSOjTQtnBZMIen+3BdrUjQiatJsNZOXlCTJnpwk7F8MJa0T1C0Gdowhw49sE4E1hChulJQ7pqU0IJ7xDDJt2EQtTEfMMbAJZCJj3Awvo8scLU4KrBLIGywhepvMFgJ4pC0/AZw3b4D0OLYAVDXh1ywh5Mi0JccA7Ddtjwwtjwo8CGb9hCPv9Uwij/P8L6WvBCONnDQm38gsHo5dNAeHCrwgMgSUJ2vK3AbQd6QoITE0Myr87B20P5QnKuIcPxCSfBDg59whZ/4kEq7jVBgvrCQTiOEkOy1g7CNs8IQ3KcBkOzqrBBPn+RQZA0zELK1tzC2ugzQpehPcObbvjCJPE/Qkijm0Jdy/lCTCoWv3un+UKdJE7Cu2xRQze6AcFgu77B+rhvwo7EDkN4O+LBnR+DwpdixsLWAAfCNoL4QYwZAcLanuLC0TnFwY6wB8IZmyvA3YYxQ1KKy0LYJqtB9701Qr6x68IMdF7DRtRUQ4K398KwE1/DfneJwCBDrkIKXPFCuha5wUBzHENOvahB6x3Owj6CsEJi+qxCGvA3Qk3ZWUOy8TTAvpKiwzKi/8JSHwTDVo32QmQ6BMNufVPDWPZwwZSaV0MG9iXCQFAtQi57z8D2aZHCWCVIQuOvNsMgFjdDAiekQgArH0LEFUZCjz3sQuhTzUJq1BlDYjW9QsmwE8LLWShCZ1gHw8hVwUGhz5hC5sVpQj+sAUOvJelD4GWNQ5QIO8EXMpfCHK+IQodRK0A46pRBTmAmwm3h3sKAELFCcOE3QzYBw0LFE/1ChqHLwByhZMFOiffCwN8Sw9a/w8KS9HxC4qEnw1C8vEH8npZAAF9RQ6BFScDGWSPD4exhwp47w0IyMpnCPHnlQk9pvMKiMI5CkuykQjPNFUKJcc1C1Me9wjhrbsKWWvNCGkEtQiiaAcMgGmfAYLYUQ2D6J0IttjhAjHJ1QkO/qcLKpBpDQMA/QhxdvELQpe1BIMHmwsDZy8Gc4+vCf5lpwfTXDkN8HvzBwq/LwlKg4UJxEStBIjuUQupdg7+FP2DDtBUGwhzDVkLK+6hC/jFJQg4ZnEL/EU7CLpMGw64f5sJUUADD5DqowsOK+0L2BhvCchZVwVzp4kJ4qibDjJu0QYILAsHw/ajC9bWswtILHUOeSB7D1psRQmBGk8CXkYhC9TsawvvzD0NxtpfCfvGrwfUs/8GIwSJDOMxSQuhEIMDIIgbCDy40wiqnEkMqfjnDErO3wiTrSUKBIinDl65nwTaEHMO+rD1C+8nMwMLT+7/yi3RBbqeqwi9OO0LoM2nCKiL5wtebBUKap6fBgiHxwuqUZ8I8lJVDTLogwei1yMJssyxDiI6Bw3Ss7sHs5g/Cn3K9wue9RMMSHfpBEnXCQjKoAUPr+CzCgKABQv5gM8BHDvFC2hZ3wpCD4EFSzRbBRM8PQ+CY0UJoFcvBoldeQzaHs8JNtO3B03EMwtO3qEJIU4pCAiXOwmXs0EJIS03AtbSXwOG6gkKAJy0+ROOcQDxXJUKfPK9CxrALQ2AvpUKIOeLCoufpQofgnUIOdgJDZrJVQrbNAsK+e0dDcqt6Qohp2cJVLx1DK4NTQw6+LcNSGfPCaHdxQXZJaMNU1IxATlYzQaHd2cKEf6lBcKpXQyqxMsI+oEnDXmuRwiKRIUILGdJCp2PIQPgDk8Lcx7vBjL71wfCtvEKWSTHD7W4Xw/LKUcNQi0lCqyqEwepte8EYKe1BnAbawsVmJUMUSVDCHUeBwpCbtULBFhBBkf4Xw4wOl0KM3oVCHDoQwqwIZMPtKW/CifPKQroFXcJIbgpCrg5Ywm7FkEK9v2/DFGkPw4DxH0P4dyXDqYcTQmN3M0PSNGFCaHCHwpAFCkLEhR9CKk4lQ8bIZ8PUWpXCKLoqQ1YjjkJkCwBDaMgkwsLxEkPOM4PC/FaSQS67i0LgBgNCmO8lw1pKEMJD55HCZHS+whT/iUKUEI/ByJGFQu5fv0JeOP1BuLVOQir+q8IihkjBhLbMQN5+70JhTolCysAew2ozUz8qmLZCVHXKwv633UKeGibCUIRGwYgh80JCQ5ZBo2xcwXDWjsIEYJNCxtEGwpvIDEIHzkLDLzAfw1hM2MIYhdHDAgQAwEgcz0FejblCpolpws2vfcFKLlVCZfPFwvywDEJ6dOnBeK0yQ73uL0Ly+KJCU5zaQSIL3cJCXtBCnIDxQjjVLUJYnO5BtWRGQ8BXCEHpY7zCvCvzwYsodkLsRErCurAUw70yhz0UM4PC2O5AwTryDkLkw+bCYocAQzgHE8GEuTlDFRHvQqg0AsPMIulCIhITQ6xA6cGa8HxD8AqzwsA23EFLc3xBvuhPwV6r30K+be7ChCtFwsRPhUK1RrZCCvWTQ0udk8M+gTLDh2EAQvbjAMINxYZC1AUzQ6qnM0MGC2RAiuTaQGoY98Jl511DBOFYQ/Ka8MJEEQpDzl0YQ/oUpcFaIrtBuuAEQqP4FsPf3fHCUpwKQyw8IEHKBDfChpCRQfAebcIABH/Dft2lwvofTkKdgAJCpBKdw6QoDsOVkjxCHDy3wqq110JkPh7CPLkQQ+LpG8My+P/B5UyFQoQajEKsVbXC3A5kw/xtQMIGTyrDFEiNwlYDyMB4LbJBdroTQ+ISR8Ay/9pB8RybQmLZp0J8aQzCNqEEw/KIUsIQEiJDSArmwQ8/T0K+dijC0ieTwY6Rj8KCdSpBGhi4Qqj7m0LjDfpCSwx6QxL0lMH2mllD0J/rwfXoNkCg0ijCrEE+wjqczcGes1PC0ipEQvfJ28HC0hDDNKSLwvYlVMIiHoFCqL0QQ+uQ/EJgk0lCTAxdQZNWG8M9apjBHZgYQ53rjb+8diJD0MQkwebzlcJifxxDD0FRQe2HvMJfsCHDRhbZQoK1Q0G2rphCUA0GwctX1z+MHkpDXj/swuOwL0M6fvRC2AcPQ8lv5sEuFm5CJEGYwk6Bh0Isn+JB9HYEQabbWkJcBhpDkLaPQgMCA0P6ZM/CNBIKQkon7j5YZ5xClpkEQsjaH8FmVUBC/rePwiBXc8LOyvbCM5pywp7IDkMtwoZDQCX6wVE9Q8H8/0VCXLURwrgWpULHX0RD6h/1wvDoL0PbxrpB6bASww0/MkNKXKvBv9TgwZh120GoMrxDqtwKQD6UiUO9TzbD/PZ/Qqp0XMJSLHpCeOoLw+PQ9cHlRLBCu1ZCw4xcrcIJ2wDBrgo6w5ixncK4M4zCuELrwKZVN0OTc5lCEyPYwpxOAkIMLcbC8LmOQrxcJEPObFzCoG2CwllCvMLUjk4/Oh+DwroDoMIbwrFCcNyqQbqWPkIKUsLA6WmwQvo5GkJKjalDGuKuQuYgAkHzxCJDMeCrQhrJBUN1hSXA7qUoQkpuvkEUUtlCwAmBQn4RgkIfH8nAGhFXQq/3/MJWBb1CL/uiQgPzjUKIJEdD/lglw8gQF0PNVK3CuKLDQr6/NkMqdQbCwx6qQvS11kIgeJrCmGUPwYpUAkOO2M5CAuMZQ8rNokJcMTTAOiSQwnAKA0PdNsRC5DwGQ5nFV0HIn2fC3JvOwjqpckJWMp3BvoIRw7vyAsM99FG+bhUaw42YWsG3Xn9De7/+QMgN074jnc3AYJ4KwzpBz8IYoPZCLBULw6sbK8KMKaTCWceXv1auEkMAHwLD6H4XQ2wQG0L43RxCsx9fQzTUrcKY+GZC3kYpQ3ZTJcOr/z1Do6mgvwbHiUKpZ0PCNG7qQsT/HcMKllrCyv/iQUC9BEJ2sJTBbu6YwSCtV8B5M+PCYA0XQzEdXEN6zwlCWgPBwgDtJMNkn/nCcL7IQvUKAMMelW7CAKWlQazOKsEM3TrDL2JFwxRpksGMFLe/EmePQlxUUUIK96nBlBHjv6gnsEJcvCVCmYGEwl3nbEH2gClC2j97wF4/tL5knzhDbmIJv0gtm0JLqjRDRILxwkTE5MGscPLBkX03Qz2auUJTICDCN8+oQA9TlkIyYQHDYWaXQkKXhUONX2fDPgg1QkpNUcGakYpBYn65wgIOkkIsv1RDZvQRw+M5C8JIvMrC/AoAwyLFocMYRvLAVBW+wmIaEcMoQsTBZpIiwgZUjkLffuRCClD9QjYCAcMKrqZC3LdVQqALREKfvwBDcHRQwbi0rcLnjgDDnTiewtjcDMNLklDDSDJVQwwlIkFx9FfBoPXoQi0kzcF+WWjDuLyTQXpUgkG8V6vCu2YbQzL3bkLpQTNArvVBQs8buMIv2vLBttIlQjppIkGOG5FCUxVrwsL36sA7Gb/BTGnzwUHMJcGAbxxD+ujkQkdRmcLOHOTCnPsCQwo618BMqo9COOAxQab/4sENHLtCOgsBQ23C4EI0DgZDhQfowidejcLvrrbBk8vCwe7Xk0KkwR/DmjTawvguqcIIuXxCCribwfKBBUP5x5pCCONLQnrcB8NZDidDPMuIwjo0mEJ4FN9B7uIcQ2ToD8P/l/tBAKU6wyRdhcKf+yVC5qHvwqfvAULZw85Cup6pwpYOaMMXAJ9CzxrEwYaHAEMpxLRC9q4FQyS3xkKMYz5CnsEZQ5jdtEKuG8bCBAE5wkp8t8J+4VBDUN3jQfoOYcLSvNNCupVAQzwl1cEoobVCRgDgwtwo0kLupB3D4wRSQmhXocJ2nr5CtPoMQ5kwk0NsselC3BvvwrzKJMMz7utCqFQZQ+qHAUMxH7lC1PP5QsjxpsDkrvzBKoALQkRApMI/8ilC0YiAQY6FbEJmobZCkvCewshUPsEmiynDkrjCwWnWgcJ3aDHDpef+wlY640BSEQzB+RguwYajiENiDzZCDNqtwdIuWULlvpnDRv4LQqyT2MKbnFfDOEA8wtr1N8EoiZtA8gEOQ2oVI0O0OuJCNf0fQxa3hcMukTDC6ogjQUAyV0EgoJbDctuTQjI2iMFIaK9Cknt5QpCvUMK8YErDbNYWwixCwMEeU2tC6ks8wwT8Gz8K45NC0DX1wp7F+sKAsUBBctFpQmL+nkKKvfrBUoSpwUKl0kJzKnfCqrMVQWzwqsJiUkPB43sIwuZps0F8majD/iOnwaRPWsHijiZCcGwKwyiSekIyUenC3lhJQYYSjEKHZIxAJgwlwDJSW8Nmn+pCMMvVQi5c5cLeCoPCUL0mQ9Ckd0LXxcDBgYFYw2wtusF+jh5DIis/Q7VrA8KkCJXCWFHjwhL7cMNkzPlCBMi1QnQAxcIKQAfDMk9jQh6SlsIYFq/A3IsCwjA7GkNdRFdC9Ja2w2YyacHVNdPBnvSbQiaYZML2W+HCdILqQsSosUPF4BTCMRZvQthYpUGCW5fCP+lcQxpfw8LksHlCkKkMQ/T7asMwH7jB8R2zwMJ9YsNo6h5C0rIeQlLjeEGAIcXCnJqAQkBrmkL4NjZBdcbBQgQpDMLoGgLCpheIwjTg4MJ64CBCx6XJwsXSSUGGTuvAJN/EQKIuj0K61NvBjk+MwMy3u0DiYonChsfBQm9GYMIunRHC4UvEwY4VJEMk+ZRCgouVQkAt9b9ScSBD9IhCQQ6wecLeEj5DvSE3wbXLZEKCGivC3AD4QrCxdEI+DSzCjBpBwiS7jMFC4aZCc6buwuJT3EH7RDVAA2h+Q7LduEE4a6RCQBSOwZxgs8JC4+XC9AnWwb5Hj8OZvblCcLazQU4QI0LM35jCTj2pwgD5QMGJVGjBsLCYQbIlEcOohFHCydxUwmwbD8NK2YpC4Mc/Q//Z70AAy2fC3JcmQu6EAEOmunZCmULBQW1SzMK9sLpApT+jwECcfEIE6JnCBgJfQ6yYxkKiVP3C5mKyQko8zUCU9n1CypZdQS4BesKJr7JBqEIrwB9IB8MnQo3CglGuwmXWi0JuMIrAaL+1wkUuWsM6aIpCqGPhQo4kssFYYYLBqGWAwkrYzkFgR+1CTZ3mwaBY20JDbJ3BoqAHQz4pkEICJJ/C++cGwuQIOULKZdfCDJCYwUhLF8OC3he/4rxdQhAENMJGWoVAfugPw7PfNUI04JrCiimLQiLTOkD4ayxCC2kSQTJ0UcIwXgLDFXrnwErOC8POJazBLB8mwzq/0UGSjuBCxoNzQt52NcGMPSLDXAXUQrCQJ0NYuPLBUjdKQyo8WUMI29HCkvQlwp6QREPBU4vCFo8ZQnYD3UL2rQtCQzpZwsWJ1UG8Z7HCLqCbwvrw58DA8P7C8jBYwo4MoEDYsRpC6PnbQPhAVEKj8e5C2lh3wmGsGEOr04PCygTXwKjBrMIxCLBBuJYaQ2wpHUNqeK/BHU3MQiyagMKSznzD5M+sQlS6gMJWc77CPOkmw6r7QkMY/AnDPrUqQqNIG0NE4MnCc/+8wlbON0H0LuZB+KlMQkyPKkK2lsLC6BxtQob0/8FsZ7bC4fmZQd59jsJU2ynCNNMwQ3jXYcIU5z5DJhntwnzNi8BLMNpChAQEwHAd3kJH2iHCIFxvQnIfT0MmfMNBQeQvw6BtEMJ1O+DCyBgow/RadsIamaFBLw2rQZ4RhsKVcYLC/oGIwboAdcL2GiJDtP0VQ9uyHsJkn1xDWbziwhZbW0JJf+RC0aoHQZDmDsNL8WNCD5LbQnjamsJQ1khA/rA2wr6mucGIQBZCruNhwlwsQ0PHiyLD5lOkwolU3MCRRV7CmjnYQQ4jMkOWrPpBgXSVQiA940IcWoZDgocMQyrVfcLBphRBAqpOwiwNlEJaAS7DYGFkwxSBbr6gIONB2aCrwq4rCUNuRv1Bih7OwZZ2tEGDE41CXC7hwTW8JUMDEKZC8g1Tw3x/tkBcqW/CxnH2QUlPh8OgPcy/pIGVwoGVIsJsxaJCuoIewh9ljcBi8GhBU7JZwsO21EJQVijCeGKKwnpbKkMV9GVAiuBqQyQjX8PrFGRDRnoIwg7JxUMPqY4+UD0CQkdnisEf5lrCFm3zQhByusIabBFC2iQGw8v45b9y8hxCYb/ywp7pzMJp1JLCwGS3whmPh8FOECLDfuJEQtBVNsLWYt7C2BbywjhtfkFtNOhBsLBZQ8wrlkJa96hCNv9SQvLZrMJslUJBZQuGQh4/hcIPOZVC9l9Aw1zA08EPYI5AQsu3QUHWq0Klge/CTKWbQpiAwcG6ofBByMzaQYkAOsHWMfjCDJ01QcL5A0LHlNU/mEuSwD62D8P8uRTD7KaBwgbppELAbXXC7BDfQpZGCcNll1pBUqodQ7SpLsOUeknCpSpCwcX/A8Kg8JnDxTeXQeiu+8GiVnPCF3GVwTAHvsIO9btBXiiEwVbVC8MwiRFCPu5dQlBogcLwJhJDhqpGQq7CrUK/sjbC9tu4QtxU70HLqRHC2dibQlg/MUPu+7bBtm8Nw9ReEcPPxsfCvNatwWj7LkLISJPCJgOzQiS1esLQnj9DniLrwnbbw8DsYfFCPeNdQlYGI0BsCopCZlyMQm5ACEOgqhFCkN/3QMTF68IHCFDCBiThQka3UsIAaApDyhvhQvPQUUF2UALCGE0lwjIKNMH6T5TCKCdewnxU/8LaQQPDlHAPwQh2CUMNAQRDDRH6wtJ9j0OoimXDBmYEw668OsGAbUTDlJXZQks99EKy8lpC2QxxwlICr0L/rBlDiDS2wTlJDMNaiYBDBtbKQd19hMJG0iHDEJyPwiEhyMHyJ5bDnhQtQkwjGMLA2CpD6oCgQsSRM0I8MlHAhCsQQ6OXaEIgxaVDaAfzQo60nkFYNa7BvRf2wtATwMGjGEdCacDywmYKXsE6oAFCsg8kQn7vGkJGuoBBfl6HQbCYQsLgvbtC6KMmw8LBAkOyegLDdfpiw1hOIsFgThLCvo7UQghqD8L0diJD2wTcwpiHU8JXRGTDucwfQuMBrUPgeixDVTTxwvmYPUPcol9C/LdFwLYgPkLA/7DCq8/UQsjND0LgbpBCu/X7wnAw78LqiHDCuCvQQordMsMAsqrCk8/0wo7JAcEWc0TCsHiSwtRiqMH49hTDQif4wugdo0LGZURDNSnpwnyzUkKCtG7C6IfGwmxTAsM4dkDDppXywg5hokLv50bBRPdcwnzyDELzYvPCMtfbwmM9zkF8wUTD3JfUQVUY8kHKLRbC9BYwwxxC2kJ2YxJD4JKMQgYY+UFmbDND1gaawjS4u0I9V6HBWGANQsKpFUMW/rFCFOSnwfQVOsOQMKVCrLmCQToaKEPk9hPCHHPswsbquUKOZtPC8tWLwN2gD0Emp03BrMpgQun/i8NG4VjCbhI9QaBxJ0NaEWLBdyVZQwLzDMPIcURA/Ij+QgKfLkIAs5ZDhIsaQyrCiUIi+ZPCLicawxY7G8MGyyLCngtqw2nXFEKOyPxCktsmw1p9dMI8aatCDQTzQM+busI+mVBB+PEGw1tJzMIMSBnC+hT1QsGAicJIwZLCwpnOQWcx5MKVLhDClQ3fwoRMMkHQBCRDS5fjQcy010HuyRJDnrbpQdItL0P4l37CzpMKQzo+EcK4WQjDYE0LQj47nMJY2HnBz4JaQBQ1N8MYwAbBrLYqQp6grkJO6sHCBEdoQ0wQIkAI2/NCy/qDw44nLkIfN69CFEqdQci9ksNebfzCO/OKQiI7vkI6TbXBwC6PQnr9oUGF8vbCwhVpQqeohUJmohPDtY2xwEA3KcIp7Wu/7KE+QuuMAMNGPmXCxEPgwoJcwUGk+frAT6m6wpdWpsJo0YnBkPRTQyriIEKO6uNCSpU4QGyBskEDRPvCgq8NQIhRlEB6OlpCmQQBQ82TFcJxlEdCYkuWQOY5TMHVKJPCZuipQehNj8JrSQrDXKSgQ9YGk8Izod/BYM2kwv/qKsJWQEpCLAeXQgWcR8NwJC7DvA4aw98wM8KmXNdCELVQQtun9sL4hhvClkTuwqbFIEM4+KPCQCyIQRqyscJwzYjCaTUUwxZiWENMUpVALxWYQGRL/0HCj6lC2Haew8JthsJMSwzDnjR/wiMeKL+2S4hBDlNCQjZdukIm/DZBPBovQ8A3/sCkc+JBj9ZOQtqTQ8JIeuFCxGYrQznDTcK/YT1AGWy7QQBV0sIc/BHDCw2cQiR1+cJhi8hCpiGAwpR5REG43BPAJxVjQWpY8kGkySBCSqI2Q1a2KcOHGyrD4vt5wl72lEIGeR3BhBkmQRj7u8G/SWVD3v9hQmoMCsJce39CNHNgwpiYVkIuUtpAGCv9Qni7hEF09ZFB46UvwtZ+YkI880+/8U3wwTk9ZkL+YTPBhKpCw8ajZUN7sYHCtWbJQAQyPkPiftLCwznOwmxaDcHkp2hAKuEjwjM5VUNWRxFB9ekmQlBN9ELi1HXC9iuowoDk6sKbx9fAcrMCQwbJoUJvcrRBIsYzwnAjaUJfrClDBwYpQuxFXcJY08RCNsSEQfDIdsE25IZACIP/QuBSXMLA0zDAHJxwwTKLCUM2uh3D0EYcw67vaEKcdQXDsDolwUoDn8Jg++DBCNf/wWFLwcKpcNxCvJEXQryVK0LulHPC6CWtwZybicKezy3D2hf7QqucJUMGs+RBs24KwQ2E0ELE7LpCzNWWwnqIPUN0CR/CzNyMwsFLUsI3Sm3Dqq0OQiJt9kLI/5LCWrTZwnoPrUFSkY5CCbvnwRIpMsIoZLHCpc3EwmgBn8FWuixDcM+Dw/8sm0IF2jtCTPrNQk9zDUEDMejC9smYwmDv4kKY5RRDsAvZwp9N3sKwPWVCQsglwyJXysJAQBJDei8jwv15B8PyZOpCa6BvQij+VcKOZIJC3p5nwQ/G90H+LsFC/QsQw+h08MJOrH9APkvkQiMHZMKk+CRCwBwGwvKx0sE0VLLBuW58QYIRcUJwjEzBCn1tw/JHGcMcmszBaShwQqx/3cLYfy7Dho+fQpYgF8NxLflA5tf1QfRfnMMzwjxDfncKQo4uv8FW6qRBzK9+QfiOkMIC8bHCEOKeQiQjv0BkyCTDVj/zQqBhP0Kphm/DPfgRwkZp1kLgHR/DxwINwq428sLSEb9BbjGnwazxXUJiD8bCMTQfwrNKg0MuoQPDPnNdwrQWyEEcibFBnCGZwkjJCsPG8dHBr9jgwoRljMK4O5vCSsQTwVKopsFoZujBww0LQCyMH0ISayhDd2L0wnE018HrkdBB9iINwmZtjUDqTfa/fsQGQx5KN0Lx8D/DtjPgQp62xEKTIX7D5KBeQ0ObUsPUGlnBgm/TQjLyh0JmMQHDiLjPwoBCTUPCvD1CJAUsQhyuicEs0/RCtFEuP772ukL0T1jC/BrmwijhycJm+RrDIC4Hwhod1UKfLoZChMjCQZ8F6kGuRhVD+du7wXLf+0GI0f7Aiq/NQPZ/zsK7NZ3Cv99Ow/SCtkLGAszCR0yNwHSbf0IcAdk/7h/vwfAq08ISL4nC/ofQwAZZQMCYN2lBJB4RQ/Dpxz+2Im3C22G2wtrDu0KeCIJCizmEQvN/W8GYKwpDNYoiQ8B/XkKhUsVBxt5/wr+QyMK2qnVDU0eAwvZnxcIGI9HCSL5kw/THHULzKlZCNi/tQYtQpUKC++lA04xMQABNDcNptuHC0fpFwiK9KMPlKSBB3KoNwkwtwUItUzzBzYQyQo9DSUP6rKk/eJ9Sw+dA+MKAfkrD1jS+whyizkFUjoxCuwEaQ4D6GMNAXi1DpUZlweAodsKM/ddC75/wQmo1yEDv2ClDoHSZwoTwr0LAAwFDdAl5w6he7MJVuPbCYCWnQnxIgMNGTclCUo8CQkBclcK6JBFCBlvhwpDgWsIIHC9BgH4bw5HGP0LMfttCC7LsQmpWNkMNZNfBhMrUwgiyxMIjVgxD4541QkQnFMJ1om7CrV+uQk2kxULKs99CrHkhQgY5nUKk9RRCnIt9QqYZ+UJ+dTjDmrCiwiB0mUJgnfTCPhx8QjSRBsNSbjjBQcl2wb/UHUNHjCfDcFfuQThHy8Ku9yLCLsW/wYvfJkPW4bHCDFXHQqDol8IYErrBtfbqQuKtz8ASHM3BmtqCQ0LQgsIpzeNBh15Lw8b3csOCxArDVMQ+wd5LLkNyI3xDLotIw+I0VMNJEp5CbmhHQf+vhsKhngBCd/EzwxwvVUK4clZCKJ7BwuIBHkFQ8StBEp49wcDGz8JS3TrC7uhDwTpGccKQW1jCggqeQfDtdsJexKPD+hewwUTNpEJXqjtDW/Gpv8MrqkE1/i3AOhQEwliTN0L2JrNCbKEnw/Z4A8NGCCNDYX5CwzYtcsPa2XRCXDsFQ5aEiEL8oE9CdYocw6A100JsWQpDqTtewgrSXcN8E8fCDxDSQlKIfULKKlVBahQxwR7JQsNC/nVAXNdmQujqXUOZXKjCQBAKQ3ENAMPwYq/B1ue2wqItZ0P12bFCL5gLw3uYi0OEfj7CLpfOQO06k8JFJjpAMK2NwCJyA0JETKtBUOSxwdwjmsJQ6erCnL7BQsKzZUG22LDC1hmIwvhbCcPu91vCusUnw7OCNkJzE6vDJjqdQz0M1kKwXaNC9i82w2hX5MILzhBC98z5wrwE00H6uxzD+S0uQzaF38KW3e1CivU4Q8RgEcJi91/DT9GUQu22gUOqgFRDwNRhw1U5wsKa3wPC/Ad5QoI9kEJKTG5CFoY7Q+YyJkIB37u+aP9lQlkqlkL7DBHCjtHYwfdzhsLcqttCV0kWQWko/kF30+zCyjFXwgaijUIgfaFC3BV1wp6NicKgQfq8CFA6Q/4cYMKglLE+DPR/Qpf5WcKUt/1BcA2NQQ4g+UIACiTDR3XGQmaoC8O9OXdBUOyUQry6JsMolfpCKvtewqfC8MAjOfXC02RAwC/EmcKLdizD7n5cQoIcSUE0AArDSvGxwqhHo0EOlRRCMFxywzlVRsJUiJDCCpNTQ41PIkL6A37CavUJwygmoEIioubCZrIWQ1C1HsO7k3XCFNYowcv0akEG52lCIq2Fwmye10IX6ABC9iKbwVIFoEH+RHZCUOh9wVT+d0JJQwfCdOXDwm1HjsLNJ6xCKZdYv/oKlsL2ijZDbDeOQm3qAUL+WgdDhksPw97yHULyBA7Dd7TvQkzEacKEs7hBxiDVQUpql8J33IBD57wsQwrZZUJgoKJCZp8vw/pKLkM5J0PDl6T1QojxDkJ5fAbDAEsdQqCY10ItxcU/Qvl6Qlcn8sJFpF1CgtAVQ/4jC8Jq7m5C0qZuwkKpAkLQTw7D2mr9QvJTj0OcG47CaqNZwqK06ULyzsxAZntgQ3yM3EIiA+FC9miowtxsGsE00GBC1sg5QpsYxkIQV+3CG/wXQ0co8cG+7gXC4lwHQ/UmsEKMSJ9AsrqQwP56PMCIAFDCUiXEwu2rmULoXnpCTQzXQhT3BMJifGbCpeHgQjVjpUHA9bpCcFoJQiZqqkL7CEhDurPNwQTogsNKTldDTe96Q96uZMKwkrtC1paCQvy7H0PGcK5ChkkHQoCPrEJbltRC2caJwi/5C8Gk94XCuhExQ1RKxULw9rzCmn7XQkCGFsNcYwTDEvcLwyHsWcKqMhFDENy6wlNLDMGIIplBHu08QsBqFsPzos7Cn4q3w/XaOEN/awfDik0CQzoyg8PKcrvBjiyYQtO+EML4/BXC2AZ4QggJbMEug+rCsoTuwsikbkEUVvPChuywwlFKB0ITmEfDbEgtQ0gGg0NNHas/GONrw1jqNcNkVJ/CyErEwViuQkPgdEdDMlyDQlbySkJcoqBC7hygQYwgIsPSUInDK34GQxCUDsMsw7xB+QLSQg+B3EKpLtjBhDgUQivYRcIUSbfCDqD3QkCaoEIcvoNBVLOmQmL2ecJQS8tCgPXfQGHXO8CYuxjCZBlTw1h5kcLWHZ3ClmFeQhZ+icLsC/u/4DP5QTht3EKPT2lDGCAqQxHBnUIzvWpB7i3JQf5GgEIfIzDCg9F1QQUqgkII3P7CbAnIwaxEesL+HvzCx/UFQTKgvEKcBIbCsDcbw8zMF8JT9AjCmwfewbpSIcJrjWLBPvP+QZ5ZiMIKzjPDfcQ6QoGjm0HpWJ1CIzqYQvrMh8JHBJ9DogcxwrcdekJqoZtCtmAnQ/irpsK21tJC56uowo5CIcEaLhpDVzMcQ1t7usJ/5avCgNjowYyKYkNmei7DNup0wm79lcJo62BDidQMw3cpIkIeyBNDbwa5QuLj9kKsgkDDXro1w74YiEPn63RC0+69QqnvsEEUcnbCxMT/Qj8Z2MIAn7FClkjzQtoFzEBS8gXDeqD5QgTgEEKiYVdBxrRFwlhTi0GwpptDkmhCwJcikEL0sTrCZlAtw+jOy0K46ujCfrqawomr8EBNKaZC0L6uwpxM6MKGuLbByCY0wroRS0E2X8bCXOcFQpyuf8IWTd9Bx7NyQivds0JSlsBCDx5uQkifgEHc+oFBmsP6wQyknUJ6yLVC1cGjQh7mBkMAR7vAuj0TQhCu5UEsBtzCqLcAw7wnI0JWv7fBeIk4w68wDsNQY/7ByHu7woRbusKsiR/DjGbZQWC4r0Ejs8PCNA0eQcj15UIFnnhBtR6JQ+umHsMGfSLDoCU0QrrTVsKgc5RCelnrQihqt8LEwCRCe+IcQr6L7EKw79DBnpIyQo18AEPAaNhCpvSlQtotiMJPD4ZCc/iOQlKTikLAZuLAxozkQk9qk0Aoi9hCsqz6QiQ1OUAolOHCkNb4woqQnMGwTs+/K2qoQhDMNsL2rDBCD7SaP5w9kkL0LHnB1PVzQjBW7sKJozzClqgMQjJPl0KuJLnCGhfpwke/p8LAdCbDFlNDw36bFMOpzNPC9KQ7wY4WX0J0KM1CaEYeQ/p7DUMmuBBALmEnQsVIPsM0UQ7CFrnUQhFMgsIIaBZBWrKRQtXBQ0F0tN5B4lNkwjTFEUE+thdCcZkjwyE7GUGs3HTBVBgVwzeS1ELg7+PBgKlrwsjyy0Lw21zDigNsQkJE1cB384BDYMRgwNZc3EL8N29BtCsywhqHmsDtGXdBwN3KQc6+usG0sq7DNtkDQjB1E8Ndx6tBymrfwdaFZEFIvbnCHmuowr6UV8PC9IpCqBj9QkSPbEIwXTJC3trNwS8xPUMklEfD8tV1wYqY9UIe2dRA7qiiQEThnUMonNfCALYswXbhMUPs/zHCfHLRQF07RUNcc4LCVCk+wXA0gUJQjuFCfa+CQj//9MJOqPLBgQ7ewLebk8ErDhFByjjxQvXh9UIoXgtCNKG4wRY9EMMA4SxDRosXQ4JIGEOSHRnC2O6UwmF9nkLfInpDlLTRwZrFU0JQ0GzB5wGgwvTksMFssJZB51gUwvRW1kH3J1VBRsxXw+iAjsESyUJDFTqjQQFj20LIw/JC6OmcwgSGuUIOlZVD/En3wVLFpMKd+YfB5nQHw1bMskHEtZJCLtsGwyHtuL+wqQFD0gLlwptt/8EGc2NDzj6sQamxZsIsteRCEoTfwf6iO0K4zQ7CYOShQdjXf8GqqoHC7Eeev611PkMG0vLCVidsQgASEUPWyVzB7mK7wYa8rULC9AnCfPx9wVLywUJu2QRCAu0NQgrwCMIutHfCz6W3wi5w8sLefJpCPBYWQx6+FcIcUBlCk3qDwjJrV8MkuHzBAvMjw6FAscJ0/GFCCGUowy1JFkMJB/bC46R2QrqWP8EF5JPCAExnwAq65UIYLGJAWOumQuis20FMVC9CmugSw1iiRsMgSzdB/M/Mv6CiHEEVkLm/i7QLwxCcQcLoayvDHgAUQ0JKMUOd+bPCbwD8QbbgOcKv3x5Cji3hwOr/H8NAVSPCJ2M+Q4qLp0Is+zDCwL/OQsbizkJ23qjC5aCZwqsqWULHeaDCjNbnQorH+kEdsXxBSR5XQ0EOckIvCQDCQ3aiwjQOD8FaxzFCOdXzwdgiGEFafQtD3twhw/WkHkLwLbNBENvFQs4dGcK3xx3D/qKOQYbshUKlmFTCGNkUw1UDF0IqfaLBak+ZwvxHmsLQ7BzDbDTBQq4F6EF66D/B+sx+wsX3zcHkGK5CqKixwrsfKMKQGTHCKAElQ+SC8sJIKe1CoE6lw5bZiULPphhD4sdVQrPIl0FekETBkUmVQSztV8KUmSjCznk2QxstOUMEc8hBNzxtwiOS9kHUI5zC4Dwnw3B6McJYBHhBVGyowr4NLcFLhRNCse6twArKp0H+6O/CelqGw4LWEkPI+fDC09TNQOKflUOzLiNDLfhWQxD1+0AYszBB7T6SweLzvsIgpXNDElAIQ6CQnUElgDZD2X+FwT3Gz8K87jfDYGqLwf9NZkJ2vH/BODMoQZywg8JSqxVCdq20wZRh1EK4fnBDpsaMQghbS8NlC8PCfqCoQgx948GBJBjCPFf3QkbDJ8OKA4jCCDVCw2/5wb6KfJrBgqsLwmQhKUNGX+HCA8cbw8cQj8E8jJdCnI0YQXAtysIg321CGqIzQXL0XcGCGqbDWnoEwmPzCUN0TjFDavwtwqjsA0JmHWbCiogYQsApjULuwFnDsHFoQsRBikIr+1xDcu8UwwRuyUJYKwlCjYVlwgx9acPpFQfDdAiAwqpq0UL8sSzCeMEpwuqv+UEYo3LD6owXwm8susIIreXCtmT2Qdo1DEKqUAFDzvp9w4j1pcJ+jaXCor5NwsjJrsGR28tCNEQuQ8C5a8LzL6XDjAkVQ4c9AEHwoT5DkdK7wkxGrD8Rc8rCrDTOwc7IhUJzGgRCmJEDw9QmfsI7zV1DgN44w4I5s0KBGbxBtpXlQc6sCkO4u5XCemKbwuLH4MIQXdFCcb8twmLa60H1ThVDqqoOwvZDfr/4mlTBbqOEwMXKKULoolRC8K+Ews5ii0IU9SrC33IIQoJMBcKwL9fCIq0VQ9K3DsNRCBNDIiZPwsr21sLMbKFDzhbOwniU6kI7AXFChpdQQiaQMMLl6DfA9Op8QSUSqD9QmOvAOLXlQu4UgcJa0udBFcylQuJCUUImbCND2gl4whsxiUIRVyTCogg+w8LSpEJEpojB6GP+QkAdecPmL1hBODyHQcKi98IWk0rCN7nhQlkLE0O+knBC/ykWQ70GtsGs1mpBmuQjQz2UisEVv2lDL2B9w6cGgsLqOz/C6G4lQnwHmsKIwaXCMIUFwR57WUOYB/W/Wn2qwnxDY8EOwdnBMOwhwgyHJMNkYFpD5kPiQQcJ1MIe9/BCKy46wphGuMKeLV1DOg+7QrBj5cGSc5pDqmZfQsUY80HcKstBDs6CwiBzhUIWbnfCuFGCwcCsOENNFMvBaogKwBvxM0JqJHZDhEnpQkjgEcP+eYHBLFawQvdQhr96W4xCtAaFQt3EykKE0/dC5qOOwmUIAMPlZ0NBeNlhQFjboULkwApB4CrbQYjzCENiKIlCmsqNQratnMLG6gdD5VLBQRUTMcKo9JdC1D71Qs2gvMJ4Rd5CbpwfwhLVfEAQQBnCGg3RQi6MeMLC+hrDfRSLQBDHC8ManK3CShMtQ+7EXcCOQKPCprYDQi5p0kF4mMhC2uDQwv7aHEMIg8BBDTCHwhPElsHAMNJCLe5JwZ+jQEPaKghD6KOlwS6fmT8cdYJDHK0KQ+pm08IEDd1C9eUDQ+aLK0HPSmfDzLkJQzXexULWu2PC+K0jQnDbc8LUo4ZBl6Q5wtrjGEL6nNhBCi0kQofEwUICEkvC7sEUw74qJkOKthvBZuKbQYYssMK+3RPD8H0VQ2JEe8MqSg1DiPHJQvYMZMMiQ/nBuE45Q+CzT0PIj7ZC7jQmwQTAgkOE2BtDMKQDw65cM8EURiLDcuxfQ/BziELae5rC9x0AwiF/qMPeOfZC0HJPw8s6LsO+V9DCNloPQw7LPsEJ2RlC+cQhwkIJuUJQih/DfE+vwlrHNcFRoEhCImrQwm66UsJ0jW1DBoMcwtx5ycH0NvJByFpIQ++VeEGCpehCYnyQQWyvX8K2pJVCdlYjQ2btKsK83wJDUX4XwVr9NUGtrulCOAQCQz3hCkNo/6bCSq49QJsTAULLTqxCgJFowXIXIMLihBDDEldaQm0qAELc26BCpsIKwlND0UIp4cPCpt6qQvZpBcK2vkBCtr61woiNM0N6R6/CUgkGQ0sDAENSzynD3RSZQo4etb+vTg5D49utwrSA6EIOcPZA6HgaQo9giMHGqg/DJrTHQlZ8J8I2BplCdlZZQcgzrEHicw7DkCEWQ04MEsKCnvDCAHLXwghieENbdnNBnuRowlJFKcL0HRVDUgYhwjA1hkEuqaHCduMXw1VihsCSvLdC3xlxQpKGO0JCchvDpphzQQgaFcOe6s1CGLaXwxYk30IMJpTBOEZOQdS1m8FSRTRCXK8EQ/gKNsFuWUFDjIPNwjhH9UJ0JsE9EKagwtFl3sLAdwjDUzipwk95RMNAycVB+nboQQD4DkKO3q5CfBbFwiuvbkN3GY5CNtvBQjKM5kKQIoxB9B+lQqbcokLqUjzC0mrGQifwEkOyYZBCgOjJQgC6akJjGJHBnCYTQ/RrjEJENYpDNMj4wqHnw0J3v7PCsBmIQi4eOEOiOVxCKb8YQ/QMskKyxwxC6Ei6wpC1XMAK1I7CrDaKwfwPtsINZABB+GEtQmlD+UJarq9D9IA+QSKsPsNExSVD/iusQnJXAcNk/n1CisXVwhRmKkGHARnAUjhbQXVcJEP4mYhDfrMOwURSHcO+z5JCkFkWQzZ0p0IKj3nAzpKpwgw/PELJnBND6t+xQpXsyUK4XUbDB6eGwfT2N0NmajVCVazZwtgHUEMiW79CBBE/w3KphUIVyVRCaDUMQky2HEPETrTCUHkGQmz7AsH+6J1BJoAlQ9DTjkJSYaDBew9ZQnoqjsLIPUzC1gC7wiQwacIMigdC2xOjwp2a/EKwOV/CO9iHw4QBU8NVberCQu7+wfiUlEIqxXXCsjNlQgx1gUPjfbhBvIdUQumcucLiBiVBPrm7wnOBqMKADSHDfPC2Qh4xcEIUxXzDhHUUQgwg+MEAWaHCi3EEwySHsEOu2e7B+gUIwK0OAEN65pfCKGvdQbh3tsE5NyrCojLvQaIgi8OezIPCI8a8wv9GmcJM2R7DuxdrQvZcJsCk3F9BY7QswebEE0OM1BVCoDfDQjyANMKk1sRCEq+JQp+wfkGi/OHCbzaHwrOUnsLXCErDc0WZQwJhw8KoPwRDgokpwuAgscInW4zBgKElwrS6CUPawYlDoD1hwniPj8KEiybDpXeIQhLoD0Ovmd3BK6y7QS8kgkGhRJnCfJiKQsJ3TcPJqbJC+NsLwvlKwsGChTLA1HEUQByogkNphrDAzF/9QXFpBkIY6J1BavDxwmQrCUPj7VFCON3+wuo7xcKeYjHCcuW0QjY9RMGSiHZCZwYAwlJJncKh9ZPChldyQiipO8O6JxDD1XerQn+o/0Av3q9B7Zdyw2JALMKwiIRBKkjGQu7bzkJqlt7CBnPGQf7QK0KXMedBxMCOwY6vv0JEQlTCQc6Hwt5AV8LAruDBfXO9Qqy7KENiMJpCJDezQmRajsL6RM7BUJv7QniM8T8jho7DqfiOw7YRNsJSlshCdljUQurYG0N9VgdDoNQwwedAH8MW54BBvgr7wVBGX78WRZ5DKDbJQi4QhMGMOh5DjDNUQjjmLkPKMsbATh34Qc5GcENQEAJCJvXpQrggd8IP1vfCMCbIQha1QkKM/wJB2XGJww7qDcI8Mi5DiHu9QdSy0ULEdhZDxlyKQnyUisHgI/lCXO0Rw953YsNQLwlB9sD+wkHP+UExZGFCB7SsPtTAHML/hfbCKDBDQNARVcL0qqvB1Cf3wqs9l8LmZKVCrrDWwM5FH0N0Ij1CPCq9QGovS8OmXjrB16Mfwlc7lkFKEalAjigEwhyIBsPeMf3CZ87xQuoZrMLEFBRC9/aaQgzwrUIVdujBGgRMwJ6maUJGX7rAO+BJwiK27EKZohdCp6hEwqbAkUL2xAlCcEAwwM6UKcICxu3CwYpYQ5U5er9wGw7DTA+SwaU6pkCCKpnClmyjQj2dLMOTLaZCRRkcQ6Rf/8KyS4HBo0QZQgGQCkKQiGJC/nCcwgZIS0HUSljDnSUWwtDlKcPnBTHD7tOzwoeRtEIB/6LCRJYpw+0l88KTXKtANL8QwxLeTsJGjHDC7jGlQSe74EGEvi9DMpIFwiqpQMG42rnCDyj2wkZbEEFEoGzCAfJOwtJmY8MYR8TBOv18Qli8lUJZwMDC4K3oQeKWSEMydulC2d/IwrAK30GxeXPAQfrDQjk7+sEazhFDsIvFwhtv2kLOkhPD6dRjQ+7oikIejq3CMBonQhZ8fkM+RyrC5/8cw/VPwcDrQ0LCEcsgwVh6cMLexJZCZEb5QNps9UK1ar7CZP8yQ6wsecB9A8PBdcjcQeTKhUJYhxe/P44fQNRC08IoiWdDb6+DwaJqecKWRWzCBK1UwpY6UEK1Xf5Atpu/wrbOEMJ8P6PCfKuywub4K0OIPOxBMLqdwytHi8J4/RhCjPDzwgTpGcDIAAjDyioLw+D0rEJRRiZCXJHdwuBBlsGV2fjCdzgaQQK8R0IXWAHBtLwsw7yZfcLEVLhCPrBAQrf7IEPBgiXA6KweQoR43UKmpkvCaG+Dw1QkwcGmfpg+ih/4QISwf0KnP85CgJg+wkSBasJ43KfApZZtQbJFS0C3hwbDWivNwpiGe8NCq8lCYtOKQUHbCMPYfwHDChm+QfjTeUJhv5LBcjWNQkQL5sKgdVVCe4wyQ/JYicKFCbTCnO+qQVBYCENyuzfDbErVwnJCPUGS+dZCHjKbwqgI+cIwgdDBHIm0wki6jsHmJ5vCpkkbQd4za0KY+fVC+q8pQpI1GcP7P7lAwbw4Q+g20sFMTUvBzh0SwnmnK8M2MCfD3nqzwpyDNkLcLIrC78G5wiJrecKyniJCa/I6QLtXbsI4d+TBfvcdwwfiq0J4qNFCoYqWwmNMAb8PaG9C3s2WwspADcKmqDnCgFkIwyRC5MIkchVCZJArw8GCVsI4MX1DSpLnwug9fUL2TvjB8EVGwxAEDsJeLORCCP0aQoEEgMCyWP/C/ebIQq/iScNoOLvCJ/MJw9lLJsL75hJDgn5eQnTGIkOg8TXDJv4HQl7SP0Ku8AXDqAWzwkrT88KXbI5CsLVxwQKPbEKaiKVAAmurQSQWocKOrizC34gBQkjLiEJtmeTBu/4/wqpst8L1vUXDUC/kQrAgBsPA7gBBZkwnwvVb3sFcX9tC9L8dQpj+e7+6DLBDnQy9wtqnDUKMxFFDbkSUwihnG0P4Sf9CLjEkwtt28kEXLvPC4DEgwgk+dMLv8hlCtQk3Qw32ZMK0C9vC7TMMQ1B3DsMDIhLBHq8OwyW320CDtsVCBmq3QiBosEI+T/PCb1fqQJito8K8b5pC8lPYwYp6BMIerEbCNkoewzzwUEI1roxCA+8zwhNpPcOWClDDiToswQMswsJt7w5DLneAQx5QXkPyKrRBnrR5Q7RnnkFy1vHBkpIcwf9k8sG0hTfCA+78wnWbUcKETFDDFuj+wkRkBsPqof1CnLOFQ11/GsIKAARCWdAFQ7qg7kLG7YTCRA00w8LSMkMyHzLC1J7mwlit8cGdQSBDFHwIwcq3tEL8uo5DppTaQlKrukHVb69C2u0qQ84nrMHMgeLCiB2IwY6FdsOuIMRCGqWuQgQtWEM3sq1Bn7Mzw4opPkNY/CNA1+W2Qm5Ro8LQCWBCuHcJwrhPAsNG3NLC+Jy7Qh0YisKTI0xBE1soQwbLjkIUjwbD6FCcQR9BGsLTTWJCttURwsFgGEPEfQfCrF0cw9blnUIe07DCmF0TQph3EEKslgTDnp7Qwd/56cLC/rVAgaGKwotlaEO5kztCCnuLQkXIrsEuRRzD4X6iQjADlMKqOL/CVn6IwoYLIcEWz/NCHrUEQy4uAUOcrHVDds61QjSgGcL8JcxC9GMAw/4XT0OA/45CUiBSQUTQjsJ0hqbCZiPKwqml48LUWozB/qTMwYBYA8NhrnrBF+Okwgwh1sK/885Ci+NsweBmYUJnYm5Cjtq7woBd1MGy2/PCUH2Qwxjq9z9s0DZDJkuHwgvBnUGqI/tCaHE5wxAi9EGkH5RCvjctQ8j4CEO++VbCBxKjQqqIkMIeJpPCnxW7Qm5giUJCRgJDIAAKw8Olo8K0otxBkr43Q2xTNULx3oBBeV0Nw8w1IsMsjXPBK/L0Qkb4DcJ6KyHDAOU3wgjM/EKvjbfBGzYcwxyR2T/OzLHCTAJfQIpuZMI3hK/BR2Y3QyzpCMP5DGvCYFHCwqEFFkKXlw5DoIuiQKbHWcM3TyxC9oCiwgT2xMI4Jq5Cjh+CQyB528KAkZbCYgrdQn4Kp8JmkCFDuCLbQtjvwMLAsC9BNIyjwe00+kCN8yLCVjjnwoBCJ0MOMxNDttIgwq73U0EIOQ3CkkYsQ6qG18Fgh9JC23qHQoINDkMLRxlCtBmQQjeWjUPGOt3CwMj/wnKhqsIE2ybD4IQEQ2bq+cC2bLBCX7ZSw26urML6lLHCnoy6whajNsKUqflBTNarwl7bCcNWoULC0iepw5rYFcNUEa5BHjtkwMiXp0JANyZD1ikDQxDh2EIMsJjD5RqMwRzJJMNW8XzC7AjoQmXzccL813BBJiecQrHSG8N+8eHCamFKwWBXgcG0g0FDoEWDQmqasUI0f1/BimhBQ0apoEJWi0rDivpVwi0czkKoHYDCRdaIwzOnAEM+ZDlD9nIAQ9A9tsEa31TDpzovQhOXwELgt4ZCGKDNwYAXsULWlC5DCKSdQtxOv8LQ9QXDuspYw5Kxt0GAg6dApBf6wnApJULcxqpCJLgswzdyxEIUCClDp2ssQnwuFcN6OLjCkiiGwjC1ccK44cbCQvlaQnC050ECFhbDAvUGQ5ZpskLyJXvCVGPjQWhOs0JwCInCOKDTwkOpXUK0bXhCjKxDwwGNWsG/VwFDiCKOwl9WdsJKKyPDAT87Qp5DAENyZsbBslgWQ5Lh2cJbtYpCCpMvwy5uUMMCjjdDIo7KQM9bPsK8IqNALLc8w9aAIkNC/gxCEX65QseTDUOpHjHAxiwlQmivE8KkhYjDatEgwtVkkMEAtBxBxFRPQjLwHEM8mILCs9vuwZDBmEKi8gFCw7Rqw6e6qEKyGUjCDgpzwRzYPUKtkqhCt06AQmqPr0J6Z5lCfoXDwiVcKsJqJQ3CCNPSQsbyl8KIEDFDSccxw0gmt0LoCB5CZwQKwyvFAEMCRj9BH6HNQWTe6EK44Q3DsM4Iw+oGucGFak7CZuWfwOpKY8L4bo1BNhhrw0REE8KFGIVCGRtBwrYbzkLUlItCPuX0wlJQv8K231vDbkUnw5mmI8K+pyfD/pnoQk6etsJqNytDFnqSwiBUB8M0b8LCnZ8JQVTOiELaa4NC7FQKQ1ZCIkMU7rrDyoK7wnj9+MJ65i3Cw5gGQsOOnMA3aI9Cak7hwSZET0LoN8y+uezkwbBA+r3UTDPCXuSawr1gE8MnQzvDpLX/wrKYxkEFQgBDJOUCwpQLbcO2W/jC998kQhauJ0MOpj/C4nvewobjJ0HWPyFDpF2rw8XBP0JwfN3CzW7HwslgKEKGoDpBxH5swQqlbkLJERZCKQ2ewmGVuMGtJvpAl0D2wtcZ68L2JwrC+AtDwvsYH8N6p8RCoMnAwUR5scFVtOJCEsz9wurbNUOh07rCdMqjwrB7MEJgaKRCoH0NQ8LPc0Kk0g1DGm2NwrtXVsKAVEpDy2+wQM8S4EKadrTC8t4IQbzoBsJw0xrDizmCwlitUEIYbxDDNv0WwxGhhUIAnw7Ddjn3wtc+2MKAiztC2J8NwhhVtsJm6hFCNMnzwhx9Cj/MGmxBq54oQ4JpHEJSgzbCgiy5wZQsL0GwNRVDzfmzwSRaR8IbTDNCFcbiwnZlA0IAeybB/lE1w9JugsO6867CGftHQIAtacHqlNE/7h2LQrZlncIOi7JCtEL0wVQY90JPpS3DRAKAQfVeN8MS9NJCLPN0QyCN9MJanSZDejmgQclrGME4fqZCcq4TwwCinsIIqC/C5CMyQtBmxMLEM9ZBk+ArQj6j6cLmGDfDtkgyQ9bL6sIA3xLCVaQCQZ6tH8ObDxjDqXjBQYiUg0G6RutCLhFqwerGjUKX6tPCLQpQwgaaycLU535DXkhNQbK+I0LA2UlCbX5jQsYPJUOYJ/1CJ0WWwk2z5kJwbIZCoG6xQT/EZkDKMmdDcBMFQSbH2UK+OgLDzpVaQ2gmkkJASJXBwARuQ2iLnkHxDIlCWPt9QjAP10Lxz7zCDwbsQTkoMUBZ/yrDjMbnwpKZ9sHGrCHCJ2ctw8opDMOtPWVCu/tRQYhz60CWSZnCmS1tQvsjlMFI3OnBf7UpQt0Ln8HObulCyhJNQtjIv0FwTBFDECUJwiJ3nsKDkDZCWphNQSIzksL/SILBtDkCQ45kE0OGADzDX7TFQrgSxkKpXdrAxHCrQrYm78JKRBfCfgjcQU+HjEJM0gpDVjLvwTkPqcKcziZBL2BRQr5a7cFw5ylDAgGjwWzCEUJw06hCzm16Q7i/BL+Z3xdA5HGJQ2b740Jsd2fDd5dpP8AtxcK8cpFCrk62wuO5WcHIcNJCxpg4Qpi8BsJlYX9BYPJPQuwspUJGWg7C1onIQOzZDcO8tTLCGUJ/Q5+OZkEizgvB0blVwnguBMOzfAlDiK8rwbtUGUI6rybDpd8TwktdO8PzYg/Dkmkqwlx0NMMoeh1DFpsXwuVGBkDM5c1BWuuEQ2jtXkOLAdfBgPHzwQTESEMiJtBCBpmewhpEI8PmZA/DXl2PQyg7QMFAdNFCmUgCQTSDrsGlh6bC2gDrQhoWGEAjFMLCxXV/QPCLycLsyCJDJAS3QosKCMMv0BnCpg8fw+t/CUPHzwvDgsGIQ4KeNEME7VrCPtImQyNCGEMM+65CaPwoQgpz6EJAeEfDHZkZQ9su58ElKHRCR/PywqA9n8Lw/7bCMzSFQyBK7sLCoh9CJAG2QcIYdcL7yYNAMXDVwmTcxsFcuBFDY3bFQa5CP0LqiUXDNgsTwL5JkkLIWipC42ehwpwos0LhlR7CBKK1QV2nskKfu3XB7DI4QvhXpkHIqSXCcgOUQdn/okLOIRhCCeWjQhLJBsE634jCiRsLw5pxUULowHJCrHfcQsLiOkPGplTD52KSQFImo0JelI3C04YBw+pb40LkQWdCWXMeQm4KtMJUZZ5BV4Z0wlkVRsK01ePCkkKRQXy/o8ImSKdCEn0LQ5QAdkIEnKfBTcU7QxbKjUFJefVBGPQiwrCt4EFkgRRCRmfDwv0pVMILPiBD4+eEQWY4L0LkTLlCGbwLQZbDD0OGjoDAAtq7QnOdzkIVHixC5Vvyv8A7ikFIx8nC5GUFwkHIEMI3a83BiMlaQzYU3cKzoFVCQmlPw4qEG0OeYk5CLMMvQ5DfVEN6vp/Chi00w0iGskGWKlfCpuk2w0ZJqkIyloFCijNSQeytSkHCapDC7FA4QJdud0IZ/FdC5rdXQYOSVkJwp5DC7H9AQ+PM98L6KmbCvMrRwiJeFsNqggrD8O/FwkZD88LLrRFC3QGTwv8WmsI+EwNDyacdQ72V+8H6uR3CSCUcQ5CcNsP6BKLD+l2AwTpWdkIwoU/B+o32wW7ZEEHmCxHCDNLdwth/8sJmtZFCmoLKwRKVGsF4GcPC0nDpwqC4sMI8OSjCaCIcQr/vGkGK2QvDwHe0QWS2SsMa+vvCjVBQQi09tL8E2NrCqMD7whiPAkH+eNZAvt8cQtc2kkJE3RlDzHJSQk7oBUAy6wO/iMQXw2B1aEJwB5hBWbYCQ/gX7sJTyrvCuo1CwbhDlsGUrRnBqLuSwhzAuEJWGkrDa+mtwpaSCkIotFXC5ngqwvT1UMKOHu/B/FaIwvWZocLultnCUFOtQS3MKEHKeDZDMry9wtT5XkLtMJVBZ6qnP4CSfUEYQyBC9kSvwkiMU8NsooNDpTXtQVLH/cKj1gNDttSBwZ4iAMJ+0eJC6/3hQYLrW0IAchVCvvIgweK6tcJTIUBDavlFQ17YV0O2FhdCqiarQoEeEEPwYLpAmP//wkh6pEJvSOvBBy9VQoFIB8KG3d3CbCKewaIEr8J6+4ZCWuuMwor3GcILDszBmJRMwkE7xUK+Tp1DxmYXQvKylkKMheXCutq3wgSXVMDghRpC/ehBQ4evDkIl4trCSQzyQh47PEMsCQ/DIXPaQgnm+MCkqZrCyPTbQRQaJEMCSLlBxDfzQW4mtELtCTFDZgmmQpBoScKIvYzCnlrkQiBqwEJGU1pCY+6NwjDubcK6IJHCTE4Ww6d/kUE+aYW/RNJeQqcIRMOQCjdD8Kycw9eKiEGYkazBnxN2wi60J0MzsNbBGKSdw5DVOEIU4KLCn8xRQUDiskKK6a1Bzi/GwUqHycINUy7CaDXwQSnpAUIk/cZCKuk9wmHx5MKR8fHC2s0UwuD4P0Kop37CqrfvwQWjK8OUrQDCnREdwwy8UMJaGt5C/Wx8wJonD0PheC5DFiQpwyT3RMImeIHAlIEyQdQ/x0HRR/3CyuwcQ2JF2cIyvApCQe0xQ/w2hEIAHNpBemGqQZXsrcJXlgBCXOPzQDiv3ULi3J/BGPGowsL8gsLAoMRBmOoDQhyaUkJIDAnBQDLFQafDcEJvB9HClBiLQ4m68ULMr6HAGgcsQoClbcLQ5izDdQsCwviI3MKU7C9C4lYiQmCmdEJc7y/BZW2GQVV4nkFpkkDCC2DbwQFV0MJ+acVCAYYCQeqLkkJQ293CAueyQkY780KoMP7BCqOTQ+exjEL5jvvCysmywhQXEkOkEHBBnL8mQxRaGMIpcx1Cut+Gw2CjGsP487hCjlu9wZ0yC8L69sFClF2hQxRZ78JU8rfBGvk6wqtHS8FQrMJCB8G0whYyJEP0fZlCuei4wcBpLsPvUR1CqqYbw5yMGUEL4NXCNmY6w27S2UIgg55CpkgjwijFWEImeEFDnhtLQ1A+E8ItkeXBSSqjwsyDS0PN2y/CmEG6Qc0DAsEBCITApA7qwnNXicLWEgjDUb2zwhrhFcMQz6xCzoF9wfiFaUL9zsDCXsHKQmTimcL97V3Ajai4wUjVX8Ow0OTBJdKMQta0hMPsZglDNxS9wu7pX0PCwN9C2rbTQuvehUEsnwRD7Ky8Qa/fQUJk/w7ApCE7wmpuLML+IGBDAmIrwtLRh0KyzLlCEuYpQsxXp0KkCsjCVtbywqZFXUP4lxDD4yNwQQUkxkEGU1lCpWGNwhaIksIuaRVChHsCw4DPB0MMWs5CR3wuQVlCZkI2obpBv9VkQzRjJ0PzHg5CZ8ZjwjIoXEPGHeRCeLCowq5o4kGWzgRDeNLlQrohx8IE+UPCG48IQfJR3MIBSu7A5D7/wmeukUKUqNnCHC5dQnR/uMJiLytCYDmlwS0BSEFhSotBvCydQmzzQkM9BSxCykdBwkzCl8OgLdxCIOtlwsiDvEA+R/PBskv4QY6FgUKuXl5CrLbHQbpYQULis3LCI0jEQqb5ukJO8/rBW041wg5Xf0G78+JC4JQwQnQQN0IYBa7BAs1qwywm6cIEL0vBPvDwQOkyp8J5gGDDotXVwUZ8CsJdBaRCCq9eQnbKFcKsHqjCFePtvzJ6xUFu1oHCZh+UQmulpUBmV5LCi7+JQtgKX0BOiE/DqmlAQmOXScN22bLCqVQXw04UosHG6QtDoNyTwrA/RsGwflfDLeqRQwWGGkL7057CVCqIvjOtZcG+vT7Dc4YAQvfINEPXGXzCkdvxQTZedMN8Dj1DFImAwYS3yUK0+TnDHwWRQdcQ08Jhh4DCxoHXQuhq4kLyRDbCaiIkQa6oFcNCNVZDNuOFwhanVkIAAU3Cfsi3wonMRMP28r1CIc4JQgBDUMM+RLZCZP6WQ1TDIMP2eLtCIpUhwXRd/0LGigVCeF5uQm77t8I8r41CPhgcQ+BYYkLckN3CH+4Ww4kydkN/foJCLE0nw0aPP0Kc/inB9U8rQxzvHEF1O9lAkBovwyowikJs9ZVCjOLDwUKKkcNd7w/DAhcZwliNi0LOax7CcqiaQYoMikI6LWlCYn8iwp4OSkJ29e7B4mlLQUN9CEHRdoG+O7AYQ5gIxMKc8EPBnJSzQr3vo0HSUhXCjLWYQiwCFEJLQAtDUid3wSh9KsLUX6JCjzDRwYreEEKW9phCWPqTw7neM8HE6f3CurJwQ8LRVcNsJErC/2lgQRaNh8JChOVC2F2vQm4MvUGY3kVAqlTBP8iGmEGTVzdCnBfQQq4PjMEkmXlC/igavw42dkEc62jCa797QysqysGQlw3DrNUTw2YGesH8fV9D6g/pQuZ8QMLsb1vD3h/8wmk7g0JiPpRC1Ef7QprT6kLZlPHCL6fOQuYYqULax2ZCOP5bw9owcUJFUfVC5kpiwXCDqUMi+klCWrr9P2B4yMIELsrC5ttWwtSoKUPnulBCBLVRQphw7cI3Q4NCJJsPQ04kYMJlO11BsvHtwhgH2cDu8HFCdiMZQ8kHzMLiTENBTsQIQwZW/cJpZY1CYZBpwyISwcLbMIRDxZKDQOcZLMJy/RTDTvjvwlTH4MBAvbHBf+JLwj6YrsKG4kTBsllMwXSziMJqV2rCwYlhQ9772kLjEqlCutkQQi16xkOGhxvD/n4QwzZKFsJmOIbCgAkewvmLkEKnvCFDwjYGQz5+x0DiABdDAX76QcBcEsKOx9NCpnjXwtJ770BF8rpB2nQMw2Q+t0IcOGFCfqFjwt/sR8IAnY/CFkIAQwEIDEM8KeHBtw2bwjp8TULNPaZC8fSjw0JHFkIRwHFDOzNJQlm4EcOEDjrCI/CPweQn1cH6CIVCsE7DwvSmqEL8Yj1BBvqGw01UmMJAF0XBoiaVwu4ECEHRch7ClDSBws92KMMt3JhCQCkXQyIX+8FRSSdDEgfdQdfMgEIqt7LAp4sswmlZM0KaXqBCQIljQd6+DMMKv7HCdNjGQpR2wEL5BSNCAa94wvR3CkNiy8vBkrSZwrof6MGSD5JBDQCBQr0WHMFgHf7CEP3WwnAKDEOokGbBJXyNwjYT7sI23urCfhsHQxB8x8J3Q8JCsuVuQmJplUJtbynB+TLIP7bf0kIYzATDq/tQwVJJ+8I+BKbCGoEnwjwoM8JiZmhA1Ma8QunzxUEYeALDxHiaQnIodsCmKh/BznHgwHyKq8BGyIPBn9qbQzBIgkGrwCVBgkXAwtmRmkIAxiO+YOyXwXUaHUPaRZzBNO8Nw2grj0O+q15DzBm7QZ+R/sFcOIBCehH3QQysQkPhbr3COLjxwtfVtEIs/UJDAIbSQZoL28I+bZTCo5nEQmIAgMHW9wHDQj03w4SHRsJmIIHCGFYkQX8MS0NUhoXBPsQHQ6CRNMPsryzDtMvDQSY0t0DRpF3CROh4wsDMTkO4LZ3CvvSpQYLrXcKiSlfD2Vp+QnGXmELkIpvBXjOewhP+FkJ7YEDDAv6twsxo1kCWDqrC7OUbw6wdmcI0fQJDaipUQzPYeUGyU67BKfFvvzTWfEIquc9Ctg6HwjDal8IcsuXCmIDCwgjl0cK4VA5Dxhp1wT7sPEOkgoRC3GI2w414KEPoBgRCju7WQiARZ8KwwW3BsGaLQvKGc0J6TyRDQIV/wBjz9ULaIazCVNAlwgatGkPaXyXC1pnhwqzvycHHsNJBTHFwQ9kQ5MJCYobCUtrnQXizXj6Tc+1CXOriQho4I8Mkbc7CujQzQo628MH6yJrB8JeEQhjuQUKG2a5CABu+wkyitMF6nHnCuqsWQ+ozAcMq/rBB6414wh+ig8Kkj1dDOOhHQx/nh0Km+wLD/+KZwgUz7kACjTZDUDKGwr6ZjkIA1Q/CxmbMQRjSdUIaOsNBbTyHQ6EYs0K2xqfCtNVTwS32e0K7Q+BBijZgQw5fncA+Tx3DFjVEwvQymEJwKJXCfMaLQifoskIE/ArBQ22RwpyRPUKtfohChM1gQlz/gEI6WiTC6gN9QpKaLkLlFB1D4HKJwY75RkITwptBLhpSQgAFecJYvhrD5tGxQs6xtcIgdjzCkj+XwtiaB8Oar55CvLyLwbyLEkNKJJ9C0Bsav4qVbUIYVxND99Jiwoi0VcPqtOVALC5+Qph21sJEhLZBZLagwdbBkkK+pjxDxlLLQnjMdELndddCbHE4QrZB4EIwpO3CdEDGQpWNhEJV2FHBkgHNwimf5MCsbQtDeFeYwofksMHk4YnCOECNQrXFc0D7KabCNEOtwqZ4QcPqQFLCNpsCQ2juZUIgRXJCCM+kwj4nr8J09L7COGxewmCWEsJEMKJB2FYGQ76KskKiqVpC04Dgwh0f+0KIAB1C9ACZQk9PikMw3/HAnkjrQu95I0I09RFDO0yYQoD9kcAc2xHDcj7hQZIKM0JsoLtAm4oYQcoopkAhNSPAvtMewuZ9WENqDgZD8iOxQqBmkkKAFQXAOvXYQqg+7sIkFynCaBjMwhhDj8JMmp3CBhIPwnFPgMOYRQPCcOCcwnzdrkII79rCzukOwhXYlsIIhzfB2eSNQ2SThsPALw3DKgzywWfODkN7wRzDRIR9Qoy980LKs6bCtaXDQQ51j8LPVMFCGCZtwjzoW0FoDqzBIuFcwrT+kMLClzfBtwYAw2oiQsIfvcnCAFj7QuoOtMLgF6rBujGEwuKxh0AMa6vCfJUuwqVDo0GH5uZCLnBiw3bM5kKwJL3BQJdEQaYTtMB6yepBHDMQQrw6XsHdNupCK7w8vvHPrMIyyRPD4CrfQSPgM8Fj90VBWbp7wgQjocJXq4dBBVYdwxhQU8PdK6pDTl2owmExjEMgwGJDCNeCwsdAhUKwiuxBeVzbQlos5EItQCXDLqwbQwMxlEBaNJZB6MX4wQ6wXkHfYUM+WKCoQkalf8J4NQZDbSRpQnnMVsLGRIlBkbpfwiyDkMPYohRCUMNswuZcp0JrQnFCsnnNwrXJmUCSC53CoAUuQjEH+MI9qY5C1gTZwVznokN+9KDD3g6bQqK0mMIBHjnDZp1fQW6nFcOplztCHsnXweKVL0I8NB/CLOoxwjdNUMMBQH/Cma3iQv9JDMM0zTpDLuU7Q1JJX8EibRtCjE/4PzAwZcMUj3pCx3oEQwKhzUIFjIrCHrRXQtRLOsOd/0rCzkXPwrYxD8OeB93Bk8CLQqx/iMG8Jo3BKefhQhwDo0GSggbDWmSFwQtnKMLspcPCBK8oQxruI0MBVAdCyjOkQdNp1MLSHKdCB94vw2yrqsFPdV/CAjGnv8HQQEMq7vPCTE9eQpK6QcJQZetCmOpMQ94Rd8JFvz9CxOWzQjSVJcJ5NSNDauY4wpuEikFosfZCkseBQrmYgcKFP6TCPRsNQ0K2pEI8DrRCCvPIwa4yJMOckXVCwDdJwhL0qMKeegPCHbQAw9aLV0Jgb0BDtiQ2wge4A8NcRvJCKG/fQmSxksIKl+JBJJLBQU6LUsH29NxC6rc2QbIMn8CkRojCyvkaQuiWWUKcHHbBHjocQ2pCwsJcsYxCviM0wtQqVUG8GxbDq0W7weQKg0Ep1crCB4sAQ3+fsEKj6iFD3DuHwuN6PsOsh/zBzvSxQpK+F0CkDDPBJWjSQsrY6kE6kgFDd9ZswmZEUcM26JbCFN5hQ+JtGEN0fb/Cpz0nw9/ZAsMmJzlCaQkSQ47eNkPq3shCQBJKvrot5UI+o/pBAKGuwpQnF8B0kszCZI4mw+OUOELz+eLACOrdwqEJe8EX1mFCvtxdwtV3KcICe0jBgoHxwd0x60Cb9l3CqPHDQlmP80GOTnHD+vJwwiKIAkMYW0rCFb+Zw6wql8PkaxXDU9JiQubsIkJIm+5CMtMpvsXAX8JPU1TCUG+XQgzbAcJOHttCCZoOQvIUn0KuKQvCKSPQPyHjIsOPjRPDaiMSQunF1T+3/gVCPPWowjr6OMMax5jCtPWIQo7WEcJYejDCkNMJw8uozELSJ1VCXo4Hw4YozUKjTbtCxlSJwefEgUIgngfCxFD4wo61jkFGwkjDtmAKw1Zrp0EOQ8nCRKedQX5rbcKyWvNCTPARQ92YPkMguRpDMoKZwdQ/4sLeT/pC3LyyQrZJBcAa3vxC3sUuQ/bfisM2kNZC+lb6wFKLn0IpMihCXK4NQx5J1sLlMHbC3GTLQSArGsNMeErCHCgGQrlbu8IQP8PCHov4QODVKkM4VcpBiiXYwpY1MUFpF+jBebTPP8u3qEFIwNnBBs6xwipOUEL8q3hDkJkaw4gpdcGimD3CyHAmw4OQX8KEd4rCcmBEwzQ0bkD5jQtCTJEKw97gf0JgryRBhAe3QfVKTEMTwJRA3g37wQ7etkHx7zPDVXEnwohbw8EScs1Cxd5Cw4gOckL8Ho9CHg4Ow5UDJcBgri7DShIZQocu+UIuXpBCO0JwQkf6UkLUFbZCLs0RQxZt3kL7WXnCSLwMQ3YxjkJanK5CLcsewqnxecG61/xCbjIVQ1e7IEDLcmfDkpd2Qzws3sJwdNxC6H/DQu9g1MJ2Lqe/BIUJwhqOzsFstbFAxne6wQaqnkK3cKxBP0GHQu39gb7qEpfCrbPcQoTXDMOkbo/C1vzYwsn7icL2235CsPHzQrtikkLMrClCGCALwqi050IwrUJCbTHuQiaRgUEKeSfCDo1LQ96NI0I4/bVCslEPQo4FOsIsX35DanhDQxoj+sLm0qJCfgjDwR5BuEEatTJDdte3wnq3QUGrDhND3+P+wmJgikI3EHNDgsGsQdQOOEEItCrC2ivKwU/mrkIQWvs+sr8ew0FST0M1mJFCf7JIQSjF28LoaUFDC0EDwQoMIkOGkl7Cc8wBQ64edcLMGhHCkcxjQs7g6EL2WIlCqaLpQeYV4cG8myxD0hlBQp08QMK6mQtDNGriwXZiI8NgZwpCo6Glwei2LMLQGkvDh8TMQSTD8UL6fbZCoupRwiCrr0E44iHCGhzhwe6oZUJs56/CVFc5QrgTA0KT1lBDeOJOwRibIkOiLU7CTBgHQUB3I8JCNStCOX20wVri/sKkR67CVGYFQtOP3ELBaspCZ/hIQ+wuosLmZaZCcGCcQa4SLkMiDJTCJXStv4WWMEFSnwDDWi6/QTRyRMLULy6/kMaowuxlLEP6uGlBnB3BwrjRHkOuQlZB731FQoCzYsL6R2jC5ns6Qql6/MJ+yXFCwH4+wJ6C0UEa+DrCJE23Q0/DyULIoYbC8M/OQpa5ikFTi6lCsOiwwpzj2cBG2hTD4ZNrQ5jvgMJ6NZTCK4ODwhKEiMIWoR9C7JDQwqYNCkMitAtDYW/ywCKg/UJSSOVCJ2Eew6AOBUOGa2fBOfxlwmmq3kFsrAjD3lopw/4bM8J86IzCkoy6wspgaEKUHqLC5k+YwiBZ18CGJ7DC0KRtQdUEhkOCnErDoDpNQjuYTMMUkmTC4f2kQnaoIkIe1ijDDneiwmoqgcOexfjBBDa1wmAJFUEE9xPDkMY5QrJIBUOSCs7BNi9OQvq/pcHO1XxAMKnTPzQvJ0Jtb9LCNSdVwRsMpELD+ANCdHGaQmAkwUIq1PfBesmVQYjlZUOMlRfDJZcIQ/rbXUEJzjRCpBYOQ45xYEHKZ+1CT7zAwhRxOsL6nvBCIOIJQ9V8H8IDwHbDWNT/QqCp1cFcdAJCQqX+QvtyqsLECGHDQMqdwZ4TZUJGeB7BmjjVwqhRUMBupGDCLoYLwy4UMMJuLKDB1DoXwYNSCMIavKRCWvzEw66qCcNSLcjCcGsRQVxyQcIMyjNCIBQEwUD4hkE0Qm1CjzvqwLQu08L5HF3Cd4WbwnoMykJ09uhCbBFCQkXT/kIEXnHCpBLHQqogssH4j9lBmljXQcx9+EJ8lcJCzDmTwrjToMIPI4JBX6PWQpSK9sLkar6+e5SBP+AS2MJW+ivDwsBrQp4bFMBaeLXCvHdFQo5yKUJxd45Capfdws1dgsHzl95CNphGwjRlR0IAIMFBON4BQ1RF2ULsrqrABV2pweArPkMYcPPCZARzQvbU7MLSeoHAlAVew1VZsEEigsBBs22ywmaofkM8Zn3BNJLXwvoj5cK5CfZC4MACQxLTvUH2l+nBMicJQp3hwELU5D1CH+env3p0E0OmqANBms6TwiEOmcJjUZJBNOyEwoLBJMNS04DBBdBQwlxT90JsZxhCJDXaw0pqsULog8PCfckqwm7MG8KaHXnD7+yxwaIsVkOwnmfCXD90wiJ0D8NgGa5BqXGBQwp8/MHgoZhC4nZBwkN4v0EImuRCPWzgQS5K28I7wcdB7lZZQ0F7XELidDzCXcmDQm5qDcKHBpTDThMOQ/KnBj+ipe1CpaEYw+vkEMN9F5XCZLEhw9RotULLJFhCzxUGQnUZlELq7/1CMj3/v3pX18KeyBfDshiAwbwr70EhLyvD0JOQwvyW9EHwa9rBYpn7QcYBSsNgi/XBnAGwQeEnC8LxU8xCIBOlwzYDk0LqdwpCUry7QSHgZUIRij/CrEOwQFi3qMJ0Wv9CynWfQkdnMUMQiE1DvOQXQaA130IY9ilBkcIzQyKi5kPRlojBoXd/QwCO98L0kk7CppWJwmAi0UI9pK/CPiNww5ye5UK23NRBoCNHwkSYFULKLWvClq7bwf5MhkNGzZnBwjVPwmC938ECGmnCiAAXQRfYQsIyIDLCsl3Dv58yukPYmChDDgmGQgnd8j+Gy8nCrnAmQo6QKkImLuVBBO2mQiZEmULg7eZClst7w2pUokJbzRHD3khnwzSvA0KQXxvD6HRGw2n7FMKMrPXCqj0Tw7QZcsJA0jnCR5v+waQxgsHYImlDZ0lqwpaRO8MD0mzDLJ7GQv9ECsEgYklCLJAEQkoeZMP+HwNCuyBcwirypkHgcr3C4vgJQ7aL5UK6ujHBoWcOQxS2o8JU7pfCAwqlwmadGMNLxpvCTneGw/k84MCiVjfCBBWeQpD1KcOSYlbD3Mv4wrApwEEyfA1CxF6JwAaWskIMHiHCFETRwpx3EENsDjpDJOSuQkzNEEML3DNDJC8uQqxzFsNQkSfDbhqcw+5zBMIKKMPCjIIMQ7d6m8LWXbZCofFvwk6FNMJija5CjBSTQnTzZ8IwlEjBMOMYw7hE5UJvk+JBEhh3whf9WsLeTBZD7kwnw+5Jd0E+5vnCAIQ2QiSZf8LE4CHDhlNfQ3/jCkOWDgFDAuwDQwZEJEN2xKxB+DsGQ+TBq0IHOMFCZXeMQpPjX0P8yOxCiDqswryWTEOT0ZRBebyxQcsBM8OeN13CmiF0Qnh6X8N2OjbDvKbLQskCbcG+XJ5C4IGgQVEoQsJ4PlvCym7bQlIMWsLSQU5DXuySQoUjj0Kge2fBUBoJQrLficK/mavBFCo0Q3C5wsEbwVHDxABRwceRJ8J58XzAJqqnw5a20MKcQ7TCdeAFQ0otmUKNC6zCLG46wtY2e0LiS2fCXrZIwpb1BUNAbpJC0HK8wg48N0DsJeXBFmMKw5Cwo8JsPTdDe3YZQYWdrcLz1EZCdEWGQntcC8MGKotCbM96wewFqUGmxuPBHGFqw1X7FMPI5Z3BjO8cQ+KgukJ4uARBBokTwt7vEMPIza9C2u+yQj79iUKok+pCL1Okwta+i8Iu00PBiIJcwtQoi8LiI8tCs5+/QogrX0I/+nTCZBWYQUA9HMLOVv3CYtLWQULaqUIWNhLCXEk2wvKPGMN6V1xBKvDgwjHVRMLd/sRCESOpQlE1PUN1YszCaRIVw8CackNfCeDBeG5Xw249p0KGug1Da3i8wj9xcsKujk/COjclwx59YUG2U9jCGttuQnoEpUKZVAzDjky/wjAKSsIalZ3CpNk5Q3p2H0I+BKHCUDGGwiMCtkJmZjFDzqU3Q5a9vcJE8khCWggSw795OkO5fS5Cya/MwhmabsJmu4bCXGl3waxtykIWlpHChEtNQlrSt8K87PNBBrjIwqXtLD7GLCTDCmHlwnhikkHAnZJDOoZlQugTl8POWRBDqsulP30eXcLQp35BSg4Fwwt/N0FWsYJC3CNLQhoQO0AUZ4NCaPQQQwK+GUNmOBxBAC5qwgIzE8MEv4VBsKtcwbcUoMHYmH3CpY2uwjj2BkP+EqLCGUwiwxT17cKS++9C1NvEwULi9kGmpQnD/p63wCzmg0GSh1lDmjD5QUxRK0MAUwTD/uqRQUQJXEMa9IrDXw5UQqrPCMPTDbHCtrAWQurIm0PM/R1Dmmkhwtw2p0JUKM7AyAINw00wHMOPfhRDbO9VwaifP8E8tgtDg8MKwyA6ZsLKPiJDTk5awhmgj0LMPt1BvAeEQ5+hikIUxBLAOsekQvqHF0PTUJI+n/4Yw5q+JcIIsiTCzPfgwl6AzMLk//zCHjJSQ8RRo0IoeJjCFmM8QrIIH0MClANByObOwvQJ1cImEx9DPGmjwuQXIELYWizDcmBXQwApvcJsoXhCI7NawCH9oEJw/5tBGDBQQfJynkLal6HC8mOzQaqVX0LfT0dDr9egwJrhYUK4dSvCitZxwmt/hkJnAmHBo0O3wWeUVcKZfbnBACaNP4Sz7kEUj2RC9g3bwkErtEJCk6fCunmnwVy3jEPQzjrC1OtJwsr0BcKwqrTCvmcsw/xnGUO7QPXChrcKQzWGLMPW7NvCqDZkw2TmGsNCDLDCx1q2v/IrPsNKKbPCpjw9QVRLmUCpXZRBMjEew/jHrkLqFp3B3CSpvzLHVsL83FBDLjZiQhr+zUDiVLdCpERBwsoFusK/UIvCfJFdQ8T7DcLZx+dBG9JKw7JjR8PO1RtDhsvTQPid1kLeuKbCLXDmQj62+UHAq+tBardHwir8o0Id3qdA0HEXwWhzjUBKrYtCABcHQrJm6sItA1DA8GuYwYYg9cA/B7TCgVi+QgqP9MEO7m5AAMGoQoxvqkKEgfbC2qz3QMi5/MKMm8ZCQhESQg5fM8Px//BCm7d1wrJTF8OMmJDD3Qf9whupIEMhb5LDeDWKQU4weEIofBxD0Jftwj350sLQdQVDrHqnwdHQ6kGMK9/CDGeewjJCw0JiNT1BbIjEQeZFqcLwkZVB0JS8QpYsVsK0eq/BMD/IQiiYH0PClHTB9jh0wxQqxkLT05LBQriKw6qB8MH0KS9Dc+kkwZUQaUKIDVXCHiQHwwoep0L+KW5DbZnVQuwKukLeUVPCrNSKQ/l3hD4+jSpA13aywYj8gEIa2RTDAiS2wgH9SsPGyabAaSkwwcQhAUJFrADD2CKowsaQHUIyI/HCRmFwQZ7lbsLELtFBqJZNwq+n0kEMtjzD3N82w9DJh8ElTg9D4i0KwnZ+zUIrXEHDYyA7waJMZ0K47wPD0Z03Q7CuAUMhNMo/KNgkwRJthsKeUmlC8p5BQmLxMEIasB5DjmW4QQbJBsPaIKnCOlW/Qbx2eMKpb2VDRIB1QGVopUJGBnVCwp+dwqFh6UF2P0DCMl/NwihduUIkF23CxpExw7pCn0If1vlBhHw/wSLABkJ4y1FCyq2lwUA12cGEd4HDLpxew8wSPsIR777C1stYQuAJHEO4pGhCbTQmQwpxa8J4Z8hCxJSKwvtGM8L2qwY/06EyQcwOkEDWFOPAUICHwyoYhEKup5xBRuGtw3Sqa0OwuBLDqeyeQmk00kFsvcVCAHd1Qx4y+kFCL55ClHllwiEJZcJ/zWrDmuY4QSf29sKEc9BCMyIzQ/Lv1EIt6JlCMhTVQYRWgkPMtYXBclwJwkD1vEEA0T3CBG+lwlos2UFLO8JBWkOFwiok1sK4FdtC1FipwqrC3cJvurDCT7Vpwa6ls0E+AinBBvkaQndKxMJi2TxBCAl4wUhJnsEQ1NxB/MgHQ6S2UEP6+uPBIv6xwliIEEJS1ZBCCMSzwsEAKMFVdJhCGOVfQlznusJuiH1ClYiCQlTrvEIyfDTCyluBwxnDWcJyWMDBG800Q0E4ukKWMuDCEqWfwufCkkKpoRZDQE2CwnWvPUGFbaBCSgyrwnCdu0EE3CpDjM/Owv8ZksKfqxXDs5oFwz2rBEOe7z/CJLlAw7Yy1cKxVo9COXqdQuum18HiCLHCH9OOQ9o7yMKagDhBfpAQQgJyXMLIkr1CmDstQqHD6EC+oOpA9YCXQoj6vsImAQdDwJ6RQgzoocKaZiLCYp/WwPJAPkOmssjCVHK3v0J2BsLEwgFCmn4uw28+o0J+kr1C83/vwhpDyEGNzXVDLhz4wKMI7sFiTyPCmDUcwkL9LEOkhajCth8Kw2kr4cL2yp9CopVmQE9d6cFW2KVCLPO5wd9f4UEW8ZpBCuLxQiwOScL6w0HC4VTnwohogUKodYbBwfkIQ1YTeUOkKCPDCtUfQ/OuP0KVlCO/3352QZSJJEEqBVNBGQgpwqSphEJq7L9CYOHEwq5HBEFG2ZJCenimQcy3HUMez8hAyAAlwVjQAUM21qDC7FkoQtUW9ELh5yvB0ssAwvKEOEF2PlnCJcOpQvA99kL2hrnBrGvPQhpeqUH6d8ZDgdpUQiTds8LKT0RDn0tSwg4ch0IgG3/DW4X0whNdIMO0wuJB9q9cw1SeikJ0Q7vCqLLJvy4MlkPOoXFB82pPQtKc1sIOI67C/fMUQ4PGUUKvRKbC3RtLw4oyPcH05VVD2koAQjqtrEJCMWdCwnyMQgimCUIyzXLDlYkpw6SXQEPAbuBCjzSiwjiPcML+AaBBrguTwviBicKyFvJCPpz/QCbaf0Kn5QzBmI6bwd5NCUFjPodAUHTmQdBolsEMfndClMCgQoXoXMJYcL1C2r6owvS6QEEpn57BcHzlwlwNHMIm/AxDkH73QnMqqkGGvtpBtLxxwxCkiEP6hy/DaA8gQ050ET7wB/9CoPLkQq4DckAMFmtCKOuTwHnMlcLQbOBAME8/QlBIakI7U7nC1tuNw0gRU0OZq/pCf/3Twg6+CkOKFJTCVB3IQtflj0JCBdJCmnKUQQm7VsKeZQhD0JfvQVxhgELVXD7DgnevQgdALsO6hBDDoOU/QCAfRkM85CRDgoQGw/5NnUFwDBJDWruawUxRoEKMivHCJK5OwvKhk8F+WFvCFrEzQ612b8IBrIW/r8B/w2bkg0Ngy4vA1WUTQjn3rkIqkyJAwE6awFY1TcG4eUhBTNdFwph9xsKBGzJBil10wXQEgEKRmFlDp4R2QvLhHMGruD3C0B45w6bMbcI0uELCIrRewjaGFEH2kiLDUvS7QiGsqEGyQztDNnb8wvBS/EK6DofDeaPBQUCpGUPQitdBtkF4QvhrB0NQLM5CyEnPwflJ/8LVetNBwvDxwYsKNEOTdSvDKyhWQhuwskKqwRlCUKyNQiayH8JEB0pCtMI9wmfItcGPSMBCyiuYwc7k2ULQj/TCXUTSwbsktkLweopCljSGQzfKB0FWYEPB9KSpQnK8rkI8qV5CgkmWQo7e8sImsq/BCBN7Q0LmLcN7YnpCv+WTwZA+lUBIY53CdDqrwrztvEIjhA3DXHrjwnA2E0NH/n3DPHpOwsStmMJdqLFCiIGMwkfSnUJ+KF3CitKrQqIhNsFcZZw/GH2Fwdg82MKty5BCio/Vwp36pEOQ8yJCoGoIQarPNsFb7N/BfAGkwqX7F0I+EfpC8kBCw5iMAsICGIPADa5YQQoy9MLQhaFCAQhcwZbGE8IOGrTCAA1/wIe+vcG022XCKkOSwu0xB8Ie7hfCPhMkwd6moELmBH3BFxWrwspXvsI9Q71Cdqi5QRIFVMLw009CU3KvQaKfy0JeyRhDnOGUwqyxucHi28RBrDb/wVs4ZMJLGw/DnANWwuI51MBCWCDDHJrcwgsppMEWuFDCXT6HwyQgAcMw+MDC99iGQeB130GwaIHBm9uJQv78BMO3Xk1CMh34wtoKjUIkMRTDUJq4wlB+e8IQ9d5C/Nk1Q/LkNkHiBd3Be+F6Q5hb10HsbUxCOuFWQ+qFqEJD/kVCmF+uQhyuNUGuGsA/BILywVxhC8MEZOtBsLudwnY8x0JoIrnCTCUWQ1apA0PCxNVATlFnQnnkUUI03y3CTF/CQQu1BUMWwpDCYGywwuz0HMIuTwxBn1waQRr5DkNMNfjCX389QAKpOsNlr4JDBCziQopRu78GX+XCWO7Uwip3jkE6a79C7nc1wmQb18BgVGzCXq8wQ0n93EIRY+dCgh0qQ0Gat0I2uGNCwk+wwmzAy8EMhcxCEvnlwiaLwUJ4W8dCADNwQojDaUIykwHD3AtDwtYeD8PKmDHCVjSpQhGQVsIeRHe+dYmkQZnkaMLnfJrCxif5wqASUMLbBtS+tEfxwj8yw8IqxOFCcvoGQ15fVcNIQiBDpS5kQ5ptskMhnovDR4OBwphGt0Ccma/Chhd3wg1T00IU7x9B/K7kwgseCMO1j4FC6E/oQEUpXUHyC05Cm1QIQ+8cAML6AQjDjPeuwvJxbMLmDc3CjlyWwvCu5sIojcvCQNOJv3fHtL8qBABCMriVQYkT2sJWtGFDTneHQgEGfsKsQpPBcokPQlTBAsOLXQxDjqCBQdxAv0K1AwTDb6IpQ77upcL8oJzCnDlAQ0AlwkJ+YalBDwUIwzZ0C8LtUW/DQzEJQ3ZJG8N4GcFC7pliQlwOKUOy1wZDEr4nw37fEsNqiBTC3Db7wQxt6cJ47dtCbOEWQzD+ncKUn8RBPgzGwDSgXkLEeLvCGm8BwfzassI0Tr/ChhDPQIqSB0IIuSBCkUSNwzrdpULcaidCOt80QpQ88cKP7YBDhKIhQtbxLEOmlnZCCZwBw7jUUsLKufJC/jgdwuFeIcNIAzvCivhnwqCbpsLTtizCGDndQVQtZULJMqtBEx4ow14oW8N+z/DCRlgVw7q+fcOm4jbCvSIUv6JWk8I+OkXDag/ewvaZDcNhYl7DlzkrwbTwj0HRCXvDKEFhQUQQl8GMFMVC+uQpQfJ91sI0xubCTKKEwkj1B0J6TAHDmnjNQs9Yf0JWWfbCII6SQlAvssLE0sZCcW/AwrI3NUPkdjpCaL7awnYJC0MwCZzCfsdQwvoiBkPpontDWi2QQIrpJkOUcfpCdmYIQ/JAy0J0kkXCGvvnwfjpu0JbDQrBIyAcwWQ4yMD6HBzC+mf6QhlSL0JmenvDal1swsoN88FI/xVD9rUIQnAmqcLEaa7CEi4GwvY/SEM8o8nCk+4PQhTQycFmxfjCeIo4QrNtHkGQ+LfB+N25v3+gHkNSoFZDyPn+whDNCUIP6x8/Nn+2QhM3BcKBETZDiwMVQ8IL3EKrVytCKkudwn7ZkUI84ENCpCbKwGZcOMHDZBnD4pYEw7O03EIo6sRCnsZSwsyLdcLyjJdCSeszQxy9E0PkMiTCZEsQQvIIkEGibu/CTnl9QvyV2EJBNOg/Ka9GwpoirEH8BiXB/i0DwxA7EMOImFpChv4EQ+41iUIoAcBCopADQS95WkOcjI7CSe+JwVIV0MIBDm1ATp0NQu2SH8Ng4GvCGsm9wa5V0sDCk5BCfgW5QipPuELIHug/ZE0bwprvM8L0dIFAdEy3QhLESkGWxYrD+MsYw7UJCkNmThhDAAxcQhwwHkKg+ZdBLmVJQmH2cUPIWDHCkrm3wsUOJ8I26+nBtsT+wGA5tEKGEH9CosT1wNMH/8Kc2K1CpAqcQj16YEJ6vEDD6R+Nw/QmlsA89M/CqukKQYBxVsL0L8JBQzTVwZjMnsJ+EfjCkUaiwthggkIQKZ/CgNbywshrTEPjreFB1feGQuWB5MICf6hCoOYOw3A3I0N+ex/BOkjPQWQdzUKYtF1CTsn3wsKfmMKRqNzCnLSEQ8JpKcMHYMnDEcazwV4ZD8PzgvvCHazGwZwCVEPHqE7D7vRSQWrH/sGGTNFCwO9NQzKNp8L2OxZD+1Vaw+Bq2sLfUo/C+nCowikAJsIKPZlC2n2rwj47Y8LSK9zBuJNdwlp4oEKsZxTDfh6gwUpa/cLsprtBkHITQ+5Je0Mi799BKfnYwlZuhcJg7gtDjsExQp97TcIE/bPC+vdDQh8GjcNq4NNBGJCrQoZNBsNa+OpBjg8uwxI2kkL3PAFCQLQVwd8wlUI+kHTBLmQlQuap/0FRRsDCNNxJQl4QPML2t81B8Hl1Ql8cuMJmvllBtCa+QfBWbUIY7xDDDCEiwTD18kEnr03BLlCnwl16g0P+LqrCAOACw4szp0FIl2DCzkvYwZUJNUHfHb3B65jaQZ7mP0JjBCtBiok+wQrJisI2oCpD0I+DQsGYP8EDKmFBUOneQrSd3cJCgWlCTISIwjAtLMItkZ9CfI9zQUQIAsNe9fRAqPyQwpLt/EHQbSxDzMfPwgWzXsLbdPpBKpOIQwq/McJUMavC5oh1wt00ckMCpbXBFOQgQ1zDjUIUQBtCRgyGQsj+wMEfbFbCV3jOQbKBXUGOAxJDHEgxw+JRbsLT1S/Ca9xpwy7WbUOq5fdBWDAxQ5wekkJjxWJCHOWTwiO1OcO+jyDDHSNGQ7gUrUAl+UrDLKjjwHBMikLA/DJDTKeVwgUSEcMjh7VCc9wIwmtVHkPm4pjBDk4ZQtJT0T8KJxlBMqKQwVpfs0EGQJ7CTtCEQ8tdj0DfidBAXh2JQ+edJkK0zFPDnhXmQvxDi8L2pDLC+73ywghX/0EOQP/Cf/45w4i2Y8HdptJC9tT9Qggak0E6hWvCiCIzQkNHPkKy5aRCCApow6FaGMMdb5vC7ICFQtpXGcLitEBDnEcHwZoiWEJtrtFCPB6NwSrQisJOH85BAFYDQcy2cMLJ3fRCjlIjwu3f6UGtJI9C7lTEQrcwgcMycB1D2nz+QsxRosHGFKnCbJlgQqS1gcLcjBlCo7ReQlQxyEFQJMDC9uTvwqzTlUOeKyBC5oqWQcXELcNBZg3CbOGFQRVe7sJMwH/C/s0MwoQCGcNE0idDJot9wNbs48IDTiJD99HzwfqczcKnR69CQm6yQrWsksK2pRTCsM4UwzYSkMJzW9LAciqxwdhU2UIU8/pC2hwCwk33tMKKvLhCLaJ0Qm6jrkL8xc/BjOWyQt5WkUI0Zz3C+DGIQjygBMOiTePCYpLuQOS5IsM2zERCFSIlwcLufMNIeZDA9dUoQ05d+kFM8MZDWlYNQVj2ukLSdJRBgqBiQ5VlbMH/rbxB9pgbQWqVh8NQYzdCFS1Rw9vSBUL/gOZCe+geQnQiMkMwIMfCahZaQXYyaUGy1S3D6ZtuQ25BJcOfK47B/vB4wllPRMCds0bCpvVewtzdr0FsRwbD6dSswmhAbMLwf0RD0nKzwoiS8MIOdGnCCH8OQ4/dskESjeZCvkX5wm9lxsF2Z0DCIvr+QgT15kEoa3pD5ja7QnrdNULGuJ5CvwJmQ42EccJfiphCwMx+Q2rXhkOomf1ABGPbQlDwRMKrx8lCZxMrQ72pzcJGSDbA3Xtjws86lMIyps1CDFmrQRHzt0Jmt+LC7OewQRyrJMHPFMjCHl3AQVvlOb8/ESzDrqKJQxCnk0LogfhBQsjCQsYLHkMM5mHC9OPNwvyMUcLiwghDSi5HQsRLtcJ4Bt1CVIlaQ3Jfa0IdbOfCzNnZQXjqI8N4Mj9CPwLHQZEfgsILNjHDJFw1wQ4uIcK6/qtBxteWQMSricFSYMLCVL/jwjsreUI+0bfBQKOwwLk1RMPBhYbC4yYMQw6ttEJgt9DCVj5GQjEFBEKk7ElCRrKHQ6xHm8By16/CUtxEw/hJbEKVzoDD6mDswtYJWsImmCnDwN8PQgbTX8FFPlfAVFoDQmQk2MI+fwFCpU8SQygm00BYoExCqLAnQnfVBEMRMM/CIAn3wLRjIcMewKBCceRnQgrDYcFAHyFDf2ATwMgHvT440afCAjgywoBgNcJAogDCCq+HwnNS7MJ0vn3CdqWdQmsFbUJyCq9BPGSbQqa/A8NYU2RC5txFw+7gCcPclA3DurG3wsihDcNMbLBByN0bQ3g3zkGx6EvCCoKXQphGqELiEEvByl+PQrLBRkIITQ7Cmm+PQv3uTsJs4KpCvCYmw9YiJMPAliZDtn4KQ6GZ7cJup7xBMME4wmwRKUOjIS5CMrMeQxCTicL8g/FCfnWHw1cQF0Fq83vCUrmzQoKFtMJuEwrDYMsiwcRYA8KgsBlDwoTPQT8HLEOfu/pBslp2QkKSncN6hC1D4gHRQW7f80Lij/9BMrJNwt/kBEG+hUDD6J2hwb7G2UHwnIFCycIlQwCdTkExuAFDUCsiw/JxTUKwKSLDSAXPQtIxHsIYOKBC7LD+wvY4AkOIsenAJM1awl1uSEP6X5bCVLkuQh7smT/TtalCPDqEwoCU1sCe7wBCT7+0Qi1Zw0DNeaK//kzEQrPRu0LQrSrC8ys4QjKwL0PYcjlCxB6JPEQsjcL6roDCYn/NwsDzukFaWPHBqqFyQgIDs0LYnwPAlnyhQoxyBcNUHKHCwqsyQz6mBUPSABJDviUXwlhptkJxxRJD5tzQwtBJTUDygAxD1GShwmAcSkMAvfdCPhiOQhZpgsJ4LTZCUH6EwVhArUN0c95C0mciQ5uA6sISziJD9hbpQQxH4kDGpoFC2kaiwkURkkFMZYlClqpCQ2almkLaabZC+DTAwoKHY0P89B7Dhq/xwTg0TkOOuo1BreaDQqZcY8PM2jFBZDU4Qw0oIkLZ+jhDUocyQhjNfkKYsZZCBLgJw9jY1MIc16FCorupwofcEMKaCIPC1N6KwgyQZUP9LTzCSu5TwgqxAUOEHAZC+ZaOQnsfnULcxLzBLIaCwVjHHUOWLdvBNFvDwkooAsPODqnCJtsMwTd0EEO20p9C4BGhwhi+qcKpaz3BXexuw9rXYMIo4cfChPPPQqYklULRBYRB9g4Gw9o30MEy7PtCTR+fv4MpbEHBnv3ByWPZQaLEP0JhSQ3CYe3pwkXnt0Hm1jnDtr20Ql3dHULRcExDKKYIw1mO7sFMwWpDvPAuQ75QssF8ipRAGjm5QpTt8kD63lNDbTeDwSoViMJj3RVDjw1Yw2XbKUNx3+hBdRQzQoRVY0JVRb3BLr6QwsUuCsOYdEBCeH9ww4JmxkJQa11Ai+feQWIOCUPsKNHCWB3mwsMEOcKKpILC+FeuQon3UUO2difD2aDRwn7MbEPmDmHBBk+kQThmv0KYSuzCcw3QwuSJCkN4TFzCuvKSQU6OqcCQAspDbuaYQmJXDUF914PCN/1Qw7zuxcK0MMtBzgc2QIHQA8NcZO1BZIl5Q+7cucK3TPDCqqg9QYKNzcFQ/6XCsIS5w3DIlcFg8KLCKDw8wiabD0K2+KNCaGPxwjgqEMI02LJDTDqCwo6OxsDcuefC6gwuw75X/sDeaKLCBVC0QoLz48LcSQbDhH20wb/zCMOBezvDRLSSQqSX+0JzvAZDPeVPwlBD+0KvlINC2QynQlC5uMBv3rnCT9xcQ9hH/EK/TjXCzzyjwsYPksACe4bCVoUKQ8pY0MIrIW/C+OQcQjwNisFmqxvCa5VRwUXLuMHkLZHCOLk/w9a4LcIA8pnBwLmfQXLuDkMCEZxCvKnovmQF28LhsOZCJ54Rw9B2D0MxDVvDAvKyQvJk0sIRPL5BsJAXw2l3HENYdNZBWka9QR2MEMPsHSBDeBKTw74fIMOwlg7DtiI1Qzx6ycJF5ZvCtq6NwjJLFUIEG2hD1PIgQ+Rnc8MwXSDDZTtYQ75YL8JESg3BU5S3Qvw49cHmL2VCqriKQvvQo0HO8LxC/7XnQhyx6UGobjdDzCK5wqJ7F8HUSQDDzQPoQTx1gUKCEUdCKAnpwTwaWsP5/eNCXI3XQc7JVcKi8ZLDt42SQ3Y28MLKtRxDW6EPQXtohEJCbM7CvuH8PwcMl0JLszBB979Hwr2GnEJwWJlC/jStQRiUHELLyQvDtKbyQpy5+ELjc4hC/Moww7atw8H3o1LCbPONQjMkX8KVQAFDQvsYwv/ZbcLXrFVCWCkYQUBzNEJKcvTCzK69Qs+JwkEn4ynDv940wionUsMTosxBgk3LQjuAC0No0btCCsPCQidR+D+YSIhD22AeQyPe0UIAXyrClHRgQm5c7EK6kI7Cw0/fwibzNsJqtpXCPkEswWvvY0DhPA9CHYcNQkZTMULcnrDB2ZUlQeN7JEJJSOZCGHcNQ4/fDkI5yKRCXOf9QTu3hMG+iS5DJJCAQ5IwrMN0y5LCpFccQezhVULapZNBUq45wpw5AUMWQvJCLF0xw/jXl8KUVFBBVPCnQsQdeMIIztxBUDXQQuxWssEfAWVCc5w5wyLcF0NcXqbCTpYDQ5S0AcMqDnzCe3JPQn7US8OEzZfDqughQyjSgkIeZ5JBBzpEQ1rr5sJF4GtBJvXpwci8E8I7QK9C64mVQiaClEKkfpVB4QTTQgbURMOtuP9BMetHQriPJ0PfIYZCGJmHQ0w/g0FeUYnB7AMFQ402rUIZLf5C2mC5QXg4hUKnRNbBZAsgQkw4ScKONLNBdrsyQipaPMMowzvCEnufQWbVEcMiLIZCsHmOwfziLMO20jRDp8WzwSb43kIuzyfCf2BVwSQVV0Omb/tCbumXQGrwHcNSRsRCwozzQbznesPmmPXCOFEPQ7BmwUIAwCXCuam3QqRPtsEFLiDC3l51wphTMcKojonBYAZfQkdkXcNIjRzCYrSVwgIN48FLXohDsrNtQxTjAD+C2HRCBLpQwjqKk8GWLXfBVCHEQRCX+8A6dEtC3i42QthtkcBoYErDetqswjdqgEEaE91CeFNlw0ZkmMLWAzNCyLv8wrqKFMLLJs7CLoSMwjkPrMGWvgdCY0PxQlBn5UKc7kLBY6Q9QlYI18KMBuXBgPzEQnw0AUN6pKrD8ObRQVZhHkPDAGzDNBbSQg7oMML2t4rCwgvNwl6BJcI4NJhCsOSrwji4zUKMfrBCU5LFQhu+kcE4GLZCuraYwh+pCUN8qZbBMX6GQmYTikJi+UTCZjjsQCZThcLdDuJA5NvYQdLV3MI2+LvAIJXzQm3CGsOIFoHC6ILKQowxDEL5s6zC2TCgQi2Q90Jc3nhBAEk/Qm5UtcLAM2lCU7b0wqAlXMJHrwFDbBhPQjdoi0GAAghDuNaLwtao5UIkaI/CyYbjQmRQG0L/SnZCUgrJwpadgkJ8VztByFzWQtlnusKKMy3C1YAKw1IEB8NYpQZDvrR/Qr+8rEJEDJfCRJYcwVRFEcICmR9DXmDvQJW5WkJVPmvAxddGQK3ZgcK6vt1C574Iwtz8fcMwhw7C/AwMQ2IoDsPReY6/NNGoQVLcC8PwzMFCsR3Dwgau4EKtsNbC1HtnwmgJvEKgMVXC/o/5QXlebsIUwwtC+kOSQbo7kUHxGQLDm8bgwQIOqsKaNkdDARAnwX76v8IKIiJDmvo/w+6M2sE0X1fDnk23wRMti0Gq8AdDGMIpw9IeKELe0qXCayKFwaTDz0GrAinCT+vwQcrKAsNmhQLD0CCBQnPVlkJetL1CGvHDQqhb18HLxYBDEac/w9oh8sKGR21DkDgWQfojPEIJaaXBtpNhQkbyvUIPw6lCQR5dwn1uU8Je+u9BKh9Dwr4oZcGcahPD+GETQryJmkIvkcRCOlQMwzbPncBCLhrCSPrqwgJq3sIEk3dD2KY+Q6Zk3sApweJCRp47QuzqTkLQWrhCl6aHQdRPmsKUjAHCXwPVwapnPUN+2DHCogYOw3BdO0LoPodAmbkxQuuGjUPNw01D3QF+QQsrVMNgo9JA3UkpQpX6H8FAR27CaImEwo6xC0MWvTtDLPLrQVRga8HmpsLCRPQnw2iRs0K8RQ7D3kyFQXJAbkMUWtlCEMsOQ8JTJcJA2XhDOtJPwnqenUI6HhhBVYM5QVlfTUPNrnbDS8KYwiAKK0L0oEvCG3rKQo3rHMNUxSTCUvi3wWJWq8ICwSvDSm8tQMAPFsOurBhAZN0BwuFkG8EYEpnDlp65wEqoe0LmONJCPjkHwzVqc0F6aw/BFsZiQ2wSwUJiMNnCcmSKwrD4K8KJu7hC9bR1wBBqw0Lz3slCFtUTw/4kqUKyPPTBym9Qwsah9UFQziHDrcKLQqijVkLoRnTCiRyeQvSNC8M8OxDDE/aKwmav/cH3BQXCGgDxQDoo3UHRXxTC36gHQFb8OcOCI8PBNG/uQhKPKkMfrh9DP5ciQozjS8CeCBhD0pBjwwbA4sKA8JjCPg/hQma45UFoR2LCIDgMwqReZEMI1XpA+jyVQjgK+EKUmQvCJ2IKw6V3mUKScyHDZoz3QS4mxsLWE/JC5FzQPvnJCMLOnwbC2K3ZwhwmFsLP6fvCPiypwiRE40IsKiLCGvepwA0BZ0L9DIjCFxHFwkRHlsKMXJ3CNTzYwpjzk8OpuwVDcnlcwn24DcMuPFnC8GezwoxzqELj4rnDKeiAQk5T9kKC1M7BADWNQuakRkL6lqZB3CI6wY5n/UHWl9nCg/kYwgYRzEKOYw5DQLc2QqUfvMJcHh9DzpSrwlisycJk8jLBcNb0QtbBQMPyLnpCnBYcwmJXacFqJrTCsL1qQrZBG0JihftBEXiYQYBWYEEJNf7CPiztQsuJBUNqn/VBkaMRQSDagMIWEhpD4QD0QTo3f0N+KK/BPv2ZwowXOEL6M9xC2KbWQfr/GUMdnz/CRgcowjYh2UCq6SS+tvc9wjtrD0PSZbVC3vmgw14VrcKubCpC3B3ZwYpCxsJGuLxAWFtsQpz9UkMyNDdDTlP/wj4XFkMUVDxCJIQTww8ZEUMxnZLCJtHaQUsrBkPSfwvD7AgWQ3i9qcL2QTBDtZ96QuDZ+cJioSxCDeAVw4DOusJYwz9DaHUoQfzU2cFhHzhC5ktGQb3h/sGCpFrBKvTSwWzZ8sD8UUpCHmc5QxoXCsNU8ZdC7D7kwvZd/kIMooXCQiyhwqkUCEKAVMlCCraqQ9ZCZkMWe/e+4iMpQ/MMBsJKUBVDto26wPrQAsMwlbdCmZsYwkK20EF0jSpCno4vQ4ZWg0FWSRBBjmK3wthvvsOzagHB6StHQjoV2cKOsUXC+knLQnDtKcO6wvbB4uL+QuuGXsJMfdvCZ5OFwcq70UL3NQPDHgY5wsL258JYEInCLUAdwnybOEJ+g/pBLEwGQrKG4MH7pg5DpiXVw8TdD0MOtJjCqEPOQlprScF+kifClfjowqc6J8K6p8BC5o5kQsxGC0PE6IHCfmZDwhX1icJkO8bClA1IQn74ssL8VbZBI0nbwqzhj8FWserBRI40QkhtA8IqiFzBFjRfQlet5cICiSxDsqk1wj0t+MGmILDCHtzmQBZL20IcqOrBNneaQh7bP8L8bp3CC1BYwqPd/0IUTYBCPPqRP9hTR8LOTOdC2QWqwY0/6r9eHr1Cr4UQw7iPC0LeL6vCArNiw0yR7cJui9FAyjGKQjeiR8O+jzdCRCUkQsQUYUJQfoZBFhblwBx5HsNbzW7Cktk/QY6pMcL4tKRAoHAUw8qfWUP3hGtCBgkOwuia5sGMFK/CdotiQx6p/kKWQcFB0uMoQowVucEqQqVCetkNQ6qgjcPHTklCWB0pw6j8c8Gmu6DBDO7lQirOzsFSKr9BM9E9wj3nH0JL3AFDPP8KQTsdnkBIbyhDZDCQwWiV40HGCr7CuE+TQvRPQ0JsaktCs8mvwlZcKsJgD0dATjM2Qm/un0I6F7fCwcoYwrsikMAp/9vBnr8oQEImo8IycdpC2Wvjv8a3G0ODVVrCyPciQ47RpEJ4smTCgDSiQVypyUJoaBFDAm2KQpojpUImqtzCBRK/wuaa6cA8HlNDMOueQgwYusCVXhJDDjaoQipxzMKuM19B3XAmwy9pp8LXFIfCF8LmQXLtKsIagiDC2MJ5QmFW5UJYoRlBKMcXQ7DzAMLeLANDi9abwbtktUBATHxCXCUHQp0hhMIIKv7CQnPcwgYxKMN0pUTDqiEVQ2Ch0MIcP9ZCahxIQqSQj8J+lTU/cDJJQxZ2vEHB9YFC+lhgQpjY3kIeQwQ/EIxwwrRnPENEkJnCWUpuQB6hOsI4//BB/1JuQUUxIcIw1VdDMBQXQ0RXJMMpsj1DOSoTP5DQDUKbCkDDPnIpQx4ujcIy5JdC+/OAQsZ39EGgrqXCvscrQrDABEONKyFCJV0swCzPJMI0WQLDfkhZQioHCkIUASRDmvvUwuyX8MIP3AXCqNu7QrGoeUL+BV/CZEY4Q8AzvkLz20tBPlnWwR9ZkUI00INBIFjHPyr+tEH6VWNC9AJ2wg5JjsJUD5TByO8Awtbnz0H4h3BCjGREw7/cYMP2zIbDDgrlQD6rWL9K2ABB4l25wfcpnEKSNsJCEo3ywcfRBEMX4w9DQp0EwqouF0NqTwJCRkJzQviiWsFi2yzAxcTgQrhdaELiispCzmhVwf6Q+cEng+FBNvSPQv25gEKkl9PBNxWpQloqWcJc4ExDWcgFwRT8oEGIuIpBiTSPQ42GhUIKOv7B+FUkQ8jFkEJNoxTD5B6fwvASQkJWHCtCp3dsQktCTsKky07Dp8Emw2rcG0NgJCxDKzMKwYvV3UJdp3xCEQyhwPbtuMKEQbTB6q76wibSAUBzWnfCyRPDQeaWEUNuMv1CkvzvQUg8OcMircrCKFYBw5aB9UI1OJHCvknuQVpiGsIs4knBSqccQufGUkNBD3VCZygjQqbHj8KkBchCMxfJQC5DxUJeHRnDHIe3QryVzsKwHvTCrgcAwiTdFUM4xerCQAMAwnXWiMKuc31BKl2oQdE53MJ1HbRBI9gUQwqBaMIasbfCmD/1QuAud8I8/lVD7Ej5QgppKsP+Q5lClG0zwZxm3cKK7jJDx+I4Q+Rw6MLI7QnD6MaOw391DcN047bCmhejQWeNnsLIvozCWsNvv9IUt0FWXIBD6wtHQrvGgENKRMo+UcIAQEJtHEMMKwDDABPkQR7bGMJOdhdBSNJowmqBmEEibE1DSDhMwn0Md8OyGCpDlf/rQmx8YEH07AbCEBcFwlOTmcIA/WhCUMhvQQ==", - "encoding": "base64", - "path": [ - "vz", - 0, - "buffer" - ] - }, - { - "data": "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", - "encoding": "base64", - "path": [ - "z", - 0, - "buffer" - ] - }, - { - "data": "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", - "encoding": "base64", - "path": [ - "vx", - 0, - "buffer" - ] - }, - { - "data": "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", - "encoding": "base64", - "path": [ - "x", - 0, - "buffer" - ] - }, - { - "data": "AwAAABkAAABBAAAAYwAAAHUAAACRAAAAmwAAAMkAAADZAAAA+AAAAAABAAACAQAAGQEAACABAAA1AQAAXQEAALQBAADcAQAAUQIAAGICAACQAgAAkwIAAJ0CAACrAgAAsAIAALcCAAC7AgAAvwIAAMsCAAAdAwAAOgMAAEQDAABIAwAAkgMAAJgDAACfAwAAowMAALIDAADFAwAAxwMAAPUDAAAnBAAAWwQAAGYEAABuBAAAdwQAAH0EAACXBAAAoAQAAAQFAAAJBQAAFQUAAFsFAABhBQAAjwUAAJ8FAAAABgAACgYAABEGAAAqBgAANgYAAE8GAABcBgAAeAYAAH4GAAB/BgAAiAYAANcGAADhBgAA7QYAAAcHAAARBwAAPwcAAEIHAABjBwAAiQcAAL4HAAAZCAAALQgAADYIAABnCAAAgwgAAJ4IAADDCAAA6AgAAAMJAAARCQAAIAkAAFsJAACaCQAAmwkAAM4JAAANCgAANwoAAEwKAACCCgAAhgoAANMKAADqCgAALAsAADQLAABaCwAAagsAAIoLAACgCwAAqQsAALELAADLCwAA7gsAAPwLAAAZDAAAHQwAADsMAABEDAAAVQwAAGUMAABqDAAApwwAAKkMAADKDAAAEA0AADoNAAA+DQAAQA0AAK8NAADcDQAA7w0AACgOAAAvDgAAMg4AADQOAAB8DgAAAg8AADkPAABHDwAAXQ8AAHoPAACKDwAAoQ8AALAPAACzDwAAwQ8AANQPAADlDwAA5g8AAPUPAAD8DwAAGhAAAEUQAABrEAAAhhAAAIcQAACPEAAA7hAAABERAAAdEQAAMhEAAEsRAABkEQAAbREAAIoRAACaEQAAmxEAAKARAACzEQAAxxEAANcRAADcEQAA4hEAAOQRAADuEQAAHhIAADwSAABVEgAAfhIAAOQSAAD9EgAACRMAABwTAABeEwAAZRMAACUUAAAvFAAAMxQAADoUAABgFAAAZxQAAHkUAAB8FAAAgBQAAJYUAADAFAAA8BQAADQVAABsFQAAcBUAAHkVAAC+FQAA3hUAAOQVAAAMFgAAFBYAABsWAABNFgAAkBYAAJ4WAACrFgAAyBYAAMsWAAAmFwAAKhcAAG8XAACXFwAA8BcAAAsYAAASGAAAMBgAAEsYAABYGAAAWxgAAGcYAADcGAAA4RgAACwZAAAvGQAAYBkAAHYZAACqGQAAxxkAAMkZAADQGQAA9RkAAPYZAABcGgAAhBoAAIwaAACNGgAAjxoAAKUaAAC8GgAAvhoAABwbAAA5GwAAdxsAAI8bAACgGwAAoxsAANEbAAARHAAAFxwAAC0cAAA2HAAAYhwAAHQcAACAHAAAhBwAALUcAAAGHQAAMB0AADkdAACMHQAAjh0AAJAdAACiHQAAvx0AAMsdAAAlHgAANB4AAEUeAABNHgAAVh4AAFgeAACFHgAAhx4AAMQeAADwHgAA9R4AAAUfAABpHwAAlx8AAO8fAAA7IAAAcCAAAHYgAACjIAAA9yAAAFohAAB7IQAAgCEAAIQhAACOIQAACiIAAE8iAABkIgAAaSIAAHQiAAB2IgAAhiIAAM8iAAAEIwAAXCMAAL4jAADnIwAApiQAAKwkAADTJAAAHCUAACklAABRJQAAXSUAAGclAACFJQAAiyUAAJAlAACjJQAAwiUAACkmAAAqJgAAMSYAADMmAAA/JgAAXyYAAGYmAABvJgAAkCYAAJMmAAC6JgAA3CYAAOcmAAD7JgAABScAAA==", - "encoding": "base64", - "path": [ - "selected", - 0, - "buffer" - ] - }, - { - "data": "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", - "encoding": "base64", - "path": [ - "vy", - 0, - "buffer" - ] - } - ], - "model_module": "ipyvolume", - "model_module_version": "~0.4.0-beta.1", - "model_name": "ScatterModel", - "state": { - "_dom_classes": [], - "color_selected": "grey", - "geo": "arrow", - "layout": "IPY_MODEL_3eb7aad0600449a494ba76a739f327d9", - "selected": [ - { - "dtype": "int32", - "shape": [ - 331 - ] - } - ], - "size": 1, - "size_selected": 5, - "visible": true, - "visible_lines": false, - "visible_markers": true, - "vx": [ - { - "dtype": "float32", - "shape": [ - 10000 - ] - } - ], - "vy": [ - { - "dtype": "float32", - "shape": [ - 10000 - ] - } - ], - "vz": [ - { - "dtype": "float32", - "shape": [ - 10000 - ] - } - ], - "x": [ - { - "dtype": "float32", - "shape": [ - 10000 - ] - } - ], - "y": [ - { - "dtype": "float32", - "shape": [ - 10000 - ] - } - ], - "z": [ - { - "dtype": "float32", - "shape": [ - 10000 - ] - } - ] - } - } - }, - "version_major": 2, - "version_minor": 0 - } - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/docs/source/conf.py b/docs/source/conf.py index 17e236c8..4b168a31 100644 --- a/docs/source/conf.py +++ b/docs/source/conf.py @@ -39,7 +39,7 @@ 'sphinx.ext.mathjax', 'sphinx.ext.ifconfig', 'sphinx.ext.viewcode', - 'jupyter_sphinx.embed_widgets', + 'sphinx_gallery.load_style', 'nbsphinx', ] @@ -81,8 +81,8 @@ # from https://github.com/ipython/ipywidgets/blob/master/docs/source/conf.py _release = {} exec(compile(open('../../ipyvolume/_version.py').read(), '../../ipyvolume/_version.py', 'exec'), _release) -version = '.'.join(map(str, _release['__version_tuple__'][:2])) release = _release['__version__'] +version = ".".join(_release['__version__'].split(".")[:2]) # The language for content autogenerated by Sphinx. Refer to documentation # for a list of supported languages. @@ -145,12 +145,9 @@ #html_theme = 'alabaster' -try: - import sphinx_rtd_theme - html_theme = "sphinx_rtd_theme" - html_theme_path = [sphinx_rtd_theme.get_html_theme_path()] -except: - print "rtd theme not found" +import sphinx_rtd_theme +html_theme = "sphinx_rtd_theme" +html_theme_path = [sphinx_rtd_theme.get_html_theme_path()] # Theme options are theme-specific and customize the look and feel of a theme @@ -373,3 +370,22 @@ # Example configuration for intersphinx: refer to the Python standard library. intersphinx_mapping = {'https://docs.python.org/': None, 'pythreejs': ('https://pythreejs.readthedocs.io/en/latest/', None)} + + +nbsphinx_thumbnails = { + 'examples/scatter': 'examples/screenshot/scatter.png', + 'examples/volshow': 'examples/screenshot/volshow-head.png', + 'examples/mesh': 'examples/screenshot/mesh.png', + 'examples/animation': 'examples/screenshot/wave.gif', + 'examples/mcmc': 'examples/screenshot/mcmc.gif', + 'examples/bqplot': 'examples/screenshot/bqplot.png', + 'examples/bokeh': 'examples/screenshot/bokeh.png', + 'examples/scales': 'examples/screenshot/scales.png', + 'examples/moebius': 'examples/screenshot/moebius.png', + 'examples/bars': 'examples/screenshot/bars.gif', + 'examples/popup': 'examples/screenshot/ipyvolume-popup-legend-iris.gif', + 'examples/lighting': 'examples/screenshot/volume-rendering-specular.gif', + 'examples/slice': 'examples/screenshot/ipyvolume-slice-head.gif', + 'examples/volume-clipping': 'examples/screenshot/volume-clip.gif', +} +exclude_patterns = ['**.ipynb_checkpoints'] diff --git a/docs/source/example_mcmc.ipynb b/docs/source/example_mcmc.ipynb deleted file mode 100644 index fc9fe371..00000000 --- a/docs/source/example_mcmc.ipynb +++ /dev/null @@ -1,2482 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# MCMC & why 3d matters\n", - "This example (although quite artificial) shows that viewing a posterior (ok, I have flat priors) in 3d can be quite useful. While the 2d projection may look quite 'bad', the 3d volume rendering shows that much of the volume is empty, and the posterior is much better defined than it seems in 2d." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "import pylab\n", - "import scipy.optimize as op\n", - "import emcee\n", - "import numpy as np\n", - "%matplotlib inline" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "# our 'blackbox' 3 parameter model which is highly degenerate\n", - "def f_model(x, a, b, c):\n", - " return x * np.sqrt(a**2 +b**2 + c**2) + a*x**2 + b*x**3" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZYAAAEKCAYAAAAxXHOuAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nBxYzMyuUA4uZmRXq/wMnMDwpfnWFmAAAAABJRU5ErkJggg==\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "N = 100\n", - "a_true, b_true, c_true = -1., 2., 1.5\n", - "\n", - "# our input and output\n", - "x = np.random.rand(N)*0.5#+0.5\n", - "y = f_model(x, a_true, b_true, c_true)\n", - "\n", - "# + some (known) gaussian noise\n", - "error = 0.2\n", - "y += np.random.normal(0, error, N)\n", - "\n", - "# and plot our data\n", - "pylab.scatter(x, y);\n", - "pylab.xlabel(\"$x$\")\n", - "pylab.ylabel(\"$y$\")" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "estimates 1.74022905195 -1.23351935318 -1.68793098984e-05\n", - "true values -1.0 2.0 1.5\n" - ] - }, - { - "data": { - "text/plain": [ - "'Optimization terminated successfully.'" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# our likelihood\n", - "def lnlike(theta, x, y, error):\n", - " a, b, c = theta\n", - " model = f_model(x, a, b, c)\n", - " chisq = 0.5*(np.sum((y-model)**2/error**2))\n", - " return -chisq\n", - "result = op.minimize(lambda *args: -lnlike(*args), [a_true, b_true, c_true], args=(x, y, error))\n", - "# find the max likelihood\n", - "a_ml, b_ml, c_ml = result[\"x\"]\n", - "print(\"estimates\", a_ml, b_ml, c_ml)\n", - "print(\"true values\", a_true, b_true, c_true)\n", - "result[\"message\"]" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "# do the mcmc walk\n", - "ndim, nwalkers = 3, 100\n", - "pos = [result[\"x\"] + np.random.randn(ndim)*0.1 for i in range(nwalkers)]\n", - "sampler = emcee.EnsembleSampler(nwalkers, ndim, lnlike, args=(x, y, error))\n", - "sampler.run_mcmc(pos, 1500);\n", - "samples = sampler.chain[:, 50:, :].reshape((-1, ndim))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Posterior in 2d" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgcAAAIHCAYAAAALof87AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# plot the 2d pdfs\n", - "import corner\n", - "fig = corner.corner(samples, labels=[\"$a$\", \"$b$\", \"$c$\"],\n", - " truths=[a_true, b_true, c_true])" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Posterior in 3d" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "import vaex\n", - "import scipy.ndimage\n", - "import ipyvolume" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "ds = vaex.from_arrays(a=samples[...,0].copy(), b=samples[...,1].copy(), c=samples[...,2].copy())\n", - "# get 2d histogram\n", - "v = ds.count(binby=[\"a\", \"b\", \"c\"], shape=64)\n", - "# smooth it for visual pleasure\n", - "v = scipy.ndimage.gaussian_filter(v, 2)" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "71df3bc1db634b31ae95e5ddce9086c2", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "A Jupyter Widget" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "ipyvolume.quickvolshow(v, lighting=True)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "collapsed": true - }, - "source": [ - "Note that actually a large part of the volume is empty." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [] - } - ], - "metadata": { - "anaconda-cloud": {}, - "kernelspec": { - "display_name": "Python [default]", - "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.5.2" - }, - "widgets": { - "application/vnd.jupyter.widget-state+json": { - "state": { - "0005f33b31ff4ee6855829edd2b058d9": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.0.0", - "model_name": "FloatSliderModel", - "state": { - "layout": "IPY_MODEL_1f17d6c8522e48349f7cc6e8d2721af3", - "max": 1, - "step": 0.001, - "style": "IPY_MODEL_0bdffb6a786044cebd9e77ba79b816df", - "value": 0.9 - } - }, - "074e21397a664ff99c7351a57d4dbfd0": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.0.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_f7db1e1c2f474a6d8972c68014252b27", - "IPY_MODEL_dbbdf2be3ae7461780f1bc09485ea0ef", - "IPY_MODEL_15022e43633743509515c1b6935d851b", - "IPY_MODEL_0005f33b31ff4ee6855829edd2b058d9" - ], - "layout": "IPY_MODEL_b436d1db322343b0a3988ed461bd4656" - } - }, - "07e807f6ef4949c5adf57520e2b7ec6e": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "0832f382d5d44ab78e71f807bd2e9b55": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.0.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_2aa63253abc940dabd7cb9543fccf6f1", - "IPY_MODEL_7031cc17231644c4956fd08390c12e0b" - ], - "layout": "IPY_MODEL_6253b38c791c49b3b4f3634c60069f33" - } - }, - "08d46231d87d4d3b9cd9141e053bb7cd": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.0.0", - "model_name": "LinkModel", - "state": { - "source": [ - "IPY_MODEL_eeee91688138483792b5df00f2cbb190", - "specular_coefficient" - ], - "target": [ - "IPY_MODEL_ac29e0359f284d9da690d6520a43ef74", - "value" - ] - } - }, - "0bdffb6a786044cebd9e77ba79b816df": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.0.0", - "model_name": "SliderStyleModel", - "state": { - "description_width": "" - } - }, - "15022e43633743509515c1b6935d851b": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.0.0", - "model_name": "FloatSliderModel", - "state": { - "layout": "IPY_MODEL_7ed2dfd9528042dfb42593787e6aff24", - "max": 1, - "step": 0.001, - "style": "IPY_MODEL_8b9acdd685c14384aa7fc7b168ebc33d", - "value": 0.5 - } - }, - "1635ca0f8ae243168c8e13ba56c1dd05": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "168e3f28754e4be8adc657ff3379214b": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.0.0", - "model_name": "DescriptionStyleModel", - "state": { - "description_width": "" - } - }, - "1cd6cc561fb442489265aa04fce52064": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.0.0", - "model_name": "SliderStyleModel", - "state": { - "description_width": "" - } - }, - "1f17d6c8522e48349f7cc6e8d2721af3": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "2899f1f050154774855b0ec720d61d65": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "2aa63253abc940dabd7cb9543fccf6f1": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.0.0", - "model_name": "FloatSliderModel", - "state": { - "description": "ambient", - "layout": "IPY_MODEL_b25354784cb8491abd4c6b5c4fb32a06", - "max": 1, - "step": 0.001, - "style": "IPY_MODEL_592d262fb25646f690e696c47ee79852", - "value": 0.5 - } - }, - "2c0b17772b5346a5ad303f28ac34cfbb": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.0.0", - "model_name": "FloatSliderModel", - "state": { - "layout": "IPY_MODEL_cb6ad6427bc3491e8d24b4692a707323", - "max": 0.2, - "step": 0.001, - "style": "IPY_MODEL_c37d2c4afbee4badb429fb3acdb10783", - "value": 0.026 - } - }, - "2e8ef13c457f461dbd990761fda0e6c4": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "38d131afa651454a92dc6a4cf817d913": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "392628bba143426e899561e28506ed0e": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "41a33310ac2b4809b364ba47ee6e5b36": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "424765a297f84d67b0973431eceff9b9": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.0.0", - "model_name": "LinkModel", - "state": { - "source": [ - "IPY_MODEL_8cf2e503a54e4ef5ad8263352aede1e4", - "level1" - ], - "target": [ - "IPY_MODEL_dbbdf2be3ae7461780f1bc09485ea0ef", - "value" - ] - } - }, - "42525291f3e745ee90f795da7d85ddd4": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.0.0", - "model_name": "FloatSliderModel", - "state": { - "layout": "IPY_MODEL_82f7d9e3c1354bfe832110e61cb0b37d", - "max": 0.2, - "step": 0.001, - "style": "IPY_MODEL_a2bedb361ec5497eb6a179d37c3597fd", - "value": 0.18 - } - }, - "43b28aea955749eea03489d31e59b7a0": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.0.0", - "model_name": "LinkModel", - "state": { - "source": [ - "IPY_MODEL_8cf2e503a54e4ef5ad8263352aede1e4", - "opacity1" - ], - "target": [ - "IPY_MODEL_2c0b17772b5346a5ad303f28ac34cfbb", - "value" - ] - } - }, - "4ba7bda4fc824cd9a449e117d615387f": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "4dacb639222e4a4e884d80a28ecbda50": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.0.0", - "model_name": "SliderStyleModel", - "state": { - "description_width": "" - } - }, - "5905fd271b8c40be8a95d52649dd7059": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.0.0", - "model_name": "LabelModel", - "state": { - "layout": "IPY_MODEL_a874c561d299439d821e6fe519d8c6bb", - "style": "IPY_MODEL_168e3f28754e4be8adc657ff3379214b", - "value": "opacities:" - } - }, - "592d262fb25646f690e696c47ee79852": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.0.0", - "model_name": "SliderStyleModel", - "state": { - "description_width": "" - } - }, - "5ffbdaf2f1cd4e58972d53c6d0cafc2a": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.0.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_5905fd271b8c40be8a95d52649dd7059", - "IPY_MODEL_2c0b17772b5346a5ad303f28ac34cfbb", - "IPY_MODEL_95e8bb0c5d2c439eb669d09727280d89", - "IPY_MODEL_42525291f3e745ee90f795da7d85ddd4" - ], - "layout": "IPY_MODEL_392628bba143426e899561e28506ed0e" - } - }, - "6253b38c791c49b3b4f3634c60069f33": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "643967548b944c61a4a0f152685eff32": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.0.0", - "model_name": "LinkModel", - "state": { - "source": [ - "IPY_MODEL_eeee91688138483792b5df00f2cbb190", - "diffuse_coefficient" - ], - "target": [ - "IPY_MODEL_7031cc17231644c4956fd08390c12e0b", - "value" - ] - } - }, - "6b20a3b600e046c7b2e53daa4d7f361c": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "7031cc17231644c4956fd08390c12e0b": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.0.0", - "model_name": "FloatSliderModel", - "state": { - "description": "diffuse", - "layout": "IPY_MODEL_6b20a3b600e046c7b2e53daa4d7f361c", - "max": 1, - "step": 0.001, - "style": "IPY_MODEL_bd25d61fc8944b89a8da4ed483066795", - "value": 0.8 - } - }, - "71df3bc1db634b31ae95e5ddce9086c2": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.0.0", - "model_name": "VBoxModel", - "state": { - "children": [ - "IPY_MODEL_c6073e2a0f85499cb66cda7e6fae3062", - "IPY_MODEL_eeee91688138483792b5df00f2cbb190", - "IPY_MODEL_0832f382d5d44ab78e71f807bd2e9b55", - "IPY_MODEL_d9fee642a88b43b893921a9c0afc1423" - ], - "layout": "IPY_MODEL_41a33310ac2b4809b364ba47ee6e5b36" - } - }, - "71e27c07a29540b3a9c21a0239f2c846": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.0.0", - "model_name": "DescriptionStyleModel", - "state": { - "description_width": "" - } - }, - "771a088c209049e091d4c05239f25fd2": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "7ea906d4e821410eb81a1c3e03b122ba": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "7ed2dfd9528042dfb42593787e6aff24": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "80b354cd9dc949289fff8717e63a5732": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.0.0", - "model_name": "SliderStyleModel", - "state": { - "description_width": "" - } - }, - "82f7d9e3c1354bfe832110e61cb0b37d": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "8b9acdd685c14384aa7fc7b168ebc33d": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.0.0", - "model_name": "SliderStyleModel", - "state": { - "description_width": "" - } - }, - "8cf2e503a54e4ef5ad8263352aede1e4": { - "model_module": "ipyvolume", - "model_module_version": "~0.4.0-beta.1", - "model_name": "TransferFunctionWidgetJs3Model", - "state": { - "layout": "IPY_MODEL_07e807f6ef4949c5adf57520e2b7ec6e", - "level1": 0.227, - "level3": 0.9, - "opacity1": 0.026, - "opacity2": 0.077, - "opacity3": 0.18, - "rgba": [ - [ - 1, - 7.112648804488951e-09, - 7.949176844016173e-33, - 0.00015034788228731247 - ], - [ - 1, - 8.810924463205317e-09, - 1.3476016082036694e-32, - 0.00017937044123099687 - ], - [ - 1, - 1.0914694655992918e-08, - 2.284551130347742e-32, - 0.00021333821688903297 - ], - [ - 1, - 1.3520778657342231e-08, - 3.872935321092578e-32, - 0.000252959310349068 - ], - [ - 1, - 1.674911312342242e-08, - 6.565678396124917e-32, - 0.00029901770201392296 - ], - [ - 1, - 2.0748271791940275e-08, - 1.1130610048292435e-31, - 0.00035237683781641764 - ], - [ - 1, - 2.570230311181167e-08, - 1.8869410375060577e-31, - 0.0004139825466242736 - ], - [ - 1, - 3.1839200482618484e-08, - 3.198878106030344e-31, - 0.0004848651088630452 - ], - [ - 1, - 3.9441394919449886e-08, - 5.4229681446564985e-31, - 0.0005661402838037089 - ], - [ - 1, - 4.885875303436858e-08, - 9.19340547628838e-31, - 0.0006590090932662574 - ], - [ - 1, - 6.052467852490234e-08, - 1.558532191171584e-30, - 0.0007647561534800583 - ], - [ - 1, - 7.497605818891812e-08, - 2.6421358191836176e-30, - 0.0008847463453313051 - ], - [ - 1, - 9.287797041722613e-08, - 4.479138593708166e-30, - 0.001020419617023457 - ], - [ - 1, - 1.150542932930308e-07, - 7.593357766083768e-30, - 0.0011732837230430254 - ], - [ - 1, - 1.4252562093781152e-07, - 1.2872805999961158e-29, - 0.00134490471995008 - ], - [ - 1, - 1.7655623308182178e-07, - 2.182290620531368e-29, - 0.001536895063477464 - ], - [ - 1, - 2.187122794830259e-07, - 3.6995759529612253e-29, - 0.0017508991831509172 - ], - [ - 1, - 2.709338569456973e-07, - 6.27178713181499e-29, - 0.001988576450370024 - ], - [ - 1, - 3.3562429605224113e-07, - 1.063238444809189e-28, - 0.0022515815036258905 - ], - [ - 1, - 4.1576076674366876e-07, - 1.8024782518298462e-28, - 0.0025415419500237043 - ], - [ - 1, - 5.15031293015738e-07, - 3.0556907194064524e-28, - 0.002860033524985103 - ], - [ - 1, - 6.380044823926427e-07, - 5.180226592574747e-28, - 0.003208552861074767 - ], - [ - 1, - 7.903397814327921e-07, - 8.781892545601319e-28, - 0.0035884880911529844 - ], - [ - 1, - 9.790479336018465e-07, - 1.4887695606410939e-27, - 0.004001087589003549 - ], - [ - 1, - 1.2128136262511444e-06, - 2.5238691924118555e-27, - 0.004447427230414339 - ], - [ - 1, - 1.5023951754936624e-06, - 4.278644505374408e-27, - 0.004928376637300599 - ], - [ - 1, - 1.8611196431917575e-06, - 7.253465773270269e-27, - 0.00544456494451512 - ], - [ - 1, - 2.3054961722278513e-06, - 1.2296596657636889e-26, - 0.005996346700950044 - ], - [ - 1, - 2.8559757668462713e-06, - 2.0846074702360342e-26, - 0.006583768580741207 - ], - [ - 1, - 3.5378924845194123e-06, - 3.533976453773569e-26, - 0.0072065376341334635 - ], - [ - 1, - 4.382629354674312e-06, - 5.991050955224524e-26, - 0.007863991848196797 - ], - [ - 1, - 5.429062681949218e-06, - 1.0156460298361896e-25, - 0.008555073812586833 - ], - [ - 1, - 6.725351203404224e-06, - 1.721796168370848e-25, - 0.00927830829265948 - ], - [ - 1, - 8.331152439907245e-06, - 2.9189126509899226e-25, - 0.010031784499572045 - ], - [ - 1, - 1.0320368242158093e-05, - 4.948350577508018e-25, - 0.010813143813084573 - ], - [ - 1, - 1.2784545886298954e-05, - 8.388799654426134e-25, - 0.011619573656717104 - ], - [ - 1, - 1.583709124362647e-05, - 1.4221296276372152e-24, - 0.012447808146455411 - ], - [ - 1, - 1.9618487922026686e-05, - 2.41089638698963e-24, - 0.013294136033758432 - ], - [ - 1, - 2.4302762573373376e-05, - 4.0871248835850364e-24, - 0.01415441634237227 - ], - [ - 1, - 3.010549391192544e-05, - 6.928787941350883e-24, - 0.015024101958322184 - ], - [ - 1, - 3.729373403310069e-05, - 1.1746179454663183e-23, - 0.01589827127610357 - ], - [ - 1, - 4.6198298629497616e-05, - 1.9912967888327475e-23, - 0.016771667834903616 - ], - [ - 1, - 5.7228991721931635e-05, - 3.375789478204703e-23, - 0.017638747700670795 - ], - [ - 1, - 7.089346557489346e-05, - 5.722881021586809e-23, - 0.01849373416756657 - ], - [ - 1, - 8.782058376353547e-05, - 9.701839347119415e-23, - 0.019330679170752492 - ], - [ - 1, - 0.00010878936260240472, - 1.6447255562761531e-22, - 0.020143530626825706 - ], - [ - 1, - 0.00013476482287232984, - 2.7882570084723683e-22, - 0.020926204753851856 - ], - [ - 1, - 0.0001669424018061943, - 4.7268537389894e-22, - 0.02167266227511278 - ], - [ - 1, - 0.0002068029692527657, - 8.013302289532912e-22, - 0.02237698728436913 - ], - [ - 1, - 0.000256180979961039, - 1.3584726147494846e-21, - 0.023033467450162347 - ], - [ - 1, - 0.0003173488984753565, - 2.3029804422015507e-21, - 0.023636674166332465 - ], - [ - 1, - 0.00039312178202628, - 3.9041780154993814e-21, - 0.02418154121859549 - ], - [ - 1, - 0.00048698683450927095, - 6.618643257837325e-21, - 0.0246634405348482 - ], - [ - 1, - 0.0006032638938574683, - 1.1220399889709437e-20, - 0.025078253620940297 - ], - [ - 1, - 0.0007473042387250512, - 1.902162856955815e-20, - 0.02542243735393118 - ], - [ - 1, - 0.0009257368639210745, - 3.224683228715135e-20, - 0.025693082910125134 - ], - [ - 1, - 0.0011467735586305565, - 5.466714843858487e-20, - 0.02588796674308403 - ], - [ - 1, - 0.0014205868276693265, - 9.267568025889654e-20, - 0.026005592693869522 - ], - [ - 1, - 0.0017597780483860465, - 1.5711047597622706e-19, - 0.026045224507463518 - ], - [ - 1, - 0.002179957408631037, - 2.6634497413475754e-19, - 0.026006908240262798 - ], - [ - 1, - 0.0027004623155765313, - 4.515271486898044e-19, - 0.02589148426762415 - ], - [ - 1, - 0.003345247337849825, - 7.654612844348172e-19, - 0.025700588831006954 - ], - [ - 1, - 0.004143986637711025, - 1.2976650012491786e-18, - 0.025436645294371417 - ], - [ - 1, - 0.005133439629180102, - 2.1998950041090138e-18, - 0.02510284550212164 - ], - [ - 1, - 0.006359142712147505, - 3.729420169647068e-18, - 0.024703121839182166 - ], - [ - 1, - 0.00787750493910405, - 6.322381193553215e-18, - 0.024242110781321075 - ], - [ - 1, - 0.00975840406082863, - 1.0718155138947046e-17, - 0.023725108884773822 - ], - [ - 1, - 0.012088402425708527, - 1.8170187159811828e-17, - 0.023158022293610775 - ], - [ - 1, - 0.014974730734142941, - 3.0803407596041177e-17, - 0.02254731093718053 - ], - [ - 1, - 0.018550222987546022, - 5.222015112901433e-17, - 0.02189992864556595 - ], - [ - 1, - 0.022979429747147055, - 8.852735449592111e-17, - 0.02122326042679528 - ], - [ - 1, - 0.028466191045713192, - 1.5007793590417513e-16, - 0.02052505812537389 - ], - [ - 1, - 0.03526301747116445, - 2.544229066089985e-16, - 0.019813375618708422 - ], - [ - 1, - 0.04368271115635989, - 4.313160026981088e-16, - 0.01909650460867075 - ], - [ - 1, - 0.054112761493832595, - 7.311978966947833e-16, - 0.018382911933629176 - ], - [ - 1, - 0.06703317809206268, - 1.2395792430291476e-15, - 0.01768117916662938 - ], - [ - 1, - 0.08303858167789725, - 2.1014238507719732e-15, - 0.01699994508389174 - ], - [ - 1, - 0.102865569608034, - 3.562484791050546e-15, - 0.016347851391062262 - ], - [ - 1, - 0.12742661539945113, - 6.0393803381475604e-15, - 0.01573349188995719 - ], - [ - 1, - 0.15785206239592325, - 1.0238391742873164e-14, - 0.015165365063489337 - ], - [ - 1, - 0.19554214419442084, - 1.7356857758802025e-14, - 0.014651829858786913 - ], - [ - 1, - 0.24223142590463334, - 2.942459312215602e-14, - 0.014201064265818606 - ], - [ - 1, - 0.30006863194387634, - 4.988268570475428e-14, - 0.013821026128353304 - ], - [ - 1, - 0.37171553418555414, - 8.456471505958216e-14, - 0.013519415492429668 - ], - [ - 1, - 0.4604694514710059, - 1.4336018464271987e-13, - 0.013303637700477029 - ], - [ - 1, - 0.5704149981317869, - 2.4303449170631186e-13, - 0.0131807663815646 - ], - [ - 1, - 0.7066120652613475, - 4.1200954299932e-13, - 0.013157505473498778 - ], - [ - 1, - 0.8753286859711018, - 6.984681981997925e-13, - 0.013240149442818377 - ], - [ - 0.9222288968527603, - 1, - 1.0920052469604206e-12, - 0.013434540944868179 - ], - [ - 0.7444724203524355, - 1, - 1.4944244843360226e-12, - 0.01374602528723742 - ], - [ - 0.6009778988240704, - 1, - 2.0451408503753615e-12, - 0.014179401223540784 - ], - [ - 0.48514145722687, - 1, - 2.798803915296138e-12, - 0.014738867806853427 - ], - [ - 0.39163209492519224, - 1, - 3.830202381825787e-12, - 0.015427967267656705 - ], - [ - 0.31614634348548504, - 1, - 5.241685637770665e-12, - 0.016249524143092824 - ], - [ - 0.2552102133466198, - 1, - 7.1733202547157455e-12, - 0.01720558116461864 - ], - [ - 0.20601931459446962, - 1, - 9.816789298833176e-12, - 0.01829733270071036 - ], - [ - 0.16630979391223966, - 1, - 1.343441373251564e-11, - 0.019525056840222946 - ], - [ - 0.1342541479937246, - 1, - 1.8385183469085584e-11, - 0.020888047479945607 - ], - [ - 0.10837711856604222, - 1, - 2.5160381235977365e-11, - 0.022384548036195266 - ], - [ - 0.08748779836007028, - 1, - 3.443233433074892e-11, - 0.02401168862443599 - ], - [ - 0.07062482342366481, - 1, - 4.71211320824177e-11, - 0.025765428732845104 - ], - [ - 0.057012129429700145, - 1, - 6.448592963230412e-11, - 0.027640507546206762 - ], - [ - 0.04602323580493002, - 1, - 8.824989843769344e-11, - 0.029630404147399984 - ], - [ - 0.03715241397127617, - 1, - 1.2077122278720782e-10, - 0.0317273098284344 - ], - [ - 0.029991412810335703, - 1, - 1.6527711092852106e-10, - 0.03392211467663783 - ], - [ - 0.024210670215275683, - 1, - 2.2618404257617566e-10, - 0.03620441046141858 - ], - [ - 0.019544146052060358, - 1, - 3.095360321141312e-10, - 0.0385625116324745 - ], - [ - 0.015777078515705936, - 1, - 4.2360439793046754e-10, - 0.040983495953254304 - ], - [ - 0.012736100407134897, - 1, - 5.797085551573872e-10, - 0.043453265938220624 - ], - [ - 0.010281260463979114, - 1, - 7.933392820388709e-10, - 0.045956631845796805 - ], - [ - 0.00829958255267547, - 1, - 1.0856959256968046e-09, - 0.04847741650994517 - ], - [ - 0.006699866304332082, - 1, - 1.4857900897649972e-09, - 0.050998581783432556 - ], - [ - 0.005408489910309304, - 1, - 2.0333245603984804e-09, - 0.053502375828211254 - ], - [ - 0.004366021914646801, - 1, - 2.782633156863765e-09, - 0.055970499937738435 - ], - [ - 0.0035244860719516316, - 1, - 3.808072472286582e-09, - 0.058384293028365425 - ], - [ - 0.002845153394605893, - 1, - 5.211400546427366e-09, - 0.06072493140866054 - ], - [ - 0.002296759775349322, - 1, - 7.13187468278297e-09, - 0.062973640943306 - ], - [ - 0.0018540671570340282, - 1, - 9.76007045280562e-09, - 0.06511191828817894 - ], - [ - 0.0014967020320048074, - 1, - 1.3356793196842599e-08, - 0.06712175750051678 - ], - [ - 0.0012082178167649904, - 1, - 1.8278958678206755e-08, - 0.06898587803621495 - ], - [ - 0.0009753379507295756, - 1, - 2.5015011120975647e-08, - 0.07068794994675778 - ], - [ - 0.0007873448851138744, - 1, - 3.423339329108444e-08, - 0.07221281198992763 - ], - [ - 0.000635586842131253, - 1, - 4.684887848158462e-08, - 0.07354667837723584 - ], - [ - 0.0005130796446743326, - 1, - 6.411334676407528e-08, - 0.07467732999971341 - ], - [ - 0.0004141852919679794, - 1, - 8.77400135609725e-08, - 0.07559428620165375 - ], - [ - 0.00033435248866964484, - 1, - 1.2007343818765016e-07, - 0.07628895350503768 - ], - [ - 0.00026990718610120764, - 1, - 1.643221829249485e-07, - 0.07675474811825801 - ], - [ - 0.00021788349594445894, - 1, - 2.2487721022048077e-07, - 0.07698718958079048 - ], - [ - 0.0001758871947454486, - 1, - 3.077476137208035e-07, - 0.07698396348718588 - ], - [ - 0.0001419855374603928, - 1, - 4.211569222954685e-07, - 0.07674495188330739 - ], - [ - 0.00011461830906503944, - 1, - 5.763591504508275e-07, - 0.07627223061733295 - ], - [ - 9.252602066315088e-05, - 1, - 7.887555747578248e-07, - 0.07557003363859312 - ], - [ - 7.469194555033842e-05, - 1, - 1.0794230580444828e-06, - 0.07464468494906046 - ], - [ - 6.0295327629026446e-05, - 1, - 1.4772055824719061e-06, - 0.0735044996054784 - ], - [ - 4.867360874194236e-05, - 1, - 2.021576541860598e-06, - 0.07215965582561555 - ], - [ - 3.9291936558334324e-05, - 1, - 2.7665558288524626e-06, - 0.07062204085215028 - ], - [ - 3.171854971118706e-05, - 1, - 3.7860704235879205e-06, - 0.06890507375631841 - ], - [ - 2.5604907365342005e-05, - 1, - 5.1812904344362885e-06, - 0.06702350880717692 - ], - [ - 2.0669648743634488e-05, - 1, - 7.090668572546043e-06, - 0.06499322338045381 - ], - [ - 1.6685644399695094e-05, - 1, - 9.703679313464731e-06, - 0.06283099462589754 - ], - [ - 1.3469543313783463e-05, - 1, - 1.327962113236296e-05, - 0.06055426924955095 - ], - [ - 1.0873334750272241e-05, - 1, - 1.817334762644101e-05, - 0.05818093079657785 - ], - [ - 8.777536538339271e-06, - 1, - 2.4870480916551676e-05, - 0.0557290687436063 - ], - [ - 7.085696288339862e-06, - 1, - 3.403560168081668e-05, - 0.053216753532602315 - ], - [ - 5.71995247998053e-06, - 1, - 4.6578197890989016e-05, - 0.05066182140948107 - ], - [ - 4.617451135617468e-06, - 1, - 6.37429165824013e-05, - 0.048081672580905795 - ], - [ - 3.7274531675633078e-06, - 1, - 8.723307466597007e-05, - 0.045493085784930526 - ], - [ - 3.008999274340948e-06, - 1, - 0.00011937968520536175, - 0.04291205189972759 - ], - [ - 2.429024920225377e-06, - 1, - 0.0001633727722461096, - 0.04035362870497154 - ], - [ - 1.9608386460539214e-06, - 1, - 0.00022357792840100552, - 0.03783181837829163 - ], - [ - 1.5828936804410546e-06, - 1, - 0.0003059695283421104, - 0.03535946877016435 - ], - [ - 1.2777963187447883e-06, - 1, - 0.00041872358753581034, - 0.03294819896964404 - ], - [ - 1.0315054336073846e-06, - 1, - 0.0005730290977303465, - 0.03060834916422791 - ], - [ - 8.32686277110857e-07, - 1, - 0.0007841983509409363, - 0.028348954322205175 - ], - [ - 6.721888353645381e-07, - 1, - 0.0010731864333840002, - 0.0261777407954617 - ], - [ - 5.426267284678437e-07, - 1, - 0.0014686706742210692, - 0.024101144563222612 - ], - [ - 4.380372760699487e-07, - 1, - 0.0020098964003071635, - 0.02212434951868221 - ], - [ - 3.5360708413417654e-07, - 1, - 0.0027505713914456427, - 0.0202513439446484 - ], - [ - 2.8545052391821463e-07, - 1, - 0.003764195496983325, - 0.01848499313267721 - ], - [ - 2.3043090837587647e-07, - 1, - 0.005151354290812471, - 0.016827125971971786 - ], - [ - 1.8601613619789684e-07, - 1, - 0.007049700540457776, - 0.015278633266818442 - ], - [ - 1.5016215997183874e-07, - 1, - 0.009647613987406843, - 0.013839575530011052 - ], - [ - 1.2121891545698603e-07, - 1, - 0.013202894947926976, - 0.012509298038538067 - ], - [ - 9.785438267086541e-08, - 1, - 0.01806834676776386, - 0.011286551019553604 - ], - [ - 7.899328394250344e-08, - 1, - 0.024726785769921253, - 0.010169612951246697 - ], - [ - 6.376759770698445e-08, - 1, - 0.03383895285884217, - 0.009156415106070919 - ], - [ - 5.147661059742156e-08, - 1, - 0.04630908122218862, - 0.00824466562413587 - ], - [ - 4.155466936005238e-08, - 1, - 0.06337462664962146, - 0.007431971573785118 - ], - [ - 3.3545148477778113e-08, - 1, - 0.086729064731574, - 0.006715957626334198 - ], - [ - 2.707943544553715e-08, - 1, - 0.11868994054671053, - 0.006094380135194292 - ], - [ - 2.1859966562222404e-08, - 1, - 0.16242884701434077, - 0.005565235559696504 - ], - [ - 1.7646532515885038e-08, - 1, - 0.22228615349272154, - 0.005126862305551779 - ], - [ - 1.4245223520713745e-08, - 1, - 0.3042017162765904, - 0.004778035163034347 - ], - [ - 1.1499505241181312e-08, - 1, - 0.41630431194920303, - 0.004518051608075783 - ], - [ - 9.283014801394373e-09, - 1, - 0.5697182851852194, - 0.0043468092893904145 - ], - [ - 7.493745339086839e-09, - 1, - 0.7796674575736584, - 0.004264874056897917 - ], - [ - 5.669570510792063e-09, - 0.9372195584454709, - 1, - 0.004273537894900389 - ], - [ - 3.344342893741449e-09, - 0.68484469178856, - 1, - 0.004374866110935725 - ], - [ - 1.9727472071524473e-09, - 0.5004294326175815, - 1, - 0.0045717331024685975 - ], - [ - 1.1636759946507587e-09, - 0.36567358998713323, - 1, - 0.004867845984227394 - ], - [ - 6.864244012698646e-10, - 0.2672048558667833, - 1, - 0.005267755315625894 - ], - [ - 4.049051976878739e-10, - 0.19525182281088801, - 1, - 0.0057768521276260285 - ], - [ - 2.3884380976456645e-10, - 0.1426743319738957, - 1, - 0.006401350419387391 - ], - [ - 1.408882024449275e-10, - 0.10425492940935698, - 1, - 0.007148254285102095 - ], - [ - 8.310655238554817e-11, - 0.07618111930700079, - 1, - 0.008025308848440544 - ], - [ - 4.902255071436272e-11, - 0.055667036290243964, - 1, - 0.009040934233547543 - ], - [ - 2.8917220237861404e-11, - 0.040676993952418465, - 1, - 0.01020414189433397 - ], - [ - 1.7057570732238334e-11, - 0.02972347635642082, - 1, - 0.01152443276367706 - ], - [ - 1.0061849544734369e-11, - 0.021719526466094038, - 1, - 0.013011676875500002 - ], - [ - 5.935242353679978e-12, - 0.015870883481280934, - 1, - 0.014675974358333453 - ], - [ - 3.5010563058311583e-12, - 0.011597165475481657, - 1, - 0.016527497999746905 - ], - [ - 2.065188669001905e-12, - 0.008474276005134453, - 1, - 0.01857631793571119 - ], - [ - 1.218204983298983e-12, - 0.006192319490743063, - 1, - 0.020832209423945067 - ], - [ - 7.185897364291199e-13, - 0.004524849161415528, - 1, - 0.02330444510959997 - ], - [ - 4.238787530674047e-13, - 0.0033063959254960775, - 1, - 0.026001573676779403 - ], - [ - 2.500358524390098e-13, - 0.002416048276119129, - 1, - 0.028931187289484146 - ], - [ - 1.47490118465455e-13, - 0.0017654538065226904, - 1, - 0.03209968074744857 - ], - [ - 8.700086340722113e-14, - 0.0012900516822337703, - 1, - 0.03551200580077516 - ], - [ - 5.1319710854898936e-14, - 0.0009426660367354056, - 1, - 0.03917142456536948 - ], - [ - 3.027225959704464e-14, - 0.0006888245401732758, - 1, - 0.04307926644073242 - ], - [ - 1.785687576654361e-14, - 0.000503337585798803, - 1, - 0.04723469333377035 - ], - [ - 1.0533340305158485e-14, - 0.00036779863448830783, - 1, - 0.05163447831786814 - ], - [ - 6.213363380852569e-15, - 0.00026875766751409885, - 1, - 0.05627280308703564 - ], - [ - 3.665113191454896e-15, - 0.00019638649270166037, - 1, - 0.06114107968323392 - ], - [ - 2.1619618687637794e-15, - 0.00014350345749162999, - 1, - 0.06622780196577448 - ], - [ - 1.2752891596598278e-15, - 0.00010486078766800074, - 1, - 0.07151843214245365 - ], - [ - 7.522623151886691e-16, - 7.662383180554998e-05, - 1, - 0.07699532738376715 - ], - [ - 4.437413950918914e-16, - 5.599053498581397e-05, - 1, - 0.08263771108911289 - ], - [ - 2.61752345880456e-16, - 4.091338078671488e-05, - 1, - 0.0884216927669124 - ], - [ - 1.5440139534364132e-16, - 2.9896208847135308e-05, - 1, - 0.09432033973357773 - ], - [ - 9.107765893701397e-17, - 2.1845745480944325e-05, - 1, - 0.10030380293897037 - ], - [ - 5.3724514205231354e-17, - 1.596311418810312e-05, - 1, - 0.10633949820344697 - ], - [ - 3.169079508932224e-17, - 1.166456025978572e-05, - 1, - 0.11239234302388326 - ], - [ - 1.8693635638228285e-17, - 8.523522694310922e-06, - 1, - 0.11842504789812573 - ], - [ - 1.1026924770738394e-17, - 6.228305011282781e-06, - 1, - 0.1243984598582744 - ], - [ - 6.5045169517943784e-18, - 4.551144486241817e-06, - 1, - 0.13027195462565974 - ], - [ - 3.836857660301914e-18, - 3.3256104344805175e-06, - 1, - 0.13600387253954235 - ], - [ - 2.263269788443898e-18, - 2.4300886942524693e-06, - 1, - 0.141551992204084 - ], - [ - 1.3350482579225599e-18, - 1.775713415109042e-06, - 1, - 0.1468740346809921 - ], - [ - 7.875127658587729e-19, - 1.297548579216849e-06, - 1, - 0.15192819006442038 - ], - [ - 4.645347856979867e-19, - 9.481441662275541e-07, - 1, - 0.15667365744395612 - ], - [ - 2.7401786546045263e-19, - 6.928275167115057e-07, - 1, - 0.16107118862106085 - ], - [ - 1.6163652949839428e-19, - 5.062626391748843e-07, - 1, - 0.16508362551966024 - ], - [ - 9.534549006278511e-20, - 3.699360282929471e-07, - 1, - 0.16867642104242594 - ], - [ - 5.62420048458352e-20, - 2.703195030393806e-07, - 1, - 0.17181813318375352 - ], - [ - 3.317580209610323e-20, - 1.9752775651684384e-07, - 1, - 0.17448088252424643 - ], - [ - 1.956960545301958e-20, - 1.4433740131911067e-07, - 1, - 0.17664076379771104 - ], - [ - 1.1543638236009293e-20, - 1.0547016675996857e-07, - 1, - 0.17827820303038314 - ], - [ - 6.809313761780157e-21, - 7.70691170459825e-08, - 1, - 0.17937825278578384 - ], - [ - 4.016649946784745e-21, - 5.631591363427913e-08, - 1, - 0.17993081928238816 - ], - [ - 2.369324921633227e-21, - 4.1151141339420704e-08, - 1, - 0.1799308165537784 - ], - [ - 1.3976076229311482e-21, - 3.006994514080307e-08, - 1, - 0.17937824435515515 - ], - [ - 8.244150263395654e-22, - 2.1972697994277244e-08, - 1, - 0.17827818814460603 - ], - [ - 4.863025390696127e-22, - 1.6055880876635984e-08, - 1, - 0.1766407411379686 - ], - [ - 2.868581381341121e-22, - 1.1732346696426079e-08, - 1, - 0.1744808501065058 - ], - [ - 1.6921069664000035e-22, - 8.573055571522103e-09, - 1, - 0.17181808821097977 - ], - [ - 9.98133085699919e-23, - 6.264499655025915e-09, - 1, - 0.16867635969963676 - ], - [ - 5.887746321903306e-23, - 4.577592621489649e-09, - 1, - 0.1650835426997158 - ], - [ - 3.473039542294858e-23, - 3.3449366050335756e-09, - 1, - 0.1610710775653591 - ], - [ - 2.04866225595881e-23, - 2.4442107056814743e-09, - 1, - 0.15667350927782572 - ], - [ - 1.2084564508635209e-23, - 1.7860326455149662e-09, - 1, - 0.15192799320181755 - ], - [ - 7.12839312280956e-24, - 1.305089043031497e-09, - 1, - 0.14687377406694505 - ], - [ - 4.204867165631733e-24, - 9.536541308570388e-10, - 1, - 0.14155164835601547 - ], - [ - 2.4803497192140436e-24, - 6.968537558082474e-10, - 1, - 0.13600342033992352 - ], - [ - 1.4630984730954523e-24, - 5.092046909581871e-10, - 1, - 0.13027136180820484 - ], - [ - 8.630464992060167e-25, - 3.7208584316674665e-10, - 1, - 0.1243976851178357 - ], - [ - 5.090903131187697e-25, - 2.7189041488323055e-10, - 1, - 0.1184240385403443 - ], - [ - 3.0030009640245653e-25, - 1.986756525758134e-10, - 1, - 0.11239103205424682 - ], - [ - 1.7713978360119533e-25, - 1.451761914570523e-10, - 1, - 0.10633780073642944 - ], - [ - 1.0449048571807746e-25, - 1.060830871459308e-10, - 1, - 0.10030161178612867 - ], - [ - 6.163641720473557e-26, - 7.751698997931348e-11, - 1, - 0.09431752000461331 - ], - [ - 3.635783583288461e-26, - 5.6643183160638746e-11, - 1, - 0.0884180752895383 - ], - [ - 2.1446610403392894e-26, - 4.1390283593646465e-11, - 1, - 0.08263308442192893 - ], - [ - 1.2650838182698408e-26, - 3.0244691070839545e-11, - 1, - 0.07698942816110158 - ], - [ - 7.46242430456511e-27, - 2.2100388268683803e-11, - 1, - 0.07151093345122557 - ], - [ - 4.401904102885811e-27, - 1.614918666163841e-11, - 1, - 0.06621829941192903 - ] - ], - "style": "height: 32px; width: 100%;" - } - }, - "92874bc07029461d95ec2c23050d6aad": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.0.0", - "model_name": "SliderStyleModel", - "state": { - "description_width": "" - } - }, - "95e8bb0c5d2c439eb669d09727280d89": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.0.0", - "model_name": "FloatSliderModel", - "state": { - "layout": "IPY_MODEL_1635ca0f8ae243168c8e13ba56c1dd05", - "max": 0.2, - "step": 0.001, - "style": "IPY_MODEL_1cd6cc561fb442489265aa04fce52064", - "value": 0.077 - } - }, - "97032152b16d44fe952d7400909c04c9": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.0.0", - "model_name": "FloatSliderModel", - "state": { - "description": "specular exp", - "layout": "IPY_MODEL_4ba7bda4fc824cd9a449e117d615387f", - "max": 10, - "step": 0.001, - "style": "IPY_MODEL_4dacb639222e4a4e884d80a28ecbda50", - "value": 5 - } - }, - "9769d5723af849348c123fec32c281c4": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.0.0", - "model_name": "LinkModel", - "state": { - "source": [ - "IPY_MODEL_8cf2e503a54e4ef5ad8263352aede1e4", - "level2" - ], - "target": [ - "IPY_MODEL_15022e43633743509515c1b6935d851b", - "value" - ] - } - }, - "9ab3d7edb041499ab4cae19f105ca3e5": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.0.0", - "model_name": "LinkModel", - "state": { - "source": [ - "IPY_MODEL_eeee91688138483792b5df00f2cbb190", - "specular_exponent" - ], - "target": [ - "IPY_MODEL_97032152b16d44fe952d7400909c04c9", - "value" - ] - } - }, - "9ebc01a3e939428ba71969793e06876e": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "a2bedb361ec5497eb6a179d37c3597fd": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.0.0", - "model_name": "SliderStyleModel", - "state": { - "description_width": "" - } - }, - "a66568887eb340de91b309eb9c957bd0": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.0.0", - "model_name": "LinkModel", - "state": { - "source": [ - "IPY_MODEL_8cf2e503a54e4ef5ad8263352aede1e4", - "opacity3" - ], - "target": [ - "IPY_MODEL_42525291f3e745ee90f795da7d85ddd4", - "value" - ] - } - }, - "a69e1edbd44543c1a2fd4f4c2eec171e": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.0.0", - "model_name": "LinkModel", - "state": { - "source": [ - "IPY_MODEL_eeee91688138483792b5df00f2cbb190", - "ambient_coefficient" - ], - "target": [ - "IPY_MODEL_2aa63253abc940dabd7cb9543fccf6f1", - "value" - ] - } - }, - "a874c561d299439d821e6fe519d8c6bb": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "ac29e0359f284d9da690d6520a43ef74": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.0.0", - "model_name": "FloatSliderModel", - "state": { - "description": "specular", - "layout": "IPY_MODEL_2899f1f050154774855b0ec720d61d65", - "max": 1, - "step": 0.001, - "style": "IPY_MODEL_92874bc07029461d95ec2c23050d6aad", - "value": 0.5 - } - }, - "b25354784cb8491abd4c6b5c4fb32a06": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "b436d1db322343b0a3988ed461bd4656": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "b8ebf2eaef7d483fbf297bee4a17ad1f": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.0.0", - "model_name": "LinkModel", - "state": { - "source": [ - "IPY_MODEL_8cf2e503a54e4ef5ad8263352aede1e4", - "opacity2" - ], - "target": [ - "IPY_MODEL_95e8bb0c5d2c439eb669d09727280d89", - "value" - ] - } - }, - "bd25d61fc8944b89a8da4ed483066795": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.0.0", - "model_name": "SliderStyleModel", - "state": { - "description_width": "" - } - }, - "c37d2c4afbee4badb429fb3acdb10783": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.0.0", - "model_name": "SliderStyleModel", - "state": { - "description_width": "" - } - }, - "c6073e2a0f85499cb66cda7e6fae3062": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.0.0", - "model_name": "VBoxModel", - "state": { - "children": [ - "IPY_MODEL_074e21397a664ff99c7351a57d4dbfd0", - "IPY_MODEL_5ffbdaf2f1cd4e58972d53c6d0cafc2a" - ], - "layout": "IPY_MODEL_7ea906d4e821410eb81a1c3e03b122ba" - } - }, - "cb6ad6427bc3491e8d24b4692a707323": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "d5f179053a8f4a149425526c03b03fe0": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.0.0", - "model_name": "LinkModel", - "state": { - "source": [ - "IPY_MODEL_8cf2e503a54e4ef5ad8263352aede1e4", - "level3" - ], - "target": [ - "IPY_MODEL_0005f33b31ff4ee6855829edd2b058d9", - "value" - ] - } - }, - "d9fee642a88b43b893921a9c0afc1423": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.0.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_ac29e0359f284d9da690d6520a43ef74", - "IPY_MODEL_97032152b16d44fe952d7400909c04c9" - ], - "layout": "IPY_MODEL_9ebc01a3e939428ba71969793e06876e" - } - }, - "dbbdf2be3ae7461780f1bc09485ea0ef": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.0.0", - "model_name": "FloatSliderModel", - "state": { - "layout": "IPY_MODEL_771a088c209049e091d4c05239f25fd2", - "max": 1, - "step": 0.001, - "style": "IPY_MODEL_80b354cd9dc949289fff8717e63a5732", - "value": 0.227 - } - }, - "eeee91688138483792b5df00f2cbb190": { - "model_module": "ipyvolume", - "model_module_version": "~0.4.0-beta.1", - "model_name": "FigureModel", - "state": { - "anglex": -0.24301490098232104, - "angley": 0.5123236861609838, - "anglez": 2.920631092389561, - "data_max": 14.714205755641292, - "data_min": 0, - "height": 500, - "layout": "IPY_MODEL_38d131afa651454a92dc6a4cf817d913", - "matrix_projection": [ - 3.017766952966369, - 0, - 0, - 0, - 0, - 2.414213562373095, - 0, - 0, - 0, - 0, - -1.000002000002, - -1, - 0, - 0, - -0.02000002000002, - 0 - ], - "matrix_world": [ - -0.8504165186586761, - -0.19102845340164176, - 0.490203911432206, - 0, - 0.32781796980716893, - -0.9211658948493419, - 0.20973500622909083, - 0, - 0.4114937708689687, - 0.33905976487543826, - 0.8459972531744112, - 0, - 0.05555238899126888, - 0.3865672916877725, - -2.772968085417851, - 0.9999999999999998 - ], - "meshes": [], - "scatters": [], - "tf": "IPY_MODEL_8cf2e503a54e4ef5ad8263352aede1e4", - "volume_data": { - "columns": 32, - "image_shape": [ - 2048, - 128 - ], - "rows": 2, - "slice_shape": [ - 64, - 64 - ], - "slices": 64, - "src": "data:image/png;base64,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" - }, - "width": 400 - } - }, - "f7db1e1c2f474a6d8972c68014252b27": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.0.0", - "model_name": "LabelModel", - "state": { - "layout": "IPY_MODEL_2e8ef13c457f461dbd990761fda0e6c4", - "style": "IPY_MODEL_71e27c07a29540b3a9c21a0239f2c846", - "value": "levels:" - } - } - }, - "version_major": 2, - "version_minor": 0 - } - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/docs/source/examples.rst b/docs/source/examples.rst index 6d6218e2..374ebf38 100644 --- a/docs/source/examples.rst +++ b/docs/source/examples.rst @@ -1,16 +1,27 @@ Examples ======== -.. ipywidgets-setup:: +.. nbgallery:: + :caption: Examples of using ipyvolume: - from ipywidgets import VBox, jsdlink, IntSlider, Button - import ipyvolume - import ipyvolume.pylab as p3 - import numpy as np + examples/scatter + examples/volshow + examples/mesh + examples/animation + examples/bqplot + examples/bokeh + examples/scales + examples/moebius + examples/bars + examples/lighting + examples/popup + examples/slice + examples/slice + examples/volume-clipping -.. toctree:: - :maxdepth: 2 - - bokeh - bqplot - example_mcmc +Feel free to contribute new examples: + * Add a notebook to `docs/source/examples` + * Take a screenshot (of screencapture) and put it at `docs/source/examples/screenshot`. + * Make a reference to the screenshot in the notebook, e.g. a markdown cell containing `[screenshot](screenshot/myexample.png)` + * Add an entry in `docs/source/conf.py`. + * Open a pull request at https://github.com/maartenbreddels/ipyvolume diff --git a/docs/source/examples/animation.ipynb b/docs/source/examples/animation.ipynb new file mode 100644 index 00000000..69b57147 --- /dev/null +++ b/docs/source/examples/animation.ipynb @@ -0,0 +1,8229 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Animation\n", + "All (or most of) the changes in scatter and quiver plots are (linearly) interpolated. On top top that, scatter plots and quiver plots can take a sequence of arrays (the first dimension), where only one array is visualized. Together this can make smooth animations with coarse timesteps. Lets see an example." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import ipyvolume as ipv\n", + "import numpy as np" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Basic animation" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# only x is a sequence of arrays\n", + "x = np.array([[-1, -0.8], [1, -0.1], [0., 0.5]])\n", + "y = np.array([0.0, 0.0])\n", + "z = np.array([0.0, 0.0])\n", + "ipv.figure()\n", + "s = ipv.scatter(x, y, z, marker='sphere', size=10)\n", + "ipv.xyzlim(-1, 1)\n", + "ipv.animation_control(s) # shows controls for animation controls\n", + "ipv.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can control which array to visualize, using the `scatter.sequence_index` property. Actually, the `pylab.animate_glyphs` is connecting the `Slider` and `Play` button to that property, but you can also set it from Python." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "s.sequence_index = 1" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Animating color and size\n", + "We now demonstrate that you can also animate color and size" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# create 2d grids: x, y, and r \n", + "u = np.linspace(-10, 10, 25)\n", + "x, y = np.meshgrid(u, u)\n", + "r = np.sqrt(x**2+y**2)\n", + "print(\"x,y and z are of shape\", x.shape)\n", + "# and turn them into 1d\n", + "x = x.flatten()\n", + "y = y.flatten()\n", + "r = r.flatten()\n", + "print(\"and flattened of shape\", x.shape)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we only animate the z component" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# create a sequence of 15 time elements\n", + "time = np.linspace(0, np.pi*2, 15)\n", + "z = np.array([(np.cos(r + t) * np.exp(-r/5)) for t in time])\n", + "print(\"z is of shape\", z.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# draw the scatter plot, and add controls with animate_glyphs\n", + "ipv.figure()\n", + "s = ipv.scatter(x, z, y, marker=\"sphere\")\n", + "ipv.animation_control(s, interval=200)\n", + "ipv.ylim(-3,3)\n", + "ipv.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Now also include, color, which containts rgb values\n", + "color = np.array([[np.cos(r + t), 1-np.abs(z[i]), 0.1+z[i]*0] for i, t in enumerate(time)])\n", + "size = (z+1)\n", + "print(\"color is of shape\", color.shape)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "color is of the wrong shape, the last dimension should contain the rgb value, i.e. the shape of should be (15, 2500, 3)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "color = np.transpose(color, (0, 2, 1)) # flip the last axes" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "ipv.figure()\n", + "s = ipv.scatter(x, z, y, color=color, size=size, marker=\"sphere\")\n", + "ipv.animation_control(s, interval=200)\n", + "ipv.ylim(-3,3)\n", + "ipv.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Creating movie files\n", + "We now make a movie, with a 2 second duration, where we rotate the camera, and change the size of the scatter points. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# This is commented out, otherwise it would run on readthedocs\n", + "# def set_view(figure, framenr, fraction):\n", + "# ipv.view(fraction*360, (fraction - 0.5) * 180, distance=2 + fraction*2)\n", + "# s.size = size * (2+0.5*np.sin(fraction * 6 * np.pi))\n", + "# ipv.movie('wave.gif', set_view, fps=20, frames=40)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2020-03-30T09:52:38.941393Z", + "start_time": "2020-03-30T09:52:38.807885Z" + } + }, + "source": [ + "## Resulting gif file\n", + "![screenshot](screenshot/wave.gif)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "## Animated quiver\n", + "Not only scatter plots can be animated, quiver as well, so the direction vector (vx, vy, vz) can also be animated, as shown in the example below, which is a (subsample of) a simulation of a small galaxy orbiting a host galaxy (not visible)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import ipyvolume.datasets\n", + "stream = ipyvolume.datasets.animated_stream.fetch()\n", + "print(\"shape of steam data\", stream.data.shape) # first dimension contains x, y, z, vx, vy, vz, then time, then particle" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "fig = ipv.figure()\n", + "# instead of doing x=stream.data[0], y=stream.data[1], ... vz=stream.data[5], use *stream.data\n", + "# limit to 50 timesteps to avoid having a huge notebook\n", + "q = ipv.quiver(*stream.data[:,0:50,:200], color=\"red\", size=7)\n", + "ipv.style.use(\"dark\") # looks better\n", + "ipv.animation_control(q, interval=200)\n", + "ipv.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# fig.animation = 0 # set to 0 for no interpolation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "[screenshot](screenshot/wave.gif)" + ] + } + ], + "metadata": { + "anaconda-cloud": {}, + "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.7.3" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "state": { + "00a1968307f74adb9fddf3dc4f38828e": { + "model_module": "jupyter-threejs", + "model_module_version": "~1.0.0", + "model_name": "PerspectiveCameraModel", + "state": { + "_model_module_version": "~1.0.0", + "_view_module": null, + "_view_module_version": "", + "aspect": 0.8, + "fov": 46, + "matrix": [ + 1, + 0, + 0, + 0, + 0, + 1, + -6.123233995736766e-17, + 0, + 0, + 6.123233995736766e-17, + 1, + 0, + 0, + 1.2246467991473532e-16, + 2, + 1 + ], + "matrixWorld": [ + 1, + 0, + 0, + 0, + 0, + 1, + -6.123233995736766e-17, + 0, + 0, + 6.123233995736766e-17, + 1, + 0, + 0, + 1.2246467991473532e-16, + 2, + 1 + ], + "matrixWorldInverse": [ + 1, + 0, + 0, + 0, + 0, + 1, + 6.123233995736766e-17, + 0, + 0, + -6.123233995736766e-17, + 1, + 0, + 0, + 0, + -2, + 1 + ], + "position": [ + 0, + 1.2246467991473532e-16, + 2 + ], + "projectionMatrix": [ + 2.9448154572796907, + 0, + 0, + 0, + 0, + 2.3558523658237527, + 0, + 0, + 0, + 0, + -1.00010000500025, + -1, + 0, + 0, + -0.200010000500025, + 0 + ], + "quaternion": [ + -3.061616997868383e-17, + 0, + 0, + 1 + ], + "rotation": [ + -6.123233995736766e-17, + 0, + 0, + "XYZ" + ] + } + }, + "02d2b6a819fc411cbc78688746d21311": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.4.0", + "model_name": "LinkModel", + "state": { + "source": [ + "IPY_MODEL_ea561674d7254c89aacdac5c4bf4815a", + "value" + ], + "target": [ + "IPY_MODEL_ff6eb48719bb46c89367ccf844932fed", + "sequence_index" + ] + } + }, + "0b15901ef7b34307971333d2fde5913e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.4.0", + "model_name": "SliderStyleModel", + "state": { + "description_width": "" + } + }, + "0b44784ed5904895a8c2cc1e5f71c18c": { + "buffers": [ + { + "data": "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", + "encoding": "base64", + "path": [ + "x", + 0, + "data" + ] + }, + { + "data": "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", + "encoding": "base64", + "path": [ + "y", + 0, + "data" + ] + }, + { + "data": "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", + "encoding": "base64", + "path": [ + "y", + 1, + "data" + ] + }, + { + "data": "3gY+vQcTrryyzIU8J5piPRPmrT0xV8k9oErBPZdknT1zOlU9chnZPLNYrDtlUwu8HuZYvGVTC7yzWKw7chnZPHM6VT2XZJ09oErBPTFXyT0T5q09J5piPbLMhTwHE6683gY+vQcTrrxw/KY8RkiBPTvAvD2Mfsg9LNehPSb8Kj0NpHu7gmpEvdwGrL3WsN+9Qj39veVdA75CPf291rDfvdwGrL2CakS9DaR7uyb8Kj0s16E9jH7IPTvAvD1GSIE9cPymPAcTrryyzIU8RkiBPV2jwD1MK8M9R46DPYO2Hjy2YVm91rDfvbhPGb7iCTG+KQ07vnqWPb5CyT2+epY9vikNO77iCTG+uE8Zvtaw3722YVm9g7YePEeOgz1MK8M9XaPAPUZIgT2yzIU8J5piPTvAvD1MK8M9LBtvPWVTC7zcBqy9UDIVvjLbN75MSTy+2UgrvttUEr530fu9YlzsvXfR+73bVBK+2UgrvkxJPL4y2ze+UDIVvtwGrL1lUwu8LBtvPUwrwz07wLw9J5piPRPmrT2Mfsg9R46DPWVTC7wr8sC9pqgkvkLJPb4MLye+2/vbvZygIL0yAq887797PVw5mj3vv3s9MgKvPJygIL3b+9u9DC8nvkLJPb6mqCS+K/LAvWVTC7xHjoM9jH7IPRPmrT0xV8k9LNehPYO2HjzcBqy9pqgkvmQlPb7bVBK+KLJNve+/ez2Z1SQ+kWpsPju+iT7LuI8+O76JPpFqbD6Z1SQ+7797PSiyTb3bVBK+ZCU9vqaoJL7cBqy9g7YePCzXoT0xV8k9oErBPSb8Kj22YVm9UDIVvkLJPb7bVBK+5+fjvMJG8T3B5Xk+tOSjPlVBsT40irA+XYauPjSKsD5VQbE+tOSjPsHleT7CRvE95+fjvNtUEr5CyT2+UDIVvrZhWb0m/Co9oErBPZdknT0NpHu71rDfvTLbN74MLye+KLJNvcJG8T07vok+4uWvPruApz5ADYI+hTo4PhViGT6FOjg+QA2CPruApz7i5a8+O76JPsJG8T0osk29DC8nvjLbN77WsN+9DaR7u5dknT1zOlU9gmpEvbhPGb5MSTy+2/vbve+/ez3B5Xk+4uWvPnEinD4VYhk+YtsqvZ+BPr51dHO+n4E+vmLbKr0VYhk+cSKcPuLlrz7B5Xk+7797Pdv7271MSTy+uE8ZvoJqRL1zOlU9chnZPNwGrL3iCTG+2UgrvpygIL2Z1SQ+tOSjPruApz4VYhk+ECwLvsBcy76FtQu/IDYWv4W1C7/AXMu+ECwLvhViGT67gKc+tOSjPpnVJD6coCC92UgrvuIJMb7cBqy9chnZPLNYrDvWsN+9KQ07vttUEr4yAq88kWpsPlVBsT5ADYI+YtsqvcBcy76qwR6/Mrwjv7uzGb8yvCO/qsEev8Bcy75i2yq9QA2CPlVBsT6Ramw+MgKvPNtUEr4pDTu+1rDfvbNYrDtlUwu8Qj39vXqWPb530fu97797PTu+iT40irA+hTo4Pp+BPr6FtQu/MrwjvxzOw75INgq+HM7DvjK8I7+FtQu/n4E+voU6OD40irA+O76JPu+/ez130fu9epY9vkI9/b1lUwu8HuZYvOVdA75CyT2+YlzsvVw5mj3LuI8+XYauPhViGT51dHO+IDYWv7uzGb9INgq+B50fP0g2Cr67sxm/IDYWv3V0c74VYhk+XYauPsu4jz5cOZo9YlzsvULJPb7lXQO+HuZYvGVTC7xCPf29epY9vnfR+73vv3s9O76JPjSKsD6FOjg+n4E+voW1C78yvCO/HM7Dvkg2Cr4czsO+Mrwjv4W1C7+fgT6+hTo4PjSKsD47vok+7797PXfR+716lj2+Qj39vWVTC7yzWKw71rDfvSkNO77bVBK+MgKvPJFqbD5VQbE+QA2CPmLbKr3AXMu+qsEevzK8I7+7sxm/Mrwjv6rBHr/AXMu+YtsqvUANgj5VQbE+kWpsPjICrzzbVBK+KQ07vtaw372zWKw7chnZPNwGrL3iCTG+2UgrvpygIL2Z1SQ+tOSjPruApz4VYhk+ECwLvsBcy76FtQu/IDYWv4W1C7/AXMu+ECwLvhViGT67gKc+tOSjPpnVJD6coCC92UgrvuIJMb7cBqy9chnZPHM6VT2CakS9uE8ZvkxJPL7b+9u97797PcHleT7i5a8+cSKcPhViGT5i2yq9n4E+vnV0c76fgT6+YtsqvRViGT5xIpw+4uWvPsHleT7vv3s92/vbvUxJPL64Txm+gmpEvXM6VT2XZJ09DaR7u9aw370y2ze+DC8nviiyTb3CRvE9O76JPuLlrz67gKc+QA2CPoU6OD4VYhk+hTo4PkANgj67gKc+4uWvPju+iT7CRvE9KLJNvQwvJ74y2ze+1rDfvQ2ke7uXZJ09oErBPSb8Kj22YVm9UDIVvkLJPb7bVBK+5+fjvMJG8T3B5Xk+tOSjPlVBsT40irA+XYauPjSKsD5VQbE+tOSjPsHleT7CRvE95+fjvNtUEr5CyT2+UDIVvrZhWb0m/Co9oErBPTFXyT0s16E9g7YePNwGrL2mqCS+ZCU9vttUEr4osk297797PZnVJD6Ramw+O76JPsu4jz47vok+kWpsPpnVJD7vv3s9KLJNvdtUEr5kJT2+pqgkvtwGrL2Dth48LNehPTFXyT0T5q09jH7IPUeOgz1lUwu8K/LAvaaoJL5CyT2+DC8nvtv7272coCC9MgKvPO+/ez1cOZo97797PTICrzycoCC92/vbvQwvJ75CyT2+pqgkvivywL1lUwu8R46DPYx+yD0T5q09J5piPTvAvD1MK8M9LBtvPWVTC7zcBqy9UDIVvjLbN75MSTy+2UgrvttUEr530fu9YlzsvXfR+73bVBK+2UgrvkxJPL4y2ze+UDIVvtwGrL1lUwu8LBtvPUwrwz07wLw9J5piPbLMhTxGSIE9XaPAPUwrwz1HjoM9g7YePLZhWb3WsN+9uE8ZvuIJMb4pDTu+epY9vkLJPb56lj2+KQ07vuIJMb64Txm+1rDfvbZhWb2Dth48R46DPUwrwz1do8A9RkiBPbLMhTwHE668cPymPEZIgT07wLw9jH7IPSzXoT0m/Co9DaR7u4JqRL3cBqy91rDfvUI9/b3lXQO+Qj39vdaw373cBqy9gmpEvQ2ke7sm/Co9LNehPYx+yD07wLw9RkiBPXD8pjwHE6683gY+vQcTrryyzIU8J5piPRPmrT0xV8k9oErBPZdknT1zOlU9chnZPLNYrDtlUwu8HuZYvGVTC7yzWKw7chnZPHM6VT2XZJ09oErBPTFXyT0T5q09J5piPbLMhTwHE6683gY+vQ==", + "encoding": "base64", + "path": [ + "y", + 2, + "data" + ] + }, + { + "data": "wUpsvT4VPr3KD4i8L8jAPIIogT0mcL09z7baPSFM2T0zkcE983+fPdkxfT12/k49CYI+PXb+Tj3ZMX0983+fPTORwT0hTNk9z7baPSZwvT2CKIE9L8jAPMoPiLw+FT69wUpsvT4VPr0P1FK8j6MGPZeRmz2T2NI9+pzaPS2utD0k8V49DYNzPNpHtLy3Qk+9vsyLvUnul72+zIu9t0JPvdpHtLwNg3M8JPFePS2utD36nNo9k9jSPZeRmz2PowY9D9RSvD4VPr3KD4i8j6MGPfjKoz1Bhtk9KNLOPWK+hT3f6SE8t0JPvRJO1L3IExK+3d0qvupvN74hKDu+6m83vt3dKr7IExK+Ek7UvbdCT73f6SE8Yr6FPSjSzj1Bhtk9+MqjPY+jBj3KD4i8L8jAPJeRmz1Bhtk9ob/IPXb+Tj3aR7S8mVXIvbZ0Ib7LsUS+gYtPvhdHS75uEkO+ZlI/vm4SQ74XR0u+gYtPvsuxRL62dCG+mVXIvdpHtLx2/k49ob/IPUGG2T2XkZs9L8jAPIIogT2T2NI9KNLOPXb+Tj1kSgi9No/3vSEoO772kU++2Qs7viu3Db5ml7i9lsFfvUQJK72WwV+9Zpe4vSu3Db7ZCzu+9pFPviEoO742j/e9ZEoIvXb+Tj0o0s49k9jSPYIogT0mcL09+pzaPWK+hT3aR7S8No/3vfDMQb4XR0u+YOIVvpbBX70Ypjg9zNoBPtnRNT40FEc+2dE1PszaAT4Ypjg9lsFfvWDiFb4XR0u+8MxBvjaP973aR7S8Yr6FPfqc2j0mcL09z7baPS2utD3f6SE8mVXIvSEoO74XR0u+NvkEvuBziLlLJBM+jeiEPkOYqD5KJ7g+ZPq7PkonuD5DmKg+jeiEPkskEz7gc4i5NvkEvhdHS74hKDu+mVXIvd/pITwtrrQ9z7baPSFM2T0k8V49t0JPvbZ0Ib72kU++YOIVvuBziLnZ0TU+YUWiPhEnwT48+7s+LyOpPv25nz4vI6k+PPu7PhEnwT5hRaI+2dE1PuBziLlg4hW+9pFPvrZ0Ib63Qk+9JPFePSFM2T0zkcE9DYNzPBJO1L3LsUS+2Qs7vpbBX71LJBM+YUWiPmaDwj79uZ8+MowrPkb0Dz3sVYm8RvQPPTKMKz79uZ8+ZoPCPmFFoj5LJBM+lsFfvdkLO77LsUS+Ek7UvQ2DczwzkcE983+fPdpHtLzIExK+gYtPviu3Db4Ypjg9jeiEPhEnwT79uZ8+lGKqPbmBRr7JvMm+lo3svsm8yb65gUa+lGKqPf25nz4RJ8E+jeiEPhimOD0rtw2+gYtPvsgTEr7aR7S883+fPdkxfT23Qk+93d0qvhdHS75ml7i9zNoBPkOYqD48+7s+MowrPrmBRr49Nwe/9/Evv0LrNb/38S+/PTcHv7mBRr4yjCs+PPu7PkOYqD7M2gE+Zpe4vRdHS77d3Sq+t0JPvdkxfT12/k49vsyLvepvN75uEkO+lsFfvdnRNT5KJ7g+LyOpPkb0Dz3JvMm+9/Evv6T9JL+v5ve+pP0kv/fxL7/JvMm+RvQPPS8jqT5KJ7g+2dE1PpbBX71uEkO+6m83vr7Mi712/k49CYI+PUnul70hKDu+ZlI/vkQJK700FEc+ZPq7Pv25nz7sVYm8lo3svkLrNb+v5ve+h9xjPq/m975C6zW/lo3svuxVibz9uZ8+ZPq7PjQURz5ECSu9ZlI/viEoO75J7pe9CYI+PXb+Tj2+zIu96m83vm4SQ76WwV+92dE1PkonuD4vI6k+RvQPPcm8yb738S+/pP0kv6/m976k/SS/9/Evv8m8yb5G9A89LyOpPkonuD7Z0TU+lsFfvW4SQ77qbze+vsyLvXb+Tj3ZMX09t0JPvd3dKr4XR0u+Zpe4vczaAT5DmKg+PPu7PjKMKz65gUa+PTcHv/fxL79C6zW/9/Evvz03B7+5gUa+MowrPjz7uz5DmKg+zNoBPmaXuL0XR0u+3d0qvrdCT73ZMX0983+fPdpHtLzIExK+gYtPviu3Db4Ypjg9jeiEPhEnwT79uZ8+lGKqPbmBRr7JvMm+lo3svsm8yb65gUa+lGKqPf25nz4RJ8E+jeiEPhimOD0rtw2+gYtPvsgTEr7aR7S883+fPTORwT0Ng3M8Ek7UvcuxRL7ZCzu+lsFfvUskEz5hRaI+ZoPCPv25nz4yjCs+RvQPPexVibxG9A89MowrPv25nz5mg8I+YUWiPkskEz6WwV+92Qs7vsuxRL4STtS9DYNzPDORwT0hTNk9JPFePbdCT722dCG+9pFPvmDiFb7gc4i52dE1PmFFoj4RJ8E+PPu7Pi8jqT79uZ8+LyOpPjz7uz4RJ8E+YUWiPtnRNT7gc4i5YOIVvvaRT762dCG+t0JPvSTxXj0hTNk9z7baPS2utD3f6SE8mVXIvSEoO74XR0u+NvkEvuBziLlLJBM+jeiEPkOYqD5KJ7g+ZPq7PkonuD5DmKg+jeiEPkskEz7gc4i5NvkEvhdHS74hKDu+mVXIvd/pITwtrrQ9z7baPSZwvT36nNo9Yr6FPdpHtLw2j/e98MxBvhdHS75g4hW+lsFfvRimOD3M2gE+2dE1PjQURz7Z0TU+zNoBPhimOD2WwV+9YOIVvhdHS77wzEG+No/3vdpHtLxivoU9+pzaPSZwvT2CKIE9k9jSPSjSzj12/k49ZEoIvTaP970hKDu+9pFPvtkLO74rtw2+Zpe4vZbBX71ECSu9lsFfvWaXuL0rtw2+2Qs7vvaRT74hKDu+No/3vWRKCL12/k49KNLOPZPY0j2CKIE9L8jAPJeRmz1Bhtk9ob/IPXb+Tj3aR7S8mVXIvbZ0Ib7LsUS+gYtPvhdHS75uEkO+ZlI/vm4SQ74XR0u+gYtPvsuxRL62dCG+mVXIvdpHtLx2/k49ob/IPUGG2T2XkZs9L8jAPMoPiLyPowY9+MqjPUGG2T0o0s49Yr6FPd/pITy3Qk+9Ek7UvcgTEr7d3Sq+6m83viEoO77qbze+3d0qvsgTEr4STtS9t0JPvd/pITxivoU9KNLOPUGG2T34yqM9j6MGPcoPiLw+FT69D9RSvI+jBj2XkZs9k9jSPfqc2j0trrQ9JPFePQ2DczzaR7S8t0JPvb7Mi71J7pe9vsyLvbdCT73aR7S8DYNzPCTxXj0trrQ9+pzaPZPY0j2XkZs9j6MGPQ/UUrw+FT69wUpsvT4VPr3KD4i8L8jAPIIogT0mcL09z7baPSFM2T0zkcE983+fPdkxfT12/k49CYI+PXb+Tj3ZMX0983+fPTORwT0hTNk9z7baPSZwvT2CKIE9L8jAPMoPiLw+FT69wUpsvQ==", + "encoding": "base64", + "path": [ + "y", + 3, + "data" + ] + }, + { + "data": "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", + "encoding": "base64", + "path": [ + "y", + 4, + "data" + ] + }, + { + "data": "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", + "encoding": "base64", + "path": [ + "y", + 5, + "data" + ] + }, + { + "data": "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", + "encoding": "base64", + "path": [ + "y", + 6, + "data" + ] + }, + { + "data": "l/iZOWzyEr11dIi9bb2nvQcDnr3tGl69/9mgvC6XlzzseFo9SHSlPbjqyz2+oOE9CpDoPb6g4T246ss9SHSlPex4Wj0ul5c8/9mgvO0aXr0HA569bb2nvXV0iL1s8hK9l/iZOWzyEr2BSo29dTCpvVjLj72RJg29QTNyPJV5hT2UiNo9o8IJPt2pGD5V8h0+d44ePiZLHj53jh4+VfIdPt2pGD6jwgk+lIjaPZV5hT1BM3I8kSYNvVjLj711MKm9gUqNvWzyEr11dIi9dTCpvaG1ib1gTbq8jSYaPXJrxD0SWQw+VfIdPhs1GT56lAY+uNHgPUjqvj3UZrI9SOq+PbjR4D16lAY+GzUZPlXyHT4SWQw+cmvEPY0mGj1gTbq8obWJvXUwqb11dIi9bb2nvVjLj71gTbq8xjQ6Pb6g4T3dqRg+Hb8aPhtg9D3fSYk92zwuPLT1Fb1OL4m982aevU4vib209RW92zwuPN9JiT0bYPQ9Hb8aPt2pGD6+oOE9xjQ6PWBNurxYy4+9bb2nvQcDnr2RJg29jSYaPb6g4T1EYBs+DPESPtRmsj0TpdA62sqzvYIhJb5Zd1e+wzdyvn1Rer7DN3K+WXdXvoIhJb7ayrO9E6XQOtRmsj0M8RI+RGAbPr6g4T2NJho9kSYNvQcDnr3tGl69QTNyPHJrxD3dqRg+DPESPuuUlz209RW9lIgavsM3cr5ZmY++w52Uviexkb5/k4++J7GRvsOdlL5ZmY++wzdyvpSIGr609RW965SXPQzxEj7dqRg+cmvEPUEzcjztGl69/9mgvJV5hT0SWQw+Hb8aPtRmsj209RW98pgvvqLGh77mL5S+u8WAvq37PL5csgG+SLfVvVyyAb6t+zy+u8WAvuYvlL6ixoe+8pgvvrT1Fb3UZrI9Hb8aPhJZDD6VeYU9/9mgvC6XlzyUiNo9VfIdPhtg9D0TpdA6lIgavqLGh74nsZG+f6xNvrucYr1CB7o9pJdDPlb8Zj6kl0M+Qge6PbucYr1/rE2+J7GRvqLGh76UiBq+E6XQOhtg9D1V8h0+lIjaPS6XlzzseFo9o8IJPhs1GT7fSYk92sqzvcM3cr7mL5S+f6xNvoQfKbpW/GY+UIzKPtx09j6vBgE/3HT2PlCMyj5W/GY+hB8pun+sTb7mL5S+wzdyvtrKs73fSYk9GzUZPqPCCT7seFo9SHSlPd2pGD56lAY+2zwuPIIhJb5ZmY++u8WAvrucYr1W/GY+Qh3pPiENCz8MKgQ/RMr4PgwqBD8hDQs/Qh3pPlb8Zj67nGK9u8WAvlmZj76CISW+2zwuPHqUBj7dqRg+SHSlPbjqyz1V8h0+uNHgPbT1Fb1Zd1e+w52Uvq37PL5CB7o9UIzKPiENCz/6JOI+E3hLPll4jD0TeEs++iTiPiENCz9QjMo+Qge6Pa37PL7DnZS+WXdXvrT1Fb240eA9VfIdPrjqyz2+oOE9d44ePkjqvj1OL4m9wzdyviexkb5csgG+pJdDPtx09j4MKgQ/E3hLPtuimr4WthG/26KavhN4Sz4MKgQ/3HT2PqSXQz5csgG+J7GRvsM3cr5OL4m9SOq+PXeOHj6+oOE9CpDoPSZLHj7UZrI982aevX1Rer5/k4++SLfVvVb8Zj6vBgE/RMr4Pll4jD0WthG/AACAvxa2Eb9ZeIw9RMr4Pq8GAT9W/GY+SLfVvX+Tj759UXq+82aevdRmsj0mSx4+CpDoPb6g4T13jh4+SOq+PU4vib3DN3K+J7GRvlyyAb6kl0M+3HT2PgwqBD8TeEs+26Kavha2Eb/bopq+E3hLPgwqBD/cdPY+pJdDPlyyAb4nsZG+wzdyvk4vib1I6r49d44ePr6g4T246ss9VfIdPrjR4D209RW9WXdXvsOdlL6t+zy+Qge6PVCMyj4hDQs/+iTiPhN4Sz5ZeIw9E3hLPvok4j4hDQs/UIzKPkIHuj2t+zy+w52Uvll3V7609RW9uNHgPVXyHT646ss9SHSlPd2pGD56lAY+2zwuPIIhJb5ZmY++u8WAvrucYr1W/GY+Qh3pPiENCz8MKgQ/RMr4PgwqBD8hDQs/Qh3pPlb8Zj67nGK9u8WAvlmZj76CISW+2zwuPHqUBj7dqRg+SHSlPex4Wj2jwgk+GzUZPt9JiT3ayrO9wzdyvuYvlL5/rE2+hB8pulb8Zj5QjMo+3HT2Pq8GAT/cdPY+UIzKPlb8Zj6EHym6f6xNvuYvlL7DN3K+2sqzvd9JiT0bNRk+o8IJPux4Wj0ul5c8lIjaPVXyHT4bYPQ9E6XQOpSIGr6ixoe+J7GRvn+sTb67nGK9Qge6PaSXQz5W/GY+pJdDPkIHuj27nGK9f6xNviexkb6ixoe+lIgavhOl0DobYPQ9VfIdPpSI2j0ul5c8/9mgvJV5hT0SWQw+Hb8aPtRmsj209RW98pgvvqLGh77mL5S+u8WAvq37PL5csgG+SLfVvVyyAb6t+zy+u8WAvuYvlL6ixoe+8pgvvrT1Fb3UZrI9Hb8aPhJZDD6VeYU9/9mgvO0aXr1BM3I8cmvEPd2pGD4M8RI+65SXPbT1Fb2UiBq+wzdyvlmZj77DnZS+J7GRvn+Tj74nsZG+w52UvlmZj77DN3K+lIgavrT1Fb3rlJc9DPESPt2pGD5ya8Q9QTNyPO0aXr0HA569kSYNvY0mGj2+oOE9RGAbPgzxEj7UZrI9E6XQOtrKs72CISW+WXdXvsM3cr59UXq+wzdyvll3V76CISW+2sqzvROl0DrUZrI9DPESPkRgGz6+oOE9jSYaPZEmDb0HA569bb2nvVjLj71gTbq8xjQ6Pb6g4T3dqRg+Hb8aPhtg9D3fSYk92zwuPLT1Fb1OL4m982aevU4vib209RW92zwuPN9JiT0bYPQ9Hb8aPt2pGD6+oOE9xjQ6PWBNurxYy4+9bb2nvXV0iL11MKm9obWJvWBNuryNJho9cmvEPRJZDD5V8h0+GzUZPnqUBj640eA9SOq+PdRmsj1I6r49uNHgPXqUBj4bNRk+VfIdPhJZDD5ya8Q9jSYaPWBNuryhtYm9dTCpvXV0iL1s8hK9gUqNvXUwqb1Yy4+9kSYNvUEzcjyVeYU9lIjaPaPCCT7dqRg+VfIdPneOHj4mSx4+d44ePlXyHT7dqRg+o8IJPpSI2j2VeYU9QTNyPJEmDb1Yy4+9dTCpvYFKjb1s8hK9l/iZOWzyEr11dIi9bb2nvQcDnr3tGl69/9mgvC6XlzzseFo9SHSlPbjqyz2+oOE9CpDoPb6g4T246ss9SHSlPex4Wj0ul5c8/9mgvO0aXr0HA569bb2nvXV0iL1s8hK9l/iZOQ==", + "encoding": "base64", + "path": [ + "y", + 7, + "data" + ] + }, + { + "data": "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", + "encoding": "base64", + "path": [ + "y", + 8, + "data" + ] + }, + { + "data": "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", + "encoding": "base64", + "path": [ + "y", + 9, + "data" + ] + }, + { + "data": "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", + "encoding": "base64", + "path": [ + "y", + 10, + "data" + ] + }, + { + "data": "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", + "encoding": "base64", + "path": [ + "y", + 11, + "data" + ] + }, + { + "data": "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", + "encoding": "base64", + "path": [ + "y", + 12, + "data" + ] + }, + { + "data": "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", + "encoding": "base64", + "path": [ + "y", + 13, + "data" + ] + }, + { + "data": "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", + "encoding": "base64", + "path": [ + "y", + 14, + "data" + ] + }, + { + "data": "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", + "encoding": "base64", + "path": [ + "z", + 0, + "data" + ] + } + ], + "model_module": "ipyvolume", + "model_module_version": "^0.5.0-beta.1", + "model_name": "ScatterModel", + "state": { + "geo": "sphere", + "line_material": "IPY_MODEL_3681c5ad188d4b8e997027c2b67dd235", + "material": "IPY_MODEL_c44c743a4ccd48e3b3325e7349818580", + "selected": null, + "sequence_index": 14, + "size": 2, + "size_selected": 2.6, + "texture": null, + "visible": true, + "vx": null, + "vy": null, + "vz": null, + "x": [ + { + "data": {}, + "dtype": "float32", + "shape": [ + 625 + ] + } + ], + "y": [ + { + "data": {}, + "dtype": "float32", + "shape": [ + 625 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 625 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 625 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 625 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 625 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 625 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 625 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 625 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 625 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 625 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 625 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 625 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 625 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 625 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 625 + ] + } + ], + "z": [ + { + "data": {}, + "dtype": "float32", + "shape": [ + 625 + ] + } + ] + } + }, + "0c447892c5bd4a61a4610427bae1810e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.1.0", + "model_name": "LayoutModel", + "state": {} + }, + "0fa46a2814a34bd59ca3e501c5d8118a": { + "model_module": "jupyter-threejs", + "model_module_version": "~1.0.0", + "model_name": "ShaderMaterialModel", + "state": { + "_model_module_version": "~1.0.0", + "_view_module": null, + "_view_module_version": "" + } + }, + "15ae0e209e304a3b9bb24fe0fea70351": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.1.0", + "model_name": "LayoutModel", + "state": {} + }, + "15ae25305a5946e9a49f0e3dae821dc0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.4.0", + "model_name": "LinkModel", + "state": { + "source": [ + "IPY_MODEL_cfb85996953142479439894fb4c96c1a", + "value" + ], + "target": [ + "IPY_MODEL_0b44784ed5904895a8c2cc1e5f71c18c", + "sequence_index" + ] + } + }, + "15d53645500840aea354c7a21d860250": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.1.0", + "model_name": "LayoutModel", + "state": {} + }, + "17d1334e9cb64d358df5ef35acb7a175": { + "model_module": "ipyvolume", + "model_module_version": "^0.5.0-beta.1", + "model_name": "FigureModel", + "state": { + "ambient_coefficient": 0.5, + "animation": 200, + "camera": "IPY_MODEL_6e3ec78da9aa467f8321c3c1d7083926", + "capture_fps": null, + "diffuse_coefficient": 0.8, + "height": 500, + "layout": "IPY_MODEL_15d53645500840aea354c7a21d860250", + "matrix_projection": [ + 2.9448154572796907, + 0, + 0, + 0, + 0, + 2.3558523658237527, + 0, + 0, + 0, + 0, + -1.00010000500025, + -1, + 0, + 0, + -0.200010000500025, + 0 + ], + "matrix_world": [ + 0.5, + 0, + 0, + 0, + 0, + 0.5, + 3.061616997868383e-17, + 0, + 0, + -3.061616997868383e-17, + 0.5, + 0, + 0, + 0, + -2, + 1 + ], + "meshes": [], + "scatters": [ + "IPY_MODEL_f864ec653a9b4f7fb057ccc1baba8ac9" + ], + "scene": "IPY_MODEL_9be9839fe9964a8e9d36c9f8e4b19fcb", + "specular_coefficient": 0.5, + "specular_exponent": 5, + "volumes": [], + "width": 400, + "xlim": [ + -1, + 1 + ], + "ylim": [ + -1, + 1 + ], + "zlim": [ + -1, + 1 + ] + } + }, + "183990fed4a245d18a801fe30c0a520d": { + "model_module": "jupyter-threejs", + "model_module_version": "~1.0.0", + "model_name": "ShaderMaterialModel", + "state": { + "_model_module_version": "~1.0.0", + "_view_module": null, + "_view_module_version": "" + } + }, + "197353e08a2a47d896802d935ab84101": { + "model_module": "jupyter-threejs", + "model_module_version": "~1.0.0", + "model_name": "SceneModel", + "state": { + "_model_module_version": "~1.0.0", + "_view_module": null, + "_view_module_version": "", + "background": null + } + }, + "1bd37a8733d045b9b28eedd3971c48d7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.4.0", + "model_name": "LinkModel", + "state": { + "source": [ + "IPY_MODEL_992acf7dd9a44c028b851bd16b142ffc", + "value" + ], + "target": [ + "IPY_MODEL_cfb85996953142479439894fb4c96c1a", + "value" + ] + } + }, + "1d444769044f4665a87e8f1ed28e6616": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.4.0", + "model_name": "FloatSliderModel", + "state": { + "layout": "IPY_MODEL_f1e04a722ad847569876e85392fab858", + "max": 2, + "style": "IPY_MODEL_78ffb23f071a47deb5aaeae37489d992", + "value": 1 + } + }, + "1fd18b0a6b764e8c92a345f2744d9fab": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.1.0", + "model_name": "LayoutModel", + "state": {} + }, + "22f0f8cc309d4401b5cdc4e70e771051": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.1.0", + "model_name": "LayoutModel", + "state": {} + }, + "2376e71f34ef4503bfccdefb9a67ccea": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.4.0", + "model_name": "VBoxModel", + "state": { + "children": [ + "IPY_MODEL_d79017ea773b4b6f9d66a60a706b6668", + "IPY_MODEL_fd44c9c13f624c51a0b923236f832f36" + ], + "layout": "IPY_MODEL_2fe81ee960c446fa8178c16622124f21" + } + }, + "239444c89b374df38fa42aa7a59fbe16": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.4.0", + "model_name": "VBoxModel", + "state": { + "children": [ + "IPY_MODEL_cc7835a92f184cba990381766ff7a5d9", + "IPY_MODEL_622cfb5427804833b3eafe2cd064c9df" + ], + "layout": "IPY_MODEL_e492fbd963294c17a8e32f74283216e9" + } + }, + "240ca8a1bc594bc0ab8adc0c4f81b4d2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.1.0", + "model_name": "LayoutModel", + "state": {} + }, + "245072663ea94bb096b2321d43813961": { + "model_module": "jupyter-threejs", + "model_module_version": "~1.0.0", + "model_name": "PerspectiveCameraModel", + "state": { + "_model_module_version": "~1.0.0", + "_view_module": null, + "_view_module_version": "", + "aspect": 0.8, + "fov": 46, + "matrix": [ + 1, + 0, + 0, + 0, + 0, + 1, + -6.123233995736766e-17, + 0, + 0, + 6.123233995736766e-17, + 1, + 0, + 0, + 1.2246467991473532e-16, + 2, + 1 + ], + "matrixWorld": [ + 1, + 0, + 0, + 0, + 0, + 1, + -6.123233995736766e-17, + 0, + 0, + 6.123233995736766e-17, + 1, + 0, + 0, + 1.2246467991473532e-16, + 2, + 1 + ], + "matrixWorldInverse": [ + 1, + 0, + 0, + 0, + 0, + 1, + 6.123233995736766e-17, + 0, + 0, + -6.123233995736766e-17, + 1, + 0, + 0, + 0, + -2, + 1 + ], + "position": [ + 0, + 1.2246467991473532e-16, + 2 + ], + "projectionMatrix": [ + 2.9448154572796907, + 0, + 0, + 0, + 0, + 2.3558523658237527, + 0, + 0, + 0, + 0, + -1.00010000500025, + -1, + 0, + 0, + -0.200010000500025, + 0 + ], + "quaternion": [ + -3.061616997868383e-17, + 0, + 0, + 1 + ], + "rotation": [ + -6.123233995736766e-17, + 0, + 0, + "XYZ" + ] + } + }, + "25277f48e0c34a6682c66c20e00a34e7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.1.0", + "model_name": "LayoutModel", + "state": {} + }, + "2a90868385684f20b94ba826b2ed0853": { + "model_module": "ipyvolume", + "model_module_version": "^0.5.0-beta.1", + "model_name": "FigureModel", + "state": { + "ambient_coefficient": 0.5, + "animation": 200, + "camera": "IPY_MODEL_00a1968307f74adb9fddf3dc4f38828e", + "capture_fps": null, + "diffuse_coefficient": 0.8, + "height": 500, + "layout": "IPY_MODEL_bb6a8238f7ab431ca448bad38fcd6ebf", + "matrix_projection": [ + 2.9448154572796907, + 0, + 0, + 0, + 0, + 2.3558523658237527, + 0, + 0, + 0, + 0, + -1.00010000500025, + -1, + 0, + 0, + -0.200010000500025, + 0 + ], + "matrix_world": [ + 0.02678726034114551, + 0, + 0, + 0, + 0, + 0.03542447592596365, + 2.1691235527101927e-18, + 0, + 0, + -1.6486250790977329e-18, + 0.026924090770425724, + 0, + -0.024263206626966793, + -0.01759644420729889, + -1.9748047549075112, + 1 + ], + "meshes": [], + "scatters": [ + "IPY_MODEL_c54af9ae087647a0a8902750e345c6db" + ], + "scene": "IPY_MODEL_ca43709a8b204164a304b73735979e94", + "specular_coefficient": 0.5, + "specular_exponent": 5, + "style": { + "axes": { + "color": "white", + "label": { + "color": "white" + }, + "ticklabel": { + "color": "white" + }, + "visible": true + }, + "background-color": "#000001", + "box": { + "visible": true + } + }, + "volumes": [], + "width": 400, + "xlim": [ + -17.7598152, + 19.5713634 + ], + "ylim": [ + -13.6178036, + 14.6112661 + ], + "zlim": [ + -19.5065174, + 17.6349411 + ] + } + }, + "2c5d0c58a1b1495fb47908a36488c868": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.4.0", + "model_name": "FloatSliderModel", + "state": { + "layout": "IPY_MODEL_c4852057e7db42df8225fa43e52eed81", + "max": 49, + "style": "IPY_MODEL_fc3eca8b4090422bbff25ef37b9707c6", + "value": 17 + } + }, + "2fe81ee960c446fa8178c16622124f21": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.1.0", + "model_name": "LayoutModel", + "state": {} + }, + "3681c5ad188d4b8e997027c2b67dd235": { + "model_module": "jupyter-threejs", + "model_module_version": "~1.0.0", + "model_name": "ShaderMaterialModel", + "state": { + "_model_module_version": "~1.0.0", + "_view_module": null, + "_view_module_version": "" + } + }, + "3bd5bd6b326b48749588ca49278a6f8a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.4.0", + "model_name": "SliderStyleModel", + "state": { + "description_width": "" + } + }, + "3d55f5ad3de442cabccb2f8b4c9658f9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.4.0", + "model_name": "LinkModel", + "state": { + "source": [ + "IPY_MODEL_1d444769044f4665a87e8f1ed28e6616", + "value" + ], + "target": [ + "IPY_MODEL_6cbccad5b7db418eb20315cbbe3ea8be", + "sequence_index" + ] + } + }, + "3ddf7e481aec4de694577c019c98cfaf": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.1.0", + "model_name": "LayoutModel", + "state": {} + }, + "3e659ec033324585a78699bc32925032": { + "model_module": "@jupyter-widgets/output", + "model_module_version": "1.0.0", + "model_name": "OutputModel", + "state": { + "layout": "IPY_MODEL_884c07ef1ced4620b5cae4676ac3f5b5", + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": "convert -delay 5.0 -loop 0 /var/folders/4h/rklzvjwj08170p1nlsntfdkw0000gn/T/tmprcddbnx7/frame-*.png wave.gif\n" + } + ] + } + }, + "3e8cee824d0f4b68ad7f23b1717c261e": { + "model_module": "jupyter-threejs", + "model_module_version": "~1.0.0", + "model_name": "ShaderMaterialModel", + "state": { + "_model_module_version": "~1.0.0", + "_view_module": null, + "_view_module_version": "" + } + }, + "4163df1232f24aeb85117381a8944736": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.4.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "42dbcaf6de244359ae06cf249b1762fa": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.1.0", + "model_name": "LayoutModel", + "state": {} + }, + "4d7a6daf02e04c048401fe27f6e9411b": { + "model_module": "jupyter-threejs", + "model_module_version": "~1.0.0", + "model_name": "PerspectiveCameraModel", + "state": { + "_model_module_version": "~1.0.0", + "_view_module": null, + "_view_module_version": "", + "aspect": 0.8, + "fov": 46, + "matrix": [ + 1, + 0, + 0, + 0, + 0, + 1, + -6.123233995736766e-17, + 0, + 0, + 6.123233995736766e-17, + 1, + 0, + 0, + 1.2246467991473532e-16, + 2, + 1 + ], + "matrixWorld": [ + 1, + 0, + 0, + 0, + 0, + 1, + -6.123233995736766e-17, + 0, + 0, + 6.123233995736766e-17, + 1, + 0, + 0, + 1.2246467991473532e-16, + 2, + 1 + ], + "matrixWorldInverse": [ + 1, + 0, + 0, + 0, + 0, + 1, + 6.123233995736766e-17, + 0, + 0, + -6.123233995736766e-17, + 1, + 0, + 0, + 0, + -2, + 1 + ], + "position": [ + 0, + 1.2246467991473532e-16, + 2 + ], + "projectionMatrix": [ + 2.9448154572796907, + 0, + 0, + 0, + 0, + 2.3558523658237527, + 0, + 0, + 0, + 0, + -1.00010000500025, + -1, + 0, + 0, + -0.200010000500025, + 0 + ], + "quaternion": [ + -3.061616997868383e-17, + 0, + 0, + 1 + ], + "rotation": [ + -6.123233995736766e-17, + 0, + 0, + "XYZ" + ] + } + }, + "551355880ae0411d851959f2aa7992b0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.1.0", + "model_name": "LayoutModel", + "state": {} + }, + "5a2ace988cc0485f8d31dd37b76a4365": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.1.0", + "model_name": "LayoutModel", + "state": {} + }, + "5b4887ec78ba48979450cc5618b18676": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.4.0", + "model_name": "LinkModel", + "state": { + "source": [ + "IPY_MODEL_e13c3dfe59994790b9a7b82c10c980a6", + "value" + ], + "target": [ + "IPY_MODEL_f864ec653a9b4f7fb057ccc1baba8ac9", + "sequence_index" + ] + } + }, + "622cfb5427804833b3eafe2cd064c9df": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.4.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_d4522e05191c44e59e373863e22cab61", + "IPY_MODEL_1d444769044f4665a87e8f1ed28e6616" + ], + "layout": "IPY_MODEL_706c95dc7c4447339433780af111bdea" + } + }, + "6b0dfc7b72df4df7bc5882fa15cb6440": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.4.0", + "model_name": "PlayModel", + "state": { + "interval": 200, + "layout": "IPY_MODEL_773829e529f94dc293c859db15bb5dd0", + "max": 2, + "style": "IPY_MODEL_edbdc0ff545b4bddb8d1bd00dd7ee5a7", + "value": 1 + } + }, + "6cbccad5b7db418eb20315cbbe3ea8be": { + "buffers": [ + { + "data": "AACAv83MTL8=", + "encoding": "base64", + "path": [ + "x", + 0, + "data" + ] + }, + { + "data": "AACAP83MzL0=", + "encoding": "base64", + "path": [ + "x", + 1, + "data" + ] + }, + { + "data": "AAAAAAAAAD8=", + "encoding": "base64", + "path": [ + "x", + 2, + "data" + ] + }, + { + "data": "AAAAAAAAAAA=", + "encoding": "base64", + "path": [ + "y", + 0, + "data" + ] + }, + { + "data": "AAAAAAAAAAA=", + "encoding": "base64", + "path": [ + "z", + 0, + "data" + ] + } + ], + "model_module": "ipyvolume", + "model_module_version": "^0.5.0-beta.1", + "model_name": "ScatterModel", + "state": { + "geo": "sphere", + "line_material": "IPY_MODEL_9401412e9014496d8a9b26f859ee9b9a", + "material": "IPY_MODEL_183990fed4a245d18a801fe30c0a520d", + "selected": null, + "sequence_index": 1, + "size": 10, + "size_selected": 2.6, + "texture": null, + "visible": true, + "vx": null, + "vy": null, + "vz": null, + "x": [ + { + "data": {}, + "dtype": "float32", + "shape": [ + 2 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 2 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 2 + ] + } + ], + "y": [ + { + "data": {}, + "dtype": "float32", + "shape": [ + 2 + ] + } + ], + "z": [ + { + "data": {}, + "dtype": "float32", + "shape": [ + 2 + ] + } + ] + } + }, + "6d29285938e64814b00bb4c8dbfde5ee": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.4.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "6e3ec78da9aa467f8321c3c1d7083926": { + "model_module": "jupyter-threejs", + "model_module_version": "~1.0.0", + "model_name": "PerspectiveCameraModel", + "state": { + "_model_module_version": "~1.0.0", + "_view_module": null, + "_view_module_version": "", + "aspect": 0.8, + "fov": 46, + "matrix": [ + 1, + 0, + 0, + 0, + 0, + 1, + -6.123233995736766e-17, + 0, + 0, + 6.123233995736766e-17, + 1, + 0, + 0, + 1.2246467991473532e-16, + 2, + 1 + ], + "matrixWorld": [ + 1, + 0, + 0, + 0, + 0, + 1, + -6.123233995736766e-17, + 0, + 0, + 6.123233995736766e-17, + 1, + 0, + 0, + 1.2246467991473532e-16, + 2, + 1 + ], + "matrixWorldInverse": [ + 1, + 0, + 0, + 0, + 0, + 1, + 6.123233995736766e-17, + 0, + 0, + -6.123233995736766e-17, + 1, + 0, + 0, + 0, + -2, + 1 + ], + "position": [ + 0, + 1.2246467991473532e-16, + 2 + ], + "projectionMatrix": [ + 2.9448154572796907, + 0, + 0, + 0, + 0, + 2.3558523658237527, + 0, + 0, + 0, + 0, + -1.00010000500025, + -1, + 0, + 0, + -0.200010000500025, + 0 + ], + "quaternion": [ + -3.061616997868383e-17, + 0, + 0, + 1 + ], + "rotation": [ + -6.123233995736766e-17, + 0, + 0, + "XYZ" + ] + } + }, + "706c95dc7c4447339433780af111bdea": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.1.0", + "model_name": "LayoutModel", + "state": {} + }, + "7448e479d27248c19a6c873e2f5bb7c9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.4.0", + "model_name": "LinkModel", + "state": { + "source": [ + "IPY_MODEL_6b0dfc7b72df4df7bc5882fa15cb6440", + "value" + ], + "target": [ + "IPY_MODEL_e13c3dfe59994790b9a7b82c10c980a6", + "value" + ] + } + }, + "75202cde091f4ea7889b666f63fc7bfb": { + "model_module": "jupyter-threejs", + "model_module_version": "~1.0.0", + "model_name": "ShaderMaterialModel", + "state": { + "_model_module_version": "~1.0.0", + "_view_module": null, + "_view_module_version": "" + } + }, + "75a153b2ab5b4400bf47853755764681": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.4.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_6b0dfc7b72df4df7bc5882fa15cb6440", + "IPY_MODEL_e13c3dfe59994790b9a7b82c10c980a6" + ], + "layout": "IPY_MODEL_82a162deabf6488c96e92705600a4066" + } + }, + "773829e529f94dc293c859db15bb5dd0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.1.0", + "model_name": "LayoutModel", + "state": {} + }, + "782e95449c6e4d0cb991480d9f939f13": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.4.0", + "model_name": "LinkModel", + "state": { + "source": [ + "IPY_MODEL_85981af75a454270ad935917abaadf9c", + "value" + ], + "target": [ + "IPY_MODEL_2c5d0c58a1b1495fb47908a36488c868", + "value" + ] + } + }, + "78ffb23f071a47deb5aaeae37489d992": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.4.0", + "model_name": "SliderStyleModel", + "state": { + "description_width": "" + } + }, + "82a162deabf6488c96e92705600a4066": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.1.0", + "model_name": "LayoutModel", + "state": {} + }, + "85981af75a454270ad935917abaadf9c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.4.0", + "model_name": "PlayModel", + "state": { + "interval": 200, + "layout": "IPY_MODEL_a62decff28d6453892e86db5124c6709", + "max": 49, + "style": "IPY_MODEL_6d29285938e64814b00bb4c8dbfde5ee", + "value": 17 + } + }, + "884c07ef1ced4620b5cae4676ac3f5b5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.1.0", + "model_name": "LayoutModel", + "state": {} + }, + "89cdd81186ea4bc0bb2aef5a531a311d": { + "model_module": "jupyter-threejs", + "model_module_version": "~1.0.0", + "model_name": "SceneModel", + "state": { + "_model_module_version": "~1.0.0", + "_view_module": null, + "_view_module_version": "", + "background": null + } + }, + "8cd7b3c022054937a9d9fc5778faa430": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.1.0", + "model_name": "LayoutModel", + "state": {} + }, + "8d8e0d6a071745a7b0e3ef10616ac0bb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.4.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_85981af75a454270ad935917abaadf9c", + "IPY_MODEL_2c5d0c58a1b1495fb47908a36488c868" + ], + "layout": "IPY_MODEL_c641231c68b14e8292677203201fa6b0" + } + }, + "8dbf31d0ae3648cbabe83f95f9b7e3b5": { + "model_module": "ipyvolume", + "model_module_version": "^0.5.0-beta.1", + "model_name": "FigureModel", + "state": { + "ambient_coefficient": 0.5, + "camera": "IPY_MODEL_cfb2da5a977640d4af4ec44890f9a747", + "capture_fps": null, + "diffuse_coefficient": 0.8, + "height": 500, + "layout": "IPY_MODEL_240ca8a1bc594bc0ab8adc0c4f81b4d2", + "matrix_projection": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_world": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "meshes": [], + "scatters": [], + "scene": "IPY_MODEL_89cdd81186ea4bc0bb2aef5a531a311d", + "specular_coefficient": 0.5, + "specular_exponent": 5, + "volumes": [], + "width": 400 + } + }, + "8dfd1ab1047f429184adb52dc5dbd182": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.4.0", + "model_name": "VBoxModel", + "state": { + "children": [ + "IPY_MODEL_2a90868385684f20b94ba826b2ed0853", + "IPY_MODEL_8d8e0d6a071745a7b0e3ef10616ac0bb" + ], + "layout": "IPY_MODEL_1fd18b0a6b764e8c92a345f2744d9fab" + } + }, + "8f267d3de871489e9d9f86652fb27317": { + "model_module": "jupyter-threejs", + "model_module_version": "~1.0.0", + "model_name": "ShaderMaterialModel", + "state": { + "_model_module_version": "~1.0.0", + "_view_module": null, + "_view_module_version": "" + } + }, + "9401412e9014496d8a9b26f859ee9b9a": { + "model_module": "jupyter-threejs", + "model_module_version": "~1.0.0", + "model_name": "ShaderMaterialModel", + "state": { + "_model_module_version": "~1.0.0", + "_view_module": null, + "_view_module_version": "" + } + }, + "9422aefc9f9d4beb922e66bc48c1dc2d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.4.0", + "model_name": "VBoxModel", + "state": { + "children": [ + "IPY_MODEL_17d1334e9cb64d358df5ef35acb7a175", + "IPY_MODEL_75a153b2ab5b4400bf47853755764681" + ], + "layout": "IPY_MODEL_551355880ae0411d851959f2aa7992b0" + } + }, + "9909dfc27b8445c9b2c0b0e34b75bbad": { + "model_module": "jupyter-threejs", + "model_module_version": "~1.0.0", + "model_name": "SceneModel", + "state": { + "_model_module_version": "~1.0.0", + "_view_module": null, + "_view_module_version": "", + "background": null + } + }, + "992acf7dd9a44c028b851bd16b142ffc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.4.0", + "model_name": "PlayModel", + "state": { + "interval": 200, + "layout": "IPY_MODEL_0c447892c5bd4a61a4610427bae1810e", + "max": 14, + "style": "IPY_MODEL_b4de25854e2d4a4981758a983b596d7d", + "value": 14 + } + }, + "9be9839fe9964a8e9d36c9f8e4b19fcb": { + "model_module": "jupyter-threejs", + "model_module_version": "~1.0.0", + "model_name": "SceneModel", + "state": { + "_model_module_version": "~1.0.0", + "_view_module": null, + "_view_module_version": "", + "background": null + } + }, + "a10382301480402aa1ddd69c44656e92": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.1.0", + "model_name": "LayoutModel", + "state": {} + }, + "a62decff28d6453892e86db5124c6709": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.1.0", + "model_name": "LayoutModel", + "state": {} + }, + "abf85081062f4e82888c09171f55ee72": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.1.0", + "model_name": "LayoutModel", + "state": {} + }, + "b05fab60e7a440729bd5414b8c187821": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.1.0", + "model_name": "LayoutModel", + "state": {} + }, + "b3b6951b0508438ba0077da1d5dc5634": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.4.0", + "model_name": "LinkModel", + "state": { + "source": [ + "IPY_MODEL_2c5d0c58a1b1495fb47908a36488c868", + "value" + ], + "target": [ + "IPY_MODEL_c54af9ae087647a0a8902750e345c6db", + "sequence_index" + ] + } + }, + "b4de25854e2d4a4981758a983b596d7d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.4.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "bb6a8238f7ab431ca448bad38fcd6ebf": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.1.0", + "model_name": "LayoutModel", + "state": {} + }, + "bc48846669dd415cb70edde4dd74bf85": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.4.0", + "model_name": "LinkModel", + "state": { + "source": [ + "IPY_MODEL_d4522e05191c44e59e373863e22cab61", + "value" + ], + "target": [ + "IPY_MODEL_1d444769044f4665a87e8f1ed28e6616", + "value" + ] + } + }, + "bf169eb7e0d9407bbd19c23a12ca33fe": { + "model_module": "jupyter-threejs", + "model_module_version": "~1.0.0", + "model_name": "ShaderMaterialModel", + "state": { + "_model_module_version": "~1.0.0", + "_view_module": null, + "_view_module_version": "" + } + }, + "c0d781a560654bd5bcdddd6a44889c19": { + "model_module": "jupyter-threejs", + "model_module_version": "~1.0.0", + "model_name": "PerspectiveCameraModel", + "state": { + "_model_module_version": "~1.0.0", + "_view_module": null, + "_view_module_version": "", + "aspect": 0.8, + "fov": 46, + "matrix": [ + 1, + 0, + 0, + 0, + 0, + 1, + -6.123233995736766e-17, + 0, + 0, + 6.123233995736766e-17, + 1, + 0, + 0, + 1.2246467991473532e-16, + 2, + 1 + ], + "matrixWorld": [ + 1, + 0, + 0, + 0, + 0, + 1, + -6.123233995736766e-17, + 0, + 0, + 6.123233995736766e-17, + 1, + 0, + 0, + 1.2246467991473532e-16, + 2, + 1 + ], + "matrixWorldInverse": [ + -0.9987277295726381, + 0.014355444150423752, + -0.04834090820338506, + 0, + -0.04993747648021216, + -0.1482497564760616, + 0.9876883405951378, + 0, + 0.007012176942454733, + 0.9888457568943869, + 0.1487780173496581, + 0, + 1.734723475976808e-18, + 1.110223024625157e-16, + -3.9000000000000004, + 1 + ], + "position": [ + -0.048481141337516576, + 3.9378234682458557, + 0.3060978795529196 + ], + "projectionMatrix": [ + 2.9448154572796907, + 0, + 0, + 0, + 0, + 2.3558523658237527, + 0, + 0, + 0, + 0, + -1.00010000500025, + -1, + 0, + 0, + -0.200010000500025, + 0 + ], + "quaternion": [ + -0.013638269261214399, + 0.6522461107103127, + 0.7575875367570334, + -0.02121633392553267 + ], + "rotation": [ + -1.4212878018971877, + -0.04835975555170056, + -3.1272199119341355, + "XYZ" + ] + } + }, + "c44c743a4ccd48e3b3325e7349818580": { + "model_module": "jupyter-threejs", + "model_module_version": "~1.0.0", + "model_name": "ShaderMaterialModel", + "state": { + "_model_module_version": "~1.0.0", + "_view_module": null, + "_view_module_version": "" + } + }, + "c4852057e7db42df8225fa43e52eed81": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.1.0", + "model_name": "LayoutModel", + "state": {} + }, + "c54af9ae087647a0a8902750e345c6db": { + "buffers": [ + { + "data": "kJ+ov7loBMJLvVzBKK5pQO7x2T4bGlBClCPpwCqakcF28ha9gDnRQTbnq0GLDpTBNis7QaaLn8EIy47BTFzIQUyNnkEJaiFAvSsmQimUM0C5CAXATQCaQXrN9MFWy5BBRidrQZiFlMHcXx5Bn/4qQe9CMT/BaMg/fuGKQEzEfUHw9HbBkPHbvwyIxEHjgn5BUvDnwSTpC8J2VgZB0GGkwbkWWsA+z5zAAMX7QOsAAMH/TU5ACNluQA8tUUCFNS5B1CrnwUY+lsHWHUvBdji/QR+DjcDZNILACcInQM9tREE2sqhA/xXzwPeuV0Ha3JRB+tgUwTEQ9UAdgwRAnVBDwaAX8UCX5pJBUWmlwC3vHUG3SaTBh6bNQDdx4T2r+HdBEmtHQTR0j8FcKIK/LlENv6ZxAMBHdPLAGff7weLRe8GuaujB71ozwYhl78B0hM5BRkGQQVh6zMHdgcM/yhKOQbl8psBjABjCXQYSQaf2T8H+zCRAKX0OP46uF0C5MR/BkmAcwTylUUEMZQVAAn2lwTKEakHCAotBRah0QRoOZL+qiPxA8U6WQOUNk8D/riHC4WtnwP6hQ0GrV0HB7V3FQQP3vsCtV5DATLDZQY9Ng0HgA/rBCfmhwRbCvMCZ/nJB8vyWQTqIjsE/YQBCM6EBQtG1CcD80wVARgSCwFsfYkH/TZ9ANLmEQQwgT0HSIBe/zOIewFJAzEBVeaxBOUsCQfh9k0GwQATBL2inQU/2RsChEZvBpla6QcZsU8G4uKPAGEbuQKkn1sCNdYVBLZRlQDoT6b/x4IE/5bLpQNqR38Em3lhB0p/mwMbxvMBXpTJBMN0GwVxUM8GzJ+4/0wEPQrbtYMFCtNZAc2QTwG3O90FkJqlBruGaQG0aY0HlqQVCAcrQQQa0w0GKNJZBP81qQVFbqkCL1v7B0xNuQDW4TEGKG5FBXVyfQXqhs8Fx/1hC9AmDPxnIMkBPd8jAv0QSQRnj9sBVPRFBgdZDPwD2AsLjKlPByiqHv4l6vsHMJ0nBQJf+wDmOdz87THDBnrkMwcJWpcBJ5UZA6cmgQBfhjb8=", + "encoding": "base64", + "path": [ + "vx", + 0, + "data" + ] + }, + { + "data": "3CidwuuwwMKylKnC67OIwlQXYMLypsfBpLulwtASsMI8QIHCZGIJwpwpWsL/L7bCzmOKwmpSn8KUjaXCkv9FwmMIRsLmDXbCrKwjwhiDmcIWwlbCHLlFwoQWwMJ06VnCnEVYwjqbj8JB8ErCMqV9wqdcf8Jg/IPCQsyQwoO1icI774zCrri3wiRQPMJI6lvCws25wnKiwMKma3HCB/imwjlzsMLO3pjC44p/wtHGj8JmX33CkQF3woGAjsKE8W7CPKe+wiyyr8KQXafCrSQswi5TpcIq0qHC9n+Nwvy2VcJfHobCLmOowmtEUsIULWbCcLGDwv5dQ8JYtJLCwKqywvAdPsI4gFXCj8eFwiC6fcKav7/C+pl6wkSahMKCrEDC0YyQwtIOpMI3xJjCxY2XwpZki8IKH63CSLGxwurQw8Io2unCAESkwh8Lw8L2zQvCMM+NwiPgzcJ28G/CUwlIwpZakMLQmMTC731hwkClu8J4V3rCkWeqwg/ussL5CZHC0vF8wiJxksIsSbTCBt/JwvQtmsKePDTCyB0zwmb+e8Jcm3LCnqkmwh7bhsIu1NPCV2ODwrS8d8LPta7CnIVGwowXk8K+upXC80P6wbzIBsKu7r/CrGmwwqY7ssJsPFTCLMVRwsn2mMImVLLBuq4nwsqIjMIIlYjCumahwphxc8IJE3zC5urtwTDLisI/NY7ClHSBws7qhcJVqFjCuOF1wqbwlMIKG4vCfNruwYYzpsIcPqDCqtpGwvJgeMKF7p/CmKhnwggCjsIjbmrC6Aszwo67tMJKfozCXIFywsidrMKPTEfCSD2wwnYimcLDy6DCQgGlwlajbsLcc5XCZWAowqSGlMIOgWDC6s+RwmnfJ8KweyLCNfhDwhcFk8LOo7LBzvdywqReNMJG2SnC/is/wgYFecJuTajC4mJ7wsUHVMKioVTC7x0OwlRfwcLisOrB9m21wgkxlcJutHTCXpBtwiIpZcLqmZnCyOWCwgJCxsLEIKbC10WPwg/S18JjapLC7w2cwlKmhcKD8Z3CGuyOwqy5isJCfjnC6DSjwta2h8I=", + "encoding": "base64", + "path": [ + "vx", + 1, + "data" + ] + }, + { + "data": "rsEOw2ipCMNy6wvDX+YJw3KZ6sIMSNDCZ1QPw8axA8PUZfrC8Jblwusz+sIbkQjDR/EGw4pq3sK0Sw/DAosIw8aG4sI8eeXCBFH7wvCIGsNWhOTCmJXpwjSfEcPmQfnCZNnkwh566cIP/NfCqusKw7DD98LDwQPDhrMLw9waD8OGCvHCLNwcw3om58KS2fPCf/0Ow2qNEcNozPPCUk7pwg9SDcN9bArDmmMDwzLd88LEhfPCCjXdwguQDsNcG/PC7zIcw+yxAcMqAfvC2hsIwxxeFcO2JgvDheQPw6ZM/MLQJgrDpqQWw1aVCMOCEwPDjDvhwjD/3cIkwwvDkJEnw0pA38ICwQ3D+kXwwhJQEMOM4RDDmiUHw24O98KSLLvCitIbw/YLCMPc4QzDcGEIw/dXAcPuRSbD0DQJw38XIcPZ3CHDNOsTw4ypGcMUtMDCENEYw/IqDcOiJ9jCRIvfwugtA8MR5BLDKRPZwhQxI8Nnl/bCo3IXwxA8I8PAivXCz7fQwoobF8NBxiHDcBc9wwrjKMPyF+bClWn9wiI968Jt/PTCiZLXwpYQ18JukQ7DmN7pwqJu/MKmxRnDcAECw0IXA8MeewTDs4nAwv5CxsKGcQ3DSDwNwxpOGsN+o/bCSnnpwtp7/8LEztfCv3ziwg5MAcM61QHDhyMSw/mXEcOIogDD9QbLwr4WDMMDkwbDMHPywlRNBsOggwbDZo78wix5HsOvA/3C5n62woQWH8NqQOTCOvv4wiHBzcIk5AXDrWgDw0pH7cLUYQjDGGbcwmnAFMNz8AjDBC79wj8WEcM3WgDDZNAvw5LaCsNuWiXDdMQJw2pf0cIc/wrDtN7zwiLoCMP5BuPCr/0Jw6sr1cIeeerCSzfRwl4UFsPy6bXCCPMJw1A59MJ+ldzCblHQwlKc6cJI8gHDrJL1wjgS3sKKbu/CXRmawlReJsMGl8zCIF0Zw4HgEcN8Rt/CbODtwk/iysKBBBHDRfjpwnJJDMOEuAjDYRULw4hpD8PBbt7CRNgOwxEPBcMM9AzD0KL8wm4C+8KRdrLC9mMUwxy198I=", + "encoding": "base64", + "path": [ + "vx", + 2, + "data" + ] + }, + { + "data": "2fBAw8koM8NdhivD7Lo+wyZpPcNaOSnD6Ew9wxZmMsOlmjjDzYs7w7XVPsPKqTbDxnY9wxGfIMMxPkbDQLBVw6CNLMPk7x3DqO9FwxOETsPyJUHD5JJFw2AONMMddj7DIecnw4CtJcPUczXD3DxNwzArN8NcsDzDOrxEw1A/SsNm5SnD8CU9wwq/M8Pu+TfDyaY5wyx2O8OKgjHDfPocw4r7LMM4yUDD5nZHwzcwL8P+7i3D9KsTwzRdU8MqiCTDNzlWw94ZI8N6QyzDZXpUw3LsR8Om5DDDRlNFw3rJQcP4zD/DpM9NwwdUS8OAjkvD8IQrw7C8MMPAjDvD+l5Ywx49L8PP6E7Db54xwwI1TsOXzUHDiPZAw0/6LMNFdg7DUTJWw2tgLcPpwULD+oA5wwVEKMM+U1HD8Hotw9kbQMNaPkfD+ZtLww14MsPsdyfDepxWwwKPM8P0YSjD73wmwyhNM8N4LjzDNu0Ww1JuVsPo4jLDZXREww47TcOKaS3DAtsqw1CAW8NUQDvDfh5ew6FvUMMk8jrD8FdSw3d4JMPaEDHDArRDwwJlJsNaqjrDdusbw2w3NsOxbTrDw8VHw/QqL8MCIDbDeEEuw0btKMO0wCzDqa46w4gaRsPFvz3D1BMvw4yQKMMYdzTDNYwzw/R6KMPyHzbDYkZIw/DCSsNChT7DBPQ5w5KLQMPrTDjDjg0zwwAMQ8OcA1DDHXA8w5L+SMNomi/DIqUjw7dzSsNoqB3DTkpIw7CsG8OcOC7DKAxCw4M/LcM2CknDsolAwyj2MMMRfEPDerU7w+ApRsPmRUvDbHRew5ZZPcOvP0TD8FYuwwDjIMP06zfDRJ05w+LSRMMOuzPDnOhEw0lAI8NwNUPDKEsfw+ZlVcMAKyXD8ztGw7AbTcMKCC/D+TYhw9zxGsNZaSrDsH8sw2O4I8OGlDPD/scbw5PkYsPwlSPDhOAxw+5VQsOOpDHDFuElw9SmGsNg/EbD9KMcw1hzMsPohC7D1qZHw0dxK8OWshjDtCxKw1nkSMMwbkbDZQclwySNLMMw2iTDaws7w6Y7KcM=", + "encoding": "base64", + "path": [ + "vx", + 3, + "data" + ] + }, + { + "data": "H/9fw07pW8MoUVjDREdmw7QMeMPzv2PDoC9Yw7ReZMPOCGvDCrFyw7EXfsNGnl7D3rdqw+QrY8PJoHPDs854wxQwZMMiZUPDi5KAw6n8a8PmXXvD5z5+w5wXVsO4mnLDXppXww/5X8NWkG7DWO5xw+ZUa8Pu6mfDNpZuw9IyecM+VVrDlLhNw6eycMMDq23DRl5cw/ImXcPC2l/DOnxdwww8WsN6tXDDiHh2w7hdZsMGZF3DhV1Lw8jgisO8NU/Drm2DwwF0WMPk72XDlqV6w26WZ8OAplnDuN5tw9bzecNqe2TDotlzwwb6d8On5IbDDAhowwEobsNjG2DDg3V0w6BPa8MyvWzDMIBow7GQcMN6W27Diehoww2cV8OWcFHDMhWBw8j7TsNmqWvDI21hw8MDR8O6tm3DxRY/w25wXsPqHWLDgfxwwzOLT8N27GzDg/KBw6VGVcPU/13DzFdWw+hhVcN+4ljD88REwzuobMNf92vDuo5dw7LxYsM2zGXDJbVtwwKDg8Opy1PDMSF1ww6yX8ORSm7DgOt9wznhTsNgDF/DcSiCw0F0X8OgzmbDZvo7wwrEZsMKlVnDtJZ9w6BuWsMzdmbDQlVwwxifacPmLU/DElRew1SVYcMsXXjD6kpkwwj+RMMoaHLDdAxzw1ZyU8O6UmHDpaBqwwTTZMOlImvDEs5/w466acMfDWDDvlFow3ffcsPXcn7DAAJ5wzNAXsPSG1XDKBdlwzqsa8NqZFzDULOEw+4OZcP2SFzDguRrw8bHYMNGY3LDqsaAw/GBUsMSzGbD54Vyw53Ob8MAaXnDooF6w9sDYsPzglTDrGlXw7pyW8NCMV/DDWhtw4BJesMWY3HDG3V1w7ZhVcMe6YLDLDNXw7SwdsNVb2XDp/t3wxj4h8OvvWXD6Qpew1S/QsNfS0/D9DpUw+rVVsMUK2XDI99bw9K9hMPQZFrDQo9Ow6HVZcP2NXPD6jJZw4LzY8MknXDDCYFJw5geU8Okp1TDr7F3w6gvRcMGfUnDeDp7wzGihsPWmnbDLAtHw+hoXcMQJm7D3P5Yw+hqSsM=", + "encoding": "base64", + "path": [ + "vx", + 4, + "data" + ] + }, + { + "data": "CIhow3HFcMPyDXfD0NR5w8xEg8M+Q4jDUDZrw8IFgcOER4PD6g6Jw9gNkcMcGHPDjhGCw86IjMNus3XDVEV4w2h/h8Pvs23DxnWOw80bdcPbwoHDZtyIw07vaMNukYXDnJl5w1LBhMNgkIbDJLt5w7MngsOMV33DJgFsw7DhgsNudXbDteVjw0RLkMNmi4HDHTxnw6CmZsN4pXfD9h6Jw0Q3gsMUzIfD7liDwwTRg8NA2H/DMoFxw4rtk8NvfW3Dkr6Fw0ZLg8Ocf4bDW+5zwylSe8NT3nrDYv14w55iisMIbnfD0mF5wzRUfMOYdI7D4ASHw/8Ji8OFaXnDGwV8wx6Mi8Pu0WzDxqSDw2ChdcO363/DHFJ5w8pqc8OW1XzDGleGwzeycsOuZ3vDrMh7w1pZacOXBnXDwNlZw3/4ZsOfPmDDUmFxw1b/ccOHgo3DyMGGw5SsacPQuoHDCn94w3LPcsMDxFrDsBpqw0PQbMMr6ovDHiFgw8gRXcPal4XDQg6NwzgdgcPGQmvDCMh0w+FpYMM0mYTDN/B6w9C5cMNgFnvDqueFw3RvhMNA1XrDZhdlw8CLgsMy92zDT5WJw5KFd8MvGoHDNRqNw259jcOAKGnDMD9rwyB7Z8OnfonDzHOFw1shYcNKMY7DI7SSw+S6ccNw8nnDhKR9w2qGasOav3/D/LaPw1TqfMOE0XfDOmaCw7MMd8MgAojDzNGIwzQFa8PA22rD3GyKwwSPdcOgdYjDzLaRw+yFisPmCoLD2DR8w8YOgsNel37DcAiFwxAWeMP5GnPDUeSEw02Ed8ORcn/DE2h6w5vtasMoGWLDNN56wzIvhsM+5XzDIMSFw5IWh8NE3YnDL9aCw0j2ecO224vD5EKCwyB9eMPuCorDyGqHw0zNi8N3F4XD3u2Gw/jiZsMxd2bD/C9rw/kufcPmLYHDZniEw2mdb8P4IYLDy915w6B+dcPkH4vD6q12w3wNisOqQ3nDfwZpw3U5ZcP6nGvDdDKIw4LtcsPmIG/D0J51wxKYk8PwEXzDHgpvwzKnfsP2D4zDM6tzw+aAVcM=", + "encoding": "base64", + "path": [ + "vx", + 5, + "data" + ] + }, + { + "data": "B45bw/3gTcNSbGzDo9Jlw3SyXMOKOInDItpdw3zcWsPbLmfDlJ54w/XtccNPuWLD4tNrw8jagcP3XgbDeGFIwxziiMPAP17DJDt9w1hCV8NYg1XDRVpzw/BYSMPShn7DWSh+w9QkesMuIXLDtAZNw+KIa8NWJGbDH34Pw/GhVsMPcT/Doz5lw8yqjcMM9HHDVvtEwyjKPMNmmWzD9PGDw/y7eMPMRX3DL41nwwyha8MObX7D6Kxvw84SdMOPImXDlNAyw3AWecMG7XLDwp5Nw5CmU8P8P3fDEP9Nw8fZacN5LWfDklVRw+AzScPz5m7DzR55w1Y3bMMkU2rD9qpJw7g3gsNEqFTDSMJxw1J9SsP2EU3DWjRhw5zZb8MCBHzDOnpVwysjTsOI3mPD+Cdlw64KZcNmiEjD2ZpQw1RRUsPm/C3DVcQ9wwY8cMMku4PD+stXw6I0Z8MyjYDD4baBw+ylX8O00TTD8F1JwxyjSMPI0nTD+9ZVwwIDQ8O2l3PDDiJ4w5KBVsPwB2vDoA1Aw8HFSsOwSHTD5wFHwxPjbcP7r3nDCp1Tw4DXhMMT6jbDyYNZw1rTfMNcqF7D0cBvw47IZcPsg2bDJzCDw5CKi8O4akjDzxZUwyH+T8O4p2rDkyqHw4KuWsPh5ofDGTKPw3b4aMMYwG/D8r1Xwx6iXcNSjmfDIVd7w9/DYcNcY2nDLsJuw7OZW8Og/nzD2VFww4H3W8OlcWLD5VGJw6njSMNiqIbD5gh6w3hJf8NgmnrDBAZew7woe8OOEl7DdLdZw6TocsMAYGDDr+hrw2nbOMNC9k/D3AFHw86iPsMipWHDroF4w/bchcNKcG/DPFKAw7YBPcPDU2nDQpBVw8aZf8PPiHHDSI6Dw/4pUMNcyIbDW5tiw7meX8PxgIDD8o+Cw9COV8OCMU/D4JBmw7GmesO8SoDDQd+Fw2KsBsPu6oXDIQJ7w/YqZ8MYB3HDMihsw0xSgMNJW0vDLmFgw05aW8MlZ2DDoAKDw7y8cMN3GG/DfrnmwvgihsP+YxTDkJhqw4x2ZsNzYITDLINrw93EMsM=", + "encoding": "base64", + "path": [ + "vx", + 6, + "data" + ] + }, + { + "data": "Cu8OwxBrwMLcKx/DdrMNw6Gc9sK0vkbDYdcSw3oBv8K68wDDIfMKw0WIBcPhjgjDJn0FwwzeFMNmLKzBxZXnwvImR8NsMrbCBggYwyf//MI8oPPC1Uocwy4vqsLgmEfD2vdLw/r+G8OFeAnDehDowgzaDcN2ZgfDjBi4wS0i4cJ+1ELCRDEXwzJyMMNGbzPD7ujfwjDWm8KU1zHDIJkRw8jFE8O5AxPDugwGww92A8NqQTXDkuYpw+CLGcMsFyLDIs9xwlA4EcPKKA7DdLL7wqzXs8Jk9hXDGC36wg4v78J8dQ7DdcG8wiQC7ML7RxLDW30Xw6Zh1cLERA/DNOClwq3XGsOiGA3DEH8Pw3ba5MLabKXCQLALwySlMsNSYzDD1ITFwnTGaMLb1hXDBv0Iw8lDHcMKv87CR8S5wn/l/cJiD5vC9jXEwm4oHsPDmxnD4tzHwrS3E8Nc2C7DTMxqwzc678L4h9TCj7E6wkVD18JcXAXDcHUPw+qy8sKoZgnD+lgRw8myAcMaGh/DhkOdwnsy8cLH1BjDEzTownhBHMNYRE7DxIvlwm8OKcMiXDbCylW2wpYzO8N25RfDFKwTw+pCA8MufwjDKKoXw/b2KcNCu4PC2PgEwzYf/cKXpgzDt+NSwzg2z8L0sS7DlmAswxfzHcNqiDHDvRzGwmjnEMM1yQfDsNcRw/BS98L2tBnDU1oTw07ADMNoK0LDwHMVw6KlDsOaqAfDZikzwxYYsMJt3yPDALYTw6AZD8MsSg3DiHECwypxH8O0XPfCYLvkwgA6GsNE8RnDqskZw460ecKySO/CPrS2wkOppcI1/hbD0HIcw+4OMMPIxAvDMI4+w6AracJCjt3CHgjKwsbuQsPSBBHDmCkywxLIy8IA8inDtQfnwrxh2MLWIybDagENw472v8I+1MvC7Ag4w+qNKMOw/FbD1HRCwwWMAMIl00fDwSwZw3slMsPKRhHDrBclw68pFMMTFdXCEBoQw0ctFsO2whrDRBZSwyCLEMN4FSXDsYluwUrBQsNAEePBmlYbw5Ya+MLyljPDJo4ZwyCmS8I=", + "encoding": "base64", + "path": [ + "vx", + 7, + "data" + ] + }, + { + "data": "UP5vwvSOR8D5N3PCqvAkwoaE/8GwD6/C30Bhwl+KGcFfc/HBcCkhwnfV0ME0ey/CSl0Mwv6OA8LEwBZC+OnewfVbrcLUjoq/7pQzwoLJD8KJfCLCIURgwoV4BEF6ju/CDprUwtJRRsLGGBrCExDFwR2DGsJrix3CY9MyQurBkMFs2OBBfC9uwvIShsJ8lrTC9MSjwQOjhEFal6rC3k3gwY074cEqJxzC3n6NwSjY7cEJmKPCZ4N+wjnEX8IKeGTCJuUMQaKv58HRP7/BPFM9woLPDMBFTjDCLr4OwgqyocFRiyLCZu+4wOjA9MEsmzXCkNgtwlZkwMEyMyTCI4yeQGYcQMIcPVPCmVgSwmPyyMGwH2lAqFcmwoaHmcJuaZzCKb8DQJT1kEGKgFrCH2YjwvJfXMJ9kW3BfVTFQGQnHMJovbpBNuLzv45NM8KNWELCQL85QTYZXsLr8m3COdAuwxj/zMFCfyLBgOQAQsqcicHcNqjB4q9nwup0B8KYlMLBI1ULwpB248EbyTzCDgecQDrZAMLqkU7CYhwNwrCthcKE1wDDXMftwUjDg8KY/NdBEKavQKJRs8LYHT/CLGExwnqxJsKMOwrCaCwgwqBfeMK81bdBUQXxwRgKMsLH7iHCaMHfwmHcbMH6q5HCaDSKwhYHW8Lzu6DCYWcRwRRlWcIWogbC8kYTwrZi5MGm4i/C0KchwqbGHcLwGuTCXjo1wrNKUsImbxTCiKWHwhxiyj/Y61fCClIxwgAVr8FrSOrBJ9MlwqZ7RsKFXQnCri3lwfLbHMIgXVDCr+FXwiIymEFRDAjC5satPy7CmkDQHnLCFN1AwllQkcLc+APC65jDwuBBV0GeB+TBHsM/wLjfrsJkahTC64SQwuC8N8GfiHvCpuUywWBLk754r2XCICFfwi9MAEA+8yjAItHEwsxnhcLTlA/DoF+ewo9Q/0H6NbvCq+j6wSEFwMLY+yHCCDR1wmi84MFMzKzAtOZPwk5GZcLS/VHCe9YFw8a3UsI+LIzC8s0fQnr22MJObAtCyneNwllbCMIEgJ/Cds0ywqbTIUI=", + "encoding": "base64", + "path": [ + "vx", + 8, + "data" + ] + }, + { + "data": "nOGXQMZzWkK7hdZAzMSoQfSsjkGOPI7BJB/0QEWJIkIWMvNBEs28QS0pUEJEtJBBltzyQdT7L0KYUZZCngmmQTr+qsG0ujlCoGTMQeJtp0E6MxBBYgNNQbYjgkLCWT3Cc5GwwQpNm0EFAdBBujWoQYI5xkHv7tNBcmOuQkY3HUIEKJBC2E2CQeyJY0DUxT7B2FokQrCrmUJ/GerAAy5QQlOcSkLBEPxBC5A+QuhyCkIGHYDBjIgZQasVf0H8/ZBBDHlbQvEILUIoKENCOvmgQPgTR0L0MRJCLiAmQfYLPUKkgP9BkH81QnSsLUEM6t1BcujwQSj+3EH8YQVC3RpiQtQC1EGIHXdBXhsJQo7dpEEBE1xCDIfOQSRBG8DEmOPAYtZgQpJFbEJ9cC9BeH/GQSNBA0GgmSZC3n1vQhGVrkB/6qpCQgBeQpxpB0Kw49RBaBeHQj71UEGFf9BAHr+6wqDLuEHY9zFCmtyQQsA0BUKhbFNCCN17QB3SXEGOpixCXko/QtpmKkIsSAhC1lZ5QiTsmkGIKVNBCBT5QA+zOr+gnivCMDJLQYxeLUBiHotCbEFfQsBJdcEhxLpBuiDUQXxThkFdnQBCv/sAQhrFEUHskI5CKH7pQUbcZECfNNpBJkINwt0nCUK4i/bAHycnwOYIi0Gv2CTAQJozQpS1nUHa99hB0qEQQolOo0GYZOJBSsLhQdL+8EH4NiXCCrfdQcTlkEFnHXpBD3+Wv0FxZEIo3oxBiO7RQb5rTUIIYDxC7GyhQdKqrEG0uKxBHr9iQSJTH0Ls8cBBjQSWQY4IikLwDiVBXGdIQrxsc0LZzZNBlvvxQUCbncBnuRBCEXTbwaYOa0K4LbtBfvVOQrzuS8Fo3yFCfFVjPtoeNEKbrkRBOYlSQvHOQkIytylBobFiwLSaWEKPemZCBOIqwWV+nEAA5ILC6FZHwS4QmUK4/I7BuOU/QrrXT8E8dQBCou9BQVgFOULDylFCiq/pQO4ilkE20IpB8jBlwoiVmkGYTEPAUe2XQjnZJcJgwZVCSBOWv5JOVUH3N1LBGvAPQpp5sUI=", + "encoding": "base64", + "path": [ + "vx", + 9, + "data" + ] + }, + { + "data": "7sVZQnp6wUKEnWNCueWDQs5FaEL6r+FBZIJWQjKtlEIWL45CzL2LQmS0wUJQK4tCwAOYQqgrvUKyzMdC5hpJQiL8sUG22ZZC8uyPQshmc0I7xGlCkDFxQpTQzELa5fZAF18HQpXJgkIbIpJC+F40QmiThEL8PJRCeDnlQgiOn0KiOcdCWGCXQmg6WUJwVzFCQGWjQjKU6UIFxT9CLzDCQhAtsEL+wZ9CzB+pQvrBmkIeRNdB3iWGQohKikJOSIdCoJKrQlSvokLKh6lClltRQm76qkKcOrpCEgRDQgbXvEL42p5CLXyeQlSvJ0J26KJCNCykQli9fUIUf6JCftm4QkJvo0Lf/I5CBEamQngdOUJ2Z7ZCZA6TQoRBU0KkTxtCZFDIQjgBqEITD2hCvjSOQlI/XkJr/p9ChTa5Qla1LULU2fdC4v21QgoqqULHnZtCsdDXQlRNjEI8REFCfbCowbipXkJyKZpCUJ++QlRMiUJegrlCl21pQmIZKEIMnp5CCeHLQnRNrkJFpqhCtoLMQh2yX0K6JmJCG7UpQnLCQUJosp1BbiVHQp3xT0K6P8FCNOOrQuWNEEKUI41C/IaXQnHGcEJyWZJCONelQvBpcUL+4chCrZaAQtiLNkKGa5VCziSKQWcJgUJ0DxJCpuEzQn6OdkKa00xCm6eoQnBZnkJ0TolC0kKpQt02TUJ88IhCGBiTQuISmUK61FdBmDqcQsB1j0JaplBChaEwQlo0w0JKQ4RCGcyYQoaCvkJYLK9CYhqGQtifhUKYQ3xCRtxMQoaBrEI+oJtCMT6SQkS6zUIiekNCQLijQvaqzkJM8p9ClCOzQoxlJUIoWpxCgQa2QWQos0LcRGVCoHG0Qv1NKkKKX7dCdoFFQrTGrEJUEIFCyUK4QjVGlEKtR2pCZ58QQjaGrEL5KsVCKKFFQnN1SkKrGpjAEqTxQVjX1UJTyQdCgNOvQoI8PELSMqZCmkV5QvKcukIWV7NCjfdEQvTBmELvXoRCAFYTPoqqkEIusTZCagPJQj6FBEHk8spCsJJEQtbkW0L6BAFC+LKvQlQW5kI=", + "encoding": "base64", + "path": [ + "vx", + 10, + "data" + ] + }, + { + "data": "2KS3QmL5/kLfSr9CnvHJQnbSvkJO9nZC7NOsQiD+y0ICOsJCfE7TQvdJ7EKKu9NCyjTZQg6+9kIed+ZC9oyWQojlWELhErtCwrPNQvZjtkItbc5CBtC7QlwS/EImH0tC4KiTQtFmwUK9Bt1CnVKOQmJrvUJSHNRCpE4CQzip2UJupedCK2/lQp3ZukJsZqxCmqfZQhXODEN/6LBCFLXiQgJd1kKiReRCJnDWQj1j00KCp2JCtkPFQtaY20LCD8pCbPXXQlawxUJIcNFCLQe6Qnaq4EKIBfNCiZatQgYuAkMTR9hCOiHRQnp9m0J8FvVCFBLoQtx7uUKe79lCPr3tQv5C90IuzeNCdrjgQir2jEIsgu1CkizUQi5ItULAyo5C+scFQ6jrxUJQQ7lCC43QQrjcqUKBldVCmjjhQkYco0LdHxBDZMLhQobH5UKQQ+VC3CsHQyjU3kKET5pCieYDQqhnpEIA08FClHPVQr6Bu0IyU+5C4OPGQvpZh0LQdstCLgb7Qkdm0UISpORCS8MAQ+hnqkLeraxCNHuoQnPdpkL0yIJCFiqrQhVJsULEruJCAJHQQlJCkkIku8hCukzdQr65ukLqw8dCeCfvQr2FxULeQupCZU6wQrW5oUJmT9lCGINdQqfypkI1UIhCKvKhQmfisUKeYrRCqDblQqBV7UIsc8lCrOHnQhRcqUKWLL1CvFjQQpG90EJ/WGBC2OrgQmKE10JCM6pCPliaQq4n/kIns8dCOtrhQtAb9ULovtxCcBvNQtj/wULDEMJCymi2QmhZ2ULAjvJCEt7mQqkU/UL2k69CxXvNQhALBUPycfJCONT+QsIylUKCRc1CXrxwQi5T3kIqSLVCYCXwQlwHnEJGgvNCqL2qQkA06kJn789CMPnpQjgZtULCKL1CLnqKQuSH1UJ86fxCAEy3QhBzokK2QypCIFtxQlxRAUM1LoZCvj3PQtRXtkJIyedCrHS/QiXo9kJ51uVC0LigQhq83kLQUcFCzVgxQuBQ20J0gZtCBEjoQoBTPEJK8+xCDBWtQgj0skLPa4FCdvvlQihS+0I=", + "encoding": "base64", + "path": [ + "vx", + 11, + "data" + ] + }, + { + "data": "tAnwQlrVEUPaXfpCinUAQ/rW+0J9iq5CvijbQqZg90JgIedC4v0EQ2irAUM9HABDyO0CQ/zPBUOQe/BCctTQQvKKnUL+Z89Cb472QhC+6UIVnQhDtEnrQkiTCEM7BapC6ofMQsql60KcJwdDZ7/IQvcq5EKGz/tCj88DQ+7G/0LwBPBCHWwKQ1JW+EL8tupCLJf7QtDoE0PqAuxCN4H1QtSm5UI/RQlDdgDxQmqo9UJAg5xCYjrrQui9DEPXB/VCH6f7Qngd3kLhxeJC1vf8Qnl/AkNMSAVDUjboQqQ/G0PwKfVCPmf1Qmho2kJRPRpDMDYIQ3vX6kJmX/ZCis8HQ0/mGEN2sAlDQl0CQ+2VxUJ0GglDEoT8QiI640KYx75C67sbQ5Io00KutOlClg39Qlik0EJIUPlC5rLzQkzQ3EJAZhBDehj5Qr+YAEMm1AxDuPYVQ0pVC0MacMNCvNGUQjLIz0IBnddCoHbVQuL33UIxmgdDjisBQ34szUKWKOJCDLgJQ9AY6kJ1VgFD/sQOQw2U2EJq3tVCUifuQpbG2kLyt8ZC/zTtQgTE50K6F/BCwRzjQkllx0KzQe1COtEFQ0QT7UL6C+xCOKYQQ37x/kKOkfNCvBXTQjTB2kLK3QNDNGGnQtG1vkIW4LZCunDZQnqZ1ULlmOlC5MUHQ3ZjCUMswvlCbmYHQ5IO30LK5d9CwI74QgvD80LnebNCGOEGQ/h9A0Pk2N1CGqDLQktPEEMpRfZCVLIKQ6ZACkOJ7vJCTwX9Qm1F60K/Q/lC5tj5QjtV7kLwuRBDHKUQQ7RhC0OoK+1CCj3mQqfgFEOBUwpDRiEOQ5YwxkKQaOlCdG+xQgpx+kK7yuxCCFgMQzjhyEJGSQtDRvTgQufDCUOW7wVDvL4DQz48yULUGvRCj+HAQrTh60KocA1DT5zyQkcizkIYFaBCiEKlQkumD0MugrNCdETfQtvw9kLFLQdDWrbqQgwKDUO0RQJDKAnQQhSXBEPK9OZC8E2eQkAuB0O85sdCcprxQn1ynEKsRfpC9vnlQro96UJEPLFCBqwAQ0O77kI=", + "encoding": "base64", + "path": [ + "vx", + 12, + "data" + ] + }, + { + "data": "oTMMQ7sFDkNQ3RFDHM0TQ8b/E0PWxtVCwj76Qo+dB0M4BAFDOTQVQxBbBUPtxQxDNogPQ6YIBkMUrtJC4D4DQ97fw0JCgNVCeNgHQ/IDDUOXvBlDYJEFQ6gSAUMdZ+BCnBfzQiAhA0MAYxJDWjD4Qgl//EKwCwZD1PnSQlI2CUOMRcxCN3wRQ6SEE0OmlAtDBDQFQ3mrAEMYHwpD5gT7QhKd4kIy1BBD4sP8QuisAUM1UrxCCrcAQ3S+IkPXugZDEpMHQ0u28kJgJ+RC+18ZQ7yUB0PwQQZD6n8JQzy3JUOBcQBDiuYCQ1MgBUMEGilDU8QSQ+hoB0M+GvxCw44KQ7Y4IkO82w5DE78LQ3nz80IAXQxD2FYHQ4jY/kKO++FCeuQgQ0b/ykKgKwRD6uUIQyxt6UKEFAVDpcvqQh9mA0NGKOBC5Pn9QlzHA0MPgRxDoWEWQ4dqGkPQZ+BCwb3UQmyf70LLM91C/AewQiTP8UJNcw5DAGoVQ/ai/UIfrOpCefUNQ4ww+0IumgJDUA8NQ0mY+EJkPPFCn/QOQ6sxAEPIb/hCgt0RQ1wwB0Mw0txCxmDhQoTy7ELn6gBDktoSQ5beB0OSjAFDHiMeQ2iiE0MyPtdCe3DqQuanA0P52xBD3MjRQpkKz0IyM9lCcrIBQ57Y60J+qwVDudsPQ3qwCUN5pwtDwd8RQ+yjAkP4VfVCgBcIQ7utA0PCjehCZaUTQ5YdD0MEkgFDOtzvQl46DUPOMQpDekEaQyi+D0N2UfJCmgULQ0HxAkMwkgxDfmcWQxwa+EJ0exlD3hwfQ25ABkOYyQ5D5JDvQq46EEMZ3QlDOrINQ+P26UJ+WflCyPDcQkDd/0K1CwtDoFsTQ27Y5UId+BNDS1kEQzbrEEPRxRpDzAgJQ2Us10IiQA5DVj7sQlQ660K2WAhDCpUMQ0vG7EK/dttC8KbGQmj+DEMaIdNCnvTpQiPGEUO0GRFDHnsCQ/vHE0NifQZD6DXzQtLhDkOTs/xCXIrVQql2FUPxTuZCfqPHQvYNz0JAuN9C9PcHQ2QCCEPEp9RC2dsBQ7xzqEI=", + "encoding": "base64", + "path": [ + "vx", + 13, + "data" + ] + }, + { + "data": "OK4XQ+pQgEIMjRxDmvEYQ6H6F0Nk+PJCXpMFQzhx9kLH5QdDjBsZQ1wBAUMKvg9DNWcQQ06l/kIF+qxB2ogUQ+di4UI6xshCWo4NQ5L0GkM/tRNDAnoOQy7Yp0L+RgVDen0FQ4eRCUN/JBNDUMQLQ/2/A0OamgVDTipHQNj5BkMI6TJBIJUGQz2XIkP6lhlDCsgAQyIfSUKJkxVDKm/uQn/S6EJ1kwlDlJL6Qt59+EKlO9NCPk8FQ/VjLUOg3wpDTjP4QlK6AUM0T+9CJl8oQyYH2EJAufZCZY4XQ3JnEUPRQQFDRXztQl5eFUMGSShDZqQUQ837C0MCa/xCGD3XQntFHUOB8AVDhBsLQ15KCEOPtMpC2kYHQxZhBkMaDPpCdrICQ1SMk0K4yQtDEe0JQ5Zr9kLbOf9ChoKqQmxTEENPvxZBKgHuQjhp/0Jm8B5DhqkBQygbG0O2HvNC65QCQ3Ft/kJaOs9CAQ9OQZRD9EL+kglDLAYfQ2piDEMemPlCw+kJQ7R9/0IVQ/pCM6feQlLAAkNObQBD5WgcQ7/FC0P/WA1DliIiQ97eEkNNgFNCgla7QkT5AkPkfARDXfUWQ12HDkOfHAZDZHgdQ3HPHkPw6ClCbUH1Qjj5EkMHLxRDZODwQh6y00Kej/FCSi4QQ8Pc9kLk2Q5DjnPwQqqF/EJjUA9DtQcUQzAZDENU9P5CWh8MQ61FBkMgpghDdGcXQz/kDENskAtD5zMEQ9uupUK+whFDqmEfQxWrCUMmQt9CgxINQ7JyCUOOhRBDK1oeQy4P+0JAghlDNiYiQyvto0LMCiFDZMfnQmUbv0IMHf1COMkCQy40AUMBsQJDHRb9Qmq3x0K0bhNDziv9Qm3m9kLeiRRDsA4RQ0te9UIKySNDHgQCQ24/5kKKcRpD8OEFQ+wWvEK5DJpCkoUWQ0iC/0KQugRD5ArfQhvYp0I7N+hCtqv5Qla9HkM61xJDDIcIQ46WDkMMW/JCQt0EQwpFDEMQmAJDOmUAQ+bWFkOg1fhClJ89wVvm90IM4eFBBhAVQ8JOEEPsIe5CIA/vQjtfqME=", + "encoding": "base64", + "path": [ + "vx", + 14, + "data" + ] + }, + { + "data": "89YWQzLlisIEUxpDrwYJQ0IoBkNwEQND4QEGQ5GyZ0GelwRDmwEPQ/Dj5UIw+AVD5ET8QuIY3UIkYLzCg1UWQzCV9kJIb5BCpUIMQ4BUEkPosvdCBh8QQ8yUvcGsexRDu9cKQ1z3CEP0bQZDQsAPQ/4FAkNwnfdC3LPAwghM5kIkAtPCFMnnQhqkJUMXHx9DjNvQQrifdMKMiBhDdtfRQlP56kK2o/NCAL/mQmzu3kJcTeJCyH0DQ7AJKUPNrAZD4lipQaDKBUOqpO5CwkEXQ2j8WsHOUclCbksbQ/ftGULIA/lCTuIVQv6yG0NUPhtD0T0MQ2blrUJHsPJCtY2RwUQVDUPDLOVC6Nr2Qm5uCUOWeBHCnLT4QmgwB0NcQQND0R6AQY4EKML2xQtDrs7/QoCq90LCd7tC+CvQwcQ/EkNPdL7CphvAQiLg50I/swxDcAyLQqbPCUME0/tCD9oTQ1Wa6ULU8qlC/OTuwlYB20Je0ORCNPsSQ4ZGDENo1vhCMsb2QuaH80IAVedCdQxsQV2g8EIhegJDQU4ZQ8jHDUNgUhdDTLwYQ8nvFUN0H7PCHwKWQVzDCUMgZAFD1qYRQ+yH/kJ1fQBD/QwGQ7D5HkOkHMXC1/3vQtyVF0N2LA1DDOkCQzJruEKcYgBDQjEXQ+UF90L59BBDX8Xtv4op3EJUIwND0KMMQ/oOBUPkSPxCagcHQxDUAEOIHhdDhj4RQ+cb+UKKxAZDtVIKQ7euIcLMRRFDHCoZQ6jk5ULGB9hCDKIBQ2ZUCEOEeAZDNDwLQ0Ok9kLANBBD+mUaQ8xuRsJK8RpDvf7HQqtJC8Hk5dpCPGvYQrPQB0NCXQFD1UkJQ/gNHMLsc99CfNddQRhh/UIoAwxDldcUQ6NxCkEysBhDYA/LQiKG7UI+4hpDTMkMQ5r0M8GhlHLC7IMXQ7JuAkPgZRVDpjPvQqpZPsJW8fNCDA4CQyBxIkONigtDpqgHQ0Il8EJ16oVCwPYGQ02T8UKGSwBDl4wQQ0brBUP+Sf9C4kHFwkfSC0OHVMDCEj8XQ5IHAEOWr/5CYrzZQkyC9MI=", + "encoding": "base64", + "path": [ + "vx", + 15, + "data" + ] + }, + { + "data": "zy8AQ7uQ3sIAEAVDB+y+QihjuUJelwZDIIP2Qk0Rm8J6LtdCxYneQrnkqkJ8v81C3YODQvaek0L+xPjCYpf3QglDAUMd7CrCkqYCQ76P0kJq/p9CQAsJQ+rR0sJgWh1DUzwJQ6zW/0Jwa8VCsOn5QuwZ7kISY7xCytQAw6SlcUICXAXDXj+pQqyAEkMamRpD8noEQmB49MJ6+hFD1tuqQiTCw0JRI6dCKGCxQomwsUIGfelC7pL0QtpJEkNwefBCGLSqwrgF4kIqaL1C6LzMQiTRvMLu35RCJeXzQn3FkML868tCXnyewuA4BUOwMPtCA/jpQvA+gcL68sJC5y3NwjyM1kK7xqhC21miQkyZ4EIod8rCFu68QrKXAUN4IgJDUX+iwiiiCcMU0gJDQszEQhkL60LiYQHB6X/4wpAR/0J+HgvDxhc1QsA1rkLGBaZCJg9CwocEt0J4FflCRTweQ6XoLULGjFJC5EIXw70Zg0L8+V1CRizIQtnA4kKdlM1CfpO5QoE30ELzeKxC/LDBwrIrg0KJ+PtCQCvfQi71/ULh1hlDKG3TQtJoDUOwhAfDGZn6wuCQCkNcPe1CsjMAQ2YuI0JXLs5CTuGAQuGjD0PQzRDDhh/RQgDOAkNQyvBCJyIIQ1EQbkHoLQNDcL0TQ+MG60JwaQtDd2G1wg+MqkKU4bRCxjrwQnY7q0KcrupCeoDpQu2H4UKAQB9D/oP8QvJ1rEKwq7tCqrYIQ7sixsKykAZDthgEQzdZeEL1sbZCOFW+Qg3i+UKbVctCnCe+QjBfyEJkavZCQ4EFQ7JK3sK+IdpCLi18Quq6qcLGYadCxVmKQhLqB0Nm0NNC+FIOQxX26cI0ShXCmhzYws7y+EJhJu9C47AKQ9lPu8IqWsVCE9W5QYucz0KKgQZDeo/9QvLiAcOzzu7CgMgOQ1CN90LVZB9Dbq72Qt4jyMJqDPZC3BXaQtv0G0OC4fBCNMv9QkQeg0KUyJTC7N/sQj6ipUKi2+xCAiEbQ777p0KKAPdC9P/nwprZFkOUtP3CWugFQxLG60F0FgND+CKsQo4JF8M=", + "encoding": "base64", + "path": [ + "vx", + 16, + "data" + ] + }, + { + "data": "0n53QvKq6sJVHJ9Cj77PQKaC6kA6GwFDmOG6QklZysKRoshBxr4bQtg+qkGcQNtB0HiBwpUakcGqK/PCB+U3Qj0IAUOsORjDZIDbQvJ/4UCGcpC/YMnrQqRvB8OQbx5DHP79QqtY1kKPUnFBYsE8Qi5tvELQOWZBfhEBw5YQRMIckPzCHNs4QS9fjEJAXAhDSgS9wjN+DMOUSP5CEkxdQeB/vUG0gjXBio2ZQetLoUHsiudCNYbOQhhCw0LAT7ZCvs7awlvwuEHc8dBALjnmQGqB5sI5dnRA2jG9QbjQ5MJm4cxBEtLmwqTpE0L6aI1C0r6JQq4PzMLW+apB/vj3wjZNJkLS2W5BLFE4wS7uv0HwzOfChk2BQXu56ELqJutCtB/vwtTuEMO2fttCXOPPQf8Uy0IUhMXCKOwRwxgfMEIeYRDDHRJvwmYoTUD7QeTBrfr/wn4iMcGi+OZCtOwgQ6VjqMI511LC600Kw9J8UsJuUmDCDiBDQXTjskHmIN5BcogAQuEnhUIiLxrAXiwMw9JtgsKy0OFCq/h5QSy0kkK6dhND4xLrQHPW5EIUVAbDzL4ew0geBEPgaMNCGya5QpOgpcK7ruFBQABuwrGEzkKmIg7DgIF6Qj4mKUKa55xCegIHQ4yP0cJeIwBDG/X8Qs1Lz0Kyp/hCGF7mwlIPgEFS7/7AZMOdQjQxJMJ978NC+kCXQp+AoEKKqB9DPbSwQvC2GsCrR9/BWuz2QuIZ6cIkm9lC0G2wQhjJRcJglrJBTPEkQT4/wkLhnLJB/N4CQbEShUFUv6tCBMy8Qrxt+8JC8ytBaGPZwSHn78LMMgJBmlJKwXg9/kJqCsdB8kcMQ2px/sLYALXCLZwIwy+G50LfFqNCWjXLQibg9sJ+JrLB8D7dwtDG6UHNXJNCvHcNQmZlFMN+LQLDJsPzQo2yyULTbiFDRHrzQoTu4sLgsOxCpF3TQZnLCEO906dCsnfXQsrKRsIaDRPDLgpQQiL8tcBoxsRCS0YfQyQl08HSJdlC4B7bwl7iG0Mi2ffCCniWQnLMlcKElAFD+ShrQV6iDcM=", + "encoding": "base64", + "path": [ + "vx", + 17, + "data" + ] + }, + { + "data": "pxkuwl6+08I4qnPBzATOwlwf2sIu9dVC1s3HQSeyy8KwJ6jCiLN5wuACxMLl77LCdTkKw1q+68Kl4s/Cbl18wmZk7ULcxR/D4kGPQhAKysK27cPCGKOfQp01BsPznxRDuazQQuESiELKt8vCVCSQwv5QNULV/7DC+kbfwpBaAMPLTc3CEWqxwneeJ8KLZ8JCpMIaw54SBMP8+7RCBFagwo74lsLKHejCt2rLwtxko8J0VdlCvqOKQrLzREHg4RhCJtvawj4ItMIElcXC8yXnwlg74cJwPMbCoEW6ws7W+8JeSKjCyhPtwuZzosI8QqDBNL+4wc5K08LGtZ3Cmhnywl4hhMKYD63CHNXTwtZUkML+wt3C7g22wvi1uUL4PKZChiABwxim/sKoToxC85OuwgtWi0JE1APDuroHw0RGmcLkdPnCF1ETw+l318L2k87CuNQdw1BC6sI7m7xCYN4ZQz9C7cKUjibDLSXXwtZNAsO08wLD4Ju4wmGfmMLKC57CnUyPwnzcNsH1NdrCRE0Sw/qG/MLT1K1C4s/VwmQ9GsI0BwFDNADqwtRNWEIgC+fCzNIUw/Uu50INMnZCdT7ZQcMf98LwN67CHg8Cw3o9oEFoYO/CZLI6wlBJlMLoTS5A8MT5QhqD/8L+1elCqGyLQhMenELRlb9Ccq7lwvP3nsItm8jChsAWQIp038Ik33RCWp8jwR1UkUGIYxVD66GhQSYbwsJGpNDCoKGyQhQ84sL1ZWhCeHPzQHPpDsPyS5fCOt+7wj0TG0LEZMXC5EPewnIaucIQAL9BBj7lQRgF78JXX9zCGKUKwwpw/8IqOrTCnGTswkEx0EKmTrHCSRMAQxFI6sLMgcvCjqoGw1xaxEKYw3VBXHgHQRBw+MIxR8rCDGUlw7zkjsLPyCTCH32PwghLCMN+4O3C/8WnQrUpKUKcuhhD9NXgQprr28KGgNNCDPyuwrJ3yEKKjppByPCRQlQHDsORwx3DBGiTwvJh08IyOXpClvcaQzy06cKIk5VCfgi1wlQ8GEPjTdTC7Oz3wVKR2MIWOPJCSKClwqEn3cI=", + "encoding": "base64", + "path": [ + "vx", + 18, + "data" + ] + }, + { + "data": "3LXXwiUJoMLudLPCGD8fw4geGMMkLDpCTf6Rwnq9tMKyqQ/DgtL8wm8JJsObhhvDND8dwy4WF8OTnpbC7tf2wj02sELcsg3DomibQKJZHcNxuAPDGDkZQR6/4cLkqPNCcj11QtyBPMBhlifD9VYLwz0zKsIUGwfDDI6fwq7VHMMWRIPCFhUGw6FwxMIcWMZBgsMjwzxEzcI94tBBhkDswo4e+cIKKhbDrIEQww5gAsOQCLhCAFQdQclElcIrG1LCw4jEwgO1GMPgnQXDXfcvw6akwMJq/QPDNnccwzWl8cI+thLDO53Uwpc+EsNua9HCwlTqwhRzwcKW/wbDzkTQwrBuDsPFpAPDyNMQw/hZ8cL0kLrCFnMNw7icV0JYrYi/8Bjzws6HxMJQ3R4+ZqgRw1xL4EAmnAbDCnrawmyrDsNeaKXCzSwvw4a5FMMuZwjDZQwewxGfH8MPg0pCDQQFQ+wX8cKn7DHDkrN/wmpSE8P9rRzDWJ8XwxIi+sLboQjDX0wRw0nm3sLOpBLDwP8Dw2phCcMlmhtC2HApwzo63cLP4LhCTF4sw58iLMKFWqrCI//1wmRepkKAScO+R5eVwk+jAcNKTAvDlr0aw7ajlsISJafC4AMRw9JsCMMljZvC9rzHQixE8cLMBLlCHl0awuGMAUIrYDlC9MnIwjOh9sIa0QTDzEyywppMA8Mq3QbBRxDqwhZYo8LWfPVCzA+WwrROBcPGbv7CVj5HQWpxvMKkQAXCDuazwtA1LsNBuOnC/i8Pw6tGh8IGwCDDAo0gw2YwCMPYkIjCyqpuwqg4x8LirCrD1u0tw4ZE58Ly4PbCxu8bw2j6WkL6UxTD41nGQtBrwMKalsTCcWDrwiqQhULwW53CxLipwjGz2sKgcQXDG34qw8gm6sLr7ubCUrLSwpPD3MIlyLfCuPifQcJIncK42f9Cf/KzQoC9vsKRCaFCgFcTw/dyGkJV9ojCSsRBQS4XLcN+SxDD3FoDw5yJCcNEQa6/UC4KQ2TEFsPgWwlAeCRywgQIBkOwr5rCqEPEwvo/5cJ2RcxC5Nv8whL/csI=", + "encoding": "base64", + "path": [ + "vx", + 19, + "data" + ] + }, + { + "data": "GPoIw9MID8Ji9ALD9Y4pw979G8MT8ITCZksEwwhPicIC2yXD/SAbwz1SMsOZjC/DCX0Ww1gcFcOQ7AjCROcTw1SVBEHeieLC45mvwrKeKsMCMwzDrlywwixrlMLL5YVCuD2SwcdiucJSnzXDnGklw0Ac8cJvFxfDaLX0wc0oG8PNhT7BNuUTwy7l9sKl2JbCeIoVw6BbUMLj/4HCTPEJwynlEMNLqhbDDL8Xw592FMNI22dCFIuxwhYsAsOGtQXD7HOdwlRrK8P+2AbDr3Iyw0x1h8KQKwLDyPkzwy2JzcLo0ibDQs2lwlVaLcOfyBvDiHslwxIfn8ILBx/DtsCVwlBSMMMdcRTDSj8Ww/A5DsMIE33C3EUbwymQKsEoLsfCDUHHwnttb8Ju9J/CPJ0iw7IdvsLKdvHCIx6Lwi2eKsNw+V7BkfQmw73mF8PUEhHDkx0Lww+TI8Ohrx/CRge2Qn422sI4+hvDsZHdwHT6CsMWMhnDNPstw2LhD8Mocx3DGu0uw7YSJsOmTxTDdnTMwtPD/8J+pzbC4vwww6A2C8OIY9hBAGstw1bJ4MJZFSvCmpqtwsL4uEEC47XCFiIVwy6Z8MIUIhnDCNEZw2P2A8PAjwHCxEkswzB5IMOCHgTDCPg5Qv7zy8KuCS9CKAffwtayT8JEnxTCdRyTwgyWEMPT9gvDL3oTw9pgAMM0stfCREsowymVGsPyDItCDH4Nw479DsM4y/3CFEW0wmtBacJjlOvCzpYVw0qwKcOYdQvDmc4dwwhPEMOyOi7DPlckwzafFcMqUhDDypsAwxaYhMKsfzHD8cwlw03fqMLPywbDwgobwybeFsKutCfDmqQfQpmjg8JY6KvCZlaxwj7VL0HIURPDcg0Dw4b2osLbeA3DJFkZw7ccC8ONXxPDoO7iwkY/k8JI6zzCVMiPwuCgFMOFDJtCRhQkQp1cjMI5/v5BX24lww5fUMIOmAbDHdelwo0/KcNeyenCrKoWw8g1CcNAdsfCz37KQmQeFcOOkrTCwR6EwUjhsEIixw/CfOUAw6IU18LuZoJCVQkMw8SXJ0E=", + "encoding": "base64", + "path": [ + "vx", + 20, + "data" + ] + }, + { + "data": "Il4SwwAdG0Kx2BTDeHUew+5WEsOIDgPDlF0bw5VsCMKiOCXDiisiwwSLJMMQnSvDcfAAw7Z7AsObdLlB5zwZw9a/vsL+wJrCwskZw4INIMNolgrDl/oWw8j6zsGSBKzB7Bnswj4aGMMiUyvDr/4nw0xJIcMOOhbD7d8FQnbbB8OCAFJCqiQRw02PBMN3pAzDxtXzwv4AAEHLtgXDOJILw2SjEMO6zwbD/cQRw07oEsMoSFjBMQgnw8aQH8OkZTDDhotIwvQGI8OG/fjCwU4hw6BxtsFbm/PCX84vwxhjjcKuHCPDu8g9wkzyMMN3CDPDB0E1w3x/WMIWAx/DAMrvwbJbN8OO1xTDcaEJw6o4DcP66njB7lgXw6tbxMJB2BDD2J50wvn9GsFRTAnDJqAfw17oIsMVO73CwY5gwXH3LcOOYHZCbM0Lw+TsCMN77gvDAlrRwr7zFcP8kwXDKB+DQWaFscI1DPLCKypbQr4D68LeeQXDIGYow/tcDsMCpRvDCjsyw3xLNMPYagTDzr1gwk3W1MJ6svnClBoiwyU9EcMkvo7CdYocw4UEE8PBHY5BukAfwu8ymsK28h/D4Jo3w3/gycJerRbDjEAIwxLzHcOPwiNCkSQqwztNIsMASB/DYU1iwmR5l8I4VUzCiBkPw47fDsMzYAHDLJP0waCnFMMIbgTDsHstw7yF38ISVynDxDo2w6OvOMOcpqPBAjYuw0i7B8Ok9uDCqjoPw0CWn772+SLDZmIwwzQWEsOK+g/DVJQYw0qSLsO2FibD3kQZw1bmEMPpzjrDIJkpw+ciZsGBvSDDMCIKwwZlGsK0rgXDfLgHwzir6cIH0CHDKl5pwsjuusEeJ4PCWIk2wouLp8KUmzXDFr8Tww/PFsKyPwfDFcj1wgXdD8OQmxzD0OvdwqB6v8GrvJhBoQsPw0quJ8Nc1N/ASKJtwjuL98FUm3jC3Ocfw5xc/cK0GCrDirIbwyBCE8NZ8prCZDYWw+Wf/cJUhSvDuwX7QcHMBsPcoBHDeBgZQnygzcB04MRB+YQLw2Z2tcIfd7bAA9AIwyL5pkI=", + "encoding": "base64", + "path": [ + "vx", + 21, + "data" + ] + }, + { + "data": "sjsQw4QH9ULg2BfDPv0Hw/ykAMMOShjDSNMdw11Ln0GqChbDsNAbw1xKEMN7HhvDvCXBwgmCyMLwE7BC9q8Tw2QkDcPQvATC+vM4w13bB8Nt9f7CPCYywzMH6kH27rnCOlouwz4SMsM6ZhXDJEYbwwTsLMNiAQnDHAjKQgOjzsKbN/JCzioEw7oLBMMerivDt8emwuJak0I8DyvDGoH/wvZiAcN+t9TCUO0Dwy9fBsNsydvCOGBIw8ZZKsME0zvDIscHwWozDMMqi87CbHgIw6HgEkKWGNzCsHUaw9VNjcHuwhDDupC/QB64IsOG4TbDqwMyw4rrh8EjTw/Dks0jQo4FLsMDCwnD6nnfwsZw98JyYG5CZS8Iw30zJcOaTR3DFu5oQEagWkJ+VSbDZowSwwbPOcMw7V/CDElMQhMqHsO+zwFDlZjHwk5W2cILzfTCZp9WwpFX8sKXeC7DRpKWwqVZcsIPM5rCzmDxQochrsLAzcrCClwUw/jB+sJvJArDAJ0mwxQnLcOg/c3CoMNUQdydlcIVNCjDamEKwy8fC8Nu6Q7DqtoCw4KvHsPOCbtCPLa4QerqGMNy4z/Dhjs/w/KbkMIlfgvDfEvXwsmoJMM2GPJCffMaw2N8FcOSZybDGisJw98FJ8JeIwrDlkkYw47rPMNM/DXD/T/vQfoHC8Pa1tvCb84xw8qGrsJQuT3DYbUww8x6OsPorMPC2pA2w4JD5sKBmbrCRmohwzw1hkK4vzLDoro1w4K/2MIstgbDTnIGw/qIMsOUMxTDuzgGw/y4/sKzOkjDYUo6w+GhdkIoPgbD4NTDwvZgg0Gw2u7C8urPwlY+HMMK9wzDepr/wjh/G0J+FQzCWfufQcCtIcNWFT7DEGcUwwqC20HIg+zCMlqiwry1BsO/4BjDFA7LwpbPPEIES7pCk4g1wz3uJMN+iqTCTBwLw6QU/UFmAhTD3hsMw6u2KsOI6jTDrGY9w5cv4MLynrvBjHgKw1C41cJWv0fDgjKDwlY218J02STD0FXKQkiavcKAn8BCAWEKwyFYgsLyftHCBjfzwuBUFEM=", + "encoding": "base64", + "path": [ + "vx", + 22, + "data" + ] + }, + { + "data": "Zm0Gw05uM0NMkBDDUBLTwifcz8KaehnD/FcUw7X/q0LtGfnCQiYMw5xy78LNFgPDCiFRwrDEZ8IxIBtDvgQHw0CMGcPGsLtBjgY/w8U0y8KzodXCNXo2w40JuEIvIQfDVA5Bw89LNcNr1vDCaJcBw2ViJ8NzZOPCFLEiQ7zrZcKYbjZDssjdwhiH+cICRDTDYvIBwtRVC0N4qTfDCt/RwnuiysKH9YDCKCbhwvkc5MID5SDDnS5Lw/jOJ8PY9TPDP0pqQla51sLL3orCAnvVwhs30UKS0bHCKA/2wh0HgkKcE+fCx0SQQtQwBcPUGy3D2PMiw26cJkLv9ejCOKn0Qrh2GcMawuXC/JqSwsgztcJYEgtDtBHgwvG5RcMYxhnDqIGsQowk+EIGly3DlJT+wlxPN8OsxBa+vo/uQrpLAMPmKC1DqKE+wnoThcJcmbbC2CKeQZzXmcKWWDbDanQHw+ZcucHgdrnBVt46Q/kPP8Kpc1/C6qvxwiGKu8LEidjCeoQQw/GdGsMGL2vC662+Qq4K9sHoYzXD6wTYwsVk+sL8BzLDAKzFwvg4HMN1cChDzZPJQmgEOsP2YkPD7IQ2w6Kt/sHK/PTCgvaFwlnVHsNwTj5DlJUEwxgs+sKMvx/DHB0qw+MEWEBNsDDDHN0Uw/xcRsOoo0jDpBTJQoxB68ISmY/CaVMowwvjWsI+WDrDFPEfw2t7LMMgng7D1v8uwwSTpMKYhojCiGMhw2/OBUOcozDDICstwyI5YcK6G+TCClXUwgJVKMPAmPfCYC3awjw8xsKGokHDbCE5w0fgCUNS0cvCaks2wh7dn0LowrrChF9vwiL7J8Na+tvC4b8fwzpV5UKODl1BGdP9QpKXQ8OL3zXD0gMLwxAZzELSMrPCXy7Rwbns4cI2lAzDAXWrwoXgB0OIBSRDvFlBw1BnF8Na2gHD3AUpw7io1UI/azjD0yfdwvwlPcMiIS/D6NpCw1uHfcJXmlpCtTjuwiyol8IgwkbD/ZgAwxqMgcLzrSPDrLslQ/KfCcMUFChD1EsBw8xJ3MHG3CLD5s++wm1DOkM=", + "encoding": "base64", + "path": [ + "vx", + 23, + "data" + ] + }, + { + "data": "Kljtwq32J0OmMwHD1gaHwgkUj8J0ZhDD97sCwylsGUPc37TCFFfqwh7stcLifsrCmEAfQQoelT8eAD9Dx7/pwqXaFsO4XMJCxK01w8EiZsI8CpnCegEtw+d6HUNy/hrD4v89wzCjKsMGH6vC/Gu2wgRSF8Mcd6DC2o02Q48tMT+mmDNDkUaiwju638LqeS7D/U8AQnYiM0ObijPDFYyNwgiMbsJlUHvA57iwwu11rcIauS7DbEs9w0jkGsPgByDDypUNQ7RggsJjYJDBlZGQwq0CKENuzmDCcqCnwswRFUPA6ZjC7s4NQ6TiusKY5BjDJnMLw+ob7UJ6I6DCdn05Q5qz+MLJaaPCPE+cwfzLF8JQJTpD+7udwm98SsMdQg3DBQYfQwHUQEMlUybDQpLOwqTKJ8NkL4NCDto2QypHsMLu4yRDvy5eQQqIocAtSDPCqqHGQubNRsG9Ly7DNEEmwyMA/EHc3DFCwMFFQ0HXlUBJgwBBdX6uwutiMcKM3oTCZtPlwucD/sLaBuBAnGQmQxqc/UFUnTDD2uaNwgQ30sI6WDzDXKNxwm4rEMMKNlJDWJgzQ20vQMOb/DXDSRAjw9Qu1EGUa8nCfM4CwQrMD8O1Gk9DkvjRwu5ds8JC8g7DzJEwwwDdcEI4HjnDOSMJwyBUPMO480XD6nwpQ59YqMLh9EPB2TQVw4wc7cCUOirDXoIHwxh5FMMONCPDfGIcw2ZjC8K3Qe/BbAoXw1yuJkNSQiPDDKcaw8/7bEGMw6PCVA6IwjheFcMGILvCaZubwniNbsLigy3DaPYqw1y5OkOLl3/CrC2XQWjvDkPIp1nCHGWIP2YzJMMwUYzCIKEow3JSP0McYK5CrHpcQ5AjR8NydiLD3lb0wn4oLUMgUjbCU9ZFQmLEm8LgKPPC2rp6wqgWVEMkOTxDLfc6w/ImA8MmMRrDmJosw3C4LEMqdj3DCDmRwihJPcOS8R3DVKM3w1q1V0AqGRZD+Qq6wpyK9MFe7DXDsMIfw16MRD+OIRfDEtsuQ6BfGsNIX0dDUsnjwk6VBEKmmzfDYl9iwri6IUM=", + "encoding": "base64", + "path": [ + "vx", + 24, + "data" + ] + }, + { + "data": "0P/CwggR2kK2FNXCTtWgwS8S6sGq6ADDiknVwoLuKENCAj7CThavwswIZsL89oLCkqXBQr5vm0I65BZDlHm7wpUtDMN0FjFDyHYiw70Hn7/URAnCvGwaw779O0PUHSDDTpAuw1PkFsPyhDDCKlYmwiK3/8JR2A7CJygKQ0Spe0LgReVC9p0jwuT1usJyoB7DK5jLQpqMHEME5SPDJ4Swwe+sCT9+GKFCipFrwoSkTsLHWSrDnr8lw4HtBMPFhQPDlgdIQ1A0PMGvAndC4pL9wVw3LUOaGgXB++IRwo5MREMsZdnB0hM6Qx6ZNsJIZPfCCrjZwvtiQUMGFgTCThg8Q+9Pr8LQow/CRiVCQnTwHULEYyZDkjULwpU9PsOiQvXCYNI8Q/GfVENYDhXDuIyVwjKVEMODgANDuspGQ2QyGMIF489Ca46YQto8okLiVq1BA7gnQ6SYmULjZx3DarwwwwrK3UJpg+tCUv/7Qpwjm0L6r6FCFFs8wuZz7UFGNBnBCnuewhCht8IBk7hCAvhJQ/Zlz0JQRSHDAXHMweEjnsIOOTfDnjFgwQ0/+cJ2lStDoChrQ353N8O4Vx7DlY4Hw8cxw0K2UZTCceCZQvDq8cIm0RNDTrSQwhp4J8JYguvCaGcpw0IH+ULATTLDKMvtwgjyJ8MfWDbDWJA0Q/7zFMIzH4JCAuf0wsKhhEJ+XhLD2nvRwr3E6cJiLyjDvxwBw6UnAUKrPOlB8MoFw65wDEOs2w3D5QcAw4povkJWWw/C1i2PwY3b98I+s2PCZCwcwkYJrsBudg/DHJwSwwooL0MYx5TBIOysQpRVK0MP1CdAYhygQqEeF8M8tJzBKFAkw+SOUUOQkidD3mJrQzafOsPjqQbD8YDFwkBGQEM8pbNB9JgLQxzw08FAoMDCzx7twRglYUOzRw1DGCAow/Yh08JrZCLDo60jwyRMN0N0HjPDpDbOwahtMMOGFwTD1jAiw/KAr0JC+WBDjghuwiekFULyxRvD3tYqw3ByrkLIOgPDE7D0Qhb/HMMQ7RlDChW5wpkj40IguTfDgL2pPZHqqUI=", + "encoding": "base64", + "path": [ + "vx", + 25, + "data" + ] + }, + { + "data": "TCyNwvAERUIrmZjCZEwiQr5X3kE2FtnCje6YwrAl+kLyWM9A4ERLwlp4kMFhULPByFc1QzSPF0O7+bVC75CCwpjF+MIAsnVDCDMIw97VfUJcIshBzO4Aw05IGEOVORvDDTIXwzbS+MIcc8xAOlmlQV27xMLpvLBBapCgQkxW/kI8qG1CG1FmQSbNicJWvwbDL9MsQ+LS00IfhAvDjlw0Qisuo0IlQCFDMh22wWYezsBK5BzD3MAHw7glzMLi0r/CBts3Qx4+XEI+HxRDzDiQQQKY9kKGXHNC+HKqQWVLNkPyaBFCwPchQ2CBP0E6jKvC5HeOwjDEOkNwiuJBgGgJQ1esK8KopNRBj6HnQtSm7kJ8TdZCDMfEQYnAJ8Md68XCYDMlQ/7HD0PFXfjCksAkwmLx58IfLTZD7LcKQ0Cew0EYliZC+jgKQ7ITJUMayrhCw7NOQ2OlIEOvHQfDuMgtwy0GPUP27j9DzmaHQh/UGUOXRhVDYQXPPzZC3UIFO4VCWtsUwqIWSMJAvSpD2gI1QxGCL0PmAwvDv+b/QVm5OMIc6ifDIjMyQieSxMK+gsFCe6FLQzPhJcNwdf/CXA3KwnjSLkO6OyjC5gAjQ7z7tMLhhopCrg8HwpAYskFZfqnCwU4aw3AlPkPcHSPDOh+9wmJEDcMvMx7DKSMEQ0Z1x0G/TApDJJGxwiYXF0Mr9unC4DqHwqC+ncIe0iLDeRq8wh6q0kIy8dlCxQnewhSBs0JPsOPCgKW7wlZaKENuoNlB60REQj5uucJI2EHBD9UiQd4VhkI4etLCkvXiwrzV7EKQlBdC+1cbQ4BQEUMw5KBC+V8cQ5alA8OYATlCcrkXw0HmFkNlWz9DArw5Q0s9JcPIacfCMeqIwiC1EEN1dNdCrAZZQ9CqMUKlSIDCyf6iQRhaIkNpdqRCIPgLw1BnlcIMbh/DAu0Tw3KCDUP6lyDD90sDQtaoGcO+tcXCcp8Fw0TJJkMemW1D6yyCwaqs60IVmPbC/IMpw2AWJEOAe9PCMJ+UQrocF8OCBbJC/keBwjdzN0M60SzDjmyeQpZhskE=", + "encoding": "base64", + "path": [ + "vx", + 26, + "data" + ] + }, + { + "data": "9ucSwo9hAsDuQRTC4YzbQhH1wkLuUKfCDAgewpc4m0KmtYhCPRKqwNIV8EGe/vZBvHJpQ2LXTEP4zCpCKgvzwUEw0cKY72NDykjQwgvm/0L4H7xCXKPCwshgzkKs5A7DKbbzwvRHuMJn9ohCfEC3QhtJfMKJaKxCgfH3QfYHOUPdY0xBoDCrQnZyEcIK787CokpiQ65wW0L8UdfCqOTrQruMIUMkHlVDjvS3QXeITkLMLwrDlDLJwpqwdcJOflXCx2T/QpPv90Jim09DDoKdQln0lEIIYwdDpp+oQgS6AUOkKttCLx7PQqLGlEJKHBnCIQDMwXSzAUPEosVCQoiOQgiRPEGcYcJCcYctQ1a8NkM3xkZC1GG9Qs2LCsPShIzCqPPXQvo3nEKIirnCQGeLv+NspcJA3jhDMHaZQkN/uUJcIzbBFxFBQ1hSW0O9UBlDHDNFQyByWEMUFdnCzWIhw8XEVEOsknZDtBigQfzzU0OCjEZD/WdnQmwPNEPI3xFDRdNJQXccVb+U+lVDKJnoQtncU0NrEd/C4VzLQhvfgsAUDRHDhN3hQq6cgcLidBpCi0/tQt84DsNiLrfCG1Vtwuj9WUOxkCjACO5dQyTMTcL/gCxBJXdPQRZ+vUJI4i3CUMAFwzRrREMnlw7Dgh9+ws8A3MI/Lf/CKpCkQgB5uUKOyjtDjIM/wogAVEO6n6XC+tG3wT7iCMLg8BXDH7xLwggmLEPqfzRDFOqlwtZXK0Iw857CxNNNwgK5WkNcQ75Coo32Qqx/XcJAJDJC7C6RQtnODEPARm3CStOPwgYEYkKgSsxCMEtXQ/VEzUJrBx5D7wVUQxIM1sKKEe5Cti4FwwwGskJrHRVDPB7cQmNACsMxyWbCkN3twZjirkKcKDlDXkR6QxTA60J867nBX0C8QtianUKvcvVBtNvPwvZzFsJ3KhTDVG7/wlVBq0Lx9QjD1sPDQqD69MI8v2nCynzGwjRIX0OgtTdDIyAnQvTFO0OYWqvCAucfw9CTTkOiT5bCPHn/QXhVC8OBExZCJq7jwVv+QUPMWxvD4IEhQ0fN1ME=", + "encoding": "base64", + "path": [ + "vx", + 27, + "data" + ] + }, + { + "data": "YwvTQC92RMIxrVxBpFE2Q9TBJUNKGFfCbwfCQJtCDkK8TwNDoh8/QnK5sUIGIrpC48VcQyz6SkPIS7o+/EJUQR4EosLSXA5DjgyFwqhhOkOayyJDVZltwt7rWUKYtfjCokSuwtgxWMIA6gdDVCUjQ6i1qcFkxBZD7URVwY7TUEOy3e7B3FYfQ2AP90BsuIDCprxXQ9A+nEDm9IjC6RU5QzjHWkOwg01DjFmoQsrw50Ioq+fCqspxwpwQDMFCiTnAgoSKQr6WO0NslUlDDB8PQ/l38kGbu0RDGgISQ3Mvi0LasDVDjElXQhKtB0NIu6dB+rz2QfpnnkJbMytDQMeGQWSbl0KkbSVDVgxHQ853S0MIhTk/blkkQ16H0MKiqA7CPH5GQj4I4kGGhFvCAWRAQq5HMsID7gdDDsPSQQDmHkPqRmjCtG5XQ9DlT0PbcT5DOPIOQ4R9WkP0zJvCvpkNw5S+KEMxglFDmvq2wZwrVEMft0pDa37qQnZvUkPEJlVDdDWGQvvRUEIawj9DtFw3Qku4MEPmvJ7CXIorQ6efQ0I0eefCTJEzQ56WtcE88RLB5hlUQuhN48L8v0jC+E0Uwf7tOEPUiD5C3B1gQ+nDub+WVRTCZLmQQvaSIUNPWsxAJlrZwiDPBUOG++vCf3jAwbM6lcI4ebbCRoISQiAhIENMmztDT/zYP5KXTEO2ky7CNxT+QcRhjEEW6wLDvLvYP2R6TkOKrFBDAOVDwoDZzL/oPhjCWUdXP9g/WkPcZx9DUu9BQ4ClKMGUdt9CnlkLQ9atSUNIUKHA+rmpwZw1oEBZKShDpv5cQ4IRY0IUjlRDNC5SQ4j3msJ5OjtDhEPbwtCjGkIaE8BCwE3rQYYA1sIKpPbAjn6kQfdZFUIOdl5Doa9WQyjhNEP2PPFBlPQtQ7FRekF2r4fBU+5wwke8+0DoCgLDLuTPwtZHFkKC4drCU4YjQwCZpsI50yHB1vFswuSSZEMK0cVCMKTtQqCLU0MOnyvCchEQw4YOQkNcBRzCFuwBwcab9cJisuTA6DCdQYUWGUPbXAXDyDpeQxBphsI=", + "encoding": "base64", + "path": [ + "vx", + 28, + "data" + ] + }, + { + "data": "ckd4QqK4vMJpMo9CLG9yQ6rhV0PBP4zBV9lnQp4shcBn6jxDcpbQQv4QGUNGHB9D9fMfQ9EyEUNHDB3Ct4OIQqrDVMLB0pRCqRO2wVj9XENGgFdDNmNhwYIrwkDj4cfCxsA6wtWrE8FMKUtD4E5gQwa72kFyYk1DssNcwjDIK0Mzh47CcjFbQ9TZjEKX137B3KYSQ1xZNcLWC6nByENdQ3MKXkPqHRNDYmAbQxJpNEMJvLTC0v9pwbflZUJahFhCFlKmQU7jZENq1hFDbGpMQ7JdP8GmsVVDCbxHQ8qQgUFsHWtDyKEhQZJ9PkPwt65C1jXDQorCDEKSyWdDZvD0wfwnDEN3x1lDeN4qQwqtLkNMey/CjlRaQ2jTgsLku9lAnw0bwB5EYsGjyyPBKLjPQjLm5L4F75hCUnGPwWwqVkOGNMfCEsAqQ/wAD0OMWT9DIMOHQo5NKENE2yrCB4bmwqbNzUKX+OpCCF6Awt7jHENNSBxDssgwQ32YPEPQ1m5DoEb1Qo7c1UJgS/NCaHkwwbL43EKUECnCMUBkQ66M2kKYI6DCbmpjQxf070GCSU7C0vWiP27AoMJ0/kDA2FhOQjqM+kJ/EtxCY7UxQ9p7c0LYgZ3C/+MQQwalUkOBtmtCJEuewjFUoUL+ULPCjNfbQWQXC8Ju1kPC9jftwDVqV0OGTAxDhA9oQq+6FkNUZ8o/2kvGQqL0j0LIYdTCVuF9QtogN0OSFjdDX2zuwE5YNsJOokJB2qeBQuiwIEO26U9DeOhtQ85qMkIcRTRDNahJQ+jQXkMONFtC15ARQipwIsLipF9DpMgUQ6ivDkFIZVND+HUUQ1jnKcINSWlDyFSiwh6YxMAdAktCUDEVwoSUj8LcokhCQDGfQi74EMEW70xDHukHQ7QSV0M+PshCmoJaQyTwDcLmvH3C4MIAwY5ChELPDtPCPnaZwoPaw8CSlJzCtGxaQyoFDsJePSlCwDJOwQg3MUPmQb5BzO9EQ3KUL0Ni6bVAhtH1wp4qCkMo6FJAOmpBwmKny8IgLELC3yChQryyvEI7QdfCBvhdQzTfysI=", + "encoding": "base64", + "path": [ + "vx", + 29, + "data" + ] + }, + { + "data": "3uIJQ6srE8MU4A9D6pRpQ6myX0M6ux5CwiP8QsiUVMIasmZDNkYtQ3moZUMZ62lDYUOEQosSYUKZZ67C0EUPQ5OTOsGU6zdBzXkgQisnQUParV1Dlz1bQoxPXcK0i3XCoEBIQdjTVkJhz4BDmL93Q6ihtEJ2j2JD5orSwmTowkKAS/bCHvVrQ2ZkH0Ot0nJCBrqMQkeR2sL/jkBCHrpCQ2z6HkOAmVVCSktrQxuTaEPYHVvCZldNQhyOCkPA+/dCSC8AwtHIT0PrZnJCckBzQwojgcJu8ShDncZoQyhEMcLPn2pD+DQfwtY6ZkOIxCNDgO0xQ6qPdcH63nFDKPqmwotiUkOEdGRD2/WwQnkYw0JCb7/C/jRnQ0ZINsH4AZNCwqB0wtxMdcJwAkFChEovQ4jGdkLWfYZBtHeIwpgSb0OY5grDYeGnQqykS0IydxJDP3TgwCC1i0KADQZBjOOTwkbSEUJWpyBCb1Powv9NiULCn41CenBoQ6QE5UJ8Xz9Dom47QxpmLUMQJRJCRHmKwjQ1MkK2ujJBfx5wQ4qfO0Owp9TBNoNcQ7ZqykKIO8fCHshSwnPAAcLmQ2lCsnUEQ7W2fEI2CT5DSpyzQr52DEMS6vbCLLtoQxaFYUOE2PVCkdkPwkwn40FDv0XCSn/eQvF8rUEw80ZB1rx6wrHnZUPzfHJCbCcAQxvtjkKqtYFCiBQ4Q5bKC0MaV4fCRhMKQ3+8z0JyTOZCtl9qQjLvysLZJaxCa5ERQ9YZdUI71VhDfCFRQ663+0KaQXdD+gpwQ04uMUNJV/xC+g/VQtpot8IwSWdDypOGQqxqWMJJhRJDhhFdQopnHUE/r1lD1LIawviOaMKAoLQ7GMbVwoY6tcFcaPNCrDIdQ7wpgcLScglDWn0WQp5dR0PYHT1D6AZAQ7zxscLjVPPCMnmDQmblH0M0jITC3RUYwgWyZMIlagrCao5mQ5IbFEKmRNZClMpWQgCDmkL4TD/ChKKAQ3buuEIiH4pCS8Szwt5CRkKYlHFCu1TLwikli8Jez8PCeDMfQ+ZgAUKYO47CPBMZQxfSAsM=", + "encoding": "base64", + "path": [ + "vx", + 30, + "data" + ] + }, + { + "data": "1CVFQzyKIcOo9UFDOp0kQ8irPkNcrMJCX9E0Q9iKwMLX+V5DJ+lZQ/vUgkPiUYNDxAGDQK3pYj9EGf/ChbxKQ8Ck+EGUCADCgMu8QqQQ9ELsTC9DBgbrQlBt28JUearBYBGNQlHe1UJqpXNDnDlSQ9yqDkPSLkJDBA4Qw5oPNkI0DiPD1i1LQ2ruWEPlPwRDzmCZQUimIcP9WtRCPFsFQx03rULJjuHAKIyAQxGIYEM7WKvBgEDbQuiZQUPQUTFDEsGRwsrgCENwtGpAhKNYQ0Yk3sJi/NNCXqpXQ+izt8JI3zdDJAegwjxBXUN2R1VDUmtnQ+SQY8LCf0BDjAH3wsfDdUNePT1DqAX2QdagE0K7QAjDxOFFQyzADUK25gZDErvUwrzoxMJUfsJCx1ZiQ/xe50KUxMzBfjnYwszRT0OkAwfDegnwQeYvBMEidKlClp5kwl6/jT9erG1Cy7X9wYqVEMHoyP3Arm8gw+CkTkGi8WNB0qtpQ9PVUkKB7edCQDRjQ8/WWkM/LJfByDrbwhp3ur+cZGxCymtFQ+i0aUOi6NlBniIqQxR1H0OMSgjDNC+5wtCVYUFaBtpCXkNCQ7ibjUFSgnFDqmjIQdRRRkN0vBbDfAiKQwwQREMI4SlDrmbYQFSxGMES1TDBbvQ0Q75YkkI8jZBCKiPgwgiGOkO2AsNAgbg1Q+ZLkUG0T+5CMH5yQ4A8QEOCv+HB6Iw/Q15aNEKd4F5CJuH2QiY+FMOOoBNDnCpMQ9qej78wXi5D7hoIQ+acP0O0vYBDqANbQ7gP1EIyKzNDXJofQz3EAcNccTdDt+d4QRe83sJW95xCkintv+Cza0KtUBdDVgKAQFnLycJcjyLC5MIbw9JdvUFGOjBDXKNUQ+Vw3sLRXZVCbg+6wZA8FEM2tXNDylwNQ3SV/sIC0yfDwJ35QgnhaUP9ycnB3R4/v5J2xcKQCtpAB1M7Q/nIyUL+pB1DgPPcQrjfJEFojcDCakl3Q+IFBELKmPRCEtdhwoJLHsH29t1C0GsYw+zDEsIiOgrDzG5TQ3zpRcEIxBLCOM+qQp0E68I=", + "encoding": "base64", + "path": [ + "vx", + 31, + "data" + ] + }, + { + "data": "7sdqQ1Q4vsL3DFxDHEPGQiJ/C0OsCiFDVLJdQzJgEcPWlzVDpHZpQ+7QakMCQW9DytdCwlppNcI4NCTDIpdyQ6faqkKo+I/CL80UQxoxZEIyMNZCjPMxQ1rrKMPVt+ZBBc4DQ/6LH0MKMTpDbnkPQ15MP0P08wZDNmkdw9rZOr/wTgjDCCsVQ/b+a0O9zURDpgXTwe/eNcPsYyFDAKmQQmmjy0EqS2bCKnNhQypnM0M69ohBjuQnQ4AUY0P+sFtDX4DiwjaDgUK0lTnC1BwcQ8xpIsOneEFC0mMlQyYdCsNmleVCXYjywiqDL0MgxW9DqoKAQ7joysJQMflCYiQdw7LTdENIY/xCvFCFwd9fhsH2ISXDfKIPQxy2pkKweURDO6UTw6xjB8NkURFDNCl4Q4sXK0MVQ4HCKnYSwwQNEENR2p3CfANswYIabMKOwstB+X3HwpJ1XsKae+tCinuiQaqBSsLoT0XCGCocw1RoBcJUyAXCYqI8QwWTAsCAskJClEptQ3pgbUMY9IXCUFwOwwyxL8JMR9pCeLEEQ4PqZ0NE47hCwiXUQs7wT0PATyLDTAMCw9qui0Jg2x5DLi9yQ2zezsFMAnxDHVr3wTtAakPK7QLDGUiBQ4/MDEO8NUtD5uBsQnP7N8KieQhCxuVpQ1RG/UJ8mgZDJuwnw6lX7UKq4yfCN7NeQ/ge6cFG/y1DtLKGQz8eaEMWy6VBAnZkQ6gtlMAsO6NAgDM8Q8BdI8OStUtDRZZzQxQkT8IEatVCP4CGQnj9dEPY3VxDdwMnQ3w1J0Iy4lxDUM1KQ8LBHcNtYu9Cs93owWPOLMNS8a1BDaNEwob930JqMJdCEIhjQrjaEcNR5KXCxnpBwwYFlUI4IVxD2JtrQ4WRH8PicpZB1rSTwpjMoUI5i4BD9P60QmTSHsM5liDDjoMyQyLQikNWQM9BZDovQpKmDMOiA11Cqmz3Qnl6IENOE0hDfRAmQ2xYMcJkngnD1KVIQ6rLisFeVS9DZml9wTQAdMLEjSNDYx42wxiPhUBXNynDFp1lQ7pWWsKOfz9AwZbiQdhUOsI=", + "encoding": "base64", + "path": [ + "vx", + 32, + "data" + ] + }, + { + "data": "EF1pQ8YIJ8J8yFRDpEg4QvDPpkJLGl9D6JFjQ0JFM8MocvRCzH9TQ5z0K0OwkjRD/Ge+wj7nqsL2dgTD9f1yQ4iWE0OAd9zCxHJHQ8zYskBcCT9ClBRkQ5NnS8PG9qlC1CBAQy48TkOw2e1CMAqhQv42YUP8O51CgOzRwq48LcJiG5jC0Dy3QvYmWkPczXJD1ieJwgDBCcNkiU9DkEudQdW82sG1C8rCIhQpQxBb8kJ1n3dC5rZdQ6haZ0OiyW1D9CMZw/JnEEF0KrjCiIm6Qkx9McMsUoS/tVTIQmjJMcPaw1lCZjIhwy3+2kJGWmtDR+5yQwTaGMOyDYVCS3UXwwDdTkOWU4VC6VxlwgMVg8IAlOvCnCitQureA0N5InJDBOcrw/ZzJcMguDtDRUZhQ6t9XkNka8rCWHgiwzrSmELK/sjB+JJWwgXaz8KQm8jB/qUGw/LyzsIX3jJDhGSlQnh+tMIkrq3CiBq1wrdLk8Kpx5XCRYT4QoKgT8KGmufABaBPQxbkUkOkUNvC/WQewxR6qcKK1x9DPz6OQsRoPUMrJh9DHC5MQjIhZkM4ZNrCpq4iwwzTA0Ms7ktDjp6CQxTiisIInFtDu6uhwnQUa0OKQjjCghNHQ+ymlEL771NDNgH2QrC9pcJyerBCR7Z3Q42MNEPA2kFD/MBAwzzEckJTuarCiGltQ2IBksKFzF9DsZB5Q/QXcUPfc6FCXRVtQ6KhQsInTyDChtdvQ+Z55MLuj3JDqIJ6Q043vMI6Yj9C/EU7QRq9hEMSph9DSMPTQouBLcGyKXFDJWRjQ1JzAsMi0oRC8DmLwj4bRsO8Qd3BD8izwswrJ0PZpYNBqwHrQrJlPMNygQHDLI9BwwsG/0KYDXJDlKRWQ544OMNPKwLC8NDpwp2ysEECqmVDtx40QkBOIsPMH8bCdiRcQ7iDhEOwRKRC/KfBQpDWLcMKjtlC2TiKQjqsUUMcQWBD4GtXQ7DNtMKL2CnDTnkLQ95leMKrI19DDHYJQpY508JYL1NDa8L9wjzFYkIAL+7C3u9RQ7amv8LMMUdCpKyywYpBUUA=", + "encoding": "base64", + "path": [ + "vx", + 33, + "data" + ] + }, + { + "data": "SkpIQ/rU9r9BfDJDtLUTPnqYCEIek4BDSPhBQ5zv/cJaHIZCvNwiQ9E22EIYAelCVD8Iw1aY8MKnIJbCKwxRQ72jU0PmdhPDTKdtQ/yDFcKDg07Ay/h9QyLVIsNyUQ5DDkxzQ+rHa0PsTH5CzDPcQdNqY0PD+PRBhZ9SwjgJp8IizvDBVlgkQp2wNEOEkoBD62fZwhWil8JaQWpDwIvbwbTslMIGsgnDBDDZQj+/jELFVd5Cgi+CQ7Y3UEM6gltDQOwyw61kE8I2CwbD2ogrQnHP8sKiNDTCuPkvQrfKKsPpT25AonYWwyP3SkI3IkpDKshEQ/wNUcNVzIZB+byYwhOoEUPURIRBFta5wlIu3MJuDmTC1toUQpg2M0ORH3VDXhwDwyxd38JG/1ZD84wtQyZBfkM5ZAbD7rvQwuyMrkHyK4xB4LKwwrIWD8PA0InCpvwdwyLjDsMOUWxDUM8RQwLjAMO0evPCCl4ewv7t2sIoEd7COneMQooZxMLb6V7CQGEVQ8auFEOYPxLD7DLxwvLZ+cLsnU5D9JykQZZXB0MoX1pDgIeeQJAyWEOwbzHC6Acew8rBQUOO8mpDeipyQ2qo5cKcyCZDG2X7wiDVS0NC27Q/mnf/Qgpph0GODT9Dkos9Q7Az9MJ8sBND0/ddQzvAZUMunnJDC04Iw8i+PUFeSvjCPLNZQymB5cJXHn5DNv1DQ+JHT0NDOg9DqO9UQyR/scLRKqPCOcR/QwgUfMJPGHlD4xhfQ6UFAcPgHNG/GwoPwva/cUMGyL9C+i9XQgbgX8LS/GVDOwZhQ8iueMLsPapBHt/WwtAlHcO7cZDCfOn5wvFkWUPecwHCX5oyQ5IdEsMivzbDdDytwh4+NUMhi2dDCtIlQ9ZmAMMKo6HCIKgYw8uy6cFpPjRDjyAfQEw8gcKbXjbCLoRvQ87XVUM43wpD2AEbQ1cTCMOnYyVDWui3Qc6Bb0NWFltD0L53QxQnAcNm7jPDNBueQmDPzcKoqXxDQ4LDQgglD8PYympDLLOVwoaG/ULIhnTCjQMoQ/apCMNKpdBCfP+JwsM5C0I=", + "encoding": "base64", + "path": [ + "vx", + 34, + "data" + ] + }, + { + "data": "YbMXQ8IX+UE8tgBDxCImwiJTG8Efh25D4nMKQ0blmcJObZlBZFXXQqEwZUJYnnxCbM8pw322E8PnnALCQmYeQ7bqgENUvzPDKlN5Q+PwlMKC2UHC+/9zQ+ywwMLeGEJD9kuGQ665aUMGroJBpeaTwRu0QENHMTzB7EIrwTxk88J6g/lA1raNwMjIBkNs+mxD/qsSw0XhdMGsQmdD6baNwm5B6sIkWCPD5C5mQspRzkHLOyRD+NiEQ8N2JUOOwyhDPjriwp4umMLUvCjDXIQ5PgJfisLqLavCl19GwDwazsLBzSHCdpK1wm357z8aARVDncoFQyY9H8M0C9rB+fvKwWC0nkKkgNjB/oL2won6FMOngHzBiYfVwFGWXEOWW05DJwCKwsRcUMI7F1dD6h/lQg/tckOuMxvD2IRFwk73wcFrwk5CyEruwtEiK8OcidXC5m0bw8YaKsM28odDmm9KQ2sYJcNe/RjD0fDBP7hyDMMOqQzD1vbFQZsUDMOSrcXCjxeuQqeir0LmCijDVsQrwi7fIsOoIG5DiqG2wQoXsEJbHYFDAGgNwlOKLkOmkqvAukaJwrOhd0MET2xD1sJAQ+pqI8NCg9tCDkIkw+b0GEPZd/VBZeaFQpab/sHmJRJDbql4Q6j3JMO/hFBDlXUuQx9OgkMP9IVD0F6gwuj69sEMSRrDZGAqQ4geGsN+WHRDgf3/QsIOD0PNpEhDTYIjQzBs+sL8o/DCcG1lQz6OjcFEFVxD1PcrQ9NeGsMKIjLChcKbwipVPENe9CpCGPcMQSBHv8J09DpDL1JCQwC3gcGYHZXBhFQOw+ZZvsJkW+LCjOQXw0YXdUPPu5TClPdmQ+SipcJw7zXD7fSiwHPWZkO5BT5DIrXgQnhZj8K4Sf3CtkQxw8jblcLgD/RCNFobwo6HG8DwkHa95OhjQ55CFUNNoz1D97VWQ6xKnMILal1DLoKLwcCMcUNGEjdDXLx3Q10aH8Nfgd3CUvDWQYCoC8NlRnND/7glQyFoJ8MQvFZDsHf0wU5BSUMeiqTBWyzqQnj+LMNbTSJDhhDiwsQPX0I=", + "encoding": "base64", + "path": [ + "vx", + 35, + "data" + ] + }, + { + "data": "m5PKQsUfcULYPJ5CBWChwoJ2RsJSyjpD5OGtQnPfC8I3WbrBolNuQoHjZUHR94hBMkM4w7crGsOakvc/RinTQiEof0PU6gzDa2NhQ4ah1cLkz7LCO85KQxyQ9cFqG2RD+1J8Q6qBRUP12crBCI9twnvIBkMuc0fCIgrGQTaIG8OVRCVCwl05wsnDq0JjCUBD2CUxw9ZtJUI4+UVDwu3ewoqQGsMImRzDZpJWQbm7aMGsX1lDXs5kQxz+3EJGzMpCtPBdwhJB3MKUsynDQGsVwr7RvsGMnPbC3LQuwh5dQcIeV5/C79kzwva3H8LAbKpCgCyJQvnBycJOHofCY6ceQYcAvkG6DoPCPFwQw1ywLcOrbIFBqiE6wmREdUMAkRRD/jWpwefCa8GAPDhD1VGCQuJBPkNu6PLCcKP9wKATgMLQPJ1CToQPw/beHMMkoQnDgx+7wvxwKcOg24JDNYZxQ9z2LMNFlSPDOREVQsUfIcPGyxzD1rpvwU4yLcMXDQnD4zERQk6DGUIonAHDl9T0QGYcLcNQRG1DNLR0wjZzN0JYxYRDVBuPwjtY70KAbrVBjGGIwQGSikMYVEdDE2j+QpoDT8P0tnJCnu48w1TbvUJmKktCg0+HQcjMk8KabLZCKGCLQ7L6I8O0ZoJDhfTrQroCfEMWrIBDFCb3wfWUisIqQxvD+6baQhEbN8PewEJD9cV+QsCQo0Jq7HBDjnTHQjf4GsOcCRvDcpUyQ9hzv0FVfidDmDXZQu3SH8Nx46TCp93nwqR49UKFzknA2H/6wQxLAsOtiPNCI7QNQ+XkiEFWVlzC+dMmw7yQ+cG83BXDanEbw2xWaEOZWN7C0KeAQ8yHGMKYjevC2koZQjm+g0P4pQBDVs2CQtjCxsHDgyjDlgktwyn85sLEzIRCHHWgwq577kGidiNC95A6Q/PMp0JAWF9DXjeDQ0BBDMJeZIRDjoRXwsuaVkOAdPtCkplSQ34zLMOes0rBiq2ewcgRJ8OiIz9DdPthQ36sGMNqkyFDyl8cQVZygUNkJzxBoKKLQk/EH8OynFtDSDsaw9M3iUI=", + "encoding": "base64", + "path": [ + "vx", + 36, + "data" + ] + }, + { + "data": "e59iQhKkrEK86glCeZTswki5rMK4ugFDDNUqQhP+RUAM/3XCfJ+IQdpru8Gopr7BpCAEwx6Is8LROwFCvjduQvBlVEPEB2jCfFwtQz76BcNm7vzCbCwQQ7559EFf0mhDgEpJQ0ZXC0OXTnzCgozAwsAmoEJu5KjCvP9fQtc1KsMfjZBCPPOqwhTLIEJqggVDKTIjw8t9vELKgA9DoJgUw+ygNMNIcpHCrNbRwfp2T8JCa4BDNhUkQ+GGT0KxMixCTJeQwTSrCsMFELTC21eOwqD+jUG4jxzDyCiewscosMD+M+XCWhn+wAtCmMKaaNNBUshbQcapXcJcINLC43QUQhSmvMH4WcfCOKMJw18UGMP9EixCbmemwojDbUO6QrtCVTeIQQghV0GeYQNDAZi5Qa6j90K4fXjCoYbOQc6uxMKUusBCAo4Tw/g8i8KuLB3DUmuuwUTwxsJCglRDOGR7Q9h5s8KONJ/CrsaLQjfHC8PoQwTDugVKwpANMMNmNSjDKhHKwMyMUsBguEbCsPMjQiYr18KM1UdD5DG/wsuA5EC5mG5D9NvQwl5/ikIS2zJCiHxyQaYqhUPSLAdD9Ml1QmpRLMN4yY9Biq8pw2q3K0Is8YBC8OHSwWAi3MKYtipC02ODQ2ARx8KeSY1D3uR8Qt47SkPubVVDYoZpQRyS0MIohLvC40BaQv6ZEcMoZ/9CRIQmQT48/kEqUXtD5pYdQmL8H8MJuTDD3qHtQpbOfkJpH9FCgBlCQuju2cJK3ufC3oAVww7DdULazi/C/7qHwl+6HcOaW15C44agQrxPLULiHLLCKLIFwyby+kGj5C/D9fKlwnVIOkN6qg7DlHB1Q9le+L+o0IvC0vaCQqFYgUP8IoJCOj65QQKVgUGQQUXDu5Crwqy6FcOabYpBZjz1wnmuR0JxOp5CrkL6QmCQ40EQfWVDiAuHQ6CkIr2xlodD2K6uwl+HJUMU94pCpe0UQ+b2CsNGGQ9Cyu16wmCsGcNTgvJCOOGDQzDkkcIeY9pCfoJCQuyoikPkVB5CisLaQbjescIAd4RDlhQ7w9I3kEI=", + "encoding": "base64", + "path": [ + "vx", + 37, + "data" + ] + }, + { + "data": "xCSCQdh600L9UMjADFMaw6A78MLAT6NCdAJpQJEdH0J4DsDCnJqpwcDEZsJbX3TCXdUmwgS3nMFsMHFCL2eUQYqVG0MjWnjBtjXbQq0sGMMeSx7Dm7ugQtKjrkIQI1FDduEFQ6JookISkMPCvHsBw5aDCUKWjufC8KunQnZsAcM+tclCRi/0wuDdAsDY8olCBK29wtfQBkOfA6NCJk8xw39kKMND2pvAhjp7wv/XrcL+MIBDSP26QkxjOb8E95bAGr8rQaD6HcPWG+vBSBXMwqp9Z0KSdTDDONHbwgzT8kH8CxHDpcDCQcjD1sKOsMPBascEwsdmfME/9QvDg3NsQpQngcLOkwHD4m2Owq5vqMJW4IRC0+vpwrNyQUMmrj1CrCVEQlLdEkLgv55CaAlbwRCLi0Im8JLBpL1aQiYz/8IKE75CaCi9wm/eFMEGeRnDskvSQWaKicGg4hNDMFRmQzGqFcLoJ6HBPQHHQkCvPcJOQmnCepelwqu058LH+zXDnvArwihvHcKh8Zg/+qV/QoByU8JIygxD7OT8wnxY6sG6iDxD+toFwzrZxUFC+HlCEm8ZQuj5XEMHEpVCtwLQQP9Q2cLoJ6PB+LenwqxGW8CS7Y5Cbv+BwpUMDMMy1lQ+YoNWQ0wLXcIuUoFDlDNzQWo5BUPsPBZDYbNqQqbVB8MlAw3CloP4QDIhicJFOY5CCVMNwtocJcGE8GZDKNkywZawxMIfIhDDfb+AQtQRzUJw/T9CtZ9MwGrTwMGmMhDDbuYtw0IsJkFV06HC7A7LwnjgJ8OFPaQ/WLbSQUolgUIg5PHCNDGBwoKjuELJ0x/D1OFEwTwFAkOgYiXDw5VMQ+gZ70EYnvHBBMKlQnOzVEPGykRBEEh8wQYkWEIRhS/Dmv6JP7TpLMMkWtnBmvIlw2Qie0I0zOVCkKBrQqLqmsEG9E9D6N9nQ8QT9EE/wWdD3mrswikVzkInMa1BlLekQqb2OcK0TXxCrILNwuIYksIkgIBCrXKFQyeDLcHaeYFCyPmvQlorgEOkL4FCMtA7wW4dJcKOyYpDuGwyw159akI=", + "encoding": "base64", + "path": [ + "vx", + 38, + "data" + ] + }, + { + "data": "I3OowRh/vEIMki/C6lA5w8YmFsPE7B5Cjlz9wXc2mkKuwf3C8LZgwpTLssIKBr/C6nM1QfUjp0E/Ta1CCM2Wwe40z0LyGU1Bi6FaQsL6EcMJqDLD4vTMQZDQAUOYECdDFIqPQiZEA0LoyQHDXywew65em8CMMQ/DrNbUQuzljML8Q+dCFoobw8CLJ8L+NSNBgYEZwrl9F0MCTeBBXoEvw332scKSEwtCClvCwiDy78JApVVDILcSQqRLP8LaKDPCvLcLQuwtGMOOAitBOAgCw1psxELirRHDFv0Hw6nddkJW0SjDhfJXQomcBcN1jonC7BuUwkEOq0HQuyrDI0CZQl6XyMKCChrDNC9mwTAS3sGmxqxCX0cTw2i5AEPcdt5ANNCYQgBFY0L2RwpCmL87wmUAykGMm2pBxHCfQpwEF8PDpYVCIP0GwnOi6UEu283C8whpQsQNB0JbmrJCxlU7QwricsCrPlVBVuLmQi/kl0CfJITAz4fgwqo3U8JCSQvDYgaWwshGjsKWGw1CCMqdQlRQS8FOKKxCCvoYw2mXgMIeLf5CHA4ew6kgdcFcoZdCweVfQsT6HkOCdM5BoEkhwsfbZcIpsV7C1OuWwSppNcJLKIVCrGbIwuAsIsOYIRXCaOgZQyZxpMHa8UxDE5vgwUSqlEI0EqNCdpXOQmwIIsNUiepAOLwDwoiAqcGCq8ZBoOyWwoRrOsJiBD5DyhNZwmiqGMIBFIPC1P2NQZiOBkOQhs29/LNBwp3j5EHdXiPDhtolw6lwBsKQVuXCqlUEwzyc+MLMbS/CElWiwdbkoULwHxbDWc9qwdonDUOwP6LCpO7aQaxCo0KeNCTDfCQWQ/rWbUIcVrRAeCS4QqZZEUMeyQDCGFVRwtJEtEIbvczCvFU5Qs7nKsNGY4jCKCVMwzsHi0JWhQZDvo52QDWwd8LERCdDZ74sQw6saUJAPihDueURwzQqH0JCIZzBjSPiQVeqf0Gz251CICgMwzRbksHy+o5BcHZvQz618UH00s9BO0AAQw8tVkNYNK5CZIBBwoxMwcAyrnhDntHKwtYQx0E=", + "encoding": "base64", + "path": [ + "vx", + 39, + "data" + ] + }, + { + "data": "uYJgwhqpMEKMzJ3C/u05w/LPLcNv9/E/TUmAwofc6UL5ERnDSc+wwlwG7sIw0v7C9nUzQst4OkI9HdpCy19WwrQqbkIjDglCrHIIQXPGncLYHyTD0OimwZ4BGkMeb+hCeG2kQVoKB8Fwbx7Dqscyw9gfHcKA5SPDjcbaQrIUp8HwA7xC1gU3w4r4n8LJUiLCZA1qQDDOCENv7I3BBLfdwqRAysFe8W9CTLEBw9JoFsOOpRlDctcbwT7is8JEuJ3CTBlhQnR/ncLn2yBCeP4Zwyr9CEN6AYzCndYbwy4Ks0JbXjLDKBSkQqV8GcOgcdbCYZ/bwtFbaUI9gj7DOkevQkUTA8NeEinDukWzQY7edUEsWcNCvusrw057kUKqd+zBo4jFQss8lEKSvI3A+NaawsANTcEGACRCbAnHQlBeJcN2I4NB7l8NQYzfX0JtUArC9omeQnoLhEIYwCRCEG4EQ76UrEH5hQ9C81/MQsznCELUr/9BsY8Kw/zFhMDKzVzCCSXOwmynxsKLkG5CqCCrQjZxnEH4eiJCGA0sw23oxMIwj3xCoMIqw4WST8LyHKBCyvCJQqhrvUJoMGjBPIuhwgoOZ8G2QLHCKuHFQVcmp8KMywpCQ3oEw4L0K8OtC43CrsW7QtwZF0EW4g1DdKGHwgze2EFPabtBiDsSQ6goL8PDcR5CCXmJwlKgQ0EgPmbBfQbewvmwnMI8pApDgFu2wrDlVkBNNoLBsMm7wRvNBEPqnyfCgomwwhU8cULfYSDDRmmpwtKykMJqKBHDPicfw2B6J8IuP6PCTL9ywlrKsUKEKi3D4ZyrQRyvJ0OOA7/BsBdQQpxtHkKSPLnC/4W6Qoznr0LQHiBCpuC1QmJbqkLbWIzCkVOuwmFk+EK0TSzCsvePQj7s5cI40dTCtXJAw168iEKvw+VCrlQowtQVycLs6OhC0pLmQub+qELC6NVC1nQnwxZ9X8F8MF3CsXWDwZyfVkJJjqxC8wwuw95hjUHAyKjBF2ZCQwxAa0ISmQvBBHAVQ6fXI0Ovoc5CHk6mwv79tUHP2EJDKCEkwrBrpME=", + "encoding": "base64", + "path": [ + "vx", + 40, + "data" + ] + }, + { + "data": "4uOywnD0lcBRvN7CQPXYwh6QN8PzygTCepO8wsTXFUPCkivDKf7rwkJVEsNQURzDMtyGQgpRfkK8D9ZCOYqswr0KpUFAnE1CYz34wQbQW8HUN7PCenR0wqBCGkN1b4hCnGu4wWQvMcIEozTDZ64zw4jdi8JyPinDjWWbQoBimEHnsupB5rVDw8Q86cLu6KnCxDISQlRplkKeeGXCEHNDwqhFj0H47ZdCvuUfw7xbL8PvTctCiz5DwsIk/sIwnNfCLtaWQsi/AMGeOHxCqoUpw7r5FUMe9JXBhEUlw/kS4UI0ExfDkqrXQsgrI8OM1wvDZK8Mw3ibwkIw/ivDwpmfQt5dHMM4iSPDfpw9QvrfRELwHZhCGEc4w65U1UE05nzCeg7eQt5yrEKgJRvCNDHTwu0OOcJm0XlCuRDNQpqQIcMnVhbCEogaQj6AlUJeJGVBmHS2Qrh/rELQEgK9PtaTQmD4KEKSU1BCUyMHQqjQU0JAdGNCwbQfw1zFB0Ii94E/rnH+wqDy98IhjplC8IueQkv1O0I+PuI/Lqotw3j3A8P6CfRAndQXwwwlq8J0NmdCUkeYQgBFIkJ0iELCOIznwvRCvkFcNu/CSgZfQpWi7MJSzXjBrnYhwwUiH8OWp8fCaGUsQlAxFEL/x6xCJlHRwmJfRcFwesfBLl4jQ/NFEsOJY4FCUJfIwi7MGEJoCELCWUAOw/Ra1MJsN6hCeu/0wnpCB0KAc4lB2OFywrtwqEJsb53CaWX2wt2NnkKmxc3CFNWfwdyc1cKyFCvDee0xww6OF0GFDOLCcgy/wtM7kUJ03S/DyFBEQohwJEPoB3JBAlmHQh5CDEDErn3Bi7svQtL55UKSuZVCEPCIQpMXE0KnQ83CBPPwwjDRC0NI/wFAJIOsQr/0L8LL4Q3Ddef6wsPESELU4z1Cgm+hwiDMB8PSMIdCqDOIQn9910IOWGZCCBYsw0ajb8LE/KzCiP9YwpnamUIVk6lCLK1Iw52/LkKxklrCfHwNQ/5WnUJT+iHCSLzvQmVX3kJuCLZC4IvowiiuPkJRhwVDwd8JQG7SYMI=", + "encoding": "base64", + "path": [ + "vx", + 41, + "data" + ] + }, + { + "data": "lkbywjgEIMLEswzDMC48wjrjIMMK24TCzjb0wgibA0Osgi7DKF0Qw2aeKcO0+zPDDHSkQnZ1k0IwHXZCbDnqwtDRbMEpRYJCft6CwvbM00Eg/NLBgoPAwrGP30I3kshBmO5zwnSdl8LieznDAPAAw+6lwsK6rgfD4D2RQf7jTkITUgPCNs4pw9x0F8MMQvfCsmR8Qthd28E+f7fC0E9ZwBqhQ0JYIKhCe0I5w863OMNcTmtClIqkwqRrHsPUvAPDhLi2QuPSAkK4xqBCkhshw9bo2kKNs4VBDtYZw5Xv8UI4AYvCfXHrQpAuGcO+zCXDxewlwyn0DEOeYLrCNk0YQrYiLsMXoeDCZgqBQqAKmEIYL9ZButgmw7wwQcGyYr3CWNa9Qh1snEIoiIrC0W4DwzZcmMICmp5Cff6SQghl6sKAtJvCloVvQpZ2rEKcgkFC0ea6QkpOwUKEmRHC9vCuQdW7bkIypH1CgCk1wszGgUKMk5NC1iYpw7TzgEL0OBhCPqISw3ogEMOBzqxCjTo5Qh7zjUK7xgDCasEBw+kMJMM3zyDC3mCYwmHv6MIC7wlB2veLQsEnrcCSwJvCCHoRw8L+bEJxYBTD6nmcQoQRFcNt4UnCruE4wwiu08LM3/nCxfp1v4jMfkJrcR9CNKAKw/HeOMJV9oPCJwz5QuQZiMK57aZCyFn/wkBfbUJ2U53CUHAowwwOAsPQjgtCs+QTw7lgZEIWAShCU5i9wub+X0EMV97CMu8Yw/ZssULDdAPCFLyjQdI+CcPzJjzDls4vw0C9J0L4TQrDcOj5wq9V3kFaG+vC/PWMQiYD40JU/i5CIEmYQrqS/sG0E+FBEuteP0Tk+ULGE+BClEpfwWTnbMD24QHDM7AXw4wR3kK1bhdCrrO3Qrbv+UDFsy3DUkuSwjGr78BMotjBOAfiwkJdJ8Mmm7xBaTLdQcZP6EI1L4BBOhn8wihAxsLIvuLCakGtwjREtELO0ItCCEpPw7XLfELc06fCwNerQsMVtUKrF4zCQSQjQh+BbEL/FCBCKEITw5/Pi0Lscp9C5zkNQg01j8I=", + "encoding": "base64", + "path": [ + "vx", + 42, + "data" + ] + }, + { + "data": "hsEWw8B1fMIs/STDggnKwCV/tMJsy8TCuMUSw14lg0L+8w/DuIolwxQ0NsPBCj/DV6GzQvgumULl7WZAzN8Rw4xlP8IS35VCgg+/whfNT0LQLIdBOIv9wuCqoUCCgGPBd8G8wjIPz8K2ogrDiCZQwgjz8sIY1YbCWNARwkDrnEJTv4fCMkzBwmzgNsMUiBzDdL+oQo4j08Jkd/LC+gj4QVZsj0IvWKVCYilEwzxwFMMFUrBB7iPewkP3NcOP2xXDbI67Qo57ZULQ67VCKDG5woNv90FQGSxCoFTIwgoEtkI4cPDA5iaqQnM8z8Io6DbDti03w9VLLEMGZgPCvrwEwfRhM8POzx7CDA+WQsI4wEIGuEnBrx7HwpAVNcJLYfjChFk+QmKMAkIagsDCpBwaw5VMzsJWCLNCkBMvQcylDcJ4a7vCTLOUQvyUr0LmApBCEM2iQl5+wEIgV4rCyIrAwXtUlEIt5opCrmicwgZYjkKfJ6dCHCsSw6JTsUIzeH5C6Noewxy6HMOKl6dCE4yUwOgRt0JTfXnCmZczwpqrPsOj4aPCdE13wTAEEMNYp+3BMEoOQmTNNcIc5c3C/h8pw3hsukI5jC3DgRW7QvsJLsN6Sn7CPKRCwxQP2sGevRDDqusgwia8tEIG9wu/Qccow+i6l8LhPsrC6q8VQjk6QME4n7xC7jIWwxwVmUIr7dLCBwc7w5X6FMPyaBLBLCUmwxpalULYb3RCnwP8whEhP8ItTAvDWiIww7aesUKYB3FBjCU/QoQZI8OshTfDluHywpH4fUJF3RzDHHsUw+fhdsHYbUnCoN2rQrMzFUFw5oJC2T6ZQh8DfcI2/VtCQlAWwoaXpkJg4hdDAPamwtgSGsLQgBfDSDsyw8IBH0IcTIZCICixQoziMkLK10bDKqwBwmkrbsJrfJfCSTULw5xLQcN4zoPBMFMDwWZzpEKqK6HBqV9bwlcPBMNKmgfDTp/kwt2hvEJFGsBBAHsfw3iAmkLS+NrC5voGQv8tuEJpj8PCupzkwa9VPEECmBnBTh4uw1PxskKG5glCUl93QjrJicI=", + "encoding": "base64", + "path": [ + "vx", + 43, + "data" + ] + }, + { + "data": "MH0ww1Lkj8IdTTPDHui7QUyx58HmXAHDZ3Ylw0tzWkC2IZbCdEQwww5SHsNanibDtDewQuDwh0LgjRzCg0orw2p/nsI47JhCYErzwkRkiEIowz1CzG8Ywyw4vsJtgUnCvIP3wjz+/sJijXPCGLHUP/alDcMlDmfBZNGPwpVXxkKhxJ/Ccv0TwjjUTcOoijbDWmnHQh41BMPSgRHDfI9nQm6Mr0J6cYBC/kYfw/x8oMLpFinBxoIHw8qKQcNGzx/Dvu5RQvyxkEJIEq5CjirFwUKCE8KolHxCE17MwVpVCELq8/5BwlLXQfjs6MHXqDrD8dA6w56WAkOAifRAGjMWwsUCIcMWHTBB7jGcQpBK1kIugxrCWXASwhsilMIiQRfDBtVlwPW7e8G3WO/Cd/Aqw3SD/sJ6qqhCZJo1wqwVqkHkSLPCit2jQoCPh0LMxa5CwE4xQhgxnkLEJcbCsRCCwuTwp0J9VoRC+hOswnwDjkLRqalCxuuXwkKd00KAKaJCdMAdw1ovGcPOzFlCoQtCwvTT0kKQ07LCrK0QQS7uQsMq1OzCJKqzQZBJJsPGekfChpWTwWDDocKU+PfC5HU4w0ro+0Kglj7Ddq7JQpW5PMMcJ3jC5jEiw2qO4EF7ixzD/8SXwvY/6EL8NBLCBQRAw4gEzMJ8BgPDmAUbwiJpxEFvsrJCmOIlw+QGskLm/QDDvkc/w1QHIMPMTETC4BUuw1NhrEKMFJdCuvgZwzkKp8J+SiLDbYQ9wy/kmEK41jtCqK+FQnNINsPFR/zCxH1DwgrUmkJI2ybDZZ8kw9S6K8KuF+DAVCO5QqQersKo5aJC6KR/QootucLHnI9CcN2QwjxJnEGUcxlDEmDKwiUbisJ69yXD9Fo/w7gy3cF0C7ZCmq+RQoJfjkLE1FDDo+HGP04xl8Kk9LzCJa4ew7peT8N611TCVjYjwn726EG6jVHCBgLhwHhuHsMg6RfDBGUJw2BZr0KIm17ClIOQwuygqUIiWgPDKjdMwSj+kkKqV/fCMv2Awsu0/MG0WCzCdrU+w1h8zkKGuJrAQkWmQk6aXsI=", + "encoding": "base64", + "path": [ + "vx", + 44, + "data" + ] + }, + { + "data": "DvVAw/xEi8IGKyzDopg6QhRuVEH87h7D1swpwyjXLMKmJ4jBsGAjwyATk8K3XLTCDJWJQgBDCEJynXrCKJM9w7Dn2sLkT1FCdocPw9T3mkJg2opCxAUswzbJAcMSqqfCzAAVw14JE8OQ//DAtPwVQt6iG8PnS7VBidypwjT53ELS25/CPHK3QPFYTsPOz0bDznbQQn6JBcNmSSPDq9edQl4ewUJWXkRBuNOPwtPu5cGSsSDCJCobww6ZOcMoGhzDeyz/QE41oELW/URCL36CQXRUksK2X5xCOkbMQQbgecFkTGdCIhGowSThwEFo4yjDbpskw5RuXkLXKRJCCvdVwkhqx8KGHjNC1kyKQn7bx0KktFvCwmnzQLY0xsKq1S3DO2sowpWNMMIEwwrDuPktwyjZE8NMy1dCRNqWwnTVYUIWeZDC852fQj6ol0Fm6b1CiwzwwB5u9kHZzvzCB07LwjPNmkKcFCxCB0KkwgntcEJSQY9CbJKXwYSe3kKE8bZC5tgAw0Z23cItqShAAtaPwgbJwUKmGePCdLooQkxyD8OUxhXD6fw9QqQwMsNaOWbC6lJOwoPe4MLKbQzDRVg6w47QFEPSfDnD+PO+QpXhNsNIlU3C3AF4wr/hgEKokRrDJC7ZwkJQ7EIAd4rCtr5Hw1XC+cL0qBvDvOqawlNsRkIgYWlCtScqw5fntkI7mxTDjKAkw6KsG8NvDKvCrkElw4L1r0KUxqlCBgcxwwRuxMJw3THDyBY6w+K7JkJA24hCjg2fQg5UPcMc6TLCk0YJv01HqUKZTCTDBkEqw3y5Z8L8z7RBNFmmQjcD/8KVULZC9ma9QVvq78LAk6JC9H7Qwvqm18EV5bZC28TAwlo0wMIazCnDjxclw2YejcLlC9pCBg4BQpz5skJOADfD4X/6QcphkcI+m8LC6I8pw5ShPsMA/a3CvvyNwub3TcEANaPCrVjHQVT9MMMWTx/D9iobw8BAfELu6MvCdrpnwWRfoEJurRTDI3BbwjZ5y0H04hLDbMyiwr7dj8Ica3XCPA00w1zjtkKyNh/CLMfFQizzDsI=", + "encoding": "base64", + "path": [ + "vx", + 45, + "data" + ] + }, + { + "data": "0Hg5w8fJXcITlPrCYjmCQnJILEJ86TjDOEoJw3iCi8J228RBiVzYwvE6dMGywNvBpuloQXDKksEUpY/Czyo+w9SQCsMkgyjAdBIgw9BsoEJyb6lCdHw2w9yjB8MxXOXCghApw889IMNcUd5BOE54QjzTHcMo8UNCMMSpwnBz0kKYTozC2IUUQpqkH8PTY0fD98SxQjSt6sKinSvDjKO8QuZSvEIEADbCBB6IwTQxAkHnE4fCmHUow8KeE8Ne7P3CIDGWwcQJokKuJaPAgnMpQvyrs8L6uq9Cil1pQuThS8IEOpZCtrxYwhzTakKEdOzCQd3CwggmbsDe1GdC2vRtwg4qn8Gg8oZCZH8bQrT3g0Lb7XXCtLYbQiMk8cJIPznDdlOHwhxGYsJshxfDiU8Nw7K/IsPkXchANlmmwhBZnEI8hiXCc8Z+QnZbDMLsgrpCYONewrvc98FQ6RbDLgsGw8/L7UEo3+PAKtyJwpRDs0FggA9C2IuZQZztukIGibtCaMpkwgjlJcLDCS/CgxucwqSTTkJRhAbDlBB+Qi10p8J4Xy/DjhGBQkNqJ8PgKF/CFjZ/woxRDMNcjhbDMTEkw1AECkPCwvzCnA17Qs1jCsNvPA3Ct/swQCmLr0Kli//CIowKw4gViEIdesbCgIErw2UcEMNMHi7DY5G+wkw5hkLIjxlBnkcZw7Y+eEICSCLDUsmjwgoc68KSe+3CckUAw9C9iUJyQ6xC7HU+w8a1xcJKwDTDzwIZw47AN8HRhKRCz9WrQtDSKsOxdQJBC/X+QZxXqELMhA3DW4Ufw/8zesKOSDBCpmdCQixTC8OzMrVCHpT6wR7uEMMoAKhC1CEFwyMbXcJ51flBQDqfwvUB8MKy6BvD9rnJwnb9scKANetCbH0nwhRpyEIK987CMv9oQizkbMLA/67C7OEnw1ld1MJmq+vCCZ3GwsaOLMK6kdjCC3k9Qlf9OMNAfBfDPpYlw2yJL0FIrtvCGtjAQZIgOUKiCB/DypK6wmrR4MFeiiTDdI+uwiCl28LEsYbCwpfvwpBiK0Ky3Y7CsUPTQq0GDsE=", + "encoding": "base64", + "path": [ + "vx", + 46, + "data" + ] + }, + { + "data": "XNIBw5whsMFc/oHCTyWfQqQZgULct0bD2+SRwpRPqMI4GlhCTnA+wjYxnkFApG1BDtk7whSUbsJ6EZDCPC8Vw2j+JcOgtx7CgpYow0yzlUJjLLtCli0xwyZW+cLMhg7D1Bo1w66oIsM22lBCWMmdQrynBsNElodCVvuUwlyCmUIo9D/CthpzQjg5qMLghC3DbHAtQjh5psJBeyTDPrbMQlTwiEL87JzCNN+MQRb8DULgRbrCho0rwxAUmMLcel/CIJ8Nwly3kkKCISnCMcVuQtb3vMI27rJCm0aeQu5rk8In8atC5iONwnQ4oULyYx7C5KtIwbKdKsJUtpNCMW5iwlPzDUKswKRClNa8wKJnVUHpCW3C8lp2Qo4gCsO8pyTDLSWgwrEtasKIfxnDEA5/wtTZJcMStwjC7SafwnGgtUIhoQFBL9/uQeT0hsJQpJpCxyOqwo/+nMIcXCvDFa0hwx8LRMEOlVbCbg8xwob+IMKOwUrByKU0QgQiREJpZ6ZC3iGjQOVZIUF/NonC+OOMwhpTkMBoNxfDIHqaQkjGF8KATkHDWKaXQhR15MKTGT7CwF18wigcJMOkSRbD6qbKwhrvkEKhnEnCVc2yQKqRg8KEulvBMl4cQvM4y0IOlYvC4lQlw+ahOkFQtf3C0Le3wk5THsPkDjjDQt3IwhC4nUKvoQrClIrFwjUV9UDguyTDW29YvxVAM8I6exTDWYFTwkAb0kEa2IRCXrM1w2TYqsJA1B/DAg+cwtbogcIO3bJCEpunQs4xzcLRGilCTvhZQuQLj0KkCqzC2tH1wlwLaMJgFnBCddZ1wUSnBMNUpYRCBkeMwtblJcM61pxCKpMew8QKicKA/nrBkO5TwoaYDMPZuN/C5Jo7wkjFu8LjddFCO3vKwjUFzEKKXAjCwjimQgS8GMLUi3nC5CUSwyz7f8EuNBHDmOr7wtX9e8InhwTDRsh9QsBOMcN05+jCpPYjw8ytQ8LO68PCHJ1NQr6fy8B6PhzDUFgAw/V2gMKwhCfDeB+nwj5lEcNqRILCV7xqwmu2rj5spMjC/ji2QqLI30E=", + "encoding": "base64", + "path": [ + "vx", + 47, + "data" + ] + }, + { + "data": "hb2DwnRSTEI7xIPBkR6zQpTSn0JAainD+buuwebjscKibpVCkVWov2POKkKACzBCpUSkwoAqmcJ+en/CUQeZwugyPcO701rCjC4jwxrQX0Iv7bxCxD4PwyoUxsK0HSbDBFMyw6B7EMNWyYpCXRizQkwijsLQg6FCp4VQwgCbn0Fwkfm/LjGdQqi988FNRtnC7uLBwRwiu8FuJAPDB9XAQug6lEGGd67ClY8lQv5MYUIuVerC65Ebw18hIsE471lBnCQ2wkIhTEJwZnTCrECOQgpLsMLaI5FCYBe3QoKOpcLQdLZCgEGYwnYfu0KCQbtBxO4rQgKNhMJFD6pCVJA5wvyFjkJgIrZCLEI+wuSnEMIO/kDC1NabQg6ZFsN98LPCDr+fwmZxWMLSNwfD5PEAwYoLDMNIoW3CajyGwrjvwEKKBKpClratwXA7nsIJoBJCJNK8wkZNx8LuMTjDqP42w/nVBMKQIo7CuPHrP4BXmcJCg13CiKd8Qg+69MCVW0JC3WU2QvwuL0J+AJjCnHhWwugYL8KY1CDDVYmqQphhPMDob0fDfomkQgq6TcLyIgPClVBcwrdXNsMAWALDnJhmwZyXgcDs5BDAjI9AwsAWDMFtRnpB8Lt1Qhhc10KYDW3BpFU7w2463sGu6xfDsu/KwSb1I8MIdTTDCkC8wtC1qkJGX33CBLbkwcIF7sGKZg7D0KlAQk7NQkEavC3DabiFQUawtME2yEhBXpH6wuGsTMJEdcPCQl6nwCguwsKyy7JCxheCQpwVc8EILoJCnO6MQhiyBUJqVfXAzHZjwqQ5N8LfWY9CEt+Pwqzj2cKYAYdBkSGmwtA+MsNen2tCDvAyw7LAkcI+EETCqSJqwYzyHMMnJgfCdvzQwD6nr8IbIXZCrsrywro0tEKCXU5BIefTQvAiYsFyHxfBTJa5wt38BUJ/oCfDOLcWw4P/j8JI3BnDeECVQla3EcOAEE/CyjEMw0wvuMKQIZTC3IaOQsxGM8IelvnCJNMfw2bEoMJh5wLDDpeGwtstMsN24lrCnD9lwUUc2sEIbv3CboA3QtExoEI=", + "encoding": "base64", + "path": [ + "vx", + 48, + "data" + ] + }, + { + "data": "G+eWwaO+8EJiRKJBD4q4QpJhtEIEpr/CMDRnQeywpMJYZrFCLhcBQnWUaUJEMIFCbFW4wtzmmMKUADHC0Gq4wVIJR8PI8mbCFt0Dw+RRjUFCpqNCTteDwqp0XMIYeDbDQnwRwwh0sMKqOaJCqhi9QkVCQMHwELFC6C0lwQiqOcKe0tZCtvC2QuyQ+0Boy5jBtvuWwoZjp0KT2XfCv9GGQtryD8Iu2aDC1uJpQvJmkEI8cwvDCknMwsf2G0KsyGtCUlRIwi8Uo0CwpYbCtNubQoC/hcLCfNlBULzCQhY9osK4OLVC//SRwhLyxkK2mIdCOpybQpXAocKjpLZCngjhwUppu0JMC7xCHOKNwgwajMKWEcTBACCyQuQ2G8N5nevBfHqKwpKDLsIYI6jCwvDYQZbfgsIQPY7CyoExwniqv0LY4xZDeEmLwmqBl8KMxGrBlpmuwh4kx8JahjPDBptCw+HWLcIqr4zCMe7eQtLUqMK8l53CG7eWQgA0V8JaTbPAhN2NQvYgg0JQQYzCsJD5wXKphMLEhRzD/JSwQghYxkFnnTnDqZinQiSDY8Dy3QzBNMAnwppzP8OA9JDC0Yo2Qkw8YMI0S+tBoOmdws/KAULc0GpC4CaXQurD1ELdw9lBTTFIw0jsR8IRhS3DNrWVQfb/F8NnahnDc9SQworSq0JaX5rCnKa8QYjLRMIkZJDCCd+bQnQZRkL2FUDD5+p9Ql6IX8JHSgbChQYrwn4x0UHuKpbBCM82Qrp7z8JAvJ5CZ0KxQWu5GUIQvKBCdqKiQgK7tMER8E5Cgu2SQPSVxcFC0J5CQKe+wkISfcKplQPCeHydwrQjKcMcHUlB8iQ+wyRGi8JnMIzCO/3vQciXJsM0Ke9BKHPBQU58icJJlARADNPlwsw8WUKklzZCEkj6QjomU0GwB9dCr/lBwai1fELvyzXDemosww0LkcJarirDQuOiQhr1ocKq46JAQAmZwutI18Io8R/C8B2rQqDJfMJBR0zCUL46w8NvosJbIo7CK1vLwQaFTsPmbAHC2z6SQQ2bNMIScRbDEw1Pwaax80I=", + "encoding": "base64", + "path": [ + "vx", + 49, + "data" + ] + }, + { + "data": "oWaeQvYko0I4K5NCCTl/QpUWlEJ1dIxCoj3PQmHFU0IAv6lCbvmZQiiZhkKKmkJC1DP1QTqqhEJbKEtCTIpMQjDOeUJGxLNC1hJrQoKzQkK7eYJC/JqPQiAZikLGrltCPoS3QuyRvEIJE5lCPZE2QqVUtULwzIVCCweGQqUwBEIgWV1CLr09QnSAi0LBcZRC/eabQhSDhkIwfGpCsWiBQpCOl0IcFG1CTl5AQjRGgULs9ihC/YKmQt9IgUI9GG1CJK+2QcItbkI/cZxC08uOQvUzjkLWM4VCAMiUQuz0MkJLqqZCmcagQmvMlkLQmztCEgovQtCkPEJrXI5C2wmLQth+7UEa8ZNCOHxCQpzpckLwmUBCDxqAQibltUI8dohCbvZMQoUsiEJeNMhBPMxgQmWjgELKIJhCMYCJQufIgkKbIGNCpqwxQqNZgEKj3bNCd71pQlMLc0JOG55Cw+iOQiIswEJhU5NCB0yfQu5CvELEGOZC0C8ZQu8XlEJoMh9CmBuBQg4DPULiDIxCD2uaQm7Kl0IG33VCEKFsQtw9eEIFA6FC/8N4QmgdSUIgd3ZCfmmvQqEG0UJ6p5JCtEqFQpKliUKpWahCYLaCQkCxEELZ1pdC5qmpQoGZAkJn2YdC4/CNQtKsokKryIdCLTm3QghIoUL9JMRCfAlqQh1gVEJ0EiFC6myFQqAMwEKQXGZCNCs4Qu574kFHrINCYO64QmZur0LXUshCo4yjQr3Jc0KM4YNC1ZqCQg/4k0JwGG1CRv6cQvBIkUJTap9C8bmFQlRxWEL091dC9sqMQQKC8UEicKpCEDslQlBkl0JKdoFCX53AQsveFULwGaRCRwYaQp9noELZnlJCmzCvQrKMokKTbWhC+q5ZQnXZRELpyWBCajfKQulpnEKSHqxCZM+JQu7kbUIJdmlCBLuBQn3nskJv44tCl0GVQuQCekLWdp9C9H9ZQuAOy0KNvLBC/oyKQv5UYkKHE+FC5uatQhIOr0JiL4xCjTuFQr7AgUJWZVRCurZkQpHGX0JevEtCwHqtQmIvtkKeBo1C6I1hQo6sT0I=", + "encoding": "base64", + "path": [ + "vy", + 0, + "data" + ] + }, + { + "data": "lJGyQltZXULCkj9CePmlQqTrMELq/JJCPtCTQrwkyEFebolC6J9QQvwmO0I0DqxB+N9EQjK9DEJQgl1CFFpKQng0V0IpYqFCUqGBQtojWkKb9YhC82lLQuhlqEJY7IlC9N6UQgy+mULUxklC8sOKQgzccULkIK1CNqCNQic/l0FxT0dC3v4LQkCvYELinoRC2k/AQubdq0Iep1hCNORPQqGsaEJga3ZC6oSJQtB8iUI2VSxCpHS+QiT3g0IkrTJCH+QBQjinjULQVJBC7jODQqxoV0JSkalCaAOPQsjaQUJ7CaxCKHmAQuerg0LOD2tCA/AlQqAiJELsBr5CQJBWQuMVVUEivINC845sQgg5qUJenZtBlgOSQrqfs0LG4lNCMH0fQg/aU0Im0ipCJu0UQh8ih0JGFHxCHiSIQlaoM0I5vUhCBkRZQuJkmUI6wohCGq9HQvAiPkK+XL9CUbaKQiLWkEJjEaxCdL2RQojkn0Lez75CeAS5QTCaoEKw62lCbclzQrRIJkL405xCZHmWQprWp0LAuBRChJuHQq4VjEIQtn9C5NdoQhmcsUH9iRBCNOmkQtIopkJCZolC/GuzQk7TrUKA+E5CFVaSQjh7sUEUlkJCQmTQQrI5C0K4yyNCcttpQgfifULyfKZCsjqJQgyuoELGBJpCc9BvQrjGVELYunxCBgxwQryX3kLMI4BCog5xQvGvK0IcdIlCSCCDQuyIq0JcKMNCcqyFQqXsD0JBSaBCnpCgQgLIYUK8vptCpuWGQvSdwEJgVcNCeJtCQk71gUIwF4pCKrIfQtMDLUI0crdCnCnSQbqWsEJsGJRC3q2mQtL1vEGRzHJCoA31Qd/OeELmFg9CPeiFQvjXhEICcJdCHFVaQhe3aEJACmVCSm/YQvLwf0KOetBCc655Qq2/JULxIoZCSFFnQiXEhkLmlKRCVX6MQkY7ikLHFIBC9m1MQlonyUL1s6tCnNZaQm0HO0ISqdlC5wnGQlCCfUIG2K5C6n9jQk1WgkJOnSZCMKFzQmSfLELgYFJC1rKcQjKJhUKYaJRCAEgjQpROO0I=", + "encoding": "base64", + "path": [ + "vy", + 1, + "data" + ] + }, + { + "data": "AiaJQsJiCkIiFx1B1rXOQqqM70EuQ4JCNoYmQgDOMEFDrQhCTNaeQSinDEIylsVBbuZxQh5Fy0FSNVNC6K1yQiiuL0KRiXpCOhB7QvEcjkIQvXtCvoSyQay5tUISY55CAodZQn7BLUI9GhVBJDy1QtQbxUFmpZdC8HeCQsk/+0GnpS1CTDNdQk/4IkLggkdCwN6/QqptrULgRUlCGhBCQlfSJkJAuGxCRDqpQpMGjULQSShCnrbAQgKgeEKFfL5BAkMXQjbJikKsdjdCqQlUQuZRD0LrSZtCu6ZUQt5lh0JPNEhC0mgpQtWjLELujYVCROtuQs4rTULuZZpCNrnCQalMCEJyVUBCOHGeQgXPzkLeKZpBCoKGQngmnUI+VN5BebsvQuVB/UFL/V1CSU4mQs9OgUIgU/xB/IlsQp43sEEwoUpCvABtQuRHlEJaBg1CQLM8QvppLEKJPK1CPil5QowWLUIMG55CwnBhQiATU0LAEnhCUFA7QqS9hEI2K6NCDNJmQggXJEJ2N4RCMk1kQj31gkJxUWxBc8WMQmCviUIqqypCcddtQvYj9ECWjt9BX7OEQhD1Z0Jq/FhCJWm7QoLlxUKUtRdBXv6XQqwZJ0KKTa1Bh8y/Qv7/XUJxWdpB0C0wQvY0MELqWZ9CNps3QmdmhUIq0kdCuG1rQr+2iELqIKtCCrRTQpRLpEIoIn5C3muhQl9BTUKYioZC2HwTQqGTSEIw75hCbuYVQpBniUEXPqNCChusQiraGkLEaJ5CZH4qQv5+zEKX86JCOfkuQtyOkULwzJdCcu1SQiXsPUJwr2lCESfoQSkxt0INIY5CFiU5Qqy5FULFtQ1CYQQdQi4fOEK2eLBBHmc0QsKiTkJMapZCmZRSQty7gUJIinNCd1CkQiJHOELmEbpCI51KQhIlkUFSr4JC6HZLQqAeJ0KcPaxC6phKQtfdgkLMLk9CQF6GQmWrgEIgfENCU0z+QdCoLEKUj5FC2CbMQgKcHkKCrtFCiNcpQlc0ckJuGxRCbC1iQkzVzkF1Q0BCFIJmQnp8D0IILIZCvtREQrZlGkI=", + "encoding": "base64", + "path": [ + "vy", + 2, + "data" + ] + }, + { + "data": "6E4RQvw+sEGMyxZA9FeHQtZ7OUJHXUdCVQAEQbpyxkGNKdNBZTiKQero30HT++xB5KBxQka6NUIm7CRCeI91QhAfAELO6AhCGHJLQmakk0JI4yNCADE3vxhPl0Jucp5C2af4QVaXTUGuXwRBdCySQhpzUsDaMQVCckFEQtatI0KYXwRC0ZRwQlq9wkFS+ZtBas6RQsZBiEL3uVxCUptJQpk7KEKt50xCfka9Qs4xTUJqYxdCpttvQsC0TEL7yIpAzIoCQpSpM0L30e1BUW8ZQtSRzkEwxw5Cb+YAQoyffkL2sZlBPnKJQX7P+EEeIoVCrjmBQjb4LELgv91BpTcRQSC1JUIIfwxC4aeTQsJ0fUJgicBBonwaQjbJbEID5EFBxtgjQkbaNECco3BCfk9BQihGYELWg0FB8DkqQsZY20G0MSNCilZnQq6yJ0JM+3xAGOYcQsjoFkIm2kZC3+JJQhisiEAOEmVC5MXwQTzmZ0H8n79BAB9pQqqhGUJIBotCLrs4Qq8aK0LQfglC/pTrQXf620GlE9dBiUtAQkticEJJYZVBQplGQijqx0EcprdBvnwWQhLB5kGdE/RBfZ+LQqr3sUIJzmNBPppyQrNlN0IEjsZA6zp+QitufEK76aFB5BbZQeR+rkGSnV9CaM69Qdad9EFUSJhBT4JfQlBNZkLaiahC19IrQjDvNkLNV1RC/H6aQkioWUIRoF5CIuKOQJT4PEH7byxCUGOxQfz94kEQUD9Cbm6UQmwTA0ISNipCqtAFQnYcZUJGxxFC0Fg/QoabTULUfpdCZEBnQqzrKkKkFoZB1mAvQv5po0L0uCNCQM0aQRsUPkK0bhRCDYYhQsZvyUE6b/ZB1PiSQf4xDUI1GldCQI85Qu6EgEKgm1NC6N1JQnjP50Hq+G5CR2kGQkT4gMAWSU9CHiQfQrbISUFGY55Cm4IJQoS5RUKwcRZCnPRjQsS+EUKO1rBBkBvNQDCCRULtuA1CKsqgQsogs0FREqxCrTTLQX7jL0JUoRxC3P8nQihZnEDQYgxC4mi7QS0HB8GTpStCR0xxQgqM20E=", + "encoding": "base64", + "path": [ + "vy", + 3, + "data" + ] + }, + { + "data": "Zg/EwHkk0UB5kt9AosCoQaX/MEK2vspBatQcwSnvqUFlp8VB3uNPQXE0s0Hig9VBZHg7QtX4OULOymtBVtjTQe4ybEE+eHHBok7UQcrwIUJuKypBAg8kv4bWD0K07WhCvJ4gQC5dsL+0fEBBPnGUQVrdTEDwwQbB56mJQeZFJ0Jm1EVBixQQQjrBRECEvNfAsvEAQrJe+kHktglCUq/0QTT56kFCnAlC9ms8Qlm1h0FDb+BB1Aw7QSy810Fy5OdAAvpjQZnMt0CZ5ppBThSJQXZ6rEF48bY+vOEXQT/bCUKYkkRBBEC4wPzMdkHzLjRCdYcXQsCBpUFFmUbBDuI2QAI7FELw4qNBof3fQZQCIEHYQXxBfkbKQL7G9UHvYutA7F2tQUNlBsGlKlpCLo1DQr7+4UHeREdAWclpQW8isUFu8qNBA2MzQlsUOT/aYYLBRIKUQRxww0GajkJBer4CQmxJHsKmyrVBdEJVwMDtr8HIk83BChNFQvU4gkA9x4BBc6KeQTp2KUJ1uHxAVCOlQAbDUz9JX8RBZJUIQaKlIUKYbebAjKKWQQQHyEEghedAcuwuwSCAu8BMZCxBHALMQX6fE0LIpalBAT/kQWHVCkLqm9O/Hj6SQSfCQEJtc21B8m6sQNfYdcDccKJBWMIHwGg6+r7lemLBrFrkQfYscUH2mwBCvqa6QYTJEL8ue61BBDQcQuTaWELzWfpBZJGzwcpkZUA7oqfAkZSeQJmszUEDat1AmjkNQqwSwEHCGndA2hfJQYaozUCSMDrBosAHQiDz+EBW/klCPghoQpc00UGUyxfABFj+QVegS0LU+JxASPSAQJFnM0J0dgRCSDr/QcPE1MDZ8NlBpJt/wS62ZEG8HiNBCin8QXQ0D0LGdPVBqZv1QJZsWEH0A51Bjg4gQch+JsFiAbZBgFe3QTdymcFwgm1CWuR1QUknbkG+PItBEnZlQeKQH0E4Qo9AuqtIQGtHHkKMsDbBFG0NQhLMxkDK+jBChf+wQIHYdUGGWvNBmPoeQYCaLMHEsgJBVso0warn4MEcvlVB2VkVQoiiSUE=", + "encoding": "base64", + "path": [ + "vy", + 4, + "data" + ] + }, + { + "data": "pN8JwgJhlMH2uC7A6F8HwgSK8MAgA1nBZhx9wcSmP8BIjahACstqP2oLNkGbm4xBkq0JQPSqrkDPrRXCxDDjwQEdScHCvYXCqLNWwVBNLsFZcK3BfnpjwXiDrMEu3KtBBof/wYp5KMEe411Am3oswtkYrsC1+NbBrg4QwkQHrkEb4N3B9PTGwTyJ4MFBKuTB3+i9wRqjt8FK2BNA0nBpwf4kTcEumDw/AwRVwSIN+MGUzg1Bj8XnwTDrosHOpxTB5JW1wfqX/8E5S+6/kulswQDXScFkfeDBmBShwVLokMHY/lo/hK6awbxbFsFO9jrBgG2JwdXEtsFcYrfBpNqQwfIuiUH+wjPBcBIKwqk6QsJnsAXBlIW9wYzw7MAgdkjBdGKIwUiZCMKwc+hBrJ8vPjDoOcHfZ2DBEC3Jwe4OD0HEtTnBSqVWQR7JCsJeoxPCptOWwThSBj9/f/rBHkYHQXqCPMKyDMjBcrE7woh3McKz51LCGgVSwBqi8cGk0DnCEc62wVgQQEESSbPBenHRwQ4Zr8GmxgdB1MQDwqgMI0DgfgnCGOXewZREOkE13tjBWp9XwpbyLMKti2rBYKMNwq4htME8mTRBpuurwRR/o0Ayl6nBXooYwljotUDHI+1ACGe4wWFYqsHXlvnBWLkIwvKsz8HkHjfCMZapwdCTDMKtG93B/dgwwZjUe8J+KIbB1DGnwTizyUGhfqK/yJXpwepnisCcBIfCb+aeweEXnD92HRXCPH/UwUYLEcGir/jByNrHwERMRcLspy/CZChZwQpIEMLDqgTB4qrPQVBp4MB4YmjBsP2mP3CnF8DkpeXBn3alwAYnlEGwzHLADKc3QRpAZMISvfLAnLdYwiQ7Y8H4OQvCcA/TPndMrsFP/BfB0P9LwsYJZcHeTAPC48zLwVxfzcFGsrzB6Fwvvvr5R8LEFOBBkIldwVKAGsI0CETBiqcTwpNsmMFSyYjAQOlmwWS5esAqdYPCNMuowcIVLsHYi6rAtd6SwViWvcFdTqpAIHtVwil51cG62yTCyrPuwUMUFsLIYKrBJISawShd8sA=", + "encoding": "base64", + "path": [ + "vy", + 5, + "data" + ] + }, + { + "data": "BnxrwjSLWsKRab3BKOPFwih2osIiHZLCu7oYwi66UMKMsWjCHGacwarjKsK1ZJjBOleVwugAj8IUOsbCwBaqwiAvXcK86N7CsMOCwp6kmcK63GbC6KETwsJ2vsKCILbBsJOQwul+A8JZMmnBIn7JwtR32cG89DDCmkq/wqqUBMJCfLbCoDWswuD6h8Lyd1TCNJC6wn0NtMIMYxLCGlqkwv4GksLppX7CIu6hwiTEqsKZPczBogyQwvInhsJAJBfCJMx9wooIicLafFPCVj9lwn7mjcIbAl/CbIQ/wlx/qMLF5TzC8nlfwspFN8LQkIzCPLu2wsGsscKi8hzC/VpPwnD/C8I+QnPCdlfTwnzev8JFWT7CUsVgwrRcYcIXmDfCIMp+wsJyscKmt7jBMliPwtfZZcK27gbCABGfwlaHBsLr02HCCwIdwvRBeMKuEHnC3BB4wuSCSsLoNKXCFiCvwa6bhsJPNbbC0PXhwiOXfMLa1ovCe9ecwtDRacI2v7TCHgqIwiCRIsL8SFDCXKdtwuxDTMIyy9rB6AN9wu55YcKkgnnCJGaKwjJrp8G4GJ/ChIHFwoFPoMKAXT3CFFjFwgSdvcKapujBn2C0wsdVUsLXk3fCxsPFwtjJeMJkI5TBq7xqwqb2d8JUg7zC70lrwnU9ZsLQMJjCVp6owlEvkcK23cTCB0lsws5UzMJzP3jCWFW/wv6rKMKi+BbClDFBwkwWCcLMTcTChGJGwlp5P8KCeo3CJwq3wgShgMJaPnfC8FeFwm+Mv8JK84PCifWSwkorj8KyqHLC1/4wwpxvUsKvhhLCDqIowrYAjcKeKnzCY7oKwsCeNMJ0KpXCAAmuweA/3sLDgovCPIauwu5CVcLwwZDC8B9ewtSarML+B5TCLmDmwsJ3W8KQVs3Cf4SnwoPeZMIwoqTCynLpwYstpcJUiEXBvEtlwiitpsICE13CyaSRwqiIRsKSiBfCim0mwvbijsKuYrjCkBy0wsfkD8I+Kn7CShAzwrByksLInxvCCHzkwt6SRcKi+L/CzExqwiGda8IennTCZ/exwvL9QsI=", + "encoding": "base64", + "path": [ + "vy", + 6, + "data" + ] + }, + { + "data": "MAWnwmYpqMKia4LC91IEw4NY+cKUNQTDs8qRwsqyuMJG+uzC0KSTwlC8wMJJYa7C7TAFw/Z9/MIkwtvCLEXWwsApw8JTjgPDrPfXwv+6EMNyEcHCoB1twswnGMOnwILCwJrcwgE6lMIGx5DCjDfcwtpAhcJq0KHC9JnnwtaYvsJit/HCGRrqwgabp8JYTZDChBgdwwggDcPE6ZXCxy3pwsLr2cKSV/zCZNENwz+7ycKCCY/CVCPbwtQtwMLN04fCok2bwvCxosLDONPCWjnMwsoG5cJTvK3CQiGswplK+sKWieLCkEO/wvyYvcK20djCDrr3wqB+9cIb9aPCKpyewqjiwMJcQNjC6A32wmfh0MJ6mZvCULu3wrDX2cKkCJzCcme5wtyJ68L0c53CAQEGwyvpzMIRZHzCEmz7wqQExsJUv87CciXNwvKvncKM+ZDCzhawwuJR3sK7xuzCDXBcwgp3ncL1JQjDnvwNw4fMjsJEYZ3CgUsBw1KYuMK8lLzCvrvDwuS3ssK/tLLCE7SYwvzUs8I8MqPCxuOuwqw89MK+WqvCJD+/wh42qcJZC8rCMi35wlJJ1sIzvKDCiEQDwx9mGMOSNcXCJJMEw/pv2MJY6b7COiIIwyy3AcO4lIXCjPq1wsSx2MLgnPnCzo6Ywu78rcLas8TCIB79wsrLusIo3AvDnL/Jwo2m18IsndLC7v4Lw9LhxMK3YIvCCKeEwsjZu8JqnNjCDnOEwt5nvsJlp7PCfkP/wjms0sJ4erXCBL3lwmzV3MK2J43CBPzpwoRqpMKSqsvC9hbDwojPqMK8sKvC4q/AwtPoAMMfQbjCjvu6wjK/38ItBPTCALdmwtKQ7MIIdN3CRza+wp5+wMKwScLCz3ftwnQK/8K4av3ClGL8wlHNs8Ig+hPDyIH9wtalqMJ3qvTC3iVywny0zMKUll3C4h/KwmNxv8L7Z8nCOOCpwig8mcIlpKTCsGaKwr5c+MLI38TCZksXwyJqp8Igk/PCKPaFwlaX18JVnLrCkPLmwiNAhMJssNLCl86iwuB6icLbZbrCxtXrwvz6w8I=", + "encoding": "base64", + "path": [ + "vy", + 7, + "data" + ] + }, + { + "data": "AZPAwqbjrsJcd8TCBCncwt5B18J0IwfDG5LUwrxyv8KFTf7CGNnMwny99sKudOzC4owDwyo8A8MWGsHCYPzIwmSy2sJaUd/CpCDwwgTUEMPm7OLCfluPwjJYFsNYX7zCYVP6wpMayMICMtHC1v29wiWkyMLWmt7CDGHSwiqeAsMUVNbCaMW/wqJqqML4j5zCrvcVw8pgDMP0wsXCX13ZwiBk2MJbdgbDoxUXw17HqsKgLM/C1hTtwswWz8JwNafCTEqRwqAztcL2ygDDSNXuwjnC5MIMm83CHPvawrA+68JMdgPDPMvJwhZY7cIl6+zC/W/twvS+5MLwEevCqJWkwsjW7ML6kujClnjTwtZ8ucL2vKHCWn3dwrrRCcPmd8PC6US4wsoPzsLkstzCInYBw74E9cLGObPCd/3ywoYe+cIseOLCSpMCw6VsvsKFMYHCsvi6wjfb+sJ2d9/CY0qiwtx7icKCBAPD1PzrwnQfhcK1FYbCREzywszazMI1Gp3CYWvRwv+E5MLameLC0eKvwogLzcLgCt3CerPHwlp4FMO4G77CV2rMwqFM2sLQsLTCH9/XwvQU38LujsHCL8sBwyxZEcMYKQXD2L7zwnVQ7sIpR7XCUqUCwxDTFMNKz7zC4NbLwhqF3cK46/XC7XupwmxTwcJqPsrCqGL0wlhjvcKaw+jCBbzmwuC9ssK5W/zCP1wEw9Rk/cLXvrDCDuGUwkpZAsOEIrLC2JuiwluB1cIepLzCSvUAw5Qd3MI2YMzCF/7hwr2mv8JXoqDCAJXewjvXscK2fu7CdJLywvD6rcI/qOvCeLUCw279DsPe3sLC2s/wwlZABcNEptjCaPqewpwnyMKcTt3C8MGWwhJM5sLHicnCaiwGw2Iq8sI4HPnCxovcwh7i3MLUagLDuEXzwjvpoMJIoOvCspSmwqCyqcLO47DCSt3jwkZ1ssK8lerCDii3wmgCt8KVMtTC+IekwqwJ+8LAdKrCBJAYwzbH7sL6gBfDpLqbwvnNwsL20P3C2LPDwn4QjsKY/rbCUCipwmDcaMLfns3C9JbKwpF3zMI=", + "encoding": "base64", + "path": [ + "vy", + 8, + "data" + ] + }, + { + "data": "zC/JwubNmsKALNPCuH+owqoYnMIEHu/CoYrmwp3nqsK+0szCe1HawglcAMNWHgPDsCjAws6h3MJmNpfCXNenwhzazcJZIKvCUtbhwvs338J2pdXCCBSTwoTu+MLRadPCwlnqwhLw0cId2OPC/ICTwhYr2MIAv/XCOoanwqCiBMN61aXCED6MwvZHnsLCQpPCyub1wlAe6MIQc8/CdIurwoLXt8Iy1ebCKXnqwor4mMKkftrCYJ3SwrXUwcLoNqnCud91wifIyMJsbufCvU7Xwm78wcIQ+dfCpM3nwlhsr8KOatHCVv60woVH6MKfFd3CpfHBwkx8t8IjsvvCGsGVwp6M6MKW4cTCDhKVwjqgl8LyJpPC0mTbwkJnC8OKnMTCnEmswuzdoMKSTO3CHN/Kwpgb+sI8PrrCnGPGwgh5+8L5qsTCdpT4wsBl0MJQ9nzCu3SzwsWR4MIzx8XCmHW9wpsTZsKnF9nCO0CswoaSfsJlkZjCmD6rwiC0v8K03J3CXNrFwlQA7sJnCOHCkuWmwkSvwcLLkuTCQMjIwpF5BcPrSLTCDmfEwp/V28K1F4/CIPekwnL2ycLSFMnCvinewnSk58LOXAHDRcTHwsT03cJ4uZPCvnjLwq6l8sIA78zC2KvAwqATwsKw4NrC1jmkwj5ZzsIG2bPCrrvGwmySwMI6bKrCGvPdwjircsJaBOjC9k3TwnQdBcNEBLvCPhqWwtkR+8IOm3DCie2jwtwFxMJdGrLCUgbjwlrqw8Jgn9LCmCG5whbfncK+3bXCTpuvwvnLx8LeoebCXMv0wjyum8I3IvbCNKn6wusB/8I2NcfCLj/vwjyt/8IVnKLCPQeqwmb5lsKkWbvCJMhNwtbx4cKYXbrC+gfzwhaKxMKZNdPCS/KowhbX3cKMmtbC8uDNwvzQhMIvLr/CUpC0wmIIccKuAdTCZP/UwhWLlMJz4+LCG6zKwq66uMJI6ODCgP2nwppS0MLUGIXCoI74wtc9/8KazxfDhoacwnQJncIa1QjDoMmSwqDsh8KLPY3C3UOxwoIecMI6T8TC3EGYwkYMrsI=", + "encoding": "base64", + "path": [ + "vy", + 9, + "data" + ] + }, + { + "data": "D3G3wh2nbsKnBcnCpn96wpexgsKUDMvCKFDSwi6sisJ89pTChOzSwjQA1cKskvnCrBeFwgm/nsKEm0bCcZKKwgzntsLq82nC/GvEwii/nsKidq3CBOKKwqLgssLAc9PCCLDJwmr6xMICXOHCX51zwtQuzMJGdMzCUqtewkuy38IE8VXCjAeBwnJBi8KbgYDCGom3wpYGo8LwHcTCDl2DwnRbmsLo7K/C3AqqwvqPicI87svC8mWmwlu1p8I+M6PC4HtAwky4ysJUF7HCavKswnFvkcIMqMTCmDjKwsRXgcJGNI/CnoySwt+ivcLAa7zCkNOOwjaKdsJTIMfCGH11wiAHzcJZApvCXDZLwr6FgMIgOHHCq2K2wlYO/8JrYLHCdkKMwraSW8KYeOfCqP2RwrFg08LK66nCqx2OwkgiysLqqY/CtjvPwh3YxsLxzHHCXAuUwvabrcJ+HanCTcG+wqB7ScJT7aTCjvBMwmRSZcKO/JnCxJh2wsCbqsIk3qLCQ06wwoam6MJVcL3CRPaJwuYspsKke9TCccq9wuSz1sKQn5zC6L6uwrRrycK62ULC7LVcwpGtq8K5Xc3CmHCswpQ8q8ImJ73CYACXwrYEv8LOpVDC/c2NwqgxrsLiVMrCwiiqwspom8LeTrrCBWqUwp76usIOkpXCvsOPwprPtcIgiGLChiTCwmq5ScKyacTC6xSYwmLQ+MKcW7TCptmOwlCVusKxQTPCCJCXwrRQnMKyQ57C7hu3wrK8nsJS+rbCHOKQwtXBgsLsDb3CiTOLwsBoycIIX8zCCpjgwiSEeMK0KsnCaqLPwuh0xcLlULfCwDrIwuAV48KK/IbCrsCkwswGPsKCJ3nCzaYHwrC2zcIunaPCaP3Mwpy+jsIjwajClnJnwniCvcKqgKXCRlKfwkitRMIapoXCxA6swoItSMIiktrCsU68wkqaVsLYUsjCkv3HwkbRqMJOj9fC1mGiwjjKncKeGEDCLlu7wtbezcJi9/fC0imRwkLPh8JiEfLChr8uwuixdcL/NjXC6HmkwhdxcsL2WrDC/CKFwj6MfMI=", + "encoding": "base64", + "path": [ + "vy", + 10, + "data" + ] + }, + { + "data": "DNuXwunnCsJgta7CCdw2whYKc8I4YKTCosKuwvBkPcLS8zzCD6m6wrIDlcK27rfC9k4nwkliN8K2qpHB9jxxwopvm8IELfXBiJugwmzePcJxl3TC7tR1wnG7PcKcpcbCNRujwqcrq8IrtsbCLBNmwoVtscJ/sYrChqukwS5FpsJuCpXBjaluwpmyYsJ4tVLCNthpwmbKGcKA7K3Cl1BWwmW4dcJMPGLCY/dcwhL7acJmXLTCei+BwqQhhsJ6tZXCcHoDwizUpsKugmzCcCV7wnbWLMLs95LCdF6Tws4FGcIZMTXCejxKwu69hMJmjpDCRvFCwpCGAMLk0H3CZccmwhJPoMLq1GfC6vUfwhbRb8LqpSHCNoh+wsby1MIZVpbCMuA4wghO1MGlcNHC7BUywmTUqcIqW4nCa/YawqpDjsJ9CxHCLy2awvqjocIaYFHCE31Owm6ObcJjd4rCGAmxwpwBKMKQNVzCOpNJwRSoPcI2mYLCWJc4wkqiksIW0JTCDo+Mwii3xMKYyojCDj0/wp7WfsKa3rjCFrOawr5kosKu/H/Cbj+NwmbUq8Iwpa7BdVTTwSxzisKw5LXCOhFtws6IWsLEgHLC5M5DwiL0l8ISJ9DBUsYywhtjYcKf5rrCdRaPwj+qW8LEEJjCsVF8wuB8nMKnzWrCzlchwuU/lMKxXBjC2N2bwtBtNcIOEZ7Cnq5DwiKgt8I8eaTCvnp9wrZNbMIIWxrCHOGDwmJ5RcJYDITC94SEwkxAZMKwVonCipZjwr9JTsKkM7fCtEBqwuTWpsI8e6LCOhu7wkS1H8JgUIbC2PuZwnOTcMIAYJPCEJKEwoE4v8LEn3HC3NeWwnIFhsFQ8xzCILR0waxxrcLsqYXCcDihwtDVIcLA8XDCEKwBwsprkMICUmXC7Cdewl0M6sGKYgHCjHSZwizDHMJeJdHCNr+fwhpL4cG/A6jCQqqfwiJXkMKWVbjC9F+QwjwIUMIRgeHBvot8wrNdjsJT47rCItt/whh0VsL48cfCAVTywGxkVMLKTHLBc5yLwqloT8JVn5fC3qtuworA/8E=", + "encoding": "base64", + "path": [ + "vy", + 11, + "data" + ] + }, + { + "data": "hcJcwhIs075SOYfCRrj+wT4fT8LS7nbC2/KDwgS7jsEboODBzxCNwrJyLcIU7GnCPMeOwXL8jMEQ/q5BBH1Jwq30ecLwe72/Ea5ywlyedcEgfArC7K5KwnBVSkDQVbHCDAl0wpGticIVKoXCDg89wsTHjcJMZAXCsRPIQV4KSMLIm8ZBpsdQwrQCIsIFWh7CbFa3we4Yc0ECFpDCYrAZwj4CLsKuqaDByzTVwdACNcL5mJjCZKc5wgSYPcIEAHnCkaM4wTULUsKDvdrBvUkUwrZizcDcHS3CNDEzwvHcs8Dc8+rB9EqrwVqwGsI6/i7CrOfjwZi84L/IstPB+oxswWQDPcJ8GxjCza7iwRygRMJD3EbBKNEHwts0p8KC7mzCAcxkwSzEwkBAe67CGpGbwfDFf8KfoDTCuuCEv4sDKMI4dyJBOrA7wvhgRMK3wRzCFJm9wf6+9sGPNlTCMCabwqb76MFbq9LBv5ICQsQTCcK5QTfC2+v7weiVUMLEWnbCZVdCwiWdh8K9ZRDCDyqhwXcRHsJJDJfC3DlLwqlCVsJYDELCRF4/wutVhsKfJzRBbCqcQCPoT8KUDJHCVqgDwjS8qsFeePXBrM+gwTRlVcKQm81AMga0waIS2sGr4ZzCeAhjwvjn58GQwmnC/Z5FwlZNdcJYEyjCu9QGwDR+PcLi7evBkBBfwnbM/cHE2mvC3bTIwXgEfMKwiY7CwopMwq+GxsHmyNnBblFWwgx0HcHGjknCt7QbwqFL/8FLuibCp68tws7+EcK87IvCNJ0zwnTaTsLszVLC2smFwoJjF8E0IA/Cty08wggXIsHyizfCVTrswR0Gl8IXIE7CJVqDwhegk0FyBFzB0r7bQMC8icInvkPCEhFhwo7oYcCuawLCiejiwEQcN8KijfbBjCD4wcEUscBmsiJB/pOAwgju18Fah73CxN2AwpAmrkCIuIXCDqM+wp5DZcLiAIzC7CdrwhlGwMEkNLjA79UAwpwmGMKbVoXCPF9WwlDMDMJee5rC9y4eQopOLsJO9bZBl6JTwkRtEMJKZHjC3DhAwngWDEE=", + "encoding": "base64", + "path": [ + "vy", + 12, + "data" + ] + }, + { + "data": "GMrswZhhS0IO8SbCTAWdwRSFDMLtwx/CLCsnwvSUukHKamfBMi8Vws5AQMH5t7jBt1wDQRKqiEBuUZ5CJlT8wa6BN8IbivFBnlsewoJuUEGccQnBSlMWwoIPhkIFZpXCFzMfwsmARcKq3ufBmGPfwWWOR8KSvMdA+vSzQrLRRMF8xapCVKYjwq6GpcHUfMjBhG5+QZfoqUJgYFfCnIGfwYACs8GeZ4NBhozVP0B168F17nPCW0TewSa5xsHIgzPCXH+ZQUwEesFQZ3BArPUCwXiQK0KQJy/BoIBZwSSKEkJU5pDB2LCJQfJiH8FuXTvBFgL9wPTyC0Jajf9AJRK4QUVvB8Fwy5DBaHROwYgh4MH1PORBnPeawFhHcMJyryTC9AvmQdgsOkKy6YLCb+nCwLXNKMII41vBWl82QrZlKsHyGZJCaL1RwepkJsEysaLBY2omQRJcOr8AuA/CNLp/wm1XJcHU1pBAsGq2QoBzjMG6uJ3B4qB1wab2vsH4PhPCtkS/wa6cF8JwP8u9OoV/Qfu5IsHCtmHClkiZwaVjucEH0ADCgkSTwczmM8KpFmBCgmokQonoCMKn1E7CsNf8wCj8gUHuEi7AtiQ8QSzH3cE8s0hCuQWzvyiSFEDSkVzC8hkkwoiEhT+NQyHCiPEEwhYFLcL0tcXBtq8/QkoFYcGmMYrBQMb5wUvCPcEBaxfC7FwjwNBFDMJxvGfCIboMwnrszkDqeSfBNxocwhZXPUI+7gHC9I4qwQzYccCgQjbB4pHBwQb2nsGxtQLCh3/WwRhyQMHnP9jBrugVwkyPCUIEGlzAIgddwf6IYkJwa0fBNHJEQFomVsIuywzCXBVXwpDFe0JkfJZB4EwJQjycSMKUFOXBusbowdQPLkJHY+a+eNmeQTvkbcHdmSXAfYuNwHefxEHuj4VCQpJDwhSaV8H4S6LCnt8/woyEWEIK1EPC66f0wMQsIcKjiTLChQMrwud6s0ByRqVBVCa1PfLqKsBQ2CLCKKwnwsMGQsFgSlPCAiXeQpMnBMJ8UplCGa/8wbhsUsFeez3CAuT+wYjig0I=", + "encoding": "base64", + "path": [ + "vy", + 13, + "data" + ] + }, + { + "data": "E1buPx4ZC0NlGxvBI61iwEPrkb/ns4LBsRVnwejqskJmKaxAyv7NP3I/p0HdWoFBvmYbQrCyyEFgIjBD2kESwGBq3cG0jIZCUvaGwWQP/UEqQIFB7mmywY6XGUN8+WbCWNuOwcVd28E9oC5BGqGovu1Pz8GQYQ5CnAY3Qzxw/EGENjdD6PlWwcDXc0DTNxDB+sNvQgobMUPC8wLCKs+oP+6w/UDW+xVCkjz0QRU9QME2QjHCLtgFwaqmnz9qN8DBgJiIQjhO1UHSxtlBdPW7QdyB7UKSfsBBGn+1QVzWvkKEKADAgjWTQhgptEFAvo1B9gBnQdj6q0IGpO9BhLSkQlqDykHgdAxBKZvcQNyh9j9UAMRC/rWkQVJPDsJB2KXBCm20QmpO0EJ4XyHCVIMrQfAamcE6MuRBDhrbQnIUyEF2zBpDhh3MQbTI9EHA/MRAeNdSQkvM/EHg5IzB/I1Awh62hUEothpCzNw0Qxf5gUBG5FhB717uP6xWKkFxYcdAMD6IQFrV4sB3AfpBhOaCQhzI0UH++gzCIDeZQRb9N0EQznHBAkyXQZhRmcG0CwBDgoyuQsiwfcFlQ+jB+dWHQZrzdUK2s8tB2AhBQrwimz++Ve1CVUmmQfiiCEL19M/Bp4XCwY7wGkJEiKvBIHdjwbamv8EU39jA1C71QgIJrEGudaBAsN6CwPwTc0Hu7nTBH9+kQTofxsAIwCnCrvZ6wakp6EF+ckpBjFaxwW++CkOKlkPBOWCQQYMm4UFosaxBMt4hQGphrr9Huh1B3+CQP5SWAkIR6Im/mRznwIo10kLMpfdBCua/QcnYFUOQwrZB0MMBQlrV68F38QDAKIwfwtjyAEPgVoFCrGuOQmo79MGclb3A3V3mP8CC3EKgvRdCPphIQpSjpEFwIOFBOiLUQXTQhkJSRBdDv5L1wVKSzD8ge4DCOLXywTZ0B0M6UfHBocsGQtagqcG0wYTB72fFwdypGEK2JlZCQPELQr3KEEJd+WTBConowVM7h0GSbdHBElBdQ6aqq8GWMydDtL+bwOTsn0EIJP3BgJmjwAwxFUM=", + "encoding": "base64", + "path": [ + "vy", + 14, + "data" + ] + }, + { + "data": "ApckQmEqM0PKZudBGKDxQc50P0KUKx1BFKmJQXC4SUP8MghCOh84QvrcYkIManZChnWZQuWHREJ4glNDIlIaQpUC7sA6SOlCakr9QMN8UUJUgTRCQoaUwITTakPB7hbC6gqlQARcKcDa+WFCo0YWQlvuyD9fTmlCtrpIQ2D7qEJdaFJDfJcLQihWC0JYbgtBThvhQkKNW0MCxgzBo0DvQVwVQ0JjaHRCIvR1QnporEEUw9DBzi9DQXkw+kHA/Wc9VnggQ8JXkUKXu15CzbheQk6YWEMKmXRC+9yHQjDXKkM3IPFBQZEoQ/VldEJG8j9CWqkdQqqiMEMvjUlCTp8lQy7qaUKbdDRCOhQCQiJZKUIoMzJDUDc7QsZ0G8Ed1zBAN38lQy7nREPgJjvBAFMTQgQyvUD4I7JCv4RFQ8zrhkKk3zJD0IaOQqzFjEJ+cC1CiC/TQhjrh0IS6hNAHsDywdCYaUKn6ZVCEIlhQ7oOCEJ04GBCpEG1QbzfWEIcKVxCllEUQrrm0kF3jnJCjJkFQxStlEL9QzrB+j6FQgAWU0LmoTVAD093QvwHMEFGnD5DRhobQ8FiWECWtIbAO5YrQiaL8kLkfWJCdPq2QgVPCEK4Fi9D5iw2QhDyikLEK/1A89bMwBjFuELm876/1KsGQcxZRsD4tz5By1BbQyMlZULkvh9C593SQTscVUKiTBRBpp42Qpxjx0FJosXBIuHvQAxFR0IwyTZCCF8iwDNITEOsTixBHQJAQjmdgkIltVpCDaUiQoZknEFcr2pCAPMtQm+Pk0Iue9JBir3GQbJCLkMIFHVCGtqJQiF3YUN7mG5CQFlxQnJcM8AYtjtCYDm/wZIhVkMEexBDJHrvQjCXG8FOVpxB6JEXQmbmSENguapCZoGrQjFOcELaP3lCxtCCQrZCCkNKzVBD9C8fweT9lUEIaTDCdHszwQvyQkPc4CLB6OaGQvis5r1AYGtBaICQwMJjlkJGIMNCfVmUQm+/j0KNZFZBzdRvwcupV0JeDGNAQIpYQ9a+CsGPZkhDqojqQdLnj0JD8GvBRi4kQnpZL0M=", + "encoding": "base64", + "path": [ + "vy", + 15, + "data" + ] + }, + { + "data": "kKW1Qg2EEkMZd5ZC4MGkQoh+0UJYuh5C8FFcQoY8TUO4TqNCaCHFQvRwwkLfzehCRi74QvZEpkL+PipDoyS4Qk95eUEBiD1DXIMNQvo8q0Ka/KlC/eB9QfOrX0NYUmTBTaXtQchszUHmn95CmjG2QqziBkK9NbBCbQMhQ1SeFkNzyiJD6wq/QpxhlUKu2+JB5GgxQ7gsO0NQbZJBYi2mQnmkykKw47tCLrfDQu/qoEKlAr3A3W4JQj0ogkKJO99Be7MwQ9Kw5EK02MBCZrq7QmJNTENOM8hCSNXjQtilMUPGYK5C1w5OQ1M7z0IskqBCJYKHQkDwXENgqqJC/BQmQ+Y8vEKworpCuLWJQlFBxELg+CNDN7enQmoLkEFJFvRBXtUrQwnsQ0O1cKpBoMGTQvheB0IHpStDTppJQ8qw6kK00BNDtAEAQ1Q72kJ8WbxCPk0ZQ2sf3EIcnMNBlx8nwVoPBkPJyOtCnHIsQ/TfoULY0d9CfFiLQmRK30JMMeJCyJCYQuYBgUIVp8ZC/jMgQ97HEENiwXBBoiLmQq3r0EJIf65BtcnTQpRxO0KZzyBDhus7Q6qKvkGtL7tBEeiMQiQVTUNtI71CGG8MQ0ySj0LunxRD+A2VQlCC1kJUvj5CorlRQeyYO0Pmxp9B3OEPQvLgnkHFtfxBOwdOQ3zMwkL5mLRCHqF0Qmfo3ULC1hJC7AyTQqp5bkKgzI3AYksLQiPSpEKqJcJCvgCmQQX1NEOirhRCWzGgQvzf2kL9kL9C3lDCQoSqLkLOU+dCCQW/Qj4j20L0pV5C9DtuQvhvIUOoObxCkM/5QuTwV0O1ksdCTOW0Qjzf2kGErtlCZMStwFRWO0M+FldDHmzqQp4DS0EtPEFC1AGjQgtBR0OwTBBDwLH9QlIF2UIEWcpCnNPvQhYFGkPwIS5DSdpWQZ10G0IglqPB56IeQSSmKkMgOzdBcFLJQggyuEHoBklC6BaRQVZL60JaewlD+lzwQg43zUIWCy1CutL8PtpQykLAghZCFcYiQ3vDs0BCDSBDlMWUQhHeHUNwhmhAiEnIQmDmDkM=", + "encoding": "base64", + "path": [ + "vy", + 16, + "data" + ] + }, + { + "data": "ZlUWQ3buyUIgvwFDkicWQ57gJUN0FJZCmS/MQiAnIEOXdBlD0n8fQ9jDEEOofzRD0o0eQ63rCkMauOpCmHsZQwCFKkJ+RDRDb4WEQkfnAkMmJRFDjuIfQrZHJEM9EFZBf19hQv6QakI85DBDxt8hQ3SykEJd5QBDuCLXQjBwUkMEjNBCQV0rQ3Ox+kJaeEhC5AJUQyiq/EKsk0RC4MIdQ7dSJkPruQhDB2QPQ56mGkOebYdBqp1qQrSxykJcRXJC6NEPQ40TG0NCHxhDKmEKQyi5GUMasxlDHBscQ5bVDkNMIiND994pQ7ZlE0OkWOJC+NfGQrSBLUOOiQNDkHsDQwh6A0MYrBxDHhr+QnQOKkOcsfpCWowNQ0TJQELeF4FCw+MLQ25SEkPPf29C8AH9QqrWg0LKFj9DYqoYQwXcH0OpJ8FCsG8+Q+zTGkM81Q5DgXYWQ+A2GEM120ZCKq09QTaFMUNCQTZDGgnXQh7MEkNE6SVDHXIJQ6r+NEMm4zFDSMD2Qtzh20KwABhD+mQJQ2RQTEN8ZzdCZJIcQzo/K0MmAihCldEVQ592tEI6yOVCCjUSQ6p7N0Iz3FpC6PHGQmujXENQug5DYFYmQyZo5ULreNFCLNDbQmyyEEM8n71CdCgLQmQmYENjKi5CTeGMQg7kNkInxFFCqxcaQ6RbFkOQpRlDcl7KQlYiK0M3WIhCjxvRQofNxkIWOZdBFLOFQlo6CUOaKB9DlrBEQqJDBEOlrodCNKPjQgwFGkMEFBhDQhIoQw4bkEL+vC5DiPobQwzmFUMREa5Cr97BQuyW+EKuTglDxFk/Q54RJEP8zhhDipAHQ1I0eUKE8TBD1tCBQQDFCEMkvjNDizSxQoo6FUJeo6FCa5AHQ34HGEOy3DxD9tQNQ3alKUMQ4Q9D/g5IQ/eY8UJoqe5CFCYfQt2AfUIysepAymYHQrRAAUOihw1CTbsKQwYfQUKlBrZCoucvQtRMG0OmIPFCmvgtQyTBE0NHbphCFGyNQdLLFkOW/JtCRrzNQs7mrkFkL9xCsPMEQ0weM0OUw79BVdUsQzuiuUI=", + "encoding": "base64", + "path": [ + "vy", + 17, + "data" + ] + }, + { + "data": "+mA9Q/obSEKlXDJDWNFDQ7TzPUNOee1C2qggQ+yW10K6PT9DqINFQxipNEOHElVDl20LQwb4IUP4v3VCmp46Q51hl0LAjARDAkfKQvL8FEND/DhDtwaJQm1yt0JyEDlCwDqrQh3zwkLq7VJDYlo/Q81H70J3ohxDiR5DQgLLSkM0rCpCTj5YQyYbHEMEVJNCklEwQ8B/XEJLS6hCmIpEQ96pNkNa0BJD66ApQ8CDTkPC2y1C0CarQhwCBkOmNcZC3OLRQpgMHkMPbiZDoDwjQ9SZwEJlSjBDStUmQwIZx0Ldc0lDQHHxQp4SJENwgAtDtJ0BQ6yy9EKIPiZDknGyQlJEHEPLdTpDeq8hQ9gkPUNUTqFCzwE0Qzkdo0JeR9hChcfCQn60u0Lwk9JCdK4oQwbJz0KqYyFDQN6+QmMIJkOGbQ5CWGtDQxSrJEOEUBJDGDHxQjy4F0OS0p5CFvATQvSEF0N2ajVDrZQoQoDLGUO5eiZDpBc1Q20EQUNeQThDiHwmQ6xCJEOVECZDHEnHQumvM0OPbqRCEoMnQyIxYEP26H1CUTwkQyqgDUNidIRCxoTEQpz2i0L+w7VCTn/+QmrgLkOc9yhDzPEQQ8bpHUOU02NCkHMTQzMCFkMHxRNDtsZtQjCNMkOC/ItCpLLiQiU6l0IE+5RCjnLAQpDcLEO2ayxD+a0QQ9oaIkNGNtJCEq8GQ+TsEEOM+TdCuuXNQgexJkP7nR1De9GpQuY5lULNK85ChvgPQ5jIGEOIni5DPaRBQ89G0kKLDUVD0L0/Q6ijGEM7Au5CHrwGQyYNoEIuTB9DNtVLQ9yHwEKwCitDFrUfQzebz0L48TxDMJcoQsc+q0IyMgVDRBBoQjDegUKaSehCH9ZCQ8xtw0Lpzi1D+V/jQnbkNkPTZSlD7DhQQ5JLpELC7m1CXtKKQg6fu0JLiiBCfi93Qh6WpkLkIXpC/u8WQ5OvlkJMlghDIr+TQl6OEkN4rrBCDktAQzT8IUNyZ+JCJMkTQoj7GUNG3f5Cwo8hQvDPIkIA1GZCDLYzQ1gAF0NdwDtCFItHQ6ghDUI=", + "encoding": "base64", + "path": [ + "vy", + 18, + "data" + ] + }, + { + "data": "du01Q8gy5MCJ3zlDAKA1Q/LNHEOzbi1DaDZIQ3xHT0Jwuy9DCBE9Q9opJkMagTpDQDTPQizQC0Ma/Q5A0e4uQ78i7EJ6GK1CVOAKQzi6EENlYClDZCfKQiYLZ0HD8KpCeOLqQhnrDUO19zVD3mwoQxryKkOemBhDP51xwQ5pHUMUdbfB/Bc1Q4BpFEOVgMBCOlH3QkFptcGBR/RCxHAuQ6z9EUP+1vVCMiMYQzrJQkN8xJZCREblQhwpEEN65AtDDJ5/QieTAkPZAwhDZM4bQ/j4DEKGVBZDwtoPQ5yCU0KeWy1DJFSHQqZ+EkN/sQ1D8BoHQ01gj0KEwCNDyDYrQgp4EkO+Uh9DAPMZQ65gFkPj7/tBbhMoQw097ULf5CJD375GQiGuJEJW0hxDFsMmQ3ApFUNUg+pC5VQQQsnJC0P01wbCar0aQ0XrA0PcKvtC12+iQrIC4UKKHuZC/KGCQhN45kLVPwRDoq3EweIsAEMG5AdDdBozQ+xuGUOGfBFDp1goQ1FdQkMqVgdD4VVgQnTMBUPpS/tCwEoKQ0OZUkM2Y6tCJswPQ0rQNkNypHJBCJBMQmKhwEIAggRD8JwNQxoM9UIw5xtDlJPXQrovLUManr1AF1IOQ+b0AUPC9DFDaw+wQvQz/ELUeMhCarEWQ06h3UKprcFCkKANQtgnGUOOjxNDuKkoQ6xVAUOc4xND9IQLQ1hGNkNU25pCaFcDQ5ObG0PcCwJDUrQAQwuDHUEzEwpDDMQXQ/mu7kKxOBZDR2ofQ5fOBUNSviFDbzMqQ5A//EI4eA9DicwgQ/Mn90G9GBpDvA4dQ4oPn0F85w9DPzYJQzlUGUMmWBZD2I+TQlzXCEJCMKtCpx7XQTARwUJmIA9D0GBOQ7aJIkLgEwhDfKubQtWSFEMEgRpDst0pQ5zvJ0KEcpbAsO/KQhhr7UKcrJ1C3zO/QqyEB0JoVrxC+HIOQ2C6zEJE0CtDBDPYQtii3UJYOllCnHQaQ/9dCUNM6xlDPZ5qQvCZ90LilztDJrPSwSKPe0Lg2RVAXZsxQ5fT4kLJ4pJCRrUiQ9rb58E=", + "encoding": "base64", + "path": [ + "vy", + 19, + "data" + ] + }, + { + "data": "CtEbQ+44lcK08yZDNgwKQyId60K4cVNDp9E/Qy3jEsGM0QpDhBQfQ+kbCkOezAxDYJmCQtI80EJIuXvCAn8TQ1y9K0NtSCtCbkMlQ6++9EJIFwRDpSj6Qga/g8IacAJDTA4UQ/zCK0MQrgVDYp0AQ/AGPENjFwNDfYGtwn+DzELwrL/CeXoEQwA6AEMOqNVCNZGMQkIx0cI9dRdDhWkBQxlH0kLuxLVC2oX4QtfNFEOqm+ZCfkEKQyLSBEOMMBpDtPSgQbDb00JgRMRCWpICQxrr98GCduVCFsziQqaGLEAS9/1CiDIuQcDo6EKCrPhCt83rQgF7oEHKfAhD75YJwUOl7kIO0/BCZZX2Qs6a1UKlVL/BzlEFQ3R2HkMCnTlDeEhHwDrWUsFleT1DWOAPQwYGOkP8Q4dCxlrPwcOL00Iqkt7CwlzMQjQHt0KGdsFC97oWQnTcmUIubRpDQuDAQrzymELwZqVCsL66wkGnvUICUL1CdM4ZQ/iY1ULI5cxC8BkRQy8MMkNfKb1C/hoDQeXgqEIHUyxDRz/XQqC1K0OQv9NCCt3lQt7xNkPFVyHCXlWCQPyV9kJJnShDDRgBQ45zjEIs0AFDrDeFQoV4HUP810nCISjnQvnpzUK1VjBD5DvxQkQAk0JrdgZDHgkVQ41XFkO8YuZC1o3vwWQ79UJ8+tpCwOYgQ0CStUKwLTFDzv3rQjrhMkNiquBCfl0FQw6t9EI3acBC6C0aQ+UggcI0LRNDuEcGQ1gQnUJJ9+xC04zjQuAWA0MAMepCv68CQ+g5z0KAKg9DcjkgQ8bkwsEsoANDgUXJQlCpgMJKhN1CopDJQv42SUPWN9NC97ffQrTBmsHqSxJCd06zwOuHBEN5Ig9Drv4zQ4mZocEKz7dCTZwpQoT62EIpkPtC+jH9QlKqzb626JfCAMP/QozI20Jd5/VC6YIJQ0jBo8HwewNDhzX0QuB09EIZQy9D7AYLQ7HHjEIPd51BoAveQnTF00KsYjhDziClQnb9q0JGD11DwgLKwg3GsEJipmrCql0aQ7ppkEJAzdBCFn/nQvjcx8I=", + "encoding": "base64", + "path": [ + "vy", + 20, + "data" + ] + }, + { + "data": "Ucj4QifbHMP3DAlDe4m3QhsQokKGdkFDNn8hQ6ZInsI0KMBC50L0Quwc0EJfkL1CrWfZQU+afkLwLQfDTW/oQqPwQUMcUDm+kFYhQ0BlrkKYqrJCVyT3QqZZBsNQcylDz70cQ5OrKEPut65CPBWpQl5YLEOSkchCeaMcwzaZNEJk7yLDrFOtQqpI0EI8n8RC8yqRQf6oKMMsPBlDjQupQg4cgkKe7llCgEa8Qj7J0EKRvSVDOrYGQ/Sl3ULHiw1DtsfiwYi4l0K6kmtCCpnBQkj41MIwJ51CAs6jQi34UsLeaqBCLIhPwnIRp0IsT8RCFNK5QroBDMJgC8JCnvuHwsawr0IWIaNC/x2jQrbSdUJ0JLTCnFa5QiTrOkO9jCdDD+l7wuwYkMJXQT1DcCzkQpB0M0P0nGFBdNa5wnickEJW1yjDJvU/QnrXRUIgm4dCjckMwY7THUKI+yNDVmX9QgxqDkL/4w5CyKEXw04ta0KWbkdCdOLfQlH8bkIB0XdCqajkQlc3DkMATktCYgY0wpAPB0J1/TxDfmKaQpO2AENq4eRCHBClQvamH0M64dDCSEwzwiCiDEO8oyxDMg/OQj5QjkGUc8pCOWTJQXn+AEN4gObCSQuwQk1rkUIE0BpDHAcUQ/MkoUFw1SVD/MsAQ4eYJkNQ4edCvpzPwr7FrUIOToFC8isIQ2nfRUKs9SdDOES0Qo+DFUPa5w5D4mLsQqxon0Ky3G9CRpQQQ3IZFMPrzQRDTr3UQts1EUJ6TqZCCkKPQlLy3UJZbp9CZHK3QlAGlEIcx/ZCdHkMQwAAs8I0A8RCx140QtwoDcMIr5RCFfZwQvHETkPrk4VCEJgRQ7w0nMLbF3zB4TQkwjCwJUMQr/lC68gOQ0zCr8Ky4DRCm7f/QBwtjEKykr1C1LanQsp9PMJEMxjD41cDQ0Sls0K6GSRDxX00QwE9psIU2ilD0pW7QhEz9ELgoxtD+8wOQ2hV8kFIs4HBnjyVQkb5jEIOrDBDWmPTQnL/OUKyO05DNEksw0pl3kI+TAHD2RT5QlXd3EFdwApDlG6LQqh0GsM=", + "encoding": "base64", + "path": [ + "vy", + 21, + "data" + ] + }, + { + "data": "6G+3Qg7xVcOOyM1CpKk7Qm4ZNkLi5B1D7nX5QqhDIcOM9lNCIuWmQr5nikKAaVNCDhc0weuUnUF3E0TDbOWoQrNGLUPwVjHC2D8KQyzaO0J8TzhCuHLXQrKtOcPcqjBDfgoJQ5bUEUNuNjRCQsUfQtQQDkMEdXpCgYNMw34MS8E87VDD4tYsQpApnUK3xKFCMsEFwjF4TsOGsgdDCCcfQpMGxUGCEGVBXnWAQmDCeEL4ckVDcfTgQjZaqEIqy+dClG+qwryNJkI1GYFBtAZ1Qpb8M8OOoyZCjB5EQqRD6sKw7RBCo+v5wm4OSkIB3olCQo+EQt3vwsIEbFdCgjMMw+t6YELO7ixCrFQJQtXTUUGYkCjDJSxLQouCN0M8cglDzBYGwyLUBsPqkCZDDOelQqhnFUMQfDHCKJoZw7xPIEJsmT7DrYTDwFjdr0CkcgFCHhprwqgZD78Yrg9DUu8MQ3WaAsFmRCDBA5tBw+yso0EmLxdApG2GQjRLNkGGr7pB6BajQr2FzEKPsodAqn/UwsQSmMEg+C1DJqo1Qty+rEJGEc9CsIdFQh4+/0K8hyfDmPTEwv4QA0OrYxdDspOTQtIDEcJE1ZBCeK93wajhwEICdijDqGlzQjX0IkIoL/dCWvQOQ6oHEMLMhyRDaGzOQn3sFkNbbMZCLPcyw/mMQEK/yWpBzBDSQiKN6EBSSgtD3lR5QiBj4ELdGxRDRD2+QiYyBELAscRBY//zQpjAUsPnTtlCOpaXQtdz2sBqLzVCisMBQpTFrELOvjdCJ5ZYQnSQIEJq/7xCNJ/dQjnYIcN2m3BCjJwRwUmSRcNSowpCvmeIQQ4JNUMeOv9BVukTQxJBEsOiBJXCKOekwjLfJkPUHcVClMzOQm2eIcPvW6m/+qLRwfJG/EE2R4BCF6onQrfJzMIcsE7Dw1jqQib7iELEYzBDxk81Q/+DHsPSVS5DFoZwQgpK1kISkPlCRN77Qv7SHcGQu1vC4PAlQgJo8UEr0RBDJIzoQkv9IUBC1ClDWnZiw0w+30IE/j/DAjm5Qgo/p8FcYR5DNEvHQdl2NMM=", + "encoding": "base64", + "path": [ + "vy", + 22, + "data" + ] + }, + { + "data": "HHlrQm6NScOo1oVCgWlZQMARGkGQAPFCHNSsQubGZcMy3C5BiikzQoYyD0J8cGxBDhpPwvwG5MEA+mLDls9TQptXDkPWcLjCAN/XQhi0kUDHKThAjM2sQusyVcPsoiFDlhvWQtCU5kIIEMBAxAliwEEy1kJEzaJB5K9Rw0K7j8LYp0vDSFShPyqLUEJSlHJCvrirwt+SScN499lCcKGvwFfQicHqbPHBvlMKQsYeqkF3bDlDXQCqQhYcXkJtYatCHBQew8/PokCG9fnBqsjJQRjYZsOkRdg/OehpQc76OcNeTZnARX1AwzxXg0FLIBxCLPEeQoqmLcN9aSJB0OBFwxpFx0GohJlAyMuKwZ7jG8JiZFvDHxILQbx7HENGHdJCrEFCw5LMOsOePgVDcH5PQkrs40I4m9zCysBDw9T44EB6XiDD3CxywsgNJsLoYSnBxqjhwhK0K8LkpeZCPG4EQ749ZML2qWHCMSFFw/wDrsEC7ELCTvPHQaq5HcJarHbBEss9QjLKd0JovjnCYiofwzBZmMIWWRBDZMRNQdgDNULee6ZCgLx4QSZ0uUICG03DrAsXw3ql1kK11e5CjBc0Qt6avMK63C5CRodnwqQ5e0IuvjvD5GMJQu4a70AC6a9CaHLwQojpxMJt1AtDbFKYQrTB9EIS7JdCtv5nw7SO7EBGvyPC3t2PQjIsGMKssdNCSJ0OQv/Hk0IibgZD8q+JQmf5iMGSPmnBgve/QsivY8M/96JC2vk0QjSMTcJe8K1AUm2rwEYCdUI2zFxBLK2KQf9+PUB0iHtCZieaQny7TsNSqKNBbtJ8wq9SYMMk6v7AoSXswcz7EEPB2wjAEJEDQ1WPTsPiVRLDupcCw4RfD0NwRItCNPV/Qh6rV8NEDj/Ctl51wh27AsGn2QhCnPPUvjRhHMP36VXD3UW8Qt8lPkIKsSRD4uQbQwDdW8PkjBZDhnmzQbnnqUImMbNC0FLJQsCFS8LcC8bC9EgaQTXlbMFkMNVCJXTXQqLJOcKePwBDgMRmw/Ibw0L+IV7DHT5vQlarmMJgWhNDP56fwa4YHcM=", + "encoding": "base64", + "path": [ + "vy", + 23, + "data" + ] + }, + { + "data": "q1rPQW7s6cKeQO9B1r0ewt5x3sHzfKhC1qY/QpIvd8P44/DBcl7SQBQ+UkAgCabBhYLAwrxTpsLsVzPD8G6tQZ0C3UJ6kQ/DpgSYQtaUHsKgmiTCuD99QiBTQMOIbQhDgcuXQhcCpUJ+DfjBvigxwsTfjUKOFMTBYxwMw/i9AMPYZMzCHlwhwm4DxkFqhB9CaSgJwxIg+8JEhJ1C8rdQwrxgdsLQwqHCVG6XQNiVmsHwVRxDyElmQo5dz0FWpFhCToRdw4OKBcJlM6vCUGk2wd6NXsP+UynC/tWowR7yWcM8Gy/Ccflmw07sncGqXBRBSudZQfK2ccMokAbCwklNw8iutsBs6gnCGXSVwjF/wMLQW0jDrAkHwoZM8EKWRpFCDJZRw14BUsOyrr9C6UCnQVBKnULygSnDuSRHw8be28HhAJPC0AvfwmsZu8LIR2/CKNYZwyWlsMIg0KxCqtLgQqYa6cIMmtHCZvq/wuQUjcI6tdHCy056wTxjvMLSqV3CftBQQVQerUEPgM/CC/80w1G/C8O63txCIOemwVwznUDU5nJC1gGfwf+iY0LMgDLDNJo4w7CIoUJEY6lC+reMQdkrHsPISm5BWUfPwvGv50Gg/AvD5jsGQcpD2cEdsUhC0hK8Qnh2I8NpANxCIHlCQkzmtkJ15k9CBVdiw12NC8IQDtHCXqUZQr0BtcJPwpBCstogQQEwEUJ7TOFCbvUkQghkkMJScXXC5HWKQt64JcPDnVZCkCB3QcxdxMKonRHCmN0uwqbMEUJk84zBneWcwUQ+F8ICnflBzEQoQk4KQsNWk6fBHj7nwtY1RMMAoFnC7O2iwmQ51kJ+fBXCCVfZQg6UY8PH/l/DYrISw+iS4EKifSBCQALHQc9OXMMCrcHCSiTFwjK7R8IEEplASmkzwpQwM8OC1AjDOiyHQnJY2EGM1gxDrCr6QqlBZcNZ2e5CUKaVwdQKcEJ8G1RCFDOSQgUeu8IQrgnDEfeuwRqYg8LcjYlCdLS1QmifzMKS9axCkIL9wvWln0KAqSzDJCzSQaZqEcNUAPdCEmqFwkLni8I=", + "encoding": "base64", + "path": [ + "vy", + 24, + "data" + ] + }, + { + "data": "/3TtwCP8bsHb6gDB4yynwqQEiMJsZkVCCoEXQdAGI8MOZY3Clxf7wZYr6cFPxVvClB8Ow/ioC8N8annC5kwbwQwQn0KzITfD4qAxQn2HrMIMCa3CwuYeQnbmqMLUXdZCNkA4QsGcRULSK4bC7EKmwlS4CkK7o43CfsPHwfUwLMPsDjpBRlKlws5Qe8CGRppBCucvw+aCZ0BkvD1CXu3KwsZk28K0aAfDFNPPwY5UcsKJNfhCALH7QTEwicDHtrJBNi1dwzlrlMJSyRTDfPFEwshs8cKxObjCthFpwpi4N8PsX6TCx4NFwxsgZcLXqqDBlfpBwSr5dcOoB5zCXjMPwzcVD8J8g5bChrIEw6JcG8OBEerCBhGbwkWzpEKKIiJCBiIjw/b1FMPYnGRC0hclwc1yMkKI7k3DXJz0wqKafcJN8gxCBGYWw1glE8M45OXCPvknw0vPBMPFEWpCDwuwQqPeOMNRExLD1DnGQTC1/8LwLBnD0QRfwijfF8M3vsLCdv6owRz7isEh9R3DEDgbwxznQMPn8JdCEH9iwveCDcJjXBpC8J1qwhZ/pUHm/qbC/GAow50kXELEJ0hC7m4HweQwVMMQ82fBAU8WwywFn8BGHTLC1KeLwb5YfcLi9zJBbo+IQlr1WcPyl6FCmz2lQWigdEL1iuhB2Ef7wqg5ncJ2QiTDIIWeQP7mGcMO+h9CTbBrwa5eJb4I/q9CwnBPQT6EBMN+Vu3CrnQpQvZSSsJu3M5BAhFYwVi/CMOaBaHCpheowjZjQEE280PCbqdmwhiSpsJdmbw+WMrfQLhF8MJCfoHCpkQcwx7YtsKQGdXC8t4Gwyqni0Jz0pTCgcynQpwmG8OKOYHD3IPfwmWAoUJrcitBXvNjwYiADMP8SRbDFlwBwxZzvcJoX8TBT1W7wgj3CcMgb4bBMqIfQlby10A3d99CjA+9QnwFIcPsjrBCS758wsBmCUJS04FBbnE1QnqBBMM3xxHDAk1Xwn3D+8LCwQNClTmPQvImG8M58zZCAJUOwWCvdkIGmn/CnCsFwTCoUsNYLMJCCuDqwmkmBEI=", + "encoding": "base64", + "path": [ + "vy", + 25, + "data" + ] + }, + { + "data": "rHsmwqZzXUJ40TzCZgcBwzAB4cJKmXZBpIvpwby9NsLC497C//yKwv1necIONbHCR+Elw8anMMPmerhBpqMmwpj8RULgJDfDauJaQdqpAcM/pQTDOOJ/QfGBFUJE05hCYHaPQWWkhEHQWs7CQEzzwmFXuL/58OzC6BJVQpAZRMMuc4dC2JL9wlXhCcIOkYC/TOs/w9yEqUIG035Bxq0Xw307HMMeKSjD9JhpwtY6z8KjxbhC0hzZQO38C8LmyRfBqz8Sw4qZ6MJSlz/D18Cywop61cA+uhPDrhfCwlbAzsL4l/PC3Dq7wlZtv8J8rUPC0KMWwjJUEMMT+PbCmhtUwtW1gsKMcevCTfstw5xDPsNOCa3BVrT2wnRaN0JkMAhBLBOgwo4gBcJqMJJBkmEpwgNtPkFn5kXDOEt2wI5nycIAhsdCP2gtw0LeL8MEVx7D4NAQw9UoGsOsLP5BBWN5QgggX8Mz7irDNjGUQlT9LcOosTPDFJTAwlKvPcOUOQvDsDpdwk9GXcIIcjbD3diswgZGV8NJUShCOHu/wob2mMIYGYxB2FHOwl2kf8H3zOZAFhChwnDM9kHCdIJBohIFwpAUacNiLTTCNgEuw/KHHMI4OQZCCAEvwsKAysKmOeXBcp4uQpoFa8NvN1VCeQEAwfZ2AEJW9PJAqEkjweya9cLG1ELDquDiwXuISsMepgxB0QMcwlzADcKo+XlCVqx8wQZSM8PWmTHDhrN1QVbNI0JExua/hqwmwnRwGsN2+PvCsLL9wqycQ8ESx6HCEOXDwji9A8M4TOrB7qncwZcL1cFHpt/CgvMyw3Se2UEMmR/DfGEpwwFmBkLWkOPC4PhqQhcqNcKq9DzDrJhmwtxpSkIUC5PBZs9XwpOl1cGw5z/DGMEIw9xyDMNo5ljC/GYWw5IvacLo+mtClqJAQWNzW8H27KBCr4yCQoY3gMKGpWpCnkLdwjihDEEdyaLBGmaQQQA+F8MJ+tjCAu2twqbEMcNiBD6/6npQQkCdMcNuccJABBZMQmJ2L0LTi6FBkC8ywihoY8MKTY5CkB8owzAhrkI=", + "encoding": "base64", + "path": [ + "vy", + 26, + "data" + ] + }, + { + "data": "0IqawphWxkKS2a/Ccu0nw6OYG8P2Q5HBUzaJwp+R4EEulRPDtkbYwvKhwsIwTvTCjxkUw9zRL8Mf/YpCam+VwmFUoEFk0s3CPf6AwZX+IMNOCijDE0L8wLiev0LTGjRCd5IKwfVzfsHZSwrDPAQaw45rFsLk7x7DKi/AQqJAOcOw9sNCrOEnw51eh8L2PajBFsggwxVc+kL1aXfBRNk6w57HM8MiQiDD/GK7wvCjE8Msd3dCBBSFwbhGhMKLXCXCpGVrwqLuFMPL8TbDx8UCw2CJYUKE1TzDFawDw0SHe8HefBvD5JhqQBRmAcN2EprCJZd8wno1IcIAcyLDX6zKQS/QvMLYhBnD+iM7w9R6OMMYsjRC6kQjwzxgNUHPOr/ByTsJQfG4AkKyraPBzreXwsCGnsFexwDDAPZ2QrQLBcPlhAND1eYow3hAHsNS2DHDdjqrws7wC8PY1LxAYRQSQhTGOMO0kBfDrn3BQhFvOsM6fCrDaZgGwxevPcORcCXDvJ2zwhQuucKu4BvDPK81wO7/KcNgJg9BIBMHw3bD7sKi7xzATPUTw8KGVcIjEGZCGDkCQfwwAkE674LBVLFjwjZ2L8PGBJvCt9kcw3WDk8LSrpZC00+OwpZMBcMumorC6oGgQTgsFcNbkNtBpjgXwpYiiEBuO0jButxZQqclHcOU2TLDK4R2wujiRsMG1avB/x18wk6bi8I7TBNC4hw0wkRcRMO8CE3D0EVBwZQeu0JykevBhSmKwjTxC8MYWyDDO9ggw3BeEsINjePCVnwLwzQ6JsO0WGbC+FV1wiJ0MUJVoRvD/q8kw0iguEKnAD7Dj2Enw74t3b/8SxLDTEUGQmhLxUF4J6fC5eGJwAKosEFKjTzCjem9wmyTPELqkkTDeGPWwgyyKsOuYKnCj49Sw9DNTEEvn8hCbMl6wTAjC8JICkFClPMUQujhf0F9AvVBLzsZw7zYgsHoXmLCVhkMwfZyCsN8WT3CIeLzwjZ+Q8PcEwLCePEDQq8PG8OPjwPCnE+sQi/L00HAE4ZCVmSmwmxQKcMmUjlCS0tDw1lZ4kI=", + "encoding": "base64", + "path": [ + "vy", + 27, + "data" + ] + }, + { + "data": "vhjmwlDF/EJyLALDieY9w34zN8NPF1DCIYvawhnQlEKABizDgEkQw4RXBcOk3xfDaaizwl468sLMq8NC8u/awlBNFcF7dU3B8Ic0wiZjLMOClTbDLjEAwgm390K8+1NB5gUIwn/QQMJl+iTDzlUrw+NPlMJAQDjD2sfvQhIa7cKAe+JCZBo/wzZe0cIecSPC35uLwlceDkOXtDrCEulAwyKHI8ML9tPCvikFwyAqN8PpnwFCch8cwqrWwsJGupLCjnwaQTcMJMMz7evCfvskw6p3vEL6c0PDnuEbwzBTT0IDfSzDrFJtQkXGGMNSs8/CeiuxwkimrEHFXTnDPl6UQnn98ML1my3D2LUZw1RYA8Moc7FC6Oo5wy46qcGOWWXCXByOQg7hh0JZJGzC/hTfwiLlS8KSW/PBVDW+QoKsGcN9Lw1DofzjwkcFt8KYLiXDmmEkwbhvscIQxJvBFgQuQTPUzMIwiWnCiC3SQhSdDsPQeOfCMCAlw44xDcMwdSLDIoXywpgh+8IA0KPCDYNzQsAyj8LuzrzB3nkjw+ZyIsO5TKvBcJ4zwxDVt8I4569CIrlZQqnKVcGjeUDCk7iewjs4hsJGxuHCsiHIwtvk2cJISMZCLOvIwibWF8OBXtvCYrgywCi4DsJ/3TdAOruKwpLGtcEsLvvB/KG6QqGwLsMNf+LCsde9wvgDBsNyp0zC7NKtwh6gzcKKCjJBhoeVwmoYIsPYjTHDNIAhwv4q+kJgDGXC/ha/woAlq8IE7y7Ddp8tw+KTdcIeng/D2CMswx4tLcNniKjCOsG7wjgjsUJ46zrDptSjwpWM/0KcTjHDlezgwq4fEsKK8yHDdhwFQbpgg0L7DoXAkJciQnEvocAyEZfCIbIJw7q9s0IkPBfDRdlFwu7lLsP+bejC9pFww0KZWkIaYvVCrHEswhjpY8J/b3hB7NAgQb76hUJcG3ZACD82w5S+I8Lft7jC5bgMwri/r8JfBkxBGGMbw9xTHMOm4XrCALdkQWPGucKaXY/CbO3WQjShFUF0ecBCHJf6wmZ0qMKIhbRBFqcvw0ju8kI=", + "encoding": "base64", + "path": [ + "vy", + 28, + "data" + ] + }, + { + "data": "1PYZw9nxCUPb3SbDn4MuwwkCNcME0K3CAicTw/zi00IKvTHDoIMswwOkI8MQHivDAliuwerKGsJ7UeRCoDoRw9W7HMKcpQ5CEe+SwoiMFMNQXyTDVsdiwkOPBUNA9ZfBZWppwiQFocJfxC7DDrsiw8hQ3MJyITfDuDUBQ5TXSMGQ1+ZCY482w+99EsO04XHC+VfSQeQNDEO+VpvCP84Zw0TQz8J4iAHCNnsow3QfSMNA0GhAtlRywipO/cJmOc/CBCtgQrihE8O9dxHC4tI2w6x+6kLKrxjDciQjw+gFv0LFvCDD7Oa8QuhiIMMIFfrCCGTfwjyrekJGADHD3njUQi6MCcO2aCfDGMqYwogfT8KY1etCfIkzw8JKT8LfHLnCNtLdQoqesUIDBMLCWnsRwyX7o8KvLy5CVHTfQiygGsOhKgFDPFhOweVQKsF0ivHCYcJkQvsKqMEz9zLCrgRpwfwuvMFXJ9BBEPTKQnQLisLIiAvCWv41w+GqesKcDuvCXwgSw4B+F8McVUxAXCrEQkSdcUE+al/C6q8owwn4RcOu7B3CzDY1w6j/AsO4INRCNECgQhaoB8JWCp7CygbIwgIuf0H67BTDwB34wUp1DsP0V9xCtqsAw0qyFcM/og/D0P7Jwf5bx0EzU6bBA8/OwkaWRMK+n0TCzkbqQmInJcNgf8vBK8f6wnR0WcJZLKHC2srawk6GAsPo1WrBuIDOwuRQpcJcrOLCsiWMwiRpDEOYxarCvifvwiimJsEEyh/DRNcSw1jIrcKKtyHD6ms5w9Y2CsN03tXCv9/0wlyX6UJMTD7DmnLQQXyyD0MCrejC/7/2wbZ3jsIU9hPDQteJwf2tuELaBjtCgu2MQmer+MF3mczC8uYvw7wx50IUx5rCjXUbQaoEEcOitxLDwI9Lw5DwoUJVvAFD/kyMwmrUocJLoo3Bvr2FwWsnzELbqbDBbgo4w02JgcLysffCxIt1wmR+lcGQ3VRCcl0rw3YToMJ+ybbCSHmBwBDIhsFiH9zCSGfrQuLL9sCeKuNCxj8nw0irrsBUzsq+2LrSwpg94UI=", + "encoding": "base64", + "path": [ + "vy", + 29, + "data" + ] + }, + { + "data": "NKg+wxxs50LZxEHDQPSlwoC/BMMIKATD8742w+RiAUOQRBLDTkU8wxZQM8PCTibDeqc6Qqz5L0JSaOxCnt4zw/CzmsLdaIdCtP3Uwhj1gcIAS7bC0EevwhKq90L8rm3CDuitwtKN68L+vQ3DBiTOwqpmE8MzIQLD4wLsQroWmULjKrhCr2r2wvMIOsNjR6fCkCGpQhbz00KK5+LCqi50woK2QMGywzdCwDw4w/onLMNzSPrB8HCrwjhfE8PWuQPDhFzBQlL2k8KOQjVCDCIdw2JNAEP9i4LCXCAIw5CaAEONucfCUPrvQpRqCMNyiAfDt0T/wg/Kw0J6IdfCiDMAQ75FC8OSQuPCUmfXQaZEM0LRLAhD4kL7wu3vrcLxDwrDxU8KQyQ+ykIp5wjDBIowwyiO7MIALbxCSJ3lQmxl5sIzHYpC/kaWQhEPekLi/yjC4WTNQt4TXUK+PJjChTs2wr/RHEI6lolCUiSVQvFUUkE6B1FCLpclw4gkDUKqxerBOGchw3YuKMP5G49CRunyQlsMkEKzWr7CKLH7wh4YWMN6nHHCYF7/wt3IKcMkCeJC+hHAQihUaMLIQeDCAijqwgprjUI4qTPDXnwyQlSuKMPyAdFC9sASwwIn4ML+rSvDLr5SwsLZhkIII0TCxpwRw1JXosJlj4rCkDcBQ45UzMJasnxCfuIXw9oXz0GBPuXCfSr7wuKuGcO1rzrCM9T/wpLKqEHRb9fBx4nawivQBENt0+vC/NIIwyvegUIMNL3CKl9ywv2f58JedBjD1l0aw2DtX8JzQfjCcE0RwzIWBUN1sATDGpytQlC+CkPO1ajBms1AQvUH5MIndJ/CeJNFwr7v3kJ32LRCgoG5QkTZd8Jqp/zCtkVMw9YmAUM8qFJBnMBtQvYUkMKB2iXDgtPWwvFlxkLa191C7oDIwniP3MIfC23CvVpGwpaCAUO68lTCV1QAwwtNuMIG/RfDoj+5wrCeX0K0iqJCNKERw2iZX0GFAfLCHQLSwYJGd0JQ0hfDMC7eQl4X58FPne1Cee5Iw6a0Z0Kmz97Bb0mtwDKBgUI=", + "encoding": "base64", + "path": [ + "vy", + 30, + "data" + ] + }, + { + "data": "suBHw/Rmu0Aq6T7DMAF7Pc7umMKczCfDvt1Cw+WhBUOEdLbC+ccuw6x1GMNzX/jCetGdQrQlokL1VMlC8GM+w9KJ3cJiOqVC10cAw9TsbUG8NX/BiFrbwjSVuUK83brC0gLZwh3zDcP5EZnC5AsGwtTDKMO+JnDCV3KVQmCH3UJzi3NB/CxuwqLaPMPracPCM4HVQrPU9kFUIAfDK9iGQRM+SULWL6VCSF8Zw2Qt2sIeU3DCkyjNwg5KEsMR0Q/DPlLwQugYpz8wmKlCPLPBwrpV7EIJ7K9AhkCrwr6tDEP6EBHCGHD/QvzkrsLR3v7CKrr4wtIE60LdUAnCeakBQ6ke7MK+7EXC+zaYQn4LvELnwAFDEJSAwj5N38JrwynDEg0PQzgHyEJkgyHDIyA2w47FDsMIu+pCsGbJQmL4YsKVSlrCYjjSQkw3vEJ2qM9B7AHxQkpvtULq5szCIYuNwkwmlEJAvKhC233eQFxMWUK5vrZCL8vbwmP3rUKsFBZCdtMYw6LnH8OkospCxjr5QqjBxULJ4PjC5MSHwuINO8MMY5jCOvyAwobJOsOMWchCPg/FQu4dmsI+HwXD5Y7uwl/5wkK1kDLDdiimQlipKcNkN4xCE0MDw+iTd8KpGTLDZrmWwo2bskJuo4/CmKEmw1Q208IGaKfCrqDwQjx64MFWgc9CQukfw+hihkKaFgnDlJrzwr6XHsOfkpLC0mYHw6AokEKK/vVBOnsLw4PopULEaAjDKGQHwznVvUJcya3B3BBlQV3dAcOaxNvC2F/AwqKyWkEaBf7C5iIXw3K2/UKHsnLCAgHVQoik1kL6IylCnnmkQsY6EsNApBfBZZGZwkpH50KACOhCKNzGQgofrcIVaQfDhvREwxrz9ELasIZCg9OfQt1bXsBMlxnDPI4CwuYazUKu0S9CLG/qwuqy9MJ2CLzCfBWawuyPCkN2J53CVLJkwmJ12cIUBSPDBhDjwiJ+sEIXU7lCNsy5wg8he0INkQrDcFMxwjAdxULy8jLDRw2LQhjFOsLxvcpCO4pGw9kHu0KsM0jCzt5WQqNSPMI=", + "encoding": "base64", + "path": [ + "vy", + 31, + "data" + ] + }, + { + "data": "Jlcxw0mJ+MLEiR7DqFVIQgTCpMFie0LDYqMyw0Vj2EIBIt3BZLECwyC5tcLgeWbC/Q3EQu5JzkKGS+VBkAYswzBgEsPlWbRChLwOwwbGgUJOGj5C8b/3wqQtqUFtHADDmM34woZvHcNMzfzAYhPrQdr+L8PgQBJBRitKwp4V/kJ0XxTD0KNUvhLlHsMAnsvCUPLnQqgw1cLYnxLDIiKKQv7grkKpdtBCkKzCwk55GMJOUrPCbrniwn2j/MKYgwzDGRcGQwvRV0JdhNtC4on2waGshEKGClxCOCbRwYKQBkOCXKZBxFPsQrt808HuV8zCUbTKwjZ7/0LOcc9BrZDMQuZSmML9J0xB2nzRQhL59UKiaY5CNgakwOJlA8NcvzvDaVz3QiXmo0JfvS/DB5MbwzpVH8OLTABDaBxpQi8tk0DApiHD1vDqQrrt3ULgSJhCB/z4QijW2UIG6/3CWnG/wgLTx0LWY7RCpE8hw8pZpELw++JCh60Swq5S60KiKZxC8oHqwkZT8MIHHulCeqraQp645EJsuBTDsM0twVZR6cLUO7PC4nWCwNE5NcPqPShC2g+yQv4hvsI0gRLDIOnUwjO540Ir7Q7DrPrTQvo2EcO5NDzCTFCrwoGt+MD+KCPD9ujEwtcxzkIAGb3Calgjw8PI+8LorrrCgA6PQprsEUKzuP1ChjUVw3D3v0I4phfD8Oe/wuFsDsP4tcjCZWb9wlFAzUL6QY5CRUofw7cae8JypQ7DQrrmwid/2ULCbDBCUAF4QmkkAMOemFHCEFYGwi7scUIAxujCyMwNw9oLpkJMH1ZANKHgQr1M2EEGlqJCCAjLQt5vLMMXRjVCXAXTwnJEzEIJAgVDri6zQvxJ2sKboQLDITEWwxIsp0LgF8tC1GqzQgwOY0JUZ+PCeqW4QVw2sUKIWebCTF/5wpwE4MJo8ADDciTTws7T/kJO7c/CCh0BQfid6MKtIx7DYQ//wpqO0EKqTbxCTkoWwilzvELGTxPDRNB5wq6A7kJxl0LDgNWswsdygsLBhL5BfsQgw/BC7kJypJDCJoGxQnJzIsM=", + "encoding": "base64", + "path": [ + "vy", + 32, + "data" + ] + }, + { + "data": "j2v8wqkyE8M5I8/C5e+bQlRb2kFVqkfDAFT+wp6V58HwgfNBfhWGwlwt18EAmdFA5bDVQnJm40IWwwTDWST5woa2McPW87NCzhgSw1UiuUJdUKlCSDj7wvsQ3sLZGR7D4fMCw/MLH8PoYi1CljeKQmLdH8NWr2JCJa8hw0ZDAkO6lDXDgm84QgD04MLKkLnCMkPlQqhtN8O6vA/DPN3IQmjQ2UJwqONCHisnwp4YrUGUl+/CIlvlwlAvtcKsgOfCWuECQzTUpULnaPVCCqSiQVxtuMIbMbBCG+LfQQwGuEIc0WhCanCFQsAv+EFSgHzC6pR5wlnc7kKRXHtC+oWmwE8ByMEAvmFCzT7vQjOnCEOI3aXCqhImQgLmEMPyiTHDtuNWQmehREHsQC7DF6zLwqUyIcOK1ftCDPV/ws/iS0JGDTjDcIvrQmCC5kJfKNlCMi7jQh+P40IuDxHDqv/swnbb60IgRK9C+tFKwzZcyUJeuvVChE/UQUpWBUPo0shCRjF0wuQeVMIjzOxCen1zQriR7kJ6KyXDAQP/QfWRGsJKGcHCwnUbQvgdEsPEyObCl7xeQuKx2sJuFxTDgL2YwveS8UJquLLC4D7qQmoOxcKCBhfDvsgMwkYQI0K00PfCDJ7wwqRE2UKuiOnCnwsDwxiNC8N4RL/COl+ownpsk0InMwdDnPLmwmxs5kImUBjD1ppWwrABxMIMw/zCghrHwsQ570LyvchCKvgew+xmGMM0lALDES2bwpPS3EL+8KVCajSxQlKT0MLA+50//MCbQStmskIknbLCbBblwpgaScJh7zJCDEXWQl7PzcIsRdNCbeTaQmztO8MJjZhCugoEw/ATBkKovwhDcx4fQtDs/sLuw9fCwIugwhwHQcICivRCuxW1Qk55vELnI3vC1Zd7QoDXxkGiOC7DfJTuwtwqn8I4Mx7Dwi0Gw4ybd0Ka9/3CuJ1IQgPK4MJS7QPDPMMCw0Lg2ELopqNC3LMjQYhw40IFtA3DggOhwpoU/EJWJDzDvOwmwy80qcLu1gTDfHnOwib8BkPAor3CeBnbQmTZMcM=", + "encoding": "base64", + "path": [ + "vy", + 33, + "data" + ] + }, + { + "data": "MjmFwhawCcMUjSbC0sy7Qu3OdkJSZyTDSNdlwmhbCMPJL4xCz/4OwDXdoUFkD1JCjr/RQuJC4EIT7ijDtj6GwtovQ8NvtptCeLoEw2ot1kLajtNCd9/bwtBbPMOG4jHDfk31wv20C8OoUpJCNvO3QllZ5cKpAq5C/Ksxw1QZ8kIiwyPDoKeaQj4ogcKYzozCuI3LQgr1P8PEefTCPsnsQupY7UJCLNxCi/+IQFaTckL0xBPDxEnKwsozPMKuFo3CbZ+NQipIxUKqHfNCaoxUQpCdIsOuCtxCsqF/Qjs6BsJoQqRC0BO0wo39iULSHpTB4XaZwX2a80FEQqxCSOLywuJNu0Hs1KhCX7P0QtQiB0MItAfDsjmSQpJuFcNKVAPDaCapwpI1GMMSTRbDpq8swtz2CMPN985CiiA0w+QnnUJVcSbD1xLWQlbP0EL8eP9C9JujQh6U0UJcMBbDSCsFw2hx/EJ4i5VCbsoxw/0L3ULwcu9CSXuBQlIdB0Pamt1C1Mypv0DkjUEA+8xCe+5QwoC23EK0LSjDxQtyQig6sEFkbLvCNqmJQrFCssLVoh7DcApjwqr+58IaIAPDnS8LwhbA50IykhPC80LpQohPLcJaUB3DgKXrQG4Uk0JG2YXCoKMGw1Acy0IVyAbDyEKnwrBxDcMsKK/CQtQgw+zIvUIw7fxCDqKAwrod+UJIpgHDgrIfwXjsB8Jv4xDDsEprwlxj+UKKDPFCkJUCw9laJcPU5MPCUJD6wRytx0Ime9FCVKLNQowggMIOjCdC9jNcQkBT1EIYLD3CwMuNwhpbB8Pn6pBCfqSzQv6GK8OauO1CMpjSQgiKN8NLzLtCwEwWw8ywA8MICcxClH+CwvoPC8PhqYjCFn81wVqeHMOigANDq5SiQkQ46UKCAm7Bg+y5QjjY2sKMGynDbA/EwrJiKMKmvDDDTmwew1oQtMICrxDDigObQtvivcJenajCfBbrwlJYykLplCVChhE5QvFv9EKtV+LCYl/DwuLK6EKUVRHDXDEkw9AI0MKmRSLD8E8xwvLaCEOKx+jC9MruQgAIHMM=", + "encoding": "base64", + "path": [ + "vy", + 34, + "data" + ] + }, + { + "data": "Evw3wUzE38IpuINBRijLQuRrrUJsMcPC7DoIQVK/E8OFN79CLsNBQpR0RkLiDZ9CiN+uQk7IuEJLox3Dolpdwfc7NcPA1A5Czt3Ewrpz30IoLOhCAK2bwjdNQsMMFTXDrZy7wmDcwcInA7ZCMh/RQunGTsJARNRCFtgfw1yFwEKBDgDDRDjFQlKYo8H0qyDCuh2QQtcrJMPYXqXCXmz7QgQi6kKCpapCQPURQoeMrUJOxirDkPCJwvkfPcDqZYbB9A2hwl+b0ULeR79C2tyWQg7OIsN4FvVCuCuuQhpfA8O0hMJCPkwcw8/GuEKEIcJB7+agQdQm+MLkI8lCJrkPw04hc0LyPcxCJzTdQkb34kLs2grDdbi9Qr4oDMN2sYvCHiYSw+caLsOvfcvCLKnSQATCpcL+oxpCOI07w5YlvkJob/rCMq2lQj49hkJyqAZDuLBmQYbvmEK8tgPDlncHwzrn5UIwJC1CKCQGw2RW2kIejMhCt7SwQmu070JQQt5CDFI0Quh4gEJ6slBCXhYMwySblEJcCBXDErKgQnNwcULi2pzCfya0QghM2cGAARbD9JAnw+a03MJIW7TC7kfrQLDOskIkZ+ZAvt3JQitSFEGgNAnDZgoQQhCSvUIXoI/AHkcGw9wxdEK/CBDDLuAOwhz99cJEGIXCijEjw5Im1EJktrRC67UMwZYp7kJYKKHCbjnZQfS66kEAhhbDAJBcwdMp50KIAwND3jCowhAJFcMTC1TCGANWQS6qkUKaiuZC4kHXQo7sq8FtXodC8O6eQnDE4kIWUqY/skmTwVbgFMM2rrZCPo9XQqTHNcN8KfJCVoilQijlE8M5O8xCeFsZw35xIcOmdYPC+lDMwjoGC8PHkafBAswhQmJYKcOYMABDzMhiQh6z/kK6PM5B0v/mQgk2CMNUNQzDCrB4wvKsCMEtxDLDW1Msw6q6DMPWHhjDgJ2+Qi7rgcJ2BsnBODWpwrKpnkKWxW/C7B6NQiYf6UJWlGrCug3awsdNoEJYfY/CFE8Lw6ma58L9jBbDDDb9QEox1UKaUAXDxHDsQuC35sI=", + "encoding": "base64", + "path": [ + "vy", + 35, + "data" + ] + }, + { + "data": "jK0AQtK1jsL+3G9CC1DMQosJ0ULAiffBJJ5TQqxHBsMiwt5C+RGiQkSDikK4PL9C2tweQnRUBkI+DwLDIHDkQX8wAsPGnOXCwWVCwn+y1UJkMupCmsIZwnAIJMO2SSHDPq1Awhf5I8J0w8lCXPzaQpTdLUHUNelCpCH6wkAJOEJAMp/CUoPgQkAClEE+7RDBXmUNQXRB4sLNegXC5zP0QpE9yUKaZXpB6H5vQjxF0EL/bjbD9WbKwRhOFkI3nANCcNDvwtILzEIkZv1ABdq0QtJZDMMESflCYOPKQipvGMMQpdJCOGYdw3QG1EI9QXNCaN9KQpgkDcMg3ddCRLEIw3bvpkKtWt9C3L2WQtcqZUK4nffCZTPaQq4C3cL6I0jBTecbw6C+GsOC1BjCXBEhQrWVl8EiBcbCKuEhw1sqz0J2R3rCY/4TQvK48sFwAf9CaAPEwjo/YUEwjK/Ca7bywgmLBUJZhTDCtpadwgzBrEI2q1NCbBPNQkVOmkIGqMhC3IGTQtJatUL2tY/Crh4dww7IG8JjOc7CDh27Qqntq0LdWk7CY9TQQjq+30EwWfrC6ggow90Qr8IKOgHCmBAtQtBqAUDshRpC5a9sQgQ3U0I4D9DC2rxbQhaz1kKs00ZCU5vewppM0MKw4wjDvJnmQNqKn8IMugrCYrwNw1QI20JKFQG/6EkiQnfhnULcOKrBzjRVQh4yjUKd9wnDzjnlQYr4pULiFv5CkIsPwoSR5sKfnujAuGlNQqOBiUHQUulCGDXOQqMxgEG+rqhC8jzAQpIA3EImFjxCEi0HQni8CcOO+s5CtkSzwfhZH8OUxthCP+yfQcc5qsJBcctChuUFwzxfFcPqugDDBwjRwrTN7sL9ZsZBuJmUQufpF8PaQ9VCp4afP2JZ/UJeQWBCvMoCQ4hA/8J8Q7/CMp+XwftHl0HgxR7DKtAjwzBkEMOv7gvDQNLTQnqo3sFKCgRCtiMcwth2BUITovbCOSyuQnC0qEK6h7ZAdOrawjDy6cB1s25ATiPNwgrV38LewPfC3uk6QnH7lcFmQg3DyKXLQiytaMI=", + "encoding": "base64", + "path": [ + "vy", + 36, + "data" + ] + }, + { + "data": "LFB8Qs33IsGPSbRCEtG9QoHD50L0uJxBzm2jQjiy2MIMqu5C6GHMQh7gpEJsddBCMoWGwpDou8ITPLfC5IloQjDgisJL6CnD+/RnQJRBtEJp7tdCpBXkvRTN4cKUf+/C6I6hvnYuY0Eu3tBC+AHXQqMpWUJm3e5CSViYwiXKXcK2HH7BgvntQoRnRkLI6JdBgt35wqK2IMJEPn5B/ZDPQgamakIuQ83CYYKaQuf25EJsyynDPliFQfZXjUJoO4NC80P0wsqSsELMU+nCJgzHQvVP0cJUR95CNjDZQm7SEcPCwdRC+OkJwwej30Kq4qpConWMQvpiAsPQpthCbMXmwi4BwUKeoONCARsGwUDzZsI7McHCLlvpQpoVasJycutB3CEPw3rN9cJQI8tBtjV/QrALBUIdaSPDxqzywqsA0kJPC+JBtahVwr2cDMNWK8lCdiYdw5ryvcKe7BLCFAK2wgJcxcLVDzfDgIsewZxJsUBB5T7C7RXbQmk6gsHW3ZJCllC3QrLS0kJ+KRjDligSw2aQG8NmdynC78rJQrw4zkI2IZ7BbFbgQgBphEKS5rPCVDkQwx7/SMK2ss9BBlyJQi7PD8O2RnZC1dT7wVaqpEIG52vC0HqHQsAN4ELFhKtCZgmNwnZoJMM8HdPCu5UkQmmay8FCQCy+ZnfVwoYV00KcLPfCQHSTQoWmR8J4x/FBzZ6KQh72u0KZEtbC/nlwQrj1Nb/M6LhCIuDZQG6FgcKS/gJCZh+bQv6rssJQlNlCMnWsQoxTLkJk3LxCrtzUQuCltkLkDZ9C3feYQqpE4cK27NpCaZQmwwgf5sJyJ4hCeNzWwi2UjMG22bVCRB2+wgx898IahwTD+Na7wtxSmMKOVXBCXzXCQjLZ7sKcaU1CNqnKwtBv4EJg7JlCuhUJQ3j81MKEwgfC8uK8Qc5cGULiyuvCVIr1wtZ+AsNQTcjCmhfcQgJjHUHQeZRCvJngQOHmYsKYWADDtAzDQuucRcETR2ZCDgO/wv3m7MIpClNCiutZwnzOtMKmQ63CYF+WQsX748Js4QTDFlZiQsTlp0E=", + "encoding": "base64", + "path": [ + "vy", + 37, + "data" + ] + }, + { + "data": "4AyrQpCiuELzwN1CijaYQo7r8ELuLlBCSy/JQpXYjsL8GPBCtjrmQrQ2tUIrptVCGk0Lw97MFcOYMiXCdrCeQsThgsEYmB3DLng+QjTnWUJcxalCvhwCQqmpMcJUUYfCqpAfQvTlW0L1A8xCm97DQmyKo0KUh+RCpHgbwQBvLsMUUZNChJrsQo1wlEIWwylCEDVJw86yN0K3omNC3g1xQoDcBsLUFw/Df8SzQgJ67EKgcvbCHXFCQtphukJCZqtCrDHewt0uZELg4hLDVPbNQkbiX8LpiIVCKunZQua0+MICGsZCzPrUwtLP3EI6CMhCXlqkQsX52cIifshCnrykwmq1zELj79dCO1oBw87sFMOedWHCJ6rqQgbfckBMAWdCRCPnwoMypcKEQoxCEiihQmhIgEJfAynD1GiJwmxFxkKQMA1D0kIyw/nUIMMEcypCQpglw3g3F8Pkc/hAaCJOwu+n98IWHDzDkF+fQoSr0cJ+xhLDnWDcQp17BcMReYhBHvfLQkL030LaZiDDCmzvwi7GKsPayntBEBvMQqpw40I8aSJBx4bgQqAAuEL+EC7CbXncwhr1J8H4XYJCZD6mQpRPL8P7Pp1CVtADw12Ty0J1ihpAcuGXQnaF2EKMYdpCqkzfwQiNHMP0qWbCKnODQh5IuEF+PvBBxhJrwgwbuULBvCPDAG+9QsBC/MJu8XdCh12dQh8f1UKMIoTCFBWhQjYgAMP3lDHBECoaQtWaFkFI5HJCTJ26Qjg/I8PwjbJCjhY/QjTOdkIm+MVC8lDdQrQuMELLA8NCRi3OQvKmlcIIBNlCMCRWwxhzSMJyA/7BTAAbwwjlD0JUp35CqN5Iwqg+ssJNNfDCQ16VwqD/scHm36NCI+/fQqIulMJ43XvCRqEPw5Znm0IYW7ZCJFwAQ4MQmcL7P1tCCd5nQqjYUELmGYTCDwiEwgHp0sKC6DXCPEzWQhOBLkKIesdCApEvQjSBFMPORObCkovMQvSv9sK8uqtCZqWKwgzHGMO37aRCzKIbQUOdcsIkURXCQI3AQp9+BMOCnczCCD1Twu5tBUM=", + "encoding": "base64", + "path": [ + "vy", + 38, + "data" + ] + }, + { + "data": "slDLQsLfXENZA/hC4r0KQqk66UJIRJRCJkngQtR8n8G6/uFC1JXyQtZuvEIxfs9CZz0Uw9UJGMPhCtlBBvG8QmC7rUE4lQPDYOyWQlbzk8H56RhCU15cQth05UHekn3BQ3iEQjJPoULKoblChuWcQipWxkJAJsZC+tyrQgaOUMNUGDZDilnYQvZ0u0K8MGtCvWBIw9LP/ULx9qZCggwCwlzCDMPwjA7DUDXEQsQ+5ULy5XXCIiCGQhS51kJCjMJCRAK3wvyZGcHuXA7DVM7HQpqlNEGCvyDCScPLQhAMtcIIaJ9CnYR+wrqMykKQtNVCDqiwQsNun8Ih8J5CtuALwr8NzEKO1bdCNtMnw1TjK8NmYnFA4gnbQhiWZ0KaWZtC+BCTwmw6AsJOtsRCMHC4QhB0pUIirhfD3uBfv+HIqEKspF1DFr9Tw1q3FMPWgF7C/j8Ww5bZG8NnyBpCflQ2wfNT8sKEhiDD4LAuQ7zpAcNmtCrDzULQQgwiLcOGEbjCCGbUQjHT30K9XA/DylKgws/CG8N2xFxCEKe+Qpjh7ELFDAxC9MHKQsQR2kKYpJ9BMsWHwoJEu0HKuK9C81S0QktSJcP1DLZCzRsew7wJ40KEbbxC3xegQmZyvEIxbPZCtE4HQdA8BcPbUzHBD2CnQk6aVkKxWFNCLtHtQK4thEKEwiLDI1jWQvJRCcOOG6JCTuClQlr53kKiDsPBBCu6QnqxJ8PvZM3CyvVzQqra6ULKBZ5CNPnKQlz+KsNy5k9CALcWwgIak0JlJMRCRt7XQuADZ8LKtdNC2EjsQk9MosFp28NCdKNEwzvHz0FjjgfD0HYYwz7jikJI10RAmuQGwa60MsK9Q8XCTXw5whraz0Fpmr1CzXHwQmAGRcFMuhXDEJMMw4h0L0GixsdCmT+qQt4eEsJwOSFDlreeQrUWeEICf1nByQhjwSYCi8ISr5hAjdu9Qp0jikKWQuVCGoWFQjy/JsOUdLjCzErJQmb3E8MgQMlCyhIbwojoFsNapMlCbf3LQsUa/cEO9vdBkr/eQvZFAMPi+GfCwicbw6NgY0M=", + "encoding": "base64", + "path": [ + "vy", + 39, + "data" + ] + }, + { + "data": "duvgQgYCgUM5LQJD7XCAwj0JyUKyu7JCJPXqQsILaEKLmcBCaE7yQtjDuULMwLxC64gHwyKjBsNiCgJDDTbRQvJ4QELImcXCD3W4QhJSBsN04k/CyneMQrgRyUIcXu9B/rmiQjJkwUJMDpVCNAQvQgaE2kL8K4pCADg/Q7Q8RMPNv4ND4u6nQipA2UIW9IlC3K0sw1u6Q0PGsMdCXesQw/ATKMMwx/nCJNnKQkRQykImucvAzG+aQuyW5EJ9hsxCjmx9wrh898K4NPXCUD2vQqY32UL4eADDWpaqQvq2J8LwKCBCIo+hwFwLpULE69VCQ7uyQrA2JcLY5g1CHDASQjAlv0KknHJC+HokwxLaI8Pww9NCi0CzQhDWskK3LLdCC6o+wfgWA0IyJ+dCJdXGQi0ku0LLIPLC8Fi4QtDOY0IuSnFDJkdDw2BL88KOsv/CLqLwwkOUCsMdlWpCwUbFQRb71sJwb/XCyjeAQ0KB/cKbFiLDDFmzQjwqLMNiXybD7IPRQnwV00KX4uDCoNrGwQAb/8Lyw59CfPSYQgzK6UKExlZC8KCOQiMS7kIaxOtCZn1uwTbKQkKC7chC+Py2QjotDMNibcZCHbYYw+327EKHq1lDtpufQsUZhEJYXQFDmtAQQjXjy8IBztJBw4vAQrLvj0LgUYRCAw/KQp0Wc0Gu0Q3DNa3hQrCNAMNWWLhCvS6lQhRE3ELSuVNBLHbGQoVuJMM24f3C4DqaQjDvVEOA5LRCxNDOQiBaGMOTeYTBE3MWw6QhoUKUlrVCHnO/QpPQCsMW59VC4rv4QplZf0LmmI1CavMdwyAcykIeCB/D8a8DwxrUtULFNtrCDqPSQUp8aUGerInCNxWTwBIOZEIsy8lChiH0QnzLm0LfcynDYojzwvC8ucK4rc5C2nwWwugSmkG0u3NDHoa3Qrq4iELI2gVC/D++QXRtlcGAGiBCHn6HQjkRqUL68PJCtmWhQqYMGsPSiHPC/ea0QuJlDsPK5dVC3OkewXtPA8OU3N5CfsBKQ8CpyMDv+wlDnbzxQs5a4cIE0WzBj+Aswx74fUM=", + "encoding": "base64", + "path": [ + "vy", + 40, + "data" + ] + }, + { + "data": "ED7sQlLaT0OFDQFDkPYvwwamgEKgvsZCqmTpQm3tLkOCBoRC9mvkQn43qkIltplCjWffwstm08JI+W1DMCrcQkiohkLS6G7CYuTKQlzOMcOLVxrDlMqfQqpxKUOPMH9CB6SyQhh800LeaydCnOWIwV2d4kLWNmdBOJSBQyy9IsNFzXtD+boQQuZV7UL4j5RCPWQEw9zDY0P4JtlChFIyw1wMIcOGwr/C4DrEQig7kEJkYPFBO5SjQvNb5EKPzMpCfc66wTTLJ8NafrfCmnVuQoJAUEMUSBXDyEBbQj7W8EG8rAvCUIekQoR8SEIo88hChmiqQoJcN0FcjFfC4Y4dQ5ZHpEI2KpFAb4EOww91CsPrSmlDGw9JQlvU1ELaGslCxpeoQrISAUM2MflC4FzMQhiDxUIKrp3CpCxCQ1ZJEUGa3z1DkOkew6ZQpsL6mxjDvrGbwvhS2MKUr49C7WhYQkVvrMIRoZvCOOiCQ9FR38JLQQnDd117QoY4F8N6oy7DEoHCQso9uEIEfIrCiqRcQp8os8JKsb5CtNQOQhjW1kLKKIJCsG6NQOYs9UKuEHFDWKReQjp+gEJTDNRCVn+vQqxM08JY681CHFYEwzhN6UKwEIdDRPqTQq5OikEuGABDCu5aQqMsfcLUrkxCNZfPQrqepUK+x5FC48FFQ4QZpMIWPdXCMb/gQii+2sLBEcNCHtaaQtyPzULMdzJCNPjGQpXhDsP0Rf/CbJiwQjwfeUPMtsBCLdzGQsUW8MI2lvnCUuovwzePpkKkq5VCfnCIQl/IGsOktctCSif2QmQGPkOkzBVBpDnYwgeJKkMZRhjDMczHwrDL0EJknh7DhJVMQjQpzkIix+DBw8eAQsVYlkIycspCci3pQqiBOENqnCHDK228wrawGcMQ5MlCqTD3wnVt2ELkMnhDq7TCQjJjjkKyBYlChkRCQnNaa0LQJ3ZC6ORDQfpZuUL83vJC4MGwQkSa/cIS9JfBUCyFQj7Y9cI3TNZCvxtvQWCbxcLe6+dC6wyGQ+E2c0H0N3pDIIH4QrspsMJ06aVBOKsgwygwSEM=", + "encoding": "base64", + "path": [ + "vy", + 41, + "data" + ] + }, + { + "data": "eh/sQpo790IQVe5CGIA9w/YMZcBSj9FCQMLZQkZRgkMkpHBBbsLFQgp7hkL2ozxCQPydwk9qhMKKNItDEyTdQr7pokKD/0LBFKrRQr+sLsPAMTbDuOipQkAvXkPZpq9CY+W3QmYT2kICJ4fBNjPnwt4830Lc4ZzCFKl0Qx526MKEBB1Dco8+wk1X9UK3XZZCXmOlwgYDN0Mgvt1CYgAuwwRUCsOqCl7CVLKnQqKZcEEmvVhCsgSkQqC+1EJ7D71Cht8ZQnjaJMN8yULCvMmTPk0eg0P5/RDDdKojQKf1EENu3fjCdOVHQwnxQ8Ayga1CaPGVQr2NvEL0ShXD2ml+Q8XmbkLSe6vCOajYwuOpxsKKIYJD0IOhweCM5EJsldFC3DpJQ2BzdkOpfv1C7ZXHQpFOxkIO9LPBduSFQ7OUi8IGf7FCklzewrjd/MErjBjDnGqnwdolhMIldqBCfqqUQr0JZMI3R8TBC1IaQy65sMJelMnCC11vQcpX6cKp+h3Dg4ikQmQXi0Jm6iXBBzMpQw7XIsJOedBCNR4swo4VrEK6GI5CtKW6wnen7kLskYtDxGwiQ+2ikkIc5tNC8a2dQuIxeMKWXspC+CzLwqAA1kJok2FDhDFuQkZ8YsKbwe1CmmGGQiSFbcEI5YVCWnPTQsDAsEJGzJVCkNyAQxKoKMO/02LCRi/TQk4zo8IAMcRCAr2EQlqMsUJypIZCcxq7Qqj32sLcGunChhi+Ql+NS0PUX8JCzkKyQrQwmsITPDPDhAclw4EYo0J6zjRCgexQQRDuEcO8e7VCBUDlQtStgUPBTsvCshhBwjLYV0P8VgPDwYBmwuCn30L7oh7DDtiJQqoUX0P9cv1B1JA3QzA2q0Je6r9CmpbKQlb9gUNlbAvDhBpswvrDJ8OMAbZC5r4Pw8sTakM41ShDMTDCQlmRi0KmKLpCKDCDQiUENkOGLJZCxnq1wjyjvUJYeuVCMhe2QgexssJOMCBCHLePQeaHusI/W8xC9A0OQmYHU8LH8eVCelpkQ4zDA0JcMYpDxJ3vQoLyVMJuYzRCqLYGw971yEI=", + "encoding": "base64", + "path": [ + "vy", + 42, + "data" + ] + }, + { + "data": "mFndQsyk0EHm1sJC6Ggsw6qJtsKB+tJCmWW3Qlr6cUO9fYHCuNCPQjZG8kG7rkLADwoRwnoRVMGms1xD+dzRQo4Mt0IbykVCqkXOQvTAGMOXrS7D5EKrQvCsUkN7JdFCEg+0Qtz01UL8LurCbg4xw0Raz0Je1R3Ds6wjQwz4aMKWXGFCDA0Fw5y360LcJo9COhe1wfphtkJyG9ZCLowYw5Ab0sKM5q8+LKU+QtQxrMJ6YY1CLq2cQuOuskJGOKFC7G8cQ4cmEMMTWUhBJvPJwnhnW0PaKQDDerGdwpDxc0MoDRvDrCWIQ/w5qMJ5qYBCHghjQhCNV0OQpyzDFoV5Q6dzxUHl0RbDVCN6wvorNcKE2FFDnybfwsxC50Lcg89C/nF/QxSkk0O41fRCEOW0Qo+/vUIkf19CNsh/Q9hKEMOmiEvBGDpWwvYyH0IYYgnDxNhiQvlCHcGmcalCAAqvQkrXhMHlGCdC+SpnQvPyYsJWdVLCUMGLwhRVisIyCAHDfWhjQhe9BULqWJVC/dpyQ+AEwkHEstdC8mXvwg3FLkISjZFCyYoGw06k10J49V1DNuSGQ2qPm0IIc8lCzfx/Qvw6zsA7ubZCmJ5ywtxtrkJijgxDxj3oQSD+88KGP8hCyHmWQt2PSEJ42ZlCddrIQu1hs0LfF5JCChtdQ6qeOMMsM1dBBuq2QmwBL8J9HrxCLrE8QpynhEJVlKZCfZygQmGGgcLcpsHCY2vCQhiu30K0ZrlCGoOOQj+ss8EwfDfD0sELw0wFlUKy+wDBR3mjwg5J+cKYHZJCLyvFQtq4bUMdcBrDKufEQdgMRUPevcjCR27Av64b5EJinwzDgQujQuphkENHFwhDuFFaQ+5dtUKBJ6lCsIWNQizkdUOkX9XCglNpwX+zHsMc5otCkrYNw3z0gENw8IhCXFO2QqkHeUL8rNtCNsWaQlLEhEOyj6ZCQuQdw/rttkIYiMlCnkiyQkBnJsKeZQZD3LiGwlvWUsL0ULhC8NtLQnaFQUFzZNhC5qYCQ7DnOUJcUlRDw3XPQmbNOsBF4nRCsQDGwkXWqsA=", + "encoding": "base64", + "path": [ + "vy", + 43, + "data" + ] + }, + { + "data": "VyK5QhTQYcKvxmhCJkEQw4NeBcOuIMlC8xNxQhLvJEOAkxHDXkXaQd0WO8KRpK7CdheoQWD5dkJQEvlCDGK1QsLJw0JShgxDWdjAQqzb8MK2VBfDrRqjQsla/kKiq+ZCvk+nQkZ/xkLqdzTDGc45w0Pir0JyLDXD1fh5QpK/WEEE5YHBltgiw1imxEIwE3tC/kNRQpSKmEEHYsFC2KTwwiZtdsKqRqZCyp/+wQaYHsMaGKRCpFqNQqhOckLReGVC4mCFQwyH48I0DtpCaBgVw7rM+kLElMzC/rcOw5A5gUPsmhvD0OB1QzIEF8MlKfdBntDYQVBRi0M8rybDsFs9Q4Yt4sF7dijDbGr4v05L7EFQQQVDJNwZw/R230LYmL9CJh1oQ1CZZ0PjWd5CZn2MQj2hqkJIFSVDrsIjQ/r2JcMIqKvC39+AQePZE0OiFd3CSTgfQ1b+h0KsNKtCdzq+Ql4uMUKzFgVD3EAHwe8yXcGXGi5BRh8hw+c0rsCwO7bCJ1d3QQD8xcEo3T9Doi5wQ97B7kJeT9VCHREOw7BOHMJIc41CDKwOw2QKqkJRswVDwn2NQ/v+nEK+O7RC52smQhiNikITxodCYAnVwMQ6VEJjACdCAjEIwk5hEsPhnIlCMEWfQk0HFkMKT6VCpp+oQrsorkL+MIdCneoAQyp9LMN6cOtCopKHQqkrGEEE7alC/Gt3QVX2/kGd6LtCCiRmQhiWrsCLmIjC1qy7Qh5ox0GczKNCsPUtQtp4QkJkzyXDKGnTwmrhcEKz17vCSBMPw/aQvMKs2T1CC3WTQsxqK0P6wSHDQcflQhi58EId9WzCrwucQlBW3kIPC+LCmbCzQtERcUOan35DOM43Q/gMt0LVeoNCFN5dQfjfIkOfPX3CqKwvQgzwB8Oc7/dBaAkBw9gzTEML2NXAtxOeQjY+MUJgRPBCEluqQsbRekPYvK5CmPgqwx75pELK3ZtCc/akQmppnUG01WJDvvIFw30OVkDE8phC7Mt2Qhgv20IO0bxCOqRHQqiZYkLIve1CwFWIQj8PnELT449C+f1Uwl5uosI=", + "encoding": "base64", + "path": [ + "vy", + 44, + "data" + ] + }, + { + "data": "GQdkQqqH+sIqEs/Aokrbwm9cEcMya69COzqeQJbtl0I7tDDDWL0vwp56CsN46yzDmXXQQsxyLUOm4w9CfYp7Qve8yEJKpYNDFEGoQmiOn8JEvuzCaEiPQqRAYkIeNvFCgZqQQiF7qULcFDzDok0swzoadULyJzHDUJB5wUDQx0L6XZTCcNkkwxjoVEL8cT1CKlwPQ/HkGcJcDp1CZ06dwro9qcBKIkRDUNDewpqxMMO63bJCa3hpQgIyiUFmdaVBAl57Q1gSl8IQnWRDhNkbwxCHMUKz5YbC9D4iwyaiT0MgoQ7DsBImQ9i5K8MxOYDBxEOXwdrHYkMuVxTDoyzbQoQYycJKZiPDrpCkQoP2BkMgAjFCf8siw9IHzkK0Z5pC+k4mQ4jnA0PIWrdCjuf2QVLZiUIyynpDxHNzQvaKIcOEYAvDpJ/NQrthdEM5cZDCnPlmQyXGLEPESaVCRXXDQshFHUOc3nFDrtZxwkS7QULqBcZC9D88w+z0pkJ++i/CTGRJws8F6cLw/oFDyyQ5Q3qKZEPt+chC8GENw9zwE8MkvYFCAEIIw0cFNUJyPRpCngVRQ3SDl0JKRZJCamoPQRxdJkO6FZdB3rSHQv1H1b/hYCzCj5ffwjAqFMNNNKFBeiyhQnEOg0P2ualCbulIQlyhoEKsZ2lCVM5NQvFAFMOz31lDpCr2QXdGukKgCYtCorQNwnrlqMGA6sdCht2tQQcHm0LmbuHBaXelQsBbLsKM6HpCKqUYQFwiEUPIoQjDcKx+wj5XC0IAlhfDKBMewwz7WsKOgjtB3esXQscIrkJi+xfDHF9LQ9IYUEKkcpXANHY+Q8YWzULumZvC9li8Qh7hFkO4IYRD/uUCQ94XsULcHRRCu+qnwlpWikI4g8fA6jAAQ3pdzcLlngnC+T7awmZEAkPPIYbCh7dtQm1I1kAA8PhCuAqzQlyLOkOHwK9Cqpoiw9RUhkKZey1Cz2qMQqIfzULWw2NDfogVwyDRrkIWbVZCHXeJQnU+VUO6y41CW/lKwa0FgEIQIOdBgJygPvMUUkMoVp1C7CXAQL0ACcM=", + "encoding": "base64", + "path": [ + "vy", + 45, + "data" + ] + }, + { + "data": "HFTiwDpWNsNRs8DC4HOKwtpoDsMmNHdCRlSuwimndEAgpTLDczkHw/ZbIcNkLkPD7ktVQzxRfEPjvgLCdANFQdYdxEJgiJdDENmBQv4p8MEwjJrCvi5XQtxoD775c/BCMr5aQtTjdELAFi7DIkIUw1hzjkGGmx/D8suawg5PNkMZzfXC1lQZw3Y0usFRGrlBZolkQ3KKrMJZC0lC53TQwewxjkLQvHdDOh0Fw5QwK8PywLpC4AUgQqnQJMIbuQ3CDd5AQ2pi5MES1YNDVowSwz5pnMFMkanBUkwfw7YgAkM0mvPCb5+QQrHeJ8OHTJfCgnSjwiR4DkOlv/XCTIWbQWo3GMMolhLDeA88Q9cXYUNMgiLCtKYbw/6ZskLKGR9CqsCgQkL0IkLVVHVCiqcmwpUSKkI+y4RDHARQwZCBEMPtZS7DpEg9Q2ObgUMAyZ/B7exyQwa4bUPGApZCZr2+QmlrhkNqgJZDRjbQwkTOGEN8vEdDJIQ3w0ZaO0NoCHRB7EIEw96TOcNUYXJDQ7jTQkoNjkOCALFCqAICw2LlO8NS6FpCljbzwgien8EeYh7CRiLhQiTJikIa+j5C2BIVwhrUf0OpmoTCcAkuQ1/YnsIO9tzCx2kEw9kpCcOmeUvC+KKbQkqSkUOdiadCmB46wZ4ciUL+mjJC/v8nwZzH6cLNYoBD+nHHwZYaXUOOezRCyUbOwoR4ysL5wcpCLAP1wcpRO0MoA/lBdFttQkmkycJccfxBt8tawmJVY0M4i8bCNrE9wa97A8EQxyLDDGUZwz9lUMBn2BPCbJ00waqWjsCUtQXDbEyHQ/LArMAO649CuwyBQ1M2rULCuQjCPoi8Qnhod0KEYElDEeiLQvxJo0KfnaTABbciwxBiNsB8sZBC+atcQ0YZbMICid/CFfikwmhuQkKE9OvCOPPwQdwsX8KWT/VCOva0QmxC00L2palCAh0Qw2amMELFSenARzFKQi7QR0PKtDJDxCIRw6qVTkOM7aRBVgiRQj3weENkhQBCoMSDwjttiUKQ9SjCbo26wnb7hkOYI6RC7GyvQhlZL8M=", + "encoding": "base64", + "path": [ + "vy", + 46, + "data" + ] + }, + { + "data": "T1PFwqwAXMNIzRrDIKqtwc6qAsNiHzBB6agjw4Y5ZsJgXiXDCPM1wyjoHMOUSjvDRBiBQ2uod0MSnrTC1CGLwny+sUKsT2xDWpoRQizAAEJ0UNjBo4DDQT+aQcIVreJCIRLjQYrdxUEyjhbDY0rrwjYBTsLp2AXDPCUAw1Nud0P2SCPDXr8Fwz53s8KswkLBgt+MQ02s+8Ka/gZBHIIoQk5OMENw6V5D8koFw85FGsMy5LtCiDhQQaHFz8JYkNzCVu/2QnCQ9UGw6FxD5kQBw8ZPlMKw4ytCRowQwxBZJkJW573CzJWWwJIYF8M6XwLDCBr/wuy7gkIclLfCXip5wnJLJcNWe/TCzit+Q+TsgEOnd+HCnGwLw3+Xi0Lnkf/BdpcOwXJE58Hi/3xBRmT2wiggjr7M51RDrLKNwpHZ78I6OjbD8ON/Q8ZWTUPe41BCEG5JQ6CPaUPIgHNCMu6uQirLfkNDc3dDoCoNw5jQdEP23H9DAc8kw30RfkP3bbtClHIpw1XgSMPnoS1DNkpXQfaodUP1xolCkGXgwsJxPcMLKB1C3LnJwj5028KY1NDC+K22QQoSa0JiJSRBQrTAwshpi0McZPfCJtx6Q02bEMO3+STDtIsBw3ZV68Ko9QLDiPCMQjg8XEMiVZ5CxA2ywoooSELA/MlB8kWAwqVSn8K6EGJDSmrKwsfbh0OQz9hARvUIww6qL8MkhMNCU969wpBugkOYxAJDC39wQd7sFMOJk4XBRA3wwvCpfEMQMVjCnK5aQpKVkMKS3RrDUOQKw9VehkL2ZMbCVqaWwrKbo8K6WtvC3seFQ1UTXsJ7aDZDLEFxQ6vPcEJE4KhBmICyQhQyA8HKFfRCnk3CPyZgjELCpH7Cvok5w5oVesKHGjJDOZ9xQwQvIsAOmxDDV0A/wpw8DcKaPCDDIiI9waQcusI3iuNCzEyvQh/1q0EYf5tCRn7uwiYqOkFDaZzCqX6iQfSxekOgyuNCYF8Dwxw0hEMsvt7BCjWSQsgwWkNYqgPCRPfiwmEdjUK76czC0P8Mw9J3bUOuv6RCdCxEQ4iOPcM=", + "encoding": "base64", + "path": [ + "vy", + 47, + "data" + ] + }, + { + "data": "3/4Vw+LaPsNgaC/Du/4QQr4o4cJAfqnC7K06wwR04cKvEg/DU54/wywLDsOYtibDwrNjQyhmPUOuXQzDQIkKw4RPiELkPBJDYAqrwExB5UIo1Q5Czk+mwVwStsJ0R8RCBkIswch49cGo1PLCIjCjwjn9CcNec8vCpm4ow86/hEMbAjzDtivYwgMl6cLqL2PCTBZ/Q1wcGsPid0jCz5MHQz7yfkN8RSFDJnD4wshbAsONgrVCXhfXwciKCsPhgRnDGt9AQu213EKGohRD0F/Vwp5+9cIGLA1Df870wlccEcLk73jCSASJwlK6/MIgOhnDQK0Lw366CkDAlFvCt1wDw4BvHsN+iLfCYiB6Q5AgYkNoxS7DvLTpwv2pK0K1WvXCkrKlwr8WrsLqpkrC6JsXw6ZPjcK8pQFD0fLswqwDs8JkPwLDSXqHQ8Zg90IU/xRDKA0CQyzMNEOWYhJCQIKRQvHaRENSOBFDUggow4jbcUO803RDII8Kw6vvfkPR00FDzOwtw1yLPcOBEqlC7quJwhOSIUMWDxlClauywuPnLsMUQIdBVL6Uwq4kI8Pyqx/DG+w7wiReKkKU8zTChlUNw/h4VENxWwvDMOd9Q/8tKMP2VkzDlorrwkiTtsL2Ri3DHwNjQrjp/EJMu4xCp6v5wk39qkFzQ+u/f4/hwsj8D8Iq/BpDshEdw5oHa0OIFljCpjgMw77IRcNQ9q9CcFcEw1k+gUMUNWxDnMhlwgJuOMPYNabC5v4Zw1LIVUNPUjI/gl0TQ6527sKQ8AnDzELswsaCKEO8JxjDVwIOw2yDEsN7AKHCU+IvQ+CEyMIwQYJDS/MvQzhjikFigb9CnJqaQljvh8J8nDhCiD+awktIU0IaY/zCZhA2w7nJ5MKhqIBDWjxIQ10CkUJlnhXDwDnFv8Ii1sKycDrDaFmHwnpCycJQ3b9CGu+fQjihScKOD4NC4Syywo7k/cHYCRfDDgDLwRQKakOklidCAKzfwqsqbkN2fsfCXFqMQjPxGEPS2gbDdZEcwybPiUL40RrDKvcaw6XLLkPk3Z5CqjSIQ6+oE8M=", + "encoding": "base64", + "path": [ + "vy", + 48, + "data" + ] + }, + { + "data": "sJYkwwvBR8Iw8S7DsBvgQuTDscJGqiLDMjw3w/Y0I8OOl+TCgSA2w7SU88L3kwvDBpEkQ0n73ULIkjbDHPkgw2DXyEGcaGdCa7yBwuxMT0Pq5uxCyMOfwhagAMMe5o5CfNOHws8M2MJTn6/CzW0fwjmnMsOc0n3CkJw/wzu5UkMaRgvDc2qZwsmr+cJi87zCuO8hQ7YIGcNW0+3CGvZjQ05lg0MQCqlCoq7bwnDUycJGnaVCnICnwoeuFcMUQSPDg7P1webGTkMxXoBCFPWewpWQJcNIBnBDOwm9wry/zcL62rTBDNL3wmImv8Ie4RrDkDYHw8TsWMKgjCvBoxM9w6kXDcNNp1zCaR5AQ/xQG0Mm0F7DCpCxwpsCvUBSGBzDGLwQw8zACcP3cgbDsvUZw8BRHMMAghVC+EQdw+i2VcL+4WDA7vFRQwxu9UGI11lD3O8sQly60kItK6PAUFpEQuPDAEOjJkVCVOMSw+rSP0OcPTlD3vzVwuP0R0PMHYNDglIiw8m9JcPkwwPBlPAFw6QMiUJ9dRXBFON1wq4qGMMm7WfBxyUlwoabMsObAUzDF2jSwqaNlEFqKPbChjAYwxKN8UKyCQrD+wZMQ5+zKMMofFHDjZ3KwoquaMJOLDnDIsMEQrTgPEI7z19CGu0Fw2nQvcGtqxvCpjgdw/W1gUEiK4BCGi0vw/tEKkNu3AjDa2YCw8ioPsO2BYxCUUAPw/pQRkMaHHpDfFHpwrq9N8MULwXD3u4fw7vZCkOM+4lCvrhxQ1bnAsMuKufCcoa4whxodUOwZirDHJcwwzJkRsNIXTbCvqWKQhUmC8OkkYFDJnK6QnRjUcJSj0NDgtdbQvhK88L3+5PBeoMXwzrm10HspRrDDuUlw96UH8MjNoZDyHUHQ9YuKEPfyA3DeXGBQnYrKMPOxxLDOOnzwq5cwsKc54NCKm+CQko448IEyjdC8JhVwkT0psIXkTjD/NeywoFRLEN8NQ/CHEqvws4/LkMGvDLD1d17QoMUjkJx2EXD0V4+w0q2eUIG+UXD68gYw374y0KRWZFCikqGQyg/McA=", + "encoding": "base64", + "path": [ + "vy", + 49, + "data" + ] + }, + { + "data": "0pQDQ0zgEUNcFBxDTxIhQ7mmJkMKqx5D5dwGQyq5J0OrMRFDDqEnQ2cWPkPwFS9DWCk8Q/7QHEN67BlDq8YpQ1uzKkOgUCVDzQkbQ89rJEPZbSxDUQMWQ6xdHUPiCi1D/g8eQxiTF0M7BhtDFh0kQ5MSEUNM1BBDy7kgQzWYLkNQkA5D75IjQ7FBEkNrmRpDNgwVQ62gHUMFERlDTkQTQ4SzMEMJLzdDKy0kQ+EqJ0O/fTBDDAEaQ0DSBUOO/xhDHl79QrWVN0MaAitDxK4iQ4WhOENPIwZDy7smQ4h/DkOmQh5DtZs2QwxAG0P6pRRDhhceQ97IAEPvRhpDadwrQ06EKUP8cixDJ38lQ1ekGkMC4RFDr9wjQyT3N0MpSSND3zMFQ/KfIUPagSpD7lE8Q61HEEP2eyFDnqk+Q9kbGUMp7DZDoQwSQxz9MkM+wiBDa1X/QjOmJkMysylD2EglQ80vG0OfdRxDKlEQQ3yjCkONrTJDKlodQw6PAUMcIylDiIktQ8uwB0MI5i1DXZAgQyg5IkPBzhhDGCQ1Q6qoQ0PyDi9DFF02Q4KnIUPK7iBDxComQ5tcIUN9ERFDHiEFQ1NBNENxVSZDpDIxQ7LSJkMIESRDnFIEQ2GYG0PSAexC22kZQ/g9PkMgjxFDacQcQwLjDkM82S1DPUg3Q1n8IUPk3RhD2uwKQ8JFN0OBo/NCrJcPQ/66AEPoyyVDcskIQ6ulHEN3YwlDGo4EQ6ovMUM/GSNDxkEYQzeaN0PsVQlDOnIRQ0FlEENKtwRDEx0fQ7SJNUMRkQhDPAwNQ9mtGkPp6C1DlZgdQw9SHEM7nSBDdlQMQ8joK0MyuA5DL6UZQ8jJ2ELTzC1Dg1TvQulwNkPOjv9Cd0ZLQxeyMEPx4jBDKaUJQ+jmMUPQ6ThDj6MZQ2utGkPljxtD1u1LQ3LMLkMNzi9DWCQuQzeuHENERCNDxXUgQ1jWL0NKIBhD+ugXQwAvO0PnZBdDWCMSQxhKE0PjwjRD05ExQ7cNIENL8ixDo4oTQzbdG0MQHRBD02QOQ4H7HUO4kQ1DyWI3Q+a7M0M=", + "encoding": "base64", + "path": [ + "vz", + 0, + "data" + ] + }, + { + "data": "htXOQqY95ULQcxVDinAhQ+RdF0OEXexCCPP2Qn6+DENKFhxDF8kmQ7ZDGkMKXC5D3HQsQ5rHEUO36/1C5NgZQ2K7CUNx+gNDM5cfQ5ZwLEO0JQdDLJAVQ8OS/UJXDCxDNBEQQ4QW40K+VAtDzAMHQ0F0AEPz/OFC60MOQ+ABDUM+fehCP8UfQ0617UK0tCdDTkcGQ2loBkMJJiVDVDYfQ+1rIENlcBpDlpYYQ0hs90Jm6hBD5DQRQwUg6UJcjh1DZ7YBQ49jJkPA9PdCmEPpQkCjGUOXcAlDzVXxQhHVxkJmxO5C44ohQ8Lo10KeA+xCFe7iQs1qq0J2KP9CEAAlQ1bjB0P0uhVDMDr1Qjp5A0Py8PBCoC0hQ94yFUOS7RVDUSHEQkaxAkNgSihDeN0tQ/QiGEMytyNDi58TQ8eKFEPKCSxDxMgWQ+mpHkMXLgRDcYHDQh/2MkOHqCtDEq0iQ3IeFEOoQRxD4GPiQkEDA0M49BFDU8kFQ+c32kJ/tBtDEH8BQ4iS+EKiPRhD6jYZQ8WqGUPeQhVDXpkJQ/AaIUPKZClDkWoVQ0xBEUOgXvtCfTsFQzTPG0OsMRxDSGvdQsz/HkO2LhND7vgLQ8Z8BUPI/ghDWowBQ3bCJEMskedCb4cOQ6UIIkNCiepCzK77QkKeGkMnrSlDmoMSQ8TY7EI8yBZDXmD/QijRIUPYtANDLZrUQpCzBkNcnC9DSojzQqhFEkPAgw1DyHrRQpv5JEOaAvVCpCf5QqDiIkPMWgxDQ/8dQy4I7kIuGghDMNb/QqiWJUOkiQZDVgEEQ/BWEEOXfxBDgIUVQ2zoCUPcmhtDoDYCQ0s9I0O1hPRCitwjQ11y2kKofApDyNPxQrGfE0MEsvpCYvwjQ+u5I0M/2AlDWOzbQmpkBUMoHxdDRnLyQqBQBUPJ0vVCZCNOQ0ikGEPk3CJD3OwlQ/p6EUMmzQVDEkMcQ/aAPUOaZNZCFrccQ9DOHkMNzvJCyCjzQhom80LxMTBDxPAsQyDKJEOrIzJD/fT3QghpHkNkagJDt9oUQ9nCBENmee1CJ/QgQyLuFkM=", + "encoding": "base64", + "path": [ + "vz", + 1, + "data" + ] + }, + { + "data": "fpLNQvm5ukL+BgFDp48LQ8jZ2kISzbRCwkPXQoTAsELMLg5DM4sFQ+bD10JTBwFDgYsAQykY70K+ua9CvBbkQt5OxkLKCLNCl0wFQ6xKFkPUlbdCUK8GQ1CNqUIXDhJD3hDvQgokrkJKEO1CLLrFQnbm2UICi9tCVL/MQsBgyELRa6tC+h7zQkc+sUKA6xhDz+nVQvMUx0IIgiBD4KQMQ5r2xkKuouVCdLb1QvYXfULLXdVCrQr5QmYzvEJO2ApD5KLTQsBG2EIm/6FCVmytQnBVzEKeLA1DZHyHQippf0K6wsVCcm70QsyDlkKzt65CXG2VQpykkULUd9hCWPgEQz3xwUJgaMlCUqWXQgQO00LY48lCWa7mQs7C1kLk4vNCHpmsQrz7rULQvAlDhivjQihqCEOGdxJDwynGQlGMB0PAjO1CwngAQ75EwkLAFMFCzkaxQrywEUPmyAZD+pgOQ6B79ELj7P1CAA6VQuKR5EIopdZC5x7TQhjC2kIuE99C+q+UQmtY10J7Sr9CbOgCQxlA7kICkA5DjtemQixp50JOzhBD+aqvQmrE5EL4BbNC5lu0QpLKAkO6BhlD4KzBQnDV6ELcDNZCaxOqQkRWukKfhsRCjOruQrhgDUO+kNtCOGXwQqkf7kIam8xCQh/AQnrbEUNbcg5DNZq/QgNSuUKpDQBDi34AQ9s95ELdJgJDDiGYQsZ96UJusB5DNnfKQnxl7ULSrPRCBHbCQvXr3UJDBp1CSvC4QvQo30IW4AxDV4AOQ/MD10IaCQVDhH7MQt5z0ELqiedCv87ZQuV/30KZRcZCyowAQywfz0KwPfJCGCTtQjYg90K2B/VCKmILQ64Nu0IpPqVCMjfQQgGG3UKdU/JCg+bhQiSJ+0IY8qhCvva4QvjUrUJAtLtCBfeeQs7oyUKOJ7BCS7sUQw4y7kISIQZDwoL4QnAT1UKQKtRCM2btQqI7IEMGualCsssNQ9ze1UKaU8FC4FCyQn5Cx0IvLQtDM7gUQ802AkOXchRD6mqsQr+aDEPMYcRCkGQDQ3CXxkITft1COR7KQoAT2EI=", + "encoding": "base64", + "path": [ + "vz", + 2, + "data" + ] + }, + { + "data": "CZWjQh6tdkJi8qNCzwubQk8pckKa4GZCz0emQlJ4PELn/5RCxAybQpj4VEJM6Y9Ch9yMQiI+kEIA+QVCgkNkQr74WkKDgRZCahGsQk5/oEKDx4ZCIlfQQqAtHEJCxsJCzJSqQtfui0L+tKJCWGp/QrDdt0LSaLZCtPs0QoZZW0JiOjxCiPh4Qi5VVEKE9gRDEKiBQjigU0LC3ehCwRGSQjREN0Jqmn1CdTGKQvgZGUIUz3FCd9u7QtaKfkI4UehC4HRsQnTrH0LLYolCvwGRQnB75UHSKcJC2GlaQoLXLEISOKhCdFd6QjLPgEL/jFlCaUhfQiciQEIkWZ1C9uVyQqjNZEIyyltCOqdiQuqZlUKgInpCiitWQn41bEJzmp5CzIB6QmrEyUF42q9CdzVCQkaF2ULe46JCxjEjQuRDo0KEkHVCBJauQojVNEKotmZCtqaFQskopEJPBpZCWmreQgsDpULuZ5tCtFsKQtJ4qkKTtXVCtuqDQmDDrUI2ClZCWBhSQulMoEKu40ZCAhGXQtwWckJktbdCPNpVQjpcbEIkEtVCWNpEQmmPi0I0qTtCsP0aQuL5t0IwGOpCfFeTQvzUNUJa7mlCHfEVQkxeY0Ku2U5CUtGqQoukqkJEUqxCWBWuQoLOekJd2JFCbeZyQvEp6kJauMVCYsfHQUcYokLmY5tClfy7QmsUgEI8WuBC+B9vQtLmpEKMAtdCeMWVQtS3hkLMsaxCF5qTQvSZRkIuP29CpFxjQt4hHEKKBbRCHiuNQv60o0LLm8ZC1BGYQhxuH0LK9LBC0UKQQl7MdULebm9CxOGcQth0XUIkE3RC8jGzQpGMjEJk3LhCDPK7QkBnbELGA7tBuB6TQiz2iULY9MJCNihbQrJKdUJKkipCTD14QorpNUJPuT1CxmHnQbhve0Kq3UFCk+q6QtBwlEKzgrhCOm2IQn4XM0KmU45CqDlsQu4QzkLGp49ChAfpQv1wH0Liv3hC4mBkQtj1g0KEhY5CiBDWQhMJiEKeEKpCJAP6Qc4i3EJQK0BCahrFQpZwbUJOML1CJewmQvgxUkI=", + "encoding": "base64", + "path": [ + "vz", + 3, + "data" + ] + }, + { + "data": "mJIXQgJk5UDqXStBE9nxQEKBlUC6nhdB6j4PQo/9I8EoYBzBVKPzQDeFhcHXT6K/x3Qmwe9Av0DXiUHCRSaRwJAQDcCamtLB0EliQYLEpL9Mxr9B26XrQduDiMEEg9pBAsgTQqgTCEI43XhBrYQ0QZqF8UFYWsxBiH4XwpTd7MDI+ULBtjIYwX0NH0Bu52NCAHtvQKpdLMG2LwlCSFT7wHgBs0BWOObAQ7wPwEQOfz+Ik5694CfwQXaPp0FfxDtCvmqdwbgrL8GEZQBCgHsLQnDU58GbWCJBaYl6Qept3b+sytJBiPnEwawUy0GK831BOmCeQRqyE8CE045B2OdVwRu0gz9IvOJAGZ2LQaTvekGcuxbAkeMzwOLXwT78LHxBeE3qQMzT78FBIWJBDB6/wRKsCkJdLUlADyzQweBMxUDMMTvBsBmnQYKmZT++mK1AfEh7QTwVA0BabwRBTKaDQjr6ekEYfxpBePpRwawi40F45yK/fGkWQck/6EGI3jy/YvWCQUZh8kFRYpNA4JNHQGMJucBwTZVBivCLQWpWbsEk9U5CvTBTQfUq+kDCyZnB1PVswQJ4CULH+QBCoIjYQUi0sMGha3u/5lc7wQZWk0Bw3QrBFi7aQcgooED2uBBCWk4WQlw5icEmyLpB2pEeQUC3/EG2ggxCHnHYwWs87kFmoeFAPMO+QTTHe76G8vFBVJCnQR665EEaAAdCYZ4cQgFJZL+XGvZBwPjDQUfCgsFFF6hBwjYPQcaHi8EXLpZAaIKGwYIb00GQc7ZBtlavQewU0MAOJUBCLCiXQVlEV8E7Jz1Byxm0QKnUNsEkt63A3vCPQSh+5j8g5zFB8v3oQe+LhsD0PsjBu1KzQdI0fUF/qgxCZhhjwcvrysF9l/nAGR1EQWCItECwD67AbLLswUJlNEFOkibAep7uQamZREEiaQ9CDIUKQTq7SML1X65BiWVNwFzlDUK0NQ1CXNsVQkSYlsFiFidBXUoQQZzEUkHwACxAOB03Qgv0eMGdo/tArLNcwp4AP0JSPfzB98TRQZI7RUG6rQxCHKp9wF5QpME=", + "encoding": "base64", + "path": [ + "vz", + 4, + "data" + ] + }, + { + "data": "e7xcwvCFmMIi+6HCVzCbwnR+isIsdHjCuqRkwtp/wcK6z8vCsZ2rwuQzwcIPosLCfFvgwkCFn8IjACrDWDCewl5coMK7QL7C6Rylwu3oscL/xoHC/BCCwlYXu8Jekk7CqBjlwav+QcKidJnCJw2FwlTtgcLeMaTCWqsVw8Z0r8J32dXCrA6jwqj7lMLAbgnCfMCTwlnVt8JZ8knCfSy5wiypWcKMeMvCsCmhwklYhsL0nqDCYJFOwpaAJcI1mDLCDKAJw6xZlMLUrlrCS9hcwm47y8JiT77CZxxbwtD7nsIG5JnCkMjswkdcRMLFhUjCqr8ywkrQr8KgFJ7Co4nTwtz9mMIu6HzCxTJRwpPKicJLhcPCwo2HwuAMjcL4zofC4E2lwsrW3sJ2GKfCmFisworxdcLMYrfC2TywwoDIuMJuocnChHCHwi6+aMJ4NpjCOQqNwu8eycK6ppbCUj3CQP5lnsIGPJXCqvm8whY9fcLRGKXCYjN/wq8ffMKYH4rCOqszwunOYMKK+mLCFy2vwkSup8JQwZrCEh9dwgb3zcK2PZDB+PpMwqq1nMKWC/TCB++fwrorMcIxbHPCkB47wuApvcKMFaHC+HGkwqRtjsICvMDC5LpPwpp6uML60kbCINQDwrg878KIEFHC64mFwqZYe8Le3jbCnpO+wo1gi8ICwJfC7CidwrZJrcImZYvCGA5AwnN3WsL+1ELCUusxwvbHqMKTLWfCenBcwsiIyMLg6kfC8uh6wiSPrMICgsjCmBTFwvDhacISy6PCMpOPwvSjg8JTxSDCbHlWwnq+5sJWR4vCsU6qwq5nwMJgdprCEuGfwsm8q8KucMDCmBNfwsEg3sIwls/CZshxwiYBWMK2DYbCAhHCwjEf0ML436LCGJ5uwho0gMK36JnCgubSwj40lcL8z5PCTocvwq4Hi8IllQLCs1iNwponJ8NhBkHCmwqQwgQVJ8Ikhz/CLBlUwqhTrcIewXDCku53wm0MfMKuhZHCp+z1wfJgwMIHIaDC8uY6wwCyOMLE9xfDzkCRwqi+ksJ0I2XClkiCwrLv3sI=", + "encoding": "base64", + "path": [ + "vz", + 5, + "data" + ] + }, + { + "data": "d/4vwyCRM8PJpkHD3JY3wzytJMMMKyLDWNktw8gMT8Mf4TPDAp1Lw7krMMOPmEjD9gtNw3j8L8MUsIvDtg8iw/NzOsNYIE7DhuM9w9poN8O6CTbDNzUpwwZaOsMpKATDAG7iwgptKMOHm0DDBmgow01cNMOT7EfDm/x9w4hALMMfPGzD6GMswwRBM8OkGf/CCCYfw9ytNMPJ5grDBKsyw5Z1HMOqr1LDtOsnwzexGMP90zfDaiwWw7SGCcMivRHDphp3w4DeIMOycjHDnfAvw/bTScOK11HDOzQUw2lzLcOYD0TDPepRw56nHcOA1A3D3JwQw8g4TcNk5z3DKOtQw5FMHMPGlCPD3HQbw9N0NsOSn0/DYewhwxzHGsO6CTLD4Pgzw8ync8M+4DjDO84ow5aCI8MZakXDgKo9w64MR8Mw1jnDapAiw/AVHcOgwDvDEYElw2SsWMP17DXDMDKFwhgAQcPuIDDDJkhjw+huLMNywjjDvoEiw0IGOsPWQSHDu/EWw3J5GsOQvhzDvds4wzwwLMOCZkHDoSMjw94cScOqWMfCXlYdw1HbNsPkf3rD1qFAw+KUCsP7cCHDvnEPw8q6N8NFTSHDGj4qwxGAHsOUbFjDWO8YwygrQcOV3iTDalz8wpvjXMMZzSDDdhopw4bxJ8M6uQnDSkM8w0BaQsPv4i/D7uE+w0MLPcMy+zLDqoYNwwa8HMMwIgTDSL8Zw+hRLcPEQzLD0owlwxzxQcM+vSPDbfoXw2hpK8P6YErDYsYswyybL8P8OEbDaL40w3KaG8Oy3ArDl48Ww044XcNG3CvD6OAywyRaOMNFICvDXkhEwwaZOsOpxkHDNLoYwz7JasPoTVPDQJUlw+DFEcMCQy/D3shFw/4hOsNYATTD8DQOw0gCHcOuySfDPjpWw5BCQ8MSdSfDVG/8wtWjL8MDjtjCxaEww8Rad8PSZxHDoo8nw75O98Lm+yfDekYbw8WjK8NEoxnDHcsZw775H8Oc4x3DTNzlwuYPPMPc6jbDlB6Cw6TfD8OIpobDHmA5w55sO8NkPyjDwOEWw5SfWsM=", + "encoding": "base64", + "path": [ + "vz", + 6, + "data" + ] + }, + { + "data": "Mw+MwygRd8Miu4fDWEaNw6S6gMOu6HjDNlqLwxQEdMNyLGnDi9uJw+b/asOVFYTD+Np/wzxheMOuZkfDJK1zw8p/isM+H4jDdCuGw8AwhMPJLIjDSnp7w4kJZsNRyEbDdhJMw1AuhsNzGYfDokaDw8X2jMPF5IXDR5dLw2Q1Z8P+CWbDhqR6w/P8csOWp07Dzidmw53WZcMIGVnD4mZuw60wgcPhHonD9Npww3GmV8OWkYzD9G12w4FAVMM2om7DoBtfw5OaZsMWQIfDWOuMwzTubsNOeITDUIR6w/CtWMPIm4XDOGCAw7w4g8NsDFnD5sNzwwtpY8PSLYLD4v9+w/PkXsPUVYLDPAiAw8YFicNCe3bDUjZ+w8rObcPvz4vD/RVkw4DffsOkA4LDFo1jwyEjgcPKg4PDbI6Ew8xOhsP9+nvDTH91w+BNf8OaJILDje5gwxO6i8P2Wo/D0IQQw7DBjcNAJojDQiFywyRphcOIEn/DvnKBw/hkjcMep3fDiKB0w6CEacM3xYHD+3F8wzwYesNrGo3DGsWFwwiOjMMTRjXDfoaDw7ytfMNoNmvDkn+Iw7anYMOc/HvDGoNlwxY5c8NVAWjDWxlew9d8YsNpcYPDwON7w+4kiMPa9HvD6Slbw9s0isPHxXvDvCR1wzO2hMOEmV/D3o5pwwyLi8OxV4fDdn6Gw8I1hcPws4rDfHNxw/fGbsNJokfDUpBwwxk8dMMdFInDo4CDw/SOcMO/h4DDItNhw379XcOqcnzDKHFkw1ycicOAcI7DZyCGw/rwcsPHl17Dsrxjw4ydbsPsgIDDDFB7w5oMX8PkRnzD9iCGw7oEgcOcUXfDjE9pw8xLV8PK5GnDVs9vwyLsc8PWXoHDR2uEw1Ymb8N6eW3Duz5gw/8ja8O+xmrDvEmDwwwTjcM/JnLD8GRPw0WZisPAFTLDIN2Kw8IdQcPmqXbDdlR7w1bJRcNXR4DD0853w5jVX8MZTnTDfHFxw1buecM5bW3DDPU8w8olesPdcYrDejsywyJlV8OEV03DKWOOw32wh8MScn/Dojt1w/j/g8M=", + "encoding": "base64", + "path": [ + "vz", + 7, + "data" + ] + }, + { + "data": "rl52w5JfMsMwd1vDzOxtwxkcaMNOelrDKLB7wxRpLsPY/j/DKgZjwwUJRcPSm0/DXKs3w7YGXcOmngDDxGxTw2ScasMlLUfDe6Jzw2R0YcM4YF3DzvZ4wzsrHcMYgmbDrhWAw0oVecMMh2LDaBVhw2SdfcPIw0vDXh4Fw0hSOMORiBbDgSxNw7D5R8OT53bDyKRDwyu4H8Od4HjDd4RNw4iWdcOCO1jDTqpiw5BLRcMWn4PD3EOAwxYMWMPMWYHD4Mgjw1w2VsPSX3PDJ3t0w5WNKMMg5UXD6Kpqw/HdGcN7fUzDODw6w+DfcMNPoljDkettw4V7I8NeJk/D7ek5wwMdS8P6oGjDxixvw0SwYMME5DHDQpRmw9rDd8MJHnXDsUwhww7ULMPCJHDDQ+Y/w36SgMOWuE3DPg07wxUPTsOSlDbDGN1bw0CLbcOob0zDars9wwp3T8M4Y37DX45Nw4QMXsPCQWLDzN0aw08xbcNxKkvDVIlqw1OpZsO0ZmbDxlpvw2gIZMP+CHLDMANKw8AFRcOEWXvDUKVsw4hNWsNkumzDmdF5w9zaWcP+IiDDuJFEw9o8fMPC7YLDfBxmw2I3MMPq4VPDphoxw9HzTsPtsjXDiL94wwD3WMMOu2vDLq19w+a0SsPhHnDDZhldw8JOh8NS3oHDWWklw7KHUsMqdmrDAH9ww0NwVMMDIofDUghtw+BnZcNi4WnD/GZww42aTsPFtW7DxMNuw4BdKsMdGG/D90NYwy9GNMOuKTvDQMRDw+MXfcOSmlzDaNJfwwpaZcNORm7DMihew1pnK8MFy1zDCxZaw6yWGsN051HDa1BYwxbAXsMjgUHDjj96w4pAF8O4TSrDeCE/w4D6gsMKiXjDpBRLwx5TLcNtaS7DPC5Qw+lKZMPSgkvDIqtFwzxTTcOJ9i7DXrGCw741g8M8OF7D+ht5wySYB8NN433D3KBgw7AjdMNJmXLDkn+Cw2A9NcMjaVbDDbNPw3P/YMP6gmfDNzNowzp+M8OWXHnDFrDawqg4asMjEAjDXt1qw1SRT8NuCXvDImNow06mMMM=", + "encoding": "base64", + "path": [ + "vz", + 8, + "data" + ] + }, + { + "data": "+2Yvw0794sKe5yXDbBsvw+scLMPGmC/D24I6w9R12cKf0B/Dykcrw7SMH8PmqBPD3BQFw6SPL8M8M3/CYgwiw/rFPMO6zQfDRMlDwy5tKcMI4BnDZBFQw/LLtsKiCkzDTuJaw6E9R8Os4yrD7bomw171Q8MO4RHDzKeEwvVBC8P4dKDCWCYjwy9QHcP4pljDcvYOw/85u8LICVTDwsonw0xVOMNbhx7DGJM1w7tLJcMyqFTDpqZewwFUNMOmDVbDGoTRwvbCMsOgyS3DOsAow2Zfz8JG+A3DNSA3w1734cJVSRXD+4HwwupBNMMNcTPDDgJFw50p0sJufRvDU67vwgEDJMOcXivDJKM9w0Q+IcP8k9/CwlUuw6amTcNC4DzDTFLswiotz8JunEDDzPAaw566WMOy0hDDkmPpwnDQDMNQr9nC/CIiw0FmNcNH8BbDRugSw9j7CcPaWEnDJqNrwwg0HMOmWyTDViKlwjRIMMMAXxbDyGwyw4cKJcP/VDXDLc5Hw9zXOMPmJTXDXFsMw/SbDcMuJEfD6pwswz51FMPoxWnDpHE2wxQeLcNFTbjC3NwAw0h7WcMbxlvD+68/w1Y1+cK5+jXD3K4Jw5oIKMNQINjC2vFIw0BIGsMSnzzDPmBaw0D8CMPtLUnD+KU0wwqCYcOaml/DMpfSwoITEMOugC/DWto8w8vHFsOGkkvDgJFCw6zHO8OcE1LDBgpIw+QJKsMaRzHD7Z1Bw36Z0cJFoULDQCEywwhlFsN3lhHDYtclw6lxR8NHmRrDO7UfwwkPNsO+tEXDANw1w6b00cLevyXDzOohw5wNuMKtcCXDGIgfw9ulMsOFVR7D3u5Ww2iAuMJ41NTC0DYKw7VvXcNubkvDCTcaw49P6MKE7wPDHkkhwyDbOcNqQCHDHRoNw6iZBsN/UN3ClJxow2q3S8OXxFTDZudIw631mcI7m1jD9Awtw+4/X8PS2EPDIJtbw3llEsOVCh3DVmoew5QRMcNwuUDDRBpfw6iOCsNCzDrDs7o4wsBuT8MInY/C7rUow7BVDcMkkFTDohM6w35zv8I=", + "encoding": "base64", + "path": [ + "vz", + 9, + "data" + ] + }, + { + "data": "FEjowvMoRcLm6+bCktLiwvD42sKsrAbDmfD+whi6RsKKzvXCvk7nwj03+8KOM8HCEFC9wsmR+sJmGqy/jn/pwkrGEsO265zCzGUSw+V06sIU4M7C/Loiwzm488GPICvD/hsyw7yjE8Ou9OLCeZ/bwtNsC8NgLNTCKqmhv6pqucIG+GPBjR7wwkOh5MKqhjLD5ki3wsoR6cE2eSnDzDUAwy825cKiTtTCAtYBw67W9sKGjCXD45Isw4blC8PiWCXDsAE1wmHQAsNSf9nCS7DPwrInMcJSCs/CZWbxwjCOiMI+edrCD11wwiYt48LahgrDcmsTwxiYV8JOvuHCOLFmwlLR9cL8a9zCSUv7wlzDysK7ikbCcdnhwtVEI8O++gvDBIuGwhvQIsKvOw/DV83mwjTKGcOcrqzCqD9Rwt9uvsJwCw3CWv/Pwp5W68JKk8vCxai2wl7OrcJaQBnD0ilRw9IDwMJA1tbCoK+Jwerr6cJ8gMrCjLLvwiqxy8KK1/LCF28Kw7zjDcOYW+jCmryawui9ucI1ZRTD6j3Uwq0PxsImrEfDHiTiwj98AMOyEt3BCxOGwui+MsN4LifDymIVwwp6ncI0RgnD4grBwjbD/cKQlxvCNjsTwzKpz8JZswnD6cYzw3TNmsKSfCHDAtQKwwe3JMPk8DbDAM5IwpQnx8JggeLC6tMFw0Ouw8KSSRLDrFQSw745E8O+oDLDBnIYwzC0/MKmUdnCRKAUww6YJsLgQxPDsLIIw+0k3cKwUN7CHKQFw8QaEsPUCsPClgnRwoxa8cKYjRzD0CoLw2B4I8Ke9OPCLJTUwocm/8GcP/DC+0bUwjgzCMPM7vjCXtIvw7w/D8KiSFnC3lanwrA1McPtpBPDKEzdwiisdMKy+bXC2IHewnkQAsPK7O3CvO60woWsicIkBkHCDhE8w/20FMNurDXDNvMcw6YIj8HpbCvDyEDkwhATOcMH3gzDuVkrw8iX1MKmXsTCtjDgwq5N9MKuyxrDWHhCw3zhy8IGDAPDaCBzQdYcMMPTYBfBukTnwkI3sMIGSyzD6hX2wnANncE=", + "encoding": "base64", + "path": [ + "vz", + 10, + "data" + ] + }, + { + "data": "W+h7wr7SlkHY1oTCxNZWwrCoVsLMx77CmJeWwsSo/UD0uanCQPxtwr0Yn8JKJlnCVM9Vwixai8KMzHhCrA6UwglF1sI0ML/BjFPFwt6vhMIQ0nHCIpLowkJl6EG8ggfDBmkIw+e5w8Jx21LCFxxlwlsmrcLyfYXCYQ+DQhKkLcJz0E9CaJiOwpC3i8K6owjDTsYlwk2UEEJGk/nCmT6Zwu2mT8JWkGDC4bybwhrxlsJIU/XC1lntwooAwcLse+HCYK9IQU6wkMJK2kvCaDJFwgIJcEFmRYbCoPx5whpRccF0b47CXJLRv76FW8IW/77C3p24wv4v4cAAwInCbJuvQJDFocICMVbC8Kd8wpZSQ8LwH2BBzsFcwoaF6sLiVL3C7pYIwarpoEEJZrvCwgaYwmYmzMIch+fBRtIfQZLGWcJNBCBCRotAwv7bUcK4mU7CDgD7wYtyM8K0rNnCTGwvw344IcJGIVjCEOs5QlHGbsJyvEXCBZ2BwryKKMIJKnrCIA2XwjGaucIudVjCLEJJwRzdN8I3IcrCzopDwpQHW8KsMyHDJqdKwlATqMLaZxRCs+btwDxxCsP4L9vCTJnPwpJSBcLmRqXCwOdRwmyIqMLGG/BBRPy3woIEaMLgi6jC6lIMw8YNr8G+V/XC85TAwi8q48IkQgvDo2rNQHPWesIyBkPClq6fwn1OSsJ8BsDCXie+wo4LucLa6w/D1e3KwkgrmcKB7EzC9uvQwjAVwEHlW8fC6u65wqbEfcLCCovCrsizwigDwMJuNkTCUkNmwkDbY8JOpOXCbGm8wvPFxUH4dYLCpEZVwviL60Emzo3CvCpiwkTRvsIN1qDCErkHw4SEpUHKolHBYBi+wWzuAcNGmrfCJKOIwrBUgcDouUDCc8FqwgBMk8LaPJjCDBQxwvaHjcBa8H5BEJsMw1jpxsK9lRLD5zXowohTKUL65/7CvulkwpaDDsNGh6fC4THxwvowdsKQBRjCeP+GwhTtiMKUF9TCcMwhw/4SacIs0qfCvjmdQjq1DsNBiVlCHJCEwperEcKCtwTDjW50wjDXXkI=", + "encoding": "base64", + "path": [ + "vz", + 11, + "data" + ] + }, + { + "data": "pdQ8wRKKv0LYA4vBHvOUQDJGWMDfqWPC93jXwWoUjUIcqwrCjk8qwALF58HzOhHBmC7YwI4PKcFulwNDQNDVwVqJicIxdvNB1mNTwpLoVcEy/5DBCDmLwgPis0IIusTCoLy7wgovScJbdWxAuGPqwG7jE8IY37/BKGYKQ8F150DQ3fZCeLGTwdtLt8GKTrjCfDoRQVyF0UJ/eZ3CPkilwTR61UB8GsjAuuzLwQ09wcFaPqXCRCmMwkIeSMKYXmzCHkOTQs5kU8F4UFBATO49Pyi3nUIvxbfBd5chwYrNOUJ0qdXBnrtvQhA1bMAcYz7CJvwWwsIZNEL8zavBNg6UQsEJEsIV6RfA9mCwwPFgm7/thKhCzM1NwIBykcK4HEzCwUhnQnZ5pUIWiTXCQFkYwjioXsJ8QO1BHNqTQrECJcFBoO9ClmjBQISKzECcz64/eD8AQjq5RcDCLoXC3UUKwyqxb0H7NBDA5HniQoUkLMD4rpdAc4cpwXHFo0DhUz/AJmCXwf4wFsKuqJ5AFq1fQobjNUBeDWLCSbdCv2rCMcE4wfDCjLeaQP5cHcIoQ9VCPpdVQgR7w8K+uGjCp/Ncwmi6YEEky9DBYPWOwKq6H8Jyh85C/BAZwnZ/RMFsTePB9rfJwlVv9kGzhKnC+u5SwrldhsIVlrvCu6qIQoS1w8FunQxBfI3fwVSUib4SCkbConctwmNMJMLgf9bCJA5FwtphqcGzJPQ/zZhywtLsv0IikVHC86s5wuTIO8FkjL/B+QrvwYLEPsJoWxnBib0+wUB6Fjz8BWPC8q8zwvC6wELPlIPBvAQHwCaau0I44IPBsXMPwfzUXsLQktHBYqe+wnCHo0LefxhCOqssQvVGq8JxlRvC1gjOwRfGaEKcChjAlC1CwHy9icEkA/3B1lsSP50xekLGvKtCuTy3wmQBUMIzvtrCzGKawnrj20KdCazCLhyvwGidwsIO1PHBWpOOwsRxRsEhIMlBMz23wSqwccHTwG3C9Jn9wgzYHcF+tiHCyqIVQ3/S18KBiflCIrWKwcFOj0G6OrzCQeIPwDKABkM=", + "encoding": "base64", + "path": [ + "vz", + 12, + "data" + ] + }, + { + "data": "NvcfQkDpPUOJigNCBFR3QuTgKULvA5PB9pWgQS98D0Ng0+BBfwpQQo3KukFwoxhCyM86QgYVQkIiLVZDkGjbQab19cG0Ca9COlkDwT4WNkJctuZBWsG0wfn/GkNq1W/C7I1MwhoWhsA+MFdCaHkvQqipKUFCELhBRo5eQyY3bkIkkk9Dj+QbQnsy30FGvzXC8ht3Qs4nM0P+rv3B/NkUQhiSakLIIC5CQMnmQeJm70GKETHCnmS/wW8HMT8F9tbAx1ERQ9/dMkIcKk5C0lxFQgZmGEOuAtRB2pYoQnre7kL8B+JBzBIBQ7g2O0Kd1SFBIuB7QTiu1UKYOgBC8jgZQ4y3hUGYZi9CQmpQQnqTQEKnmydDuNkxQux688FinvbARscGQ6pHGEOueZw/5NJHQf4yOsEqCLhCYMYPQ5aWE0JhfE5DOH9vQvmoY0I5r2pClNjHQsxlJ0LEYcrBSQLGwpiJk0KB1kZCo3c9Q4COYEIoKHdCQXo3QsywUUIOJV9CDCYPQrIxZEEdUGpC9voCQyNyX0JsNFrBWKE6QlgPB0J+uZvC2m1fQlT0xkDfvjtD7WXvQhDzY8JtGyvBSj6xwIPQg0LFGwBCG3RFQn4k2ECBNztD8MhgQZ0kEEKwM9lBknB1wsa5qEL0KT3C+tTuwProucEa+kDC/mUMQzBNqkEys3JCRne1QRBBWUIMVJ7A9G//QK5e9kCe8YnCXJBhQP4KLEKVdmRC0IGDwUJbM0P+XKDAYrhSQExLLkK0pcFB5toKQprStz5RAQZC/GYJQpCcTUK2RjLA59HBQB2oM0OdGg1ChhlDQlwwI0NbCSVCmFkhQp9Hg8HSdBVCi0FawvHPGUOhM8ZCugDzQuBCLsIlPkVB/7CRQf/XAUOLgj9CXoJjQinbJkKKxn9B/vw8QiQmCUP2YydDSWYmwsIzi8CTQI3CSvYcwqrhP0ONqTjCaQssQmYJSMLChaFBqm68wQ9rJUKmPbxComS8QVaHIkLSzXDBdRG0wsVdLULs68A/TJZtQztzj8KosFFD3v0EQhbcm0LNc2DCwp5eQpACXUM=", + "encoding": "base64", + "path": [ + "vz", + 13, + "data" + ] + }, + { + "data": "6Ci9QjLfmUP02KpCHOXjQvMfsUKcNqlBKPWGQsbkbEOUdL1C8pLSQpK6nEI25a9CacXYQlQB2UJayZdDyhmvQhJQ+kDsVxhDKooQQvEF2EJgCa1CJD7KQUaeYUNjZ6HB938DwUy1JUK3LNFCJDTFQvvrZUJADKZCGxqFQ6dr5UJHHZFDdoLHQsbwqELGLmNADBnuQuXbc0PzmH9B1dvHQuspzEIo18BCx/2tQiawsEJGgtXAkVirQU5GYkKMYzJCGBxuQ6hh0ELeo8JCgqm+Qkz4c0OYQ6NCVjHEQibFUUPIr7lC0nhUQwQRyUIkp4dCvK6LQs+KOkPEVLxC/Dp7Q6jClUIyR7dCGAbhQkjqy0KyP4lDS5i6QoDQJkEk/RFCSkViQ3WxbUMuRDtCSjKaQpD1/EE9BCFDXnVhQ2T8sELBgYFD5K3lQoa7zULc3vNC5HItQ8bduUJOloBBxPlnwoKnDEOuAs5CxnSNQ/Zz7kLan/VC0HbWQoaV0EIgctVCENK1QjxqgUK6YdFCGMZXQzhw50KFmORBFJ2/QtUQo0LWWAfCzvzOQjx/VUJqeZFDIiFGQ07pfcF0mwtCqNYyQjDv+0J4XrpC9l/eQokKYkKQ8JBDhj6GQpQes0JE7aBCyNOqwdCEEUM0fRrBCO0hQklJnUFA+iTAQFxnQyNEn0KcSONC/lqSQjU450LSCBxCKGhwQrRcXkI+HujBxhJkQhJB3kLWF+xCKJjoQRBKikMmzCxC6XhdQoilzUJk8Z5CtNjLQrHvRUKwUaZCmbusQr4Cx0KcTEJCrhdiQr4JjEMG6bxCycfJQsb9a0OM28lCzIK7QiSpuUF2h9FC2mhQwVLceENiQTBDtoZcQ7InJcBQnHxCAKqBQhhmWkMFnNFCqWf2QsJD0EK2aYlCAI7FQjX+Y0MsaIVDYDsNQYRUNEK6PPPBNIqyv96ak0OlX97AOMO3QtDNi7+Se4pCpsu7QSa3yEJnii1D/GaUQkzPzUKw0+FBPBdOwqnBzEJ1syxC7p1/Q+E3B8LSz5xDf72uQgAaFEOcPpHBZO3ZQpiviEM=", + "encoding": "base64", + "path": [ + "vz", + 14, + "data" + ] + }, + { + "data": "tvEZQ1KBQUOE+AxDsgEkQ6o3D0MA8XpCIHLpQsSai0N4QihDIEUgQ3zvCUPwdA1DtKE0Q3DhK0MaFiZD/FYaQ5iHP0IGFmpDKvahQpEMLEO5URlDyGKVQh5HMEMKkapB0/kNQinrrkK6cx5DfaMeQ22m0UI8xhpDbfgOQ6oXLkMQuhRDWT8gQ25oFUOJw1xCLy84Q8o/EEOb7YBC7nwrQ5EzGUPuZR5DkJwWQ22XGkPkzfdBHy6GQlzt5kKkt79CJIalQ9MtJ0PW7RpDcDwSQ+D9b0O6TRVDjwoiQ0Tgj0NPkSRDXgmZQ4pRH0M2/PlCTj78Qu5FmEM4VyJDojWMQ372BkMCuxFD1tcwQ74+IkM0j3xDnKYUQ+h5SkLupaVCaI6HQzyGkUO6bLhC+OMSQ+CplkL7PW9D4e+CQ6ZQEkMRBRZDhGssQwEZFkN0mUBDc4N6QyKLGEPcCGpCYhpzwVxiX0PY4xxDCkAbQ/LDPUOU3jxD6p4rQ0GlIkPAPSBDP/MTQ6Eu50IeAxxDWvuTQ4ysOkOe9o1C1gESQ0gxBkN8mj5BqcAWQ/fezUICEGFDqlyVQ9LG0UFGtp9CntLAQt64SENt3h9D5p02QwrJ20K3oF1DgHj3QsKWF0MUuQRDDNaeQRfEXUPAsOZB9rK4QvpNekLUbC9CSBd1Q+NmGEPADSxD0BL5QgfRO0Pa8KZCsozlQrrUz0K7Ik9BtjbfQjN6MEMEAD1D9uSZQvBPP0M4LbpCmNTaQmABJ0O9kBVD8VIuQyr5yUKjPQtDhi4TQ4YJFkOMpcZCvIDVQpqkbkOaVCJDwbsbQ3QPKEMmViNDpDYZQ56ff0JlQSlDICDvQdx8hUMpTY9DgoWoQwrqGEJA7ORCBiTnQqzEhUPMoCtDVjtHQ91sKUMwvABD6U0fQ9hJpkPm60JDlHFuQqkAxEIw/jdBmK4UQj7eXEPW8AFCR8oVQ9jlREJkLOxC426NQtOiJUP6toZDe10EQyorLEOs0Y5Cjq0vwd1sKEPKOatCfFfeQisqzkDdTTND0A0TQxoGbENsDKNBcGweQ8roFEM=", + "encoding": "base64", + "path": [ + "vz", + 15, + "data" + ] + }, + { + "data": "fhNbQ5QQokJ2QUdDOmJbQ3AeUkN/atdCKgMpQzJ8CkMkjXdDr+FZQ81vS0M/NUhDpy6EQ5MdcEPQoFlCq7ZiQxYgtUJSSp5DLu39Qhpxb0N7+GRDWrX8QoiweEJAAIJCppuhQhCbBkMsqFdDu2FfQxSIGUPjfmlDwt0bQvYubUP2bAtCdXpfQwYMYkOiE9xCrW+BQw7ZGUKlM+RCcm1xQzeGWEOP7GVDiwZeQxeDYUNm8IpCvg/kQtwrL0MQ7BND2ydAQ+DhaEOG7GFDjLpRQzie20LQDWdDFN1nQ+tONEPhrGxDGjIxQ4/KXEOAXDZDwHw5Q/CfS0M+MWxDgkgaQyhCRUOok1VDKP9xQ4hoZkMHTABDWvdXQ/99tUIotgRDoOMkQ4boCUNB4QlDkCRfQwEt8UL2q4ZDOqUBQ/SzUkPC+CpCxBFpQ4iyUkNIhoVDtwJ1QzLlW0OKGs5CSZftQcBzpUP8HWFDTkHlQd3eh0McAoFD0ulmQ7rHZENOxlxD4H9PQ+BUKEPJc11Dpi5BQ+niiEPZp+RCN4NLQ+stQkMiiG9CVeZPQ2aZG0M178JCz79PQ5APjEKC+/lCM3QWQ/LykENVAmxD6iaCQ4oHJ0NVVbtCrCI7Q+AXYUPNiThD1oF8QpA9n0MA7YlCeKsVQ4re1EJmg7dCTeToQkTqakPgNW1DBCUxQ4y7iUPbbQFDerItQ+aiGUPYoGVCRmgnQ8Jmb0MsdYlDEm8AQxpVnEI9aRFDGK8lQ7YFbEOaGGRDGmp3Q8AqHEOcdE1DxzlYQ8xZV0NXDxZDcrkcQ4Gp8kIYX2hDH1hWQ8K7e0Jf82VDoKhdQ1b+1ELALGlDnt+VQpqXAUMqSWtDTs1WQ4JZn0JmkCZDwQEsQ4ODDUMmqHhDCsSOQxLmcUPED0VDKCNsQz8DQEOiwZlCrR/eQn2KHEMvw11C7LCaQmhW3UKr9JFCTJNdQ8b8yUKeBCdD5uztQiTsbEPwEItDH8lKQ+cPcUOXvOZCMmwAQgNucEOWxQFDav5hQWRrR0Kbw4ZClsZVQ2FUnUOxu3BCkqBZQwYWBUI=", + "encoding": "base64", + "path": [ + "vz", + 16, + "data" + ] + }, + { + "data": "ZwWOQ5JnK8DCzX9D6hyGQ+QYkENg1R1DGqBgQ1NdKEJ+l5pDtFiIQ6PwiEN/J4RDdrSBQzbWlEMONLTBApWTQxJRCUMMdShDplAuQ+TbkUOVNZhDrK40Q6X06cG6u95C0I4AQ8sWN0P0BYdDMFeLQ5bKS0Mw25xDzyMZwm41VEOuWyzCpruQQ1d0m0OoVShDd59IQ+VLNMKs3CRDesSXQ+YLjkN/CJZDnCaXQ1Dgk0M+UttCGv4iQww6aEMq20hDcn25QvBok0Mp5ZRDdkiKQ46WjkFXEZ1DEvSTQxAFsEJMvpVD7XiJQi6ojEMUtmxDroZ2Q01NukKoZZdDFhxnQpougUMSgJJDOkSPQ2xpi0MkUBhC1vGQQ2o7A0Nw0DtDmUORQjbmB0JukzdDH96WQ5pkKEOYdR9DMPbIQX4Mi0OyMjPCMq5sQ097jkMuJoJDz5cVQ0L/iENM4BZDbUOaQorAYUPqmJVDWKxOwlVqkEPKhHFD0j2OQzr/iENlEYxDmF+FQ0FcX0OIUpFDlhazQkakY0MwLB9DjhSJQ2bbgkNsVN1CHhyIQ74YU0Ms7yFBfXGsQnTC6EL8sSpDvJ9OQ5yEMEMhrqBDZmxuQ0QpYkPzpCBAen+CQ7kzlUO7t2lDDgrbQsQgLUPsQt9CxbNVQ7gUGEODsQ1D7jPJQZ7XnkMoVYdDZpJlQwpChUMarjFDGGttQ035TEMn5NFCeh9fQwibkEOBlY9DjeA4Q2Ks78CfRkhDNL9eQ3RqhENU/5tDpA6YQ/XmV0MU7oxDL7OQQ9hckUNWAUhDm8hMQ18S/UGqk5NDCWWGQ2LovMGq85RDzDeUQz7KF0P+UpFDtPb1Qj4PIEKcUexCwEzfQkEO9UJWa1pDHWJqQ80VNELa6HNDQLFxQxbmnENG3oZD6kGdQ8X+oELdaw7BlykjQ/xZX0MJm8tCz1fwQjH570Ht3OZCBJ+UQwL7GUM0yFZDH7goQxLMhEOGzR5DB9WPQ849l0M0xSBDUNacQpAMhUNFczBDsqpSwkQbw0JZVCjBuH+NQ7gZQ0PMC8xC8dONQ/xXWsI=", + "encoding": "base64", + "path": [ + "vz", + 17, + "data" + ] + }, + { + "data": "0QN4Q/V1jcKJAnlD5jU8Q7IxcENONldDfkSLQyBo2sFAIV9D5HtfQw1DgEPKk1xDeAwdQ3r0QEOgRqDCuTl2QwoJPkNfioNCDgpeQ7RoSEPW1mFDhrJsQ1EWvMIypCBDSmEzQ3qoZ0My7EtDbIZIQx5dfUNUJWdD7rvDwoIc4UInKcnCEMVYQ2ysgUNUm2RDlui9QsFC2MKoV1dDHI9PQ45nQ0MNHUtDMHOGQ5WJYENbfRhDBBlWQwsph0MuOnxDlNigQcdDUUOoWUVDOm1gQ35ORMIetGJDk2FhQxJmaUH8f1dDQdQJwfynV0Ny94NDoISSQ8EipUHSj1FDramGwVICgENmo2NDyuk8QxYLM0MkJwLCaHtgQwwgLEO4J3lDSUcawJXgD8KISmNDYNWBQ0hAW0PSO3RCRGFCwgbGVEMWnubCk5cEQ2ZgRkMxpS1D4PxtQm+6PEPPJ0tDffP+QuMN6kIgMyFDGOPUwnTILEOEDBBDjgdTQ7w6MUPhmEND5/V/Q45liUNc8T5DJRiqQE4c4UK2fU1DXtZdQxBsaUN+liRD2uBXQydVhEMclF3CrvyNQI4IJkOSXlhDxGmCQ07onkJOG4VDI9AUQxz/iUMIjIXCyjOgQwXKYUM6sYFD9kEgQ6RyeEJu2h1DesuMQ6QRSEPysUFDRFElwpzIZ0NgAi5DitqIQwQZHkNeK2RDoaSVQ54qf0Ow8BtDsHGIQ08dPUMygzRDLa92Q2IFlcLWJ39DKkiIQyGwKENPzGhDvzBQQ0n/ikNx7XBDPmpvQ6SzVUMOZHVDGJF1Qxn4HcLsX11DKigfQ1JPssJUC0xDbJZLQ4wuSEOWvk5D4tMuQxpExMFuHiJC/Bz6QT5yJ0Neh4RD5iiHQ7C+0cFF1RpDKUYHQ/wuWUP6BIdD8ghJQ+ah7j7qq5TCy5xWQzSVlUMzsRZDcuImQ8VnBsIGziBDhkxfQ26mTkNLEYBD9JNbQy7/K0OSeoFCDAh8Q3qjS0MGl09D57AAQ/ScLUNng2FD1b/MwjTqFkMgNIzCTNiAQ9hKxUIVvBJD1ktEQxjS88I=", + "encoding": "base64", + "path": [ + "vz", + 18, + "data" + ] + }, + { + "data": "4HgsQ+ZNAcPU0DRDq4HWQjwuFEPxpotDekJgQ+buo8IVYv5CevMRQ307JUPmbgtDKYiMQqNjsUKwhvrCs0AoQ+SRekNGUFvA7peEQ14DzUJhZflCICGQQ1SVCsMQzlNDaZtoQ3b0iENY9/dC2zXtQuJ3gUOEngBD94kQw/4CxEHWMxDDyIsAQzheOEMExI1D7LxlQQs0GsPdFoJD35DUQgoS4EJGo8tCho0yQ393A0Oa8UZDpHKEQ0rpXUPIZoVDgCMbwh5o6kJM0sVCeH8NQ4XqycLoDv1CII8JQwABPMJAe/RCi1iIwkV8BUP7DFNDZjdmQ36eCsJ1F+NCVgydwq2UNkMpYwdDcvWvQp/IrUKqpLfC2qQFQ5FwVEOlqJhD8KiDwgK4r8Larn5DB3MpQxZch0P0lXLBpGnOwtsmA0MODSvD12AEQlTuyEJiu7JC5ZOEwU5ixkLK84FD5oI0Q8Y7HULq8UpCv2oQw5jgmUIoo1RCPCnyQkyVsEJyx+JCFcYtQxqyT0OCDrRCznl/whJC4UFOHntD6j8PQxN3E0OctFxDd54IQzBqckN5y9fCwNBgwm8YW0OOK4FDUm+CQ8ifJUFIwChD99GJQsPzXEPPyvTCchFfQ/JSDEMuFk1DKGVYQ154G8HBgVBD+MmMQ7SZeUMC2nVDGmy6wntX+0LwGZVCdJ9fQyraj0KgbIpDq4p0Q/KVbEPitlFDmjd7Q8hKukKPM7tC4p6ZQ3DEAMOiyIxDKFloQ/T3j0KNRwFDSOzdQulYj0OC7R5D9JMSQ0yw+0LZ8XRDpiliQ3/OxcIi0/tCGF5MQuJ+CcOG69tC4s7CQqS1eUMqn/BCH2tmQ4Qfl8Kat5XBynkTwmSVVkO0RXdDnq1BQ/vkpMLXHJpCekNFQhYV8kK43EJDimLhQjVHe8KA4/zCD0mCQ5ZymENlGElDXsVaQ6+vrcL+6FFDECYBQ/gGfkPu2WFDwvyFQ37TnkJAMhbBkIwnQ8o/z0JyB31DGFQ3Q8gqn0KKQYVDZEIMw9orU0NKcuzCBGkzQwnlykFiEkNDodfXQnzsLMM=", + "encoding": "base64", + "path": [ + "vz", + 19, + "data" + ] + }, + { + "data": "qLDRQlTaNMPNQ95C0FAXQh+6hEIvbHlD2oINQ7ou/sKm7ENCJguXQnB0uEItnY1CcDEiPels6kB2YyDDflvIQgDenEMSeF7C2hBvQ8L6zkGPPTlCCySDQ3mRGMOA3YFDwfyMQ7XfZEOW715CdvRAQuQrPEPQQTZC4oAyw77DKsJ8pibDk5hnQiAw7kKkLoVD1Xs2whh7HcMF8XJDWAAOQl9YMUJEdqRBrK7AQpRoZULwXXlD/BuIQ1W0H0PQCEhDzkWzwprPKEIyucdBmiCAQvQgDsM8PDtCjkhlQlS0ycL6wUNCuIPownqYa0KgRRFDEOgZQ4PHoMJVgCBCmKMDw/p110JU0GVCSdXtQDEEj0Gymg/DwkNlQqYTeEO29GRDugjywiQJAMPsC01Deb+1Qqz0dUPKfpbC3C8Qw+axaUIeTzrDknUmwuAQr0HopDhBRHmgwl4EyUHQ4JdDWuRpQx+0r8EU77XBwhURw2hCPEC42qLBWNA3QhwimUGOhDZCoGm6QpqZ7EL6LilBmNzzwjkqDcJywoJDyuqJQpdemULC3ohDcQR4QtZfKkNOFhfDNjnQwkhCiEO2Y2xDwEtCQ6zjKcIDBb5CjzjKP0odF0MqmCfDkKUGQzuIgULYMQZDAkKKQ6CUd8IsXoNDng5MQ+nfjkMov5BD8/IGwy0uK0JnS2tAYqYXQ1vOY0Apw21DGAMjQ+rXHUMg74JD+Nc2Q9gvoEGOcrpBNOV+Q3JKLMMeSltDVd4kQyjUzsCE2D1CyH0fQnzqUEOAv6NC2FKCQjZFSkJAJTlDkjYoQ3TVFcPpbjRCDpbSwSgTJcPMmiRCYapdQRdve0PlqEpCDsCOQwTx68LOvofCEkDEwnLvgkOPrDRDzOjoQr54AMMDPU5B8oKbwdZwMkKeMvpCZ41AQliv58IssCfDCv17Q9WDVEMej3hDmMCJQ/31BMMpBYNDfkBEQu2IgUOOKh9DdFCDQ0rIYEDOSY7C5pu9QkWj3kGjrWhDPvBwQ93AfUCOO0lDGjQewwxhikOwnh3DOC7aQnXbCcL6zXZDDrYcQsrGM8M=", + "encoding": "base64", + "path": [ + "vz", + 20, + "data" + ] + }, + { + "data": "ZOJBQnLiOcN4QkdC6OuNwcWELT9M8yJDrUWJQrSkJMMBLknBPmaJQQKs4UE3DnpBRDlpwsptZMJ4xhrDSoswQshJcUOM9sLCpBUrQ27ZDMLAwV7B9LQ+Qwvs58JO7n5DduBsQ67tG0Oc9GY/lmQQwW0g2kKrraPBz8YNwzZVu8IG0vPCFqmMPyawfUIkZkhDUTK3wsLy18K88TNDhqCowSloasHqEjnCIKQNQuhDTT7AhpVDUmVJQ0Z6wkK+OPFC+UIHw6zSm8EUrQ/CIaPLP7YmKcPsVoLBM+okwewJFcP4qhTBA4cbw0J9osDeGqFCz/+nQroh8MLKbITBL+Uxw2IyKULOc87A1ltlwlS1LMLILz3D/R+ewBpGWkOKxhBDKWIpw9CkHsMAQAdDs3nqQUZKIkP08/bCrDwlw/PQf8Di4vjCNuLAwtDUK8Kk31vCtngFw1z7JcLMWmdDa5iLQ859ksLq4JfC7urKwiAJYsK+u57CfH86wSAjHsKcZTXBP/fRQQ4eJ0LcolnCtooqw973qsLXhkRD9hmZQM5Pq0HxdYlDQE6uvUQux0JNijfDCOYOw9RKjEOifCRDGHL1Qs78qcLhGRVC54Jbwkixq0I2/TTDQD2DQsRpR75gWoFCnnSUQy9ezMJamJJD2OwCQ2rjXENyFHFDWRAnwyqMqcE7V2zCrBCjQpbGUMJflRxD+Pe1QuZZnUKe4IpDktzbQs08JcLUzRfCFEcuQzp4I8M+uxFDEInEQqiHi8I6hoLBAgV9wfbjAkOfEJxBpZwlQMo9WcGXZ+NCv/LMQrLXQMMiD4TBelCkwp15/8KOEo3Bkd1QwiACNENixAHBVHCLQ1zMGcMqed3CDoAbwwryhEO+K9hCAFRUQozrJcPnaCHCDOCYwqIaisF7SINC4mNVwOV1IcMMpxjD1tE9Q6JGBEM2J4BDXIqQQzggLcP6Co9DvB91wbLUTEM4Kq9CgvdAQ9V8asJfDvnCwEMIQthJAsIgGhxDduWSQ+U7a8JNc+xCNuPpwtH8oUMexirDYUVJQmi4qsJWXpRDcgSIwYik8MI=", + "encoding": "base64", + "path": [ + "vz", + 21, + "data" + ] + }, + { + "data": "MBebP6nnv8JX6CLAH+J2wuQfVcKQE7hCWogfQeYYH8NJ7HbCFkn2wXQdscEmQ+3BlObYwppy3MK0/8LCGy4cwNbNHUNODATDeI7HQthqqcIEjXvCkTDsQojldcKYKURDG7ghQ4KFp0Jsai7CkANdwkgkIkKQX5DCubuLwksHBMNC7CnCqlE6wirIb0H6iQNDhGb+wp93CsKXztxCOnSJwu7mhMJSp87CllpWwSLDN8L/JnBDZKT1Qt2xHUI5gUFCdT0xw6XOjML5krTCMPpAwqR7/MK+s4jCWzuBwpD6P8Ns8GTCzMktwz8sbcJY/q5ByOC/Qfd4G8O+BnbCnJtBw+z3VsGos2/CJurcwgEcwsK4JTHDJ6phwionF0OAFphCuBBKw44iD8NEW4JCAOyawZfqp0Iv6iHDQd/6wp5DZMLWcfzBHi8Iw4fyxMIkJ9fCavMwwwW2x8KwoxVDsHd2Q0/86sL7nujC1MLwwU6p08KwyP/C9HRjwmqstcK8v3PCAibowTqqjcEVY9vCEfpKwxYA/cLL0u9C+To/wsZQtsEGIlVD5DVMwg4ZG0Ky3QnD05gsw/oBVUM2Gq1C7lppQkps8MIY8R/BWLnPwj436EF+A+7C098iQb/dYMI9FXBA+jtfQ8H5BcM2kmBDVIOJQrcuCkP0HSpDJjkDw+YnkcKk4+PCemKmQVyzxMK0aaFCK4r2QWySVEHZnV5DfE4uQu2UusJEXLPCKq7OQsYQu8JtcJxCVLcbQrQL88IbGYrCcBd3whpTgUIQv/HBfj8+wpayh8Iq0DZCcF4fQnwjK8OUiYDCfEv2wireicJg5YrC/KzUwsos1EKi/2XCmI1QQ+ZrJMNDdhXDApVSwx2PQkMJoihCd6DRP3b7GMOcFqvCEu35wgCwi8LyDm1Brmw8wmWWRsOYeaPCWPfrQnLhhkKXO0pDwlRQQ6LONMO0p1RDNOSEwhc+C0PURrpB1gLoQgxk3cICYyvDRieBwcZZqsKGCZxCVeaKQ4Jz5cI6Yz1CVhMmwhzXgkMYWuXCBJRIP4gMAsM1IoND8hWCwvJU3sE=", + "encoding": "base64", + "path": [ + "vz", + 22, + "data" + ] + }, + { + "data": "vnIcwrTRKUIkMj3C4enBwiPUxcL6iRNCEEIVwvBtsMIOTcvCKMWMwhzSd8Kaa4bCMJ8Yw8iRGsP272lAXZsnwuPptkKLOSDDsdQUQvcz+cIeKdDCCEVYQicHfEEUOARDMaK2Qj5asEFAKaHCzK25wsxvccEBDOHCdxAjQrXwHsPE26tCxNOvwpYw4cF3uIhCpZcZw7slg0LSsThCXL/awuVy4ML0vRjDn/9ZwsykqMILPhxDNLdaQlzSTMGa3UDBephFw6i74MJeYQvDjNexwgIwNsIGxOHC0HLXwoOmKMNOqMPC2Dj1wkSqz8Id/+/BBBLawahOJMOvN8TCFjzywlBncsK9s9LCWnEZw79AEMPP86fCPZrHwqc6nULSa6hBb3UNw/AmqcKkV41AkPVrwh4+rkEQGDTDSmJgwsKFysL8nqpCkbkiw16qEsO1ABnDL9tCw0SPFsNHNqNC8qg4Q+iuHcP25hLDchOvQpv+E8OvIifDxNa6wv3jB8MLRdHCjXeUwlDcgMIVIh3DeYQWw7L+H8NUB1FCgWK3wtiBbMImBhFDMfS7wnT+RMHNjDbCyiYJwxOwDEMA6ppBagI7QDhVFcMOCkjCNBAUw4JJoMGs1SfBmkAOwuc80cIE3j7CnHEUQ/45HcPKcxVDLk18QVR+g0Loq8hC1SFXwn7M48JS0SDDbtfywcj/DMPQ9ppBABKewdQ0G8IX8x5DmpNfwQ0sCcM/6QXDjrYxQgSliEH2YqJBELtLwWEvI8Oec+LC/DbKwhZSFUGec47CzPixwvgl5MLgbVbBooZ5wYw2qcIn0szC9BsYw5A9YkGHLObC7EIXw+4qMkISeMfCuFsJQwSq08KRXTjDeBFVwwLD6ELawWTBZNUjwkuDpsKTu/zCEWomwx5c5sLrD+vBrPirwue8EsPKrQNCTn1IQlrgWEExYAtDdKgCQxt03sKIxARD5PbVwrA0lULEWPfBrsY/QsNFGsNB9VHD5gZtwoLNA8OazF5BVEtYQ3zdI8NPX/XAlJisQkreQEOkzijBNCQnwnFDK8MX4TtDgNjWwriCw0I=", + "encoding": "base64", + "path": [ + "vz", + 23, + "data" + ] + }, + { + "data": "NiCUwlhnIUPfZKvCrFj6wo8oCsPGserAZaOXwtK3G0JDFAbDOCHOwls+vcIK2sTCaa0+wwDUPcOa7xFDHs+XwjxaHELEQBHDoChvwcu5G8PxvQrDtBQzv8fK8kKWN5NCeucAQm6x5sHDIt/CinT5wqqwb8Lg2A/D2asmQzHZD8NpHFxD6JX4wtqxhsJzRENBgrYNw4VtMUNA6BjBo9cPwxxRGMOeUkLDTW+0wmtE6cIOW6tCHw2Qv+imbsIh33bCChnwwoZkEsMQPDfDXeP0wgDgpUIsthfDBt8Nw1romMJ6mgTDoHvewRDKCsNb05bC0HWOwqR7usLpDADDRZOFP9hhyML4EQ/Drrw5w9jlN8PsPlhC2mkIw6/bfUGSMcDBR0AawjTAsEHKpjbCGvC3wlLS18FIYQjDkChZQjYtCcNjqUBDxoERw0ZwO8Merj7DW+MQw47kQMM4hdhBRBLyQoOPQsOqLRfD3CRtQyzaN8N4LzzDf5X1wrA+LsPSfw7D5PzbwpXsysKOsUPDyJxwwlyyI8McySrAhcwAw+gUs8JAB6RCLfICw+CJXcJkyb9Czo9twjjsmkIWcgrChv0xwiooFsNAWqnC2s06w5JfesLWiwJDzt+UwmbvEcPMFLXC8taqQnuC/8ItA6xCtxTywdCZAEHgDR1CQqWQQj1IEsPUkEXDel6SwviZNMOVU+vBxWB7wjOnoMLaAcZCjRJ9won/LMOgjy7D6PSgwOwGEEPvoOfBOlRmwvBpPcP3YhXDaC8Hw9DwFcKksNPCz2r3wuAyGcNkenzCerF8wu4kKULcTQXDGAkOw1BV8EJtDhvDuAQ7w7lKmcBhpAfDNjiXQqSxC0GouAfD+NvMwjGdSULzZ3fCfJ+ZwjSGA0J0qyPDgcxGwz7QGcPSA4nC/gXzwvLRGcLsQiRDbhAUwVS0AsIshp9CQueJQlQrDkHwBoZC/a8Kw2BBfUFWQpfCvT4KwdSfPMOiMR7DHr/CwryjLMOlLBHCUQkZQ0JiTMOVNEnCqBheQ3RUA0PG9ARDqvedwq1YSsNw3+xCYh0Rw7ooWEM=", + "encoding": "base64", + "path": [ + "vz", + 24, + "data" + ] + }, + { + "data": "nUPRwvCxS0PICO3CNLISw7NqK8PZhi/CIG/WwpyeLkNYgh/DMKoBw/+z88KnfPjCmBwzwxigJMPqYm5DZvrSwuSDacAmIqLC5NBnwphJMMOIkSbDcB8+wgthZUN1mrNBMoKFwUoCjcIbFAnDBJQXw+r0v8LYfSfD4BplQxLfysK8f01D/9kbw+IDz8IPRhbCJY/BwjVNWENa4WPClq8rw86QOcOmMjXDTp3zwpSBD8MWBvdBeLk6wsD3ysJgaszCYaaZQXRALMPuYj3D26UVw0u3TENojjjD4NsnwxJyOUIckyHDglDZQlb1JMM2c+XCHhnawqT6Q0IQIBjDSFz+QtwABcMW1yzD/iMjw9IYL8PCbSRDNZsmww51CcLESXfCChefQsKaLkPPRqzCqFLvwvxHg8LCcXDCsf87Q4IAJcP7g1ZDhabQwlsnK8M0DknDxMiAwlF2NsNKPIvBuD57QrHgI8N9cNvCkaxSQ+/3N8MWhBLDHJ4Rw6tqMcPzqS3DosUJwwhmAcOUshvDfoFlQsLD3cIW0TrC8NUfw8Qo5sLAn9NBDqciw56st8IMLFFD4q6QQny7wkHGa5rCeCiqwiHWxsISOObCPII3w5gmx8LyM2NDZFXYwn2qM8O69/rCW4kEQg5yfsKoiQlCRuyNwmjdFsJbm0vBxARDQ69EKsPmpxzDVH7ZwsTjP8MF6ojCguHHwsTN4cJOCDdCulTSwqi1LsNAsFHDamQ9wpCOYEOc643C8t/AwpARFcOu5TDDbIIjw0JHm8IEMwfDjIMYw7q7OMPIONDCvUvOwhyLG0Mc6R3DxmfHwqvhWEPYVzzD7MIkwyJPMsKV9yTDOJq6QYp5GUNB0oXB4SYGQrIrDcC2AcvCol/WwoBjIEMw3z3DYPIcw1vtOMOiKs/Cwl8aw4GH00Kb21hDDlRvwhzCksJkWddBDgegQZBABEO+oG9BKt0iw341EMLGs9/CNMxcwuYcJsMi9lzCoJIDwyODQ8Oo5ZbCst++QuCyJ8MTLafCUt9KQxStm0LyrGJDp5XfwvBtDMNJL3NCwFUxw+cVW0M=", + "encoding": "base64", + "path": [ + "vz", + 25, + "data" + ] + }, + { + "data": "NU8Dw1YOGEMK+hHDLqoUwwt0RMMpj5XCO3MEw3b4T0MmMC/DyFsWw/ZGEMNj6BDDvBDSwuq6ucIOWjVDdi0DwwJqHsISmydC5IG6wogGFsMJKi/D6nKvwnb/O0Pkxq7BHMFlwuzh0MJUqxzD4g4ow9A++cKmCivDpq4qQwH8EcKi+QtD+As1w2gdCcNanaPChVm0wQ8zFEOQxsHCeGAkw8LVJMMCJNPCNsgVw1hxJMN25kPBihCowv5LCsPgnAbDSUcKQ/ndJsM6HePCNBsqw4oPRkOk9jXDEHw0wy78DkORljLDJIhTQ1O5McOQ9RPDkEsNw1I7MkMckiPD+OVKQ0Q+H8MokzjDsCvPwojC2sKvcklDitc4wxRJk8JsCLzChJsmQ+xuakM8cezCIKYOwyb+wMKJFUtClr9iQ3cYMsMoWhVDrmAowiqqusKGDhrD0sQdQvAn4MJOrVnCVEo0QUgQb8LIdwrC9PQJQwDB8MJEIZbC/uUgw9Ku7sKKDSnD/FMew3JDFcONw4jCqOYgQwW+gcFSDqTCpaA3w1oQCMMcfbHBZOY5wzoL9cJNSEZDq91HQyCMo8EBxNzCWk7vwhrIq8CKzw3DlObmwj50A8MdyTxDTaQJw6thR8Oz2RjDNOwvwY1lYELEogLBs8bWwruWlMLreGPCVB9DQ1TzKcPOtJjCB64JwxDX78KAlMfC+ucDw0icCcPgr4i/2i4Mw+q28cIfpSjDOj+owpRNK0MindXC2sgBw3SYncKmkTHDZ/Ipw9it4MJCbR/D1uUuw6lpMMOU8wjD/r4HwxfkVUMdbynDY979wXK5OEPUpSXD8sm8wsLxmcLi8jDDGGGqwRoGVkMsDP1COqQAQzyvMMIa+QXDFqkEw68RU0Ofyg3D2WKSwlRANcOFHwfD9/M3w4zXSUMKQxxDWZHMwlHB28KU7pjBnMSewZgNSkMGQdbBRZQqw7h3osIcQgzDo9u6wl5iycLa2JJCdBMiw3RDDMMgdtPCAk8xQlSFpsLS+NrCcJUMQ/B89kHKyzRDYaEMw66StMFHvlVBUOEew66QFkM=", + "encoding": "base64", + "path": [ + "vz", + 26, + "data" + ] + }, + { + "data": "aAgaw6BovUJAiyfDcF/mwo7kKsOsgMrCxrIXw5xyGkOKkRnDROMjw/tvIcOaCR7DdYX7QOZRj0E57/dCivMYw8knjcLsPzdDzNPzwph/ycIyXwnDHFb0wprd7EKyN3HCPDa3wmCjA8O/7xbDZqwNw0KQEsO6QgrD7rfdQrKMXEJMQZpCuJUhw6IpKMO8MPLCC42sQvfKokLC8wHDsJXkwk6cwcJEywJBU8stw+48H8Py8jvCc0LlwgCXKcO/Zh/DRJBDQ6TJ98KIlOhAnskfw/jnC0NWu/bC3vQbw6dqQUNkmxTD7lE/QyBAGsN1hy7Dttsnw8HOOkNWwwbDbmczQ8ICMsMyQhbDpv5HwbPJR8EgShtDIUgcw4DTz8LwJ/PCWvxCQ0QrLUMDtw7DtcAgwzL48cIYJiNDdB4jQ7iLFsOkUp9ClkY9Qt70vkEOmp/CyiULQ/baEsG/c6vCP3IIwqDhpUIKxLlCWW6RQh4oKsGpYM9B3nMQwyRC5cE/oujCckooww7OG8MmGVZCguVbQ1Cm4kKQgdzC48Akw9bYF8OBy4HCKI0ew8azE8NHpA9DcpVPQ1SKasLEhwfDsIsUwwDk9UIgoSTDwEpEwVAcHsOaOQJDsPMiw7RTKMPzQizD/fZDwjkNSkNAsy/ChRAMw+tRz8LYwrzCelIKQznVA8PM5wZCgQ4gw7elQUAOcfnCougew/bjGsM2ninCaUQow8iV/cFMP5bCOrPowt2330IQGgnDhJYdw2sirkFAiwjD1A4Aw2IwDsPqwTDDhfgnwwmB8cKO0SHD/9ggw5owKUObewzDSGmQQtT37kJOALzCHkV8QULRzsL4OAzDFH5vwvgqI0Myp0ZDPPg1Q6jdm8LOfR/D4QwZw05zHUM+XmHCQJQwQrYfBMNyCCPDGlgcw2oiQEMM2L5CFTAJw9LgDsN/f2zCymRUwix8LEPEtnPCMksLw0Qa8MKTByHDGh/5wqZ4PMAvMChDUMs7w1QaJcI+oQDDppyQv74J60HlGAHDjpyjQkbLNMH2ZPxCVD4lwyJEzkIYANLBjMCywlzXoEI=", + "encoding": "base64", + "path": [ + "vz", + 27, + "data" + ] + }, + { + "data": "2+Erw2S580Hydy7DhLBjwn8l4sKw2PfC8IIgwxqwyUIiRuDCvrQUw9IdGcMipgrDzorrQnQRCkNpZIVCyv0pw2hgw8J1plRDl3sQw6DkxcGcNZPCdTsXw1VPWkKihrvCvmfwwpx8GMOBqunCOue2wiCpIcPvF6bCCvZFQogBIEP2Q1ZB/JPZwuDCQ8PujRvDXlhAQ1/veUGEVxzDCu4EwlL5nkC0LfdC7Gg3w7DX9cLQDZfCDEkLw2bVQcP5BzDDSC0jQ9GbU8JLmPdCdCDwwi5jpULpJtjBon3ewpxWHUMTm7TCRicKQ+lJ4MJsDUDD9no7wxpiDEOPXqDCAUoCQ1yrJsOtQbTCUJHKQqfNuEIyEM9CCTnIwmxJ/cKF2RDD7LUXQ6/G50KNzB/Dqjoow37GC8Ocu2JDIz7MQqfkycJd6rFAEiwfQ8pRCkMaoVxBahpPQ9TRx0KSzODC9j2Uwm4fLkMpgGBD5HYXQZmL5kLmZAVDjr3bwkqsmEKG3PHB/pwWw4BlCcPCqyFDWEgwQ8xJT0NRXATDOinjwsfQDMO0/MzCTuXEwnDVJsNeSa9CzIwZQyEEt8LXVBnDw1grw9YNT0MXOzbD14K5QrxtMsM354lCObs2w9Cb38IkASvDhHukwn7kV0Mp9pTCsuEow6wH/sLyLPzCpCalQmLnjcIKxwtDGMEuw/AF8EL81Q/DDBw0w8KTGsOmM57CTWU8w/YdqELGFzJCtHgQw9krRkIC2yHDGvEyw7DMA0NoyI3CMPpYws4ZJ8OGUxvDjDT/whxg+cFH7THD+IMxw+hH6kKEbKnCIiVDQ5ekYELvLV5BlPQJQ79j+cL+spPCLRy7wpz04UIfmCFDMKgmQ5Vd0sJoejHDGcogw1TUzUIliUFCQncUQ15QYMLLJjrDFEGQwgKeDkNQQwNCcqYkwzxtLMMgtbvCKrqiwv49/kL+eLLCjeelwn2OGMNKdSrD4jkVw7RZ1UK8mkxD6iwuw9gcpEKK0hDDOsUnwguGBEO2tQ7DOHu3QRC9RsKK24xCJQ84w1qDMUOWe2/CgreRQZLY4UA=", + "encoding": "base64", + "path": [ + "vz", + 28, + "data" + ] + }, + { + "data": "+yUnw0MgNMI/cRXDeqAiQmhdy8EA1w7DbsMNw9WnNEJUEELCItHqwry768JYv8bCPOc6Qx49WEMxXtdAtdUmw7cY88J+diJDhtwgw286m0KqU4JBG5suwxbHz8AkcvXCvKUPw0aPJsNelWLCFp9Wwd54HMM2lgPAro5+wReYZkPquV3CFH/OwYrkUMM4lTjD6gdOQ7QLTsIgfi/DOLKKQsnZ3EKkW0dDPQwTw5IrbsIoa8bCnB8ew4EHQMMrKiXDXH70Qlq4QELZokFDH/RJwj5Hv0Gp8aZCZwsuwo6R4EJQeYu+mHunQmRvQ8JK6ivDwBgww3K6vEKWM9hAwPmWQto/BMOO9GnAitxEQ6ZeK0NQLDZCJByBwV2oDsMWZiPDjbzJQpj2bUKbziHD/mwTw3uxGMOOsDRDQg4mQiTPz8FELJfCxOF1QyCXT0Mma9NC0qhCQ85PNEOJ9QbDpLnawmwrO0POyFFDEGNhwosfRUNcC1FDFk5VwsFdH0PKcppCZCLswi4a08Jy01VDfGf1Quq8PUMosRTD2hjnwTTM1cIOagfDjF8cwIw/J8NTBeFBjOvHQkKy78KyoCDDVBo3w1NYLEPcsibDgk4lQ4h8K8MHghdAcn0hw6QdAcKetxLDUjbfwqVVIEMwrcnCoJ5Aw6jeEMNuTBjDskLLQV10bkGNQlBDbk8gw2ELOkP+4xzDvGIxw56zBcMsct/CniU1w2B+NEPKNAhDnEUow/RCkcEiLTTDFjIzw7z7UkMKapNB5rNRQhrcOcMPMdnCU/5mwm7vnULo/yTDVv8lwxPZbELS2a5ApAdgQx+X1MBaZPNCTOFZQ0oJDcOPlMhBnBH2wtQ3d0K/tO1C7zT5QqDX/cLK/CzDXiIIw/KkOULyEARDc2NQQwQiFUIPOzXDC6Y4QsdXskJmpQvChO83w7xsRcMPhffCdjvTwrogm0LQjuHCPLKPQNA0MsMegRnD/VEnwxGxPEOq5CNDLufowtyYLUO4wBXDJtOdwtLzRkMmzAzDtAMfwjReqsIV0C5BKUomw/gQM0M4frHCsiP6QvinksI=", + "encoding": "base64", + "path": [ + "vz", + 29, + "data" + ] + }, + { + "data": "gBL3wsQ8J8NBuLfCCjsqQ2hNrUIMtx3D4KLAwjL+9MG3QlZCnvtVwhWzB8LuAIHB4PoxQxjfNkOobZjCPID9wo2EEsOFBc5C6BYhw/wEQ0OUogNDgO09w/uVo8KtIBjDVNgkw6mzGsO3Zl9CIyfOQvjw/ML2AuRCxQXXwkq6KEMblxzDpzGsQnUJG8NmvlDDDHYPQ9zSC8PKMCvDvM0qQweOQEMkXDdDtvlSwtZgVEIwVvXCNpEnwy6mEsOSg/7CFNmCQtzMLUN6NChDFqWUQmxsXcIZqDBDlDmBQvL+P0IG7fBC/BJHQbzkWUIcQvLCul79woITDUIQGf5CfDURwBSjd8K8l+JCxChRQy7IO0MGLxzCfNy+Qr5kFcPQLSLDfC/jQaAkU8GWPArDEDe8wjc7DsOQ1elCtGYTwiYntEJ25j3DeZE5Q4zFJkMdFDtDqkAGQ0I0QUMR2BzDHlgSw2wCDEPyGAtDgjMVw+6IPUOCCD5DcJdLQnX5PUOXAjNDcFBVwn6mLcLKBxxDGNhAQsObAUMU8xvDRgvCQlu28cGeMSnDKBz1Qpo5BMPFZ1zCQHj+Qf7GFMMEhw3Dy3kZw7TH6EJcYNfCWO02Qw0/+8L6arvCNpSxwuDTm0JYDcHC2tMOw+bLwUJ6KwDDsNk0w8xaHsNuTTDDjg5Owro1BkN2qSxDnmvwwtZHJ0PMKBLDIJMCw+o+ssL+ZhLDHYoLw3oRSUPGfUFDrCQ8w7SH5sLKXirD5x4Mw2rhPUNIFAdD3M0sQwLkJ8N2Ez/BFP5wQvIWN0P4Mf/CxEsBwwwlusEs+QRD8LwVQ2R9rMIM+0dD+q81Q9HjFcO+VxhDAbMZw5bFxMCfAn1Ce6tqQpmJEsMh1grDauSXwh5+7MEG7jhD2qYrQ5AvC0PGyPbCHBURQ2YVekFkBAXDECEuw2beNsOi0BnDhIoCw89hC0E80wfDTqYBQ5y8QcPgO+bCBHcow827QkOBS9BCeufZvwCDQUPF9wHDOm3vws7oL0MsG+rCXNIBw94L+8JmMpLCkpHTwobRA0Okee3Cbp5FQzJ3PsM=", + "encoding": "base64", + "path": [ + "vz", + 30, + "data" + ] + }, + { + "data": "PDJvwkjdlsNIXrDB0qNPQ0I0F0N7SArDPucOwjDB0sLirwRDHgGlQSiJi0K+0JZClkoIQwOkA0PcRyDDQEiFwva/IsPym1ZCflwMw0YuYUNCrEFDeBYow8wkE8MDdyrDEmEkw3aV/8LAFxJDoCMvQ3obqsLSpDhDEtRHw1g05kLAK4bDClAWQwAklsIWLjjDDNa5QhDUWsP0gA/DSlNGQ1KiNENmmgZDJH5WQkb/CkNckAnDMosVw3AYr8JCcJrCrAoyQUifZEOARfNCK2IkQzzWBMNQtEJDdoITQ8yFZ8GqvDlDFKtWwiVZC0MpCG7CH61xwk2alcFuAzxDckOgwtzshkHQDzZDZnUeQ2jfD0NbPADDRTsgQ+yqCMO+OgLDrrYowvQ/ocLfl9PCafemwZK/6cIoD3VCpOLawvLqKkNPPIzDFQUAQ3b850ICFlBDqUybQjj4EkNTbCfDmBMrw0zTwUK0nKhCqNt4w/4uEkO+4wxDZlUQQ4YnFUO5b0VDdImxQRq18kFGBsxCfi+uwb+gnUIQFA3DC0MrQ3oUdkK8Qj7DUsQ6Q6ddo8IkGQzDOVjswVZDJ8OuRuPCuWLXwrGujEISAcXBKq8RQ85Cf8I6JETDa0w5QT5MGENRRhbCoDokw1CHNULkhBLDutsBw2KfEsN3jzTDtvn8wlpISkPShvFC3N2HwlR4/kIgOfHCyBR7wlSHBcJ4ASrDCu+owsJlGkOeQChDuiolw6A1V8O4aQjDWXWrwt56CkNkIUpDtipSQ8vk9sLVnaVCKZ0PQ7LZT0Ml0KDC6rCmwgqq1MICyERDvCa5QsJVHMPq4DFDrJIBQwaIBsPwdlZDasItw8S1jcJa6EpBpCMvwaipG8PwWbnC0lXqP4FhzcKDUhtDFjj8QjJ7P0OoCTHC7AovQ0gEYMIYjmzDjgcPwxCS9MLwLizDSvYSw5YmasIkzBXDPKlFQ/KGK8OiPIfCWsIRw3bcFEOW4z1Csw2yQtTfFkMOscrCT44Vw+6O/UIe/KbCivljwxoiHMPAaiDDczbQwebKrkJEMwvDQhElQ1njlsM=", + "encoding": "base64", + "path": [ + "vz", + 31, + "data" + ] + }, + { + "data": "rlPEQQUqVcPdamlCDC8oQwVgO0MgpcLCjKM6QvwrTcOaXjpDW3LMQpIjIUNi+RlDIAmxQsTkl0KYR4nDbKWDQfqIIcMft2Q/SaXTwrpDNEP+7j1D5HH9wo8vWsPoLDDDapIMw3Aeq8KmDEdDgFlIQ0pGx8HoVVBDhvKVw8a8dUIILGnDJG04QynAcUFN7gfDXEgnQvzPR8N6RsfCPHchQyR1C0MZnp5C7tcHQ9CcPkP0QRTDCv3owjbCbMGzWwPB3l9cwvWzO0M2kIlCqKRUQ17CacPsDCBDsz1KQysotsJ+E0dDWJ4FwwSQR0OQtGdBdO68QSxTpsIunjpDpJg1w4RNx0IHaFBDaCXPQtIvukJiaXvDzI9CQyyV5sJ+y5DCuZIAwzYGJMO6W27CACORQrCClsJO4Vw/uABGwz4dWUOKuDHDot+OQjqhbkJuvStDKTdoQSxSukLEkhbDMoY9w060QkKiSOhBuh9vw0YwxEICNq5CVjdPQ1uiy0LzTR5DbZfZQhhP7kLgJClCJjbQwsXAxkGTSeXC+clOQ2YXEkMqYUDD30ZIQ5uiIsGK1YDDqufKwvqmMcNf3pDCO8Ekws40sUGsEo5CHr/KQs+6a0GM/6LDWqPhQoquR0PKwwxC7sA0wwDNDsG0uSDDbpdFwsz09MKATh7D7Ntfw+x/SUOyuntC/3EKQFq3o0KIPp7CLbbWQXDsJkLAEzzD4B07wa7LzkKfIwNDQjzqwlcNiMNnj6PCjJxSwTBypUI940tD2hMqQ2o/UcLOPRtDWkxAQ0wQKUNOvo3B9ua6wY7jVcOMzUNDZIURQl6wZsNp3QdD2J6SQvoh1MLaOz5DCiA6w8zFGMNUMDrCar7PwloXEMMdn+fBGgC2QnZXQ8OYxupCwCaWQrVgO0PIgDFCNXwVQ4DAE8MxInHDHuW+wpL2z8Gvly/DuAYfw6q6D8PSUxrDm9dKQyVDBMNWKZbAbvXWwsDlwkJvv5jBmPATQ0YpzUKG4WnCZPEvw6RejEJQ9QLCZLaOw0BcOMOTAo3DxBF7QiZQEkL64BvDifT2Qjx4TcM=", + "encoding": "base64", + "path": [ + "vz", + 32, + "data" + ] + }, + { + "data": "597PQigl3MJ87ABDhsT+QqrQNUN6TdbBkrUEQ3bxnsMyVEdDnIEnQ7prUENaREVDyvQHQqRSaEEVUXrDtxLGQiKJA8PwPmvCa1Vbwp53A0NevxdD4lF+wlCrOsP7yhrDAYXFwsDYy8FvlTlDfPUqQ0jJVkJsJDJDt744w6Yt1EA849jCiu0pQ1bXrEKwdYPCjig6wUo/s8JyLRvC0GTuQsKpuUJOgoNBheYzQ8YDO0PqbRDDyF2Bwo4Ha0JMtJVCqF0Pw/3EDEP4ivxApgdAQ+aXg8PC4+1C1QpQQ/gUPsPyUilD6iZww0g5VUP/7K9CqTbSQtSdKcOcrRpDAIuaw5zdJEN8XzRDSN0yQgJ8D0KuZYrDEGUyQ4WPp8KM2WVBreRqwyCwjcPWZNI/mOYYQ8y0Q8EqRobCWFSYw3U6QkMYcJXCLlZmQdrOgcCm0ftCx3tjwmKe/0HypubCujg3w5Ze6sBGOu7BTAHGwisqMkJs6+NBQltMQ94XQ0KSF+RCFGQ1Q325Q0M6c8zByOBLwwLjC8LkdZPCOro2Q+jUQUMNWCPDrNUrQ4CTkEI45o3D1LBCw/hpH8O3ZXLB1WAdQjJN9MGijQ5DWudIQgUpuEKkRlTDTEUvQ8OMSEOidt5CL3orw0Rwi8ICHiHDeJAnQnwNpsIhPu3CvJGBw0KQI0P+BPS/OTejQmzp7kF+VYrB1dnfQlm0/UIDOTjDjFyKQrKcQELJkq5CN9YiwtrEGsMeLeLAarWCQjPosUH2aiRDKmn7QqrCF0L5NEJDWuQ9QxTw90JlsWJChrA5QielmcMk2SNDRuyqwTQ6MMPALbFCKJA3QQDxccLY6xJDOGUmwwP9h8N5LfTC/xRqw/jY8cJubkBCqY4fQ1Ywk8PCXZNCECuLQaQ+FkNeR+RCdFLuQrxqi8PoAfDCIG75wWBhkUJv/BjDGkMWw3THgcO3VwrDr1MqQ7aol8JOkotC6K9KwmPFIkLeXcrCLqYxQ7irQUIXqhRA9rRFw0wzpUB0Ix1CKVYSw8HvUMOsJXfDV7cDQ8kXvcFO2yfDdnybQjk5vcI=", + "encoding": "base64", + "path": [ + "vz", + 33, + "data" + ] + }, + { + "data": "apcdQ9wN48F8PDBDPnOrQgDeHENNd4lCL3NBQwTfN8OQiyxDr/xLQ5aSPEPBzjNDDA/uwTqpXsJqiQPDPpQcQ9TzksKR8gPDZAtXQSyWoELm/NpCqHuJQSJAj8Kg2ufC0aMNwro5S0KmiBpDoqIIQxipCEOOzg5DxOCmwoQoTMJA+arBbmMPQ+T+BEMeRn5B1tOLwmREnUCaFw1C1EuSQhr/IkJ43mTCfr0zQ7pOHkN8I/vC/sADQb708EJQ0RlDLR2Kw87ItUIIYYLCe9MfQ19+CcN1EJFCwgMyQ2kck8NQLAZDIr6Nw15ONkOulBNDQtUkQzV7mcPUT+9CbJNiwxv4SkO8EBJDImydwZgt6sHUyyXDUtUWQzNjH8IK8tZC6JCBwxGpgcNp/ZVC+ilHQ4izkULfdRPDEFk3w/oiH0P0mT1BSGw0wt5NnsLopZFCjhsLwxhsGsLP+13Cjp8Xw9pnmMIM5MDClBsBwS1thsF+oxLCH9gqQxReMcE+KoNChqxeQzRtY0P8n9TCQd+Xw2Q/0sLmsW7B2KgXQ16DMkN1FuLCnLoJQyQuD0NCXiHDwfehw1iq9cJxdmtC6PLmQpjAtsIOuTVDkogVwdt2FkO7Y9jCaY5BQ3ABKkP2Fy5DHDwHw6ySD8NDMgvDsIjlQpH9vMGSpmzC31YFw1Ik9ULSSJnCiLgXQ1Fc/sFq7IFCSuUpQ6MVREMr1RnDvAYNQwp6T8FZFhBCGtFMQpgnb8KX8ZZC0eADQ2acM8IEK/FCBpucQioF8EKfvTVDhm4iQ4Xlk0Kg1AJDyGvnQlF+RcN55QBDQGunwo8QjMLQvw5CP3pswsh/wUAej8dCkNP7woCYecOU32nDSjGSw9JapsJV5vhCjtlCQyi8LMMOj71BZjhHwlCM1EK7cx1DmIWqQn5LjMM1cO7Bpr40Qu4FDEOi8OLCNSb1wjT8hMNAaNfCJFAGQ+LGscB3wA5D8YXGQdbBt8HU6lDDliIjQ556W8HkjKJCfhlNw3CajsLX3vtCtQhRwsxKV8N4IQXDq5ksQ/CZxsLmkR/DzDbZQYAKwMA=", + "encoding": "base64", + "path": [ + "vz", + 34, + "data" + ] + }, + { + "data": "t9w4Q0oOK0Iiy0FDXccpQlOU/ELmPRVDSCJPQ32Vr8KGIwxD+yc7Q/qeHkM0vBZDGxLXwsglDMOA9TzCEn86Qwc8hUGxoGrDMES3Quoy0UHHsn5CxqHEQn74tkG5Z2fCILQ4Ql6nAUPcevFC+iLGQgDrRkOoBdBCkr+ZwCHS48KJfzhCiGTgQuWhH0Pst7VC2MAIw3SFmkL2YdxCCpa2QWDrk8GumhPDDMYcQ6q3+0KoArfCR9W7Qkx+JEM3sFBDbouLwyyJFkLRsR7DgrP4QnFHPsLadqBB6HIOQ3//Q8MGkr1CpJIiw/SeEUPFCDtDpodGQw8UWMN6kaNCgHIBw/eEQEPko9ZCXCu5wjSN0sLMPKDCnDztQj1wlkGuzytDmmQiw+AGCMMz9BNDzPVFQ5bTHkOUhnXD74CbwqbS70LSYqtCOmXbwofPLMOs90RBz4pnw/dI9MKwK/JBPEjIwoC3KcMSLDPDYK1kQkgZtcLHu97C420GQ2uvoMJHzD9BrBVLQ0j0QUPark/DpiFRwxIxQsNgWnZCXo3oQhJsFUNr1inCBKzGQi41PEN1JpLConNYwzqyf8LaIQxDKMQqQ3ZGJ8PxATdDXXihwjX2OENPXdfB7vIpQ5SIBEPB7FRDNriPwnjSdsPnvsPCT6QgQz7XZEII/YtB0vIuwrrankIssiXD0BpGQ5Xx2sLEWBVD/MBGQwE1X0OkNc3C01A/QytWpsJg4snBnDD/QtOlfUEuthBDNKkwQxL688J6YJNCFpPYQSB+LkNQ2RpD/H8CQ+iDkUHJ8TxDMMgrQyKE08Jw57ZCWCgbw4itkUHiH8fBh0QQw5K/sEIEoEJCgPt0wuaSBsNM/JDDovZCw4KP08H2FjdDQvItQxDUl8J0kwrCEc0DwyBjYEJQTjFDgo88QogWKMNncyJCXczxQmCLMENS01/CD5CQwqoWIcOebGPC5L2/Qhi+iUKqc0VDfSTYQngpwcKK+aHDRp0KQzR2sMJQ8yJDRaAww3bTI8NqQEVDgRSGQcCSL8P270rCsEA1Q05MS8PQbAXDbKvzwcUaiUI=", + "encoding": "base64", + "path": [ + "vz", + 35, + "data" + ] + }, + { + "data": "NI4sQ/Bj2kJmNyxDnrV2wHKatUKUoT9Dhe0yQ3J2dMHsoc9CWoceQ5am/ELUBO5COZVOw+xjdsO+VJxBmFAxQ5rM2UKytKHDwuMgQ31KAsKYi1dBDJ4gQ8K7s0K0m3BB1dT7Qo7sPUNcWqlCDOBpQkSvXEMPanhCnpFwQrS1OMOiIM1CZYyZQhi0JEMzRxNDnohZw3TIA0NgIipDTH4GwolxsMIMfYHD47wBQzfstEKy+A7CsrgnQ30jPkOQS1tDfDcvw6QXpcHiLYvD6CasQs0lqEEQiSTCgrTNQtIC28J+7ktC9piTwrIS0kI+nEVDXiI+QxwO5cIjuSFCjH1LwiL2I0NdJIFC7GkywxKJQsOH1P7AiKakQnwBtkKq/EdDdLKfwi4qU8JspUpDaCItQzY4VkPpaIrDeIkhvuBhmUJIvhVDB9s2w8rbjsMsq2PC1vCHw0SmXMOqhe1CJNv2wbFumsNyi5PDzNLXQiCzOcOXLEfDfua/QqxaIsPg2UPCCewqQ6waHENzIZfD7UbqwnNjmcMpuQ1Dft+ZQqNj7EK83xVCFjpiQlohQkMALPa/emTjwu2cdkHpxk1D8CpJQ3xVhsMiIyJDfcsowxrpNUOlMStCa8cNQ6zOskJUxEpDDGpyQV2MmMMjRv3BYDo3Q0SbD0M/UsJCKrO8QdZXBkLyR4XDiqxNQ37dV8MGR09DAWo0QxpXQEMNJQLC8+ZVQ3ixJ8N42MvCCrQuQybSn0KQQD1DkOBDQwSAVMPI8bpBY9PvwcWsSENY/PdCh+29QiJ7NsIygl1DfsFOQyRM7MG5KExCPi5yw5cuqkLmVcLCQc17wzOjIUM8ev/Ar1avQToxXcLFQynDFDbjwnqiS0KqRVhDJZMRQ4QfJ8D4H9LCOEprw+Y7c7/CPyFDgjZDQPNYpsI8pMZCdKs0Q4ZtMkM4mXJBu7HSQALqoMITtpZBRhFbQm4/BkPQIFtDONkwQ28lOMPXZF7DKuDaQokYN8MUYFtD12X4wqAfhsNaj1pDf0uRQjr80MIE2oBBZjEhQ1seosNMvq7CElnGwuIZBkM=", + "encoding": "base64", + "path": [ + "vz", + 36, + "data" + ] + }, + { + "data": "Fm0WQ7KnLkOCWhBDvPZdwoqkSEIrQDNDznoSQ35zNkL61H9CKZb8QgkMuEJqTqpCjrGaw2Ank8N/p5lCXrMbQ3cYJ0P8GD3DUqJNQ8jixMLCSivCa/JFQ0IICENGmK9CUqo1Q2l4XEN6aThCqkBkQeL3QEN214VB6bfoQmKwgsMIuxdD5NcSQhRpFUMFDDdDBouEw3vkKUPRzU5DckPGwlZFLcPCaIjDqqPGQm7eT0Jp7jdC2B5UQ3RaNUOk1z1DPkvCwsBmrcJ/wHXDaJQyQk56m0IyDufC7Q5uQmo5F8IUJPM/rzptwLy8c0JS/S5DtXUkQ1+MLsKqKbXA0ruPQaZXAkPgx4xBV3SKw68vi8P6uGZCNM8mQhhYJENktTJDnpALwV4DSEE4klxDZIkQQ21pUUNOtSzDQ7J2QgbU60G6oktDlO2Ew9zAZcPYJgjD/AE4w0pXjMPZrzJDUng0Qt5Gg8Pe1G/D3IYUQxI1msN6/JHDXYNdQu75fMNu1fHCNR0HQ8LZ6EKVXUTD7SQZwkqnUcOU7EhD8pQEQqmKqkLG/NhCjG8GQW6IKUMqdHJCqI8XwkiGwUJaIWlDKno7QzDZVcNu/ghDNiWGw1cMHkOOZNVCjpHcQhAqIkIEcyxDLzHFQnj6KMOVh1hCNXooQwp+TUPnoSBDK+OcQn7KgcFWWmvDDOYzQ7chnsNpy1ZDQsIZQymAHEN6BC9C8j4/Q0JdhsNFqUrDYDtAQ35tCEOO8klDzcsvQ9rblMOC1fzBKnvAwiZWNkNul7NCVsheQtDF8sKNEUdDnvVFQ5YUGUKb2NJAIF9yw4iqBkPWWTvDjqePw7qzTEPL65HCLPTJQqSO8UCqq6/CvLglwtgJB0MgP0hDaEbkQlJuZkKwfD/D+AGWw2TihMIKswpDkmBIwhLZOMEuABZDToxYQ57eHUPEGq1CNfrFQmd4VsFUKthCSOIhQQaXNUPhqkBDSIRZQ9YejMMK7ATD+4qXQogTlcMes1VDSWNLwuf9ccN8NDtDpCnxQvDPisFsmpVCDPAHQywtWsPAeYvBBo45w7h3QEM=", + "encoding": "base64", + "path": [ + "vz", + 37, + "data" + ] + }, + { + "data": "KtL4QmtHcEPyWOBCcJvowp0RXEBUvRlDKBffQobDyEIwZqJBdtC2QkyAXUIP8kNCalZZw9K5PMPAmgBDSEUCQ20XPUNlXsnCr4FQQ8IYL8OkudfCwG9IQ1ZOGkPKgBBDf8VNQ+K0RUP8kIdAOuQKwuTqH0P7YwTC3AYmQ+onQsM+OEFDgLQQwR2IAEPGt0JDVgUdwxJNCUOwWElDjYIxw1pSh8PCXC7DLqCCQl5xGkHOTgdDXNZPQ/QMHUN6hxpD+3v5wdzaJMMw0xTDb11zv1gF/kJ4DFHDzllBQZpSykE9Z1jCZpZhQuTqUUHE8hBDLE4FQ3hQXEHTIWrCRlykQnKUuUIZRwrCovB8w4aVQsN5IfJCvGiDwDpnWUPEEhhDuWheQrgfiULS+UBDApTiQnLcMkOCv6vCZlzjQg7PssFWJClDW9VhwxriBMPnU17Dji/Iwln+PcNg0ktDFj7fQqQIJcP+6/jC/l8hQ5QdhcMYOGDDbQ9CQVljXsOeHlDDzHTBQo67lkLOHdDCVn3/QcxD4cKAfVxDlsCCwbCXSUJakR9Dst47wrDCC0MIDu5CGB/GQV55HUPj40tD6vEgQwLQ38LJBdlCllhrw563AEP6KihDgvGWQiqZaMFa1ghDrigbQyR9o8KSMANDcZwRQz5tXUNQhEdDbqb6QlkPkMIy8QzDjWUUQx8mU8OOSDpDoi31Qhi27EIcwtlC0XcgQ0WjecOIH53DZnstQ3OvOkPUJzRDGocUQxIOTcPITrrCyCcxw556HEO8Q1BCNL8+QQzLVcPqYSZDUjUpQ3jvy0IsmC7CmsX4wscaJkNkeZHDcj80w1+vQUMn2RbDlvYcQ1Czd0Lzjr/BBLbYQfaFRUMu0ipDsEOgQsLF20IQaIrDKqpKwyMcDsPQ/N5C8YTrwlipV0LqJj9D+A5OQ6scBENdhQ9Dse0mQ6rTOUJIdTFD1jEewlYtUEMwZx9DJrdQQ1yQaMM94mXCP9MTQsSvb8N1ZjRDxkLdQQLfFsNIzBhD99AiQ7j3ZkI4RgFD7VLVQkbvA8NC4YZCth+Pw6HmTEM=", + "encoding": "base64", + "path": [ + "vz", + 38, + "data" + ] + }, + { + "data": "Rk6+Qi1XHENrfZhCqgFBwzLSS8I4uvtCzu2UQtQmGEMyPd/Bx+lXQsb9eEFo/B1BNjEEw9xIycKJ4zBDqpTLQvhVKkPsKgfCCp02Q971g8Pw1jjDLMMxQzbW7UIMuDNDwkw4Q3mYJ0PI9ijCOqO0wtQf+EIu07HC1BdIQ/StwsI9pglD09h4woA+zUJYqS9DWsqHwn/ll0LARS5DyOOEw3aaacNCObXCIiHXQfcMF8I62kNDo400Q4DA+0JwM+dCNDLpQW5FgcORI4zCTJZRwoKeKkOI8JnD6HYhwn5wp0I5Ke/C9tzdQoKtHMITstpCplbDQoXEgEIBxvLCkDMRQ3PhTUL9A7vCIuUaw+pO3MKYdjlDWCxiwvo1XEO0wvRCZl3oQpRT70L0YR9DSBSfQlKSEUPdOWTBJm0eQzqGoMJX9pZCrhDywjR1VsLtuI7DTbDOwYyY0sL5zDdDSFgfQ+xptMLLDzTCbQ/UQoI5KsOsmgXDMnMLwjuxB8MbkZLDMoNfQqSvAkIChtzBbB7CQhg0G8IOkkJDGj+TwkieTkGanT1DLtrgwnK51EJaPTBDXOagQsTIP0Md8ShD3EoBQ9bWHMKYeZlCujgXw8ACvkKDqmRD+7ISQkpYmcLkLMNCJK04Qzxug8H56jJDWmfrQmp0QkN6a0tDqu0lQ9HLCMMyKG/CCD3iQj7N/cLQ9xlDjOyuQi4YnUIEcxpD3ov4QvgMGMMUmG7D3vUUQwAmMUNsIxhDkmnoQta/5MLQoyPDHpiJw6I//EICniBBIRgXwgKZmsN05gBDuakGQ8xpJEOW1MzCnf4PwjG9AkPOtWbDvAq5wr0jJkP+anbDDA48Q7O930KkaftBfDjAQpxYXENrWghDPFctQn6kHEOrlkTDiEbtwpBdYcOZu59CPvFQwxwq60KIrgZDfYQwQwSzy0KoATRD9tpHQ4ivzULG9VNDMOfAwurSQUM0sfRCHjs0Q6RADsOIsSZBYdkGwTK4EsMMcBBDCV+6QqIQjsJPoOpCTC8vQ0rG3EKI3DVDjgOTQmEcd8J+1AtDtChSw9IC50I=", + "encoding": "base64", + "path": [ + "vz", + 39, + "data" + ] + }, + { + "data": "CGx6QhxXY0FazRFCSXSRw+NP5sKNWMBCCMYLQnSTSkMzjaPCKiJaQdIC5sEFAgXCss5wwsLF1cHyjkhDyJmMQshlE0NTR7VBWtkXQ8CHh8M644bDvikVQxSvg0JkbzxDbNwcQ77eBUNtpr7C9OIaw+czrEJyhxjDlmQHQ3akmcGUkrFB1jT6wlTVjkLeBhVDcPWrvs7DPcGchg1D1mFlw6rhEcMiYY7BbaeLwXtyuMKKtVJDtgwVQyV1sUJKZ5NCnqCvQsbujcP21um/55zgwpudLEOMnmPDclzGwmwHDEMGKUXDXmIiQ1onwsK8uIlCWHVmQqqn30LYe0bDLo1RQ0aqvkBC6CDD0ouPwoYrE8KKPnxDjxnrwvaNPUPOHbRC2L8uQ51NKEOeUfVC+KUrQnp/3UKcRD9Cqig6QzoWEsPAWyrCoGAUwlJVbUECaFfDdrcjQrJF98G+qB5DrVo7QxIE0cFyDYpBIOZAQGjluMJdFGDCXlKuwghtccLEHE3DGjNCQZaaRcECbh5CvzkfQ0WtsUHgwCNDCsMNw1z14cHUdT5DM4c/w3hti0LIWmlDypcEQ0InP0OkfANDzAO7QurLikFMsCRCIs2cwpNIZEIkSjZDTsTtwFR+EsNL5VxCioczQ7cfGEKKBUJDhhiqQipHI0PItDRD4AcgQzvuVcPE9ytBS1+VQtIkZsI8Le9CkYdAQpi8E0JQ0jRDqSinQhTAjsJg2xzDRK7wQpSnqULgf+9CGv6eQikRFsJLz3LDAad4wxiwt0KGkhbCdCS/wqxKY8NJDrBCmDLAQv7qYkMj4C3DJz7vQRQykkIIjw7DwD6ZwX7bB0O0RpPDYCo7QzDjH0O7gqVCvO4pQwmQQ0OgVMRC7AFDQNRnQEM2V+3Chs88wnB/hsPkdC1CMMqVw5oTN0OIYtZBGg8NQ3SjhULm6D5DoCw5Qx1RHkMLXEFD/rcjw5yoJkN4KKVCri8TQ+I2gcJ+25VCihp7wtGJjMLAjNZC+FULQxDwxL3UHaJCkAHLQlyYD0MWsVdD5PwPQtCnxj2z8zdDWmT1wuY6QcE=", + "encoding": "base64", + "path": [ + "vz", + 40, + "data" + ] + }, + { + "data": "rgbSQeLjvcJdbvnAbm1jw3dePsMaDYFCNGb3wFLVKEPwag7DquDywdhLn8K286PCs9RvQEjBG0JhsOVCMIkNQnzr80J0ZpNCZiPsQvDpL8MqFGrDtyfoQq71FsG4HypDKtX7QuYiw0Im0R3D1itlw3HbN0IGGWDD3im4QRaZKUIUC+/CWu1Gw/PzB0K2gehCCNRVQtAx9sIKb9FCMI0Pw4I1j8KKG0NCSnyMwt5LHMN6TztDZoXlQir9NkIWmOVBciwUQ9wWO8PIw3NCbWU4w2PStkIeohHDKo4lw0yQQ0P2eIzDcVZTQ9mLIcNWCbxB5FZJQUaqHkP+2I7D4CBxQ/5sMsJ8pGvDIX12v0yO30H4aSZDc3U8wxNAG0Mtb1tCixlmQ3noVUPTl6dCaXsnQNb9lEK8p89Cuer9QlZAXMPj4xPD1h3mQY5LmkLO7gvDr67MQlRWEUIIpgJDFrw6Q1KdA0JtXYxCuqITwy7Vx8FOnjRBy9gSwxnPl0CopvLCaD4NwobicsLpCstCqZBaQzSLl0KSgAJD4Hhfw+hSlcJqRSpDYomMw0yF7EGqZSBDmFI3QwJuKkNM5LhC9MpWQt7egELEOE4/rYtjwSbUZ0FMIzpCVEFswuI7XcMutxpBOsAfQ5gprUKspC9DGsA8QiL4AUNSQRhDOCqjQphDlMMMwpRCXiUEQuTaf0ByBadCZuFvQHzd4cBU4jVDONwZQuq1UsB8Ha7CVPWvQoJ2LMLuFKdCt10ZQqt36UFUUojDpsAaw2C0VULSE7rC600kw2wVDsNYoDBCutJYQoAqT0OFgYLDeMKjQsXZDMEAH4rCxrU3QpjCz0LoLkfDOpsnQ64bT0PJBwVDLuN9Q0sfJkNdWmJCz5InwkhWAUMY0lHCJG2FQTgHQ8OD1ms//0NTw9KmfUNuFdXCvpTKQk4X0EGyRixD0AUiQx1/VkOuVydDmIxzw+NABUPnSSFCbg7eQi+mOkD4JgtDRK0Bw0uubMCPNIpChbInQ6K9gkKE+S5CQPYBwq4JIkOEBfJC5oHcwJwzaEJKV0VDPrtQwkLt/8I=", + "encoding": "base64", + "path": [ + "vz", + 41, + "data" + ] + }, + { + "data": "9GhtwUYJIcPol2XCNK4Hwy0/hsMeJvNBvn9awu32GULuFFHDBf+dwppkDMNadQrD+hB9QjwQyEKnbMfBD/JwwCS/vEKbuPRCMr6jQsaqu8KM2xXD2sKdQt0g4sLSMRJDc1a4Qqh9a0K40GfDtAGPw0hLS0Dop5HD0PPKwrfnt0JO+U3DErGIw+wCNcHsVJtCpOjDQo6pXMMXwIBC9AKOwnR78MAYouBC4YcHw/cCZ8PGqCBD2wWcQi+MVsA4zZ/Bzj9WQ1yC0MKVEvNCoRCHwwFKJcKl7pfC0LdtwwnDVUMYioXDuhkiQ7/lZsNmV9jB9MkZwsrgTkPf4HXDI1L6QoSeysIN5pPD9Qd3QpNnrUKRTNRB/J6Dwyzv7kIdpIBBKgsoQ4uOC0P57itCxEIqwjDGEUK0oRtDznqPQZQ4ksPLF1bDO1ekQpQ7CEMwPorCQXofQ/Q8xkL+p8hCXtwmQzAEtUIWNutCPKplw0Z/FEJUP49CHK5XwyKkekJSw0zCbiavwnN248LemSBDvKxWQyuu+UJOGb9CJM2Zw3CdAMN+9w9D5CmQwz77a8GqeYVBZIRYQ3MiEUPch09CoS8XQUTI0kLa6TfC7DEyQtVKBsJovJjCDK/zwkz9jsMNzB3Cq+AHQ5oLBEOS4hhDzBRBQBEYvkKnZ+9CEpRBwp0EZsNqdwVD44REwaI5d0ICGDZCYG88wqIcWcLFaiRD+Ig3wbSMY0L2IMPBfUxOQgERFcNClC1C63T4wOMAskJuMz3DEUWdwr+1IUH+0x7DKl90w2mYisIS3TTALB0SQdr8p0JYU5XD0j/4QpyF5MJLManA2dnUQh63jEIyV+nC4j0PQ1G2FEOU8zhDqHeEQ+BxBkM+2TZBVkm6wviiTUH0jqxAdNiYQqZ+8cKcs0TCdG0JwwxNSUP5BUXDcOlmQj5Vs8GfkRNDplwIQzpzTEM85ApDCj2Zw5aovUKoJpTA/jeQQhfkfkJUr01DoAFUw3ztZULG5OxBsGw0Q6eS/0IalJlAPFchw1p/IkPcdLLBfQdjwtVL5kLwpzNDrjbxQGQ/ScM=", + "encoding": "base64", + "path": [ + "vz", + 42, + "data" + ] + }, + { + "data": "wmN4wizbKMN5t+LCrHWFwhVbisMHvuPAbGDWwrxBvMIuD4jDsF8Fw4u4V8MooUzDyq/xQmTfHkOoJwnDPqZBwpbmgEIk9CpDe/EsQgNPy8GcbpvCf0QVQiRUX8O2YexC3GBeQnb0i0GdA5PDWpNUwxk5LMIKDWfDNlw4w6n4A0N2AivDy2F1w5kFhsJapQNCUkgHQ2MsNcMzgKNBFEgYwf8MSEIK8i5D9rxaw3wTk8NzaQRD/jsaQv3Ca8L4YpLChH2KQ1p+DMK/VjZD5qGYw7r6HcPD1mbBSLyVw3ZN5UISpT/D5QMQQhfnkcMsNKbCXKnBwh7hDUO+SSfDl+yCwEW+JMMwImbDQiHuQm4DDUMnTpfCLXmHwzKdpUJEudvB3EFQQko03MCAsim8QOO8wtUmg8DLSktDE03nwmKhecNCIifDDY78Ql6UQUM71VzA5FxTQ54CH0NTOodClRYNQ2rbFUNZkyFDdBAnw103wkIQIv5CkeCPw4ba5kIYmxVBXOERw2KuLMOFWFlDrhDhQk7xKkNop2tC4FmEw6LWQMNGZuFCbgVUw25/gMLgBsDCZmrzQoTu6EL+7BZBTzEgwpbTDUONTsvC/GbIQrhisMIalBjDojRJw3xydMNuKrnC9nHZQuRCMEOA1/5C4CVFwjaKaUJfG6dCj80mw7UhFMNGvjxD+Px3wgab7UJw0qFAROLUwqab08Jsew1DRMeFwuwV4EIaaQpCzZQkQUKaR8NguKO/bXduwu7MD0P6Yt3CkDZywUrAHcLuuGvDqjOYwxKYpcCoJ1XC4vEcwuYIDcIsBFjDJxceQ2K4VMOKfVJCO5gkQ5AFDEI95D3CEEXmQhWE/kCsgV9Dq2f6QsJkykJ4YhfCkL0Yw+TF5MK8AmdCgl8GQ8S0VcLkidrCg1GawoWnWUJwRy7DZ58kQdMAo8LSBO1CbLnZQoi4pUIIgNlColdkw4IRT0KC5VLC/JrxQfIT8EKwvYhDWRWTw0Zu6EJaxjzBZn0oQ2lKPEMeWxLC44hGw4JfFUOODP3CzpXnwrsgLkO0YR1DenFyQmRTM8M=", + "encoding": "base64", + "path": [ + "vz", + 43, + "data" + ] + }, + { + "data": "IdnqwmYv+sK6ti/DdqE1wVgVVcOqeUXClAInw9c6KMPIVHPDjK9Bw9MnmMOee4nDdDcyQ+xXWEN1W0DDhq7Iwi0W/UHSUl1DVrLjP0xMBkJoJ4PBOj0VwQ2rQcNORq1CQpV7QXZV2cE6R1rD7oYLw1CQu8Jk/h3DgoY2w7juIkPxbezCGrsyw6YYCMMVqpbBLZUlQ6ro5MLMA9zBbIAxQje/zkIF6GxDrb+bw1EBYMNm5s1CsBWHwGJe8cK04APDcU8RQ+D3x0GwxXNDcAxhw+hgQ8Nl8ihCnuBww1wV6MCaHffCHA+ywkBtbcP2KxDDeoAjw7IvTMF04MrCx1O7wuQZaMMGJB/DYTUsQyDFPkOpKgvDpAZNwxr2NEJiL5vCTLZfwhMy/sJTkTbCzHgbw8uEQMIn/kJDEBBKwzBFL8MTdNLCfCoiQyiVZEOJz2hCjtRPQ5mhV0OqFwBCjhHdQkfBVkMumklDGCjXwjyQHUPzXDJDbkx5w7bOI0MoTX5Ci4RSw4knbcMm1ENDhFyZwEz+UEM67aFBKPc+w5qmhMNkcplC29EOw2k68MLs6h/DLg23wZ1vqUKFGw7CSpi/wvZnLUMiiynDMTMaQ5T6FcP3sDXDrkWUwwoRMsOiuxXDIrOcQiYFS0NhecdCJHDgwtkBnEFDyi5CSJBAw6pvoMLKWV9DtLzpwjiPMUPMCRvCkjgwwxitIsM1MORCSD4Aw9ywI0N3+LhCYDAVwj3GGcO7wU3C4MrrwtzIQUOENS/CObshQpQzwsIaHZjDvaBqw2QPVkIcI9fCCvK1wjom6cKHyQ/DldccQ/4tPMNVXtZCFBNdQ5yeL8ABXlJBxAGnQlD94sKaZdtCFjCIQaO5hEJfyLfCES9dw66tPsNwB9VCbApAQ1W58UCbEDXDVjXIwezxUsI+gPDCDrclworAG8MUcatC+RSfQgRhHMKR5ZlCZrIZw4t9fkAS3NDCi+p0wczdLENIUzND4DJ0w9OULkPcz1/CJkEWQ8Lgc0MH/qLCnhAWw0xAA0MwgzTD9ME5w2yXbUMaNQRDkgvbQvBO98I=", + "encoding": "base64", + "path": [ + "vz", + 44, + "data" + ] + }, + { + "data": "hGc2wwiUiMKqk2/DtjwPQtX8FsNU2cTC0thpwyvYJcNLUzHDVPR+w3gZi8MKc3HDxINrQ7puYUOcQhzDvpIhw/4ToMC6pyFDzYsswuAjrEJuMxVCcYF4wloG98JECE5CkDHiwTrfl8KiGRHD+caZwigbFsPr2bnChMcGw8xyGUMOQXbCTqDrwqSKWcMsGp3CcOgTQ5zrQ8J29J/CZf65QpjzGUPrqlNDlrSIwzZuGcNAUJBCXCNNwn15OcMSC0TDNi5zQUKAnkL/FzJDcOkYw6CQFMO+iMBCRE4rw+yWw8JWqX7C6igjw2gqJ8OgtU7DWoJrwxSG+cKsxTXCSt8Vw+7Ij8Mz+73CIi1cQ8Q+SkNwtizDbHYNw/w1zkCe6wjDCewCwxOBOcPk4rzCgKNjwwwJwsIn5M5Cwocxw/6l1sLpbwrCbpIuQ/BzCUNGoulCIYz4QrcvVEMOJOnAs/qWQsmFjUNDWQ5Dfp9BwgzDXEPRfF9DECAsw535TUOUHuNCqvWJw88vkcNeaqdC0FHCwpTrC0MmoqjBuzH7wnRYdsNo6g5CdLajwoe6NsMOSSfD+Bv6wg61RkJsm6fCfksewzrBCEPnkHrDnrVOQ2wzWMPBPg/DOriSw2Z+4sLW7FDDdmMxQrd+30L2k4tCaog7w7j2ssGMdse+ku0OwzpPuMFm1xJDUuUwwy9OcENnO67CHq19w1JzYMNuAqVCqVBCw5N6U0OWchdDBn26wveIyMJRddjCiME1wxD6VUOkkF5BwOm1Qi/tJMMYD2/DdlElw8vy2ULWSyXDL4gRw1ibJsMeL6bC5oXNQvMh9sJ2/x9Dn8VSQ/3fLsLA04hCBDVAQgx7LsO42Q7C5H9swgyW7EGy+xbDZTGOwwh4JsMsshhDjHx4Q3rRfkLWxYDDAkmyQchX78JgqXjCSLPDwjyHd8Mo/ERCIz9AQp1Q6sLKmSxCbuu0wjZOQ8LMuR/D3KKCwpLfXEOOPktC4JQxw5NIaUPYw8/CEhj+QtrjLUM2RgPDPn3HwjD12EI46hrDcIuCwxVDWUPsWNFCeKsbQ0XJaMI=", + "encoding": "base64", + "path": [ + "vz", + 45, + "data" + ] + }, + { + "data": "1jF9wwBaskA6yobD0H6bQhgwvML6VB3DAFOTwwbj+sKLauTCaPOBw3oRR8OWBCnDpL5LQ1UB80L8ed/Cx8hnw0KlO8IdiERB/Z24wuLNBUOAU6tCBn/0wqkpbcIacUZBmCabwo2wAcPIzafCpue3wVUiVMPOFRHCfLShwmvszkIjXeI/bnR+wlq0kMNVXBLD1s2qQv+0h0HcMwnDKK8JQ3y0SUNcsL5CSCNKwxwPucJUkx5CFsrPwlCVc8PsjYLDAieCwvmWAUP8wkVCYva2wkaVxMI8UxVDfIbVwrV/GcMTQh3BdQYtw9reysLy/oHDnwOUw2BSLMOMD35AZhQrw9oga8MC3hfCU249Q9La+0JjeQ3DQbOowqdMCMKVUVDDugQww2U7HMMgtBLDupaXw4uCGMPYpIHBMgb+wpJZPcJuBztC1pEAQ7iBTEGKoixD4piPQY7h6kJUWE7C/u0OQorIHEN4t09BXMNiQV4KiUO+uzBDDo/RwnK0IUP7XiBD7gOKw/DyXsPyhRLCVDAfwwA8gkEkxoPCrJ+Hwrf6KsOyLzDB8crWwTaXd8Ol+AHDUPUwwyfuK0HGQAjDJNRgw0dLNkKOJJ/DLP9YQ5WGiMNOhbrCDQNZw0vGU8L6J4PDx/67QG4WIcLOxxRC+qGFw4yZiMJqMUbCsgq3wp2s1kE9AAtCHoduwyEuVUOofQ3DVvSVw8NujcMC6zlC4gWBw5LeO0MOj1VDFwggwwq+HcJILizDVIR0wyB6DEOS6oFCQC4KQ9rHccMo5yrDx8XQwhKdIkNphV/D9WJIw2hcJcPi8PHBYo0NQYAsb8KQZFNDtkXIQlIPssKA3fBCoBMBQWq8GsNePO/CMH3mwsrGHMHdYFXDjNRdwwRV7sLU4UNDMKs7Q0Z26EJ4h4jDbPeFQtRLIMOycRZArr0ewx5Ro8O+DwxBs9lcQex7IcPi2ddA1IgPwlxd1cL1kljDPcnxwtIDOUOQ2zbCYGftwkAcT0P4rhzDME7GQgiVdEKoRTvDiDU4wjSYoUJrHuLC0DmLww/CpkKDlJVCVPpGQ/HSnEE=", + "encoding": "base64", + "path": [ + "vz", + 46, + "data" + ] + }, + { + "data": "RDiNwyYW1kJtQFbDWHvoQj0UJ8LGQmXDlg5qwwYqncJWWWbCJtZEw45OBcOANtTCPsWxQtyCur8SqnPCjzGUw3qmwMJwosXC7moSw/1NMUP1DwJDvsE9wyDf7j8A9PrBJJEFw6KkPMPS9v/BNsrEQVIpicPpfl1Bst+bwWLmu0HqhJpCGjZqwW5+gMNsG1rDIWuHwWoTrEJdu0XDgpIyQ2zySUOqG5HBlvgMw5QqH8KkmJlAYV0jw/r2f8M2eo/DrHvnwljlMEM7yF7CL9EWwuZbLsK5U0pDFFRDwkscJcNCFx9Cd5UGwxSeKsKFu3XDcBZ6wxUtDcMoBERC0NcIw3/eKsNbg1dBv4O3QqAKo0EuLL/CFVQDwkjYmcJssY/D7IYdw6oV5sL8fUnD/mmMw7QSWMME9+DChAWSwhu8yUD20g5DFopCQhpTr8I+2V9DB6KawkAEvUDWc83CWCsVwR61yEG08uvCrpGqQrzKJkP7eZ1C4AY/wrgRjEKqcEtDkzpQw87YE8OpIPXChTA6w7tJxsKgbebC1q12wZ661cKr/4DCUoPBQUNdiMOyBabChmYaw1YqBMJyN0HDyh+NwzTfp8JToH7D12D+QvmkasMIgvDBfn8Xw5w8RECiGXvDdJsZwsiyDcNYCaM/Mb6Nw0xn78Iai9HCpEQTwipwj0IMUIzCNseNw4Iho0IkFEvDTSxtw/e9bsPn+axA7ImMw6aQskLDsopD6YRtw1m7/kFC82/D5EmGw+R2/kGu+91CIsc2Q9DQmsP4q93CLuZJwuCIVkOKL4jDFj54w7yo+sLdX4tB5BnqwpaAOkCeclND6K6uwdUEDMPYbypDilYWwrJP6MJaDSDD28ccw+yPUsIMZ4fDVo8Zw9CUhsIaPzdDcsKJQtB/JUM2h1XDTHDdQkoAGsMmRpxC5kFdw/nagsNOXhHCmHPBwV+9GcM7rgTCdzhLQUpUKMMrdIXDUaQ2w/tOrkI/Kd/CLYaEwtbWr0JQo1bD5KeEQhS9LMK2oXjDDOFhQZCrPUIUFH3CuJxYw6y6ysH46yhCtZUvQxoa6EI=", + "encoding": "base64", + "path": [ + "vz", + 47, + "data" + ] + }, + { + "data": "WuVew2hqdkMg1xnDDzwYQzW55UBmDpjDDO8jw6DcucHukNzAnlcFw7jVm8JC5FPCWLmdwRgru8IRh4+//P57w3+gHMPUqhrDGfJMw6SRVkM60ipDuYaBw6yVe0KFVaHCqOpEw/6VecPAWlZBUCSHQuBLh8NMFmxCEF5UQrgzpMIKmzBDdI/0QXT3ScO0ZYvDeHADw2QxIUPq437DSqRHQ40d5kK9PMjCpAKvwjYD4UA+/gTC0nxlw6YhUcNnJGHDLi8Tw3kOXEN01vjCYlUuQXpPlEHCDnhDSD9iQB58AsNL8qxCHaGxwj60IEFRaUDD0g48wyiS0MKlQ7ZC7v2wwmai28LMsHJCtkK4wedKm8ISYgbCkoJnQUR09cJcsozDwMbkwr/+h8KGvX3DGodTwzzrjcPCZCvDu1xZwUyUXEJoGHpDEIF6wtrzF8Nu1GJDlHgSw8gUq8LCKSPDqOBxwgadYsJ8SzrDtM4uQ7RjIUJgxPXB68fEPznvDsL2LjtDNfcMw5g6pMJzcy7DVJIVw7omJsOHAirD0HIFQlCEV8L9EfvCloWRQtJzVcNMjcDBcuHmwl8OpsJaNnzDPQl4w+yhLcNMbz7D2liHQY93L8NZJ1NCEN+9wp47XkLMXUDDLt+0wtzcMcMLBhzC/ltfw2AqMsMQkCbDRvfBQawV4kKcUhDDPNxnw39HzsGIlobDoL8sw47gJsOMiibC4tNiwwS12sF0Kz1DxjGaw+Yc8EJuxJPDeCVYw+NNksI+uxhDUAJYQzUXgsM1t2fCTc7Nv/hQZUOvO2/DgGNxw/TajsKOynZC0tBQw1CehkJMbORC8Nvawm+dRcMiJlpDPuu0wnkLkML5cQrDdkctw6hEyMIC7oTDix28wrRaDcGSF8RC1IgNwtP+UUPXnhvDyNYaQ0Cr58I3cS5D+sSJw6DcRMOSZK3CRpWGwqh/7cKWw5vCOIFkQk6zZMO6oHTDCB54w5UDtsHrVhvDjESSwX2wx8EMc4jDJhvfQTqp7sKi9YnDnsisQgiT3kAAEibA6pIcw2CvvMJCJcxApImdQnY2bUM=", + "encoding": "base64", + "path": [ + "vz", + 48, + "data" + ] + }, + { + "data": "3Egjw1ocdkNQdcLCFIk5Q+JNV0Iu1nDDQFrLwvjANkIADBxCsjyZwr5v68GWCOTAqI+/wt2fGMOiE5NCEnU+w4OWZ8PMnRrDkTuDwzirK0N+0U1DrByWwzBh/UIuGAjDn4KDw+QKkcPzrlhCgvfVQmKUS8P0rMhCLi4QQ/PYL8Ok4JpDFD6SQsDAFcO54YPDqHJKw6hocUOUC4bD4ukKQ47SYED7chrD2p0cwoKERkJKepfCdteSw4TCG8N2oR3DeO8Ow4QOO0Nm1CXD2jxgQj6xu0IEZSlDTDBOQr4/qsJMLANDPpYJwrxNZ0IhWAfDqXoAw1i8ecLdTgND5i25wSB4WcK4K9FC0gvjwkIYE8PJrVFCIc5qQnbSK8PqwFLDTAxrwvRhScFa8oHDJgoVw2klicMS0S/DzaVcQvSNyEL3NWBDzEwkw5kSMsOomhZDkA09wz0TFcMYl2rDEInswl4A2cJU/iTDTvOVQ7P3RsJUPejCCsM0Qo1v78Lq2sdCagKiwi0508GiiSXDqpjFwheUKcNOv2XD8LqfQkbtDcGM8EDDlf7vQpTiFsOP7lVC9TmKwhvBDMNA+ZDDOug7w67LLsOXkAXDQBKPws0M7MLsLClDBkcxwiFQ0kIs1gHDZbUYw5b6EMPvP6rCHHQkw7bpc8PPdWjDWjPCQvp9F0PKzTvDA2opw/5yvcL6yZDDpkTkwpxRycJhTL/CEGslwzaw58Lj3opCFbiDw7BXaUPqYnnDDOQdw9PEE8NyjD1DNfoVQ/YXRMPUWiTBEBIvQlpWDUNcYjLDxf48wwCjuzygtc9CCDg4wyznB0Mkmnu/350jw6ZSgcMgD1BDrDAYw3y4ocGAJtLC2KcDw3KxGcP4d0/D1GQrwnvmcULQpgHBcJ7WwpyoS0MXsc3C7EJIQzM5dsI4NJJD4nWBw1zBCsOseQ7DayrrwnCbksKTKgHD7knFQrGoicOeADjD/LqXw47F2MLeWCnDY4PWQbKIzMI4hH3D2h+KwRYtKcPC80zDEzU3QwPGKsIO65dCm9vMws94CcOGywbCchYTwvBnhkM=", + "encoding": "base64", + "path": [ + "vz", + 49, + "data" + ] + }, + { + "data": "q2p7QUZUfEEeBn1BbxB5QZUdc0FEyHJBMDB8QTGYfUFw93VBquBsQStIekEqtn1BBAh7Qbxud0FTymFBSiZ1QZQXf0EVRmJBdtt1Qd94gEE+tnJBUdtxQaBYekFLM3tBIu+CQcT7c0FYqW1BMGB5QZ+NdEFmTHdB+DVSQbyifEEwiGdBE0eAQW8QgUHS529Bq+50QcI+dUH8CnFBjep4QW/sfUEFv4RBgL15QW71dkGFJoFB3vNoQeJ1iEERH2lBdDx6Qa+0e0FVoHtBpM1yQf6JgUHCx3tBZiB7QeugdEHyUHhB+ZSEQYOedEGTAn9BLERzQViIcEHNHXpBPUKFQbtQcUHiSXVBtyB1QUm1eUEkP4BBiLh2Qa76fUFdPGFBip59QXQOeUGJ6H1BEFR6QZa6bkGIXINBzGR1QcDCgkGZ24JBXn94QbofgUEwZ2lBXxV+QSu2gEGnsXFB/NuLQRNDdEEvcXVB+nZaQasBhUEiaHZBM/R9QdvKgEHMiXdBbQZyQSxEg0GL4YBB+kOIQQdUgEEdz21BXR5yQeaRbUFM5YJBDmxuQRhYc0HH+35BiC9iQatNf0FD8YBB2GV3Qfkmd0FZDHpBGRFpQRy9a0E+mHpBPet5QSNSgEFGmXRBoHWGQevna0EO+2pBdOp4QSQgc0HleHxBOk+BQZKTd0GfFHZBmEhqQSdEekHwMnhBmMpzQesHeUGkT31Bsjl4QaFOfUGYVm1B4odnQRzLgEGoMHdBjWJ8Qe8obkFm53pB2u90QeI3dkG4hXdBzz1vQQcpf0FwM3lBAB12QTDFb0HKnnNBQmSEQclEZkE3an9BsW97QYENcEEZJnpB8aF0Qakcc0GQOnFBU/R4QXApe0EJ9XBBISptQfqpgUFxG2dBzkF6Qb47dUESeW9BlH5zQb9KYUHOEHFBvRB2QU+ZcUGeSoJBnYljQcq0XkFQIXhBr+Z/QQrHfEFIrHNBgVxsQewma0HysXxBrmhmQSJUfUGKfnpBrT6JQZo1gUGCgm9B2UtbQQZUhUEKvGNBVMduQa1ic0EHz2hBeRl9QagQWkE=", + "encoding": "base64", + "path": [ + "x", + 0, + "data" + ] + }, + { + "data": "6jFuQa4AZkF3oWxB/WluQZfIaUFpM3hBNeVsQa/fa0H8R2tBi4hrQSjMdEEIXWtBlVlxQQxtZkGmN1FBkOFxQfUSekHZUlhBbLx2QQXhdEFuc2lB+t5sQbVEZUGfP3VBci9/QcbDZEE2zmZBM7JwQX8dakH3qmxBXtpGQX4sdEFwQVlBY1dxQYdhfkGLo2lBW5lgQXZXX0E5h2hBTC5nQQiAbkF043tBl3VwQYmYaUHXNnhBMTBfQX7cgkHlFmFBGWFlQUNJaUGOO2tB5k1wQal+dEEKkW1B6N9vQTLebUGxOG5B5eB5QdtUbkGlk3hBAItmQfZHaUEpbm5BdeZ5Qah/akEW729B2RtpQc3ycEESR21BHpJtQXXhckEmhltB6WV0QTxtaEFX9XBB+pdtQRX4YkHDT3dBWmRhQV/jckH2X21B8TFpQc/VcEHfzGdBhel1QdcFbEHgtWdBTC2JQWlwZ0FIrF5BnF9SQbFGeEEBf2xB7CdwQSKCc0EgmmlB3stlQUKHfEFsSnNBrsJ8QbSGdkG2G2lBT65tQVL0YkEpB31B70poQaogZ0EK1WVBxJBWQcHmdkGqiHFBuphzQXTraUHGwmxBvUpoQWhpaEFjPmVBgMhnQRnucEHlk25BRp6DQYBVXEFyvmxBbGh3QRg5Z0EWdXFBHGB0QVZFcEHjkWxBgPFnQd9acUHwUWxB8ZJoQQr7bkHlInhBjV5vQZo/dEGUjGBBgZRlQZ2Gc0GFYmZBCBZ4QR6UYUHNmmxBjc5sQessaUFV5HBBXTNoQSu7b0F6y21BfHltQUM0XUFFDm5BrGR5QWWZWEHaKHRBDhhsQc21Y0EoEm5BHlt0QTLSZEH/52hBnYNsQfkweUF6Wm5BDhpmQSBZeUG4z2hBvzx1QW0bckGegWtBatttQT6oV0EP1l1BcEJsQU7QakHewX5BBGBgQZUsS0H5bXxBPSRxQd4+cUF6HmhBuhBkQbtKYEF9snFBP4dbQQN2ZkErjWpBSUiDQVY1bEF3/mBBYBRNQdfpf0GnWVRBd5NhQV77ZkGnTmFBFHtwQTd7TkE=", + "encoding": "base64", + "path": [ + "x", + 1, + "data" + ] + }, + { + "data": "AFVKQa++QEEf+kdBo2JNQQ3KTkG9HmNBmm9IQQzZR0Gc70xB1ZFUQfP0V0FrsEZBp2BQQbh6R0E/9ixBevRTQbH0X0Ef4ztBW9BbQR7DT0GgVk9BcmpSQVcfPkFok1hBHxNkQYqYRkEnpE1Bfp1QQSYETEFd/UxBqrYkQejEUUHjrTpB0ChIQR5QZEGbME1BeZU6QVpuOEF/IUtBMHVGQfWkSEFRVllB1zBRQQcXSkG+dFpBeQZDQUx8Y0Euy0NBTig9QbYxRkEqDElBoORTQYIfT0F+oElBMHZNQbpzUUEHLk1BSxRUQZebUEE0Z1pBYhhKQVxaUEFp4EtBK+dQQXlZUUFlAFFBLQJLQSBDUEGJKkZB0AhOQVBUVEGCO0RBJBRPQeVIRUE4+E1BQUZLQcvTQkGI9U5BrAI9QW3uR0F8LUBBdT1EQXgXR0FpB1NBln1RQSlCREG2PU1BBlZ4QUu0RkHmSTdB7K83QTjaTkF7pE5BYHhJQSMOSkE4GkpBu9dKQS13WEGSg0lBKItOQR/hTkFFd1BB1hRTQfvgRUETll9BhK1RQbfmSkHjMT5B4RQ5QQCcWEHMjkpB8NdWQbTlSEF5LUtBD3pUQQ8HVEHexj5BRc5CQYpYSUGkXFJBmQxsQWVzO0GqM1hBNYBeQdDyRkF9jlFBm+NPQZAvT0Gu501BsEZUQdQoT0ELOEtB/c5KQdKsTkGsKFpB8kVRQRh2TkEKEUFBCUBTQY0rTEHCa0ZBGVtcQUsOR0EAmUlBS8lOQU2QSkE/oFFBMclQQY5oSEE2jUxBq3NPQVEjOEHCvFFB/ftOQcnoNUHn2EtBh29IQfr1SUFEXEtBC69ZQaAOQ0F50U1BuKxKQes/YUFZS1VB94lNQV1XVUGbZ1dBlM5UQWCdV0HJZ1NBHYFVQU2qOkHbdTtBD15OQR5tUEHkAmNB5z1PQZz3IEHFB2dBSHlIQbtDTUEnFU1Blz5HQTvgRkGbsE1BVeM9QRoYQEFru0ZBrslkQfATQ0GqE0NB9acpQYXyX0FYHzFBGatBQf6fR0GmCUxBqt5KQXeSL0E=", + "encoding": "base64", + "path": [ + "x", + 2, + "data" + ] + }, + { + "data": "tKIVQXiHD0EvwRdBa6kZQeq4HkE3PzhBzBAUQQ7UF0F9eBxBQswkQXeZJkH61RRBRIodQeTWHUHOEu9A5sscQZRHM0FuHhFBWg0pQRZ/FkFYLh9B97QhQTkrC0HwPydBZ+M3Qb/MGkGXdiBB6usZQQ40HEHKtRpBQOrfQAGiG0E4Zg1BYLsRQUgmNkGmgh1BYDQHQYtWBEHLdhxB+rQcQRq8F0FkgiVBx58dQSUQHEGFNCxBFkMbQZtBLEFqihZB9UMDQdmKGEGfJhtBdtAcQVsFGEG7ThhBdMcXQeo9H0HNNRlB3SkcQTfwGkEvOCZB5BEeQe5dI0FodhhBuKkTQYuBJEEydBlBYt0cQa1uGEFQYBFBHFAaQRroJUH9AiFB4/sUQexbFEHfVhlBXNQYQRyiE0E+NRNBZSgMQcAYEUHDtgdBABQNQVI2E0GxGCpBuMwXQc0+EkESASJBGsNMQUTxFUHMzAJBfhwPQXVRE0H+bh9B9coSQf8CEEHtTBxBNnQgQVdeHkGW1BJBUlMNQTSoEkGBmSBBzaMdQTi2GUElrTBBvgQiQbFZIEGs+gpBMDAOQadQKEGfwhRB4QkjQSLcGEHZFhpBNy4qQUYOKkEMoQ1B3X4PQQ7yEUHwaCFBUGc+QVvxDEHO3ipByrwwQSETGEEGrSBBTWkZQQXZF0GxxxtBdC8nQUL5GkHHHxlBhAYcQdgdG0FhIiRBLS0gQUwjFUHWsxFBmFQrQXheE0GvHR1BMKUpQe6vH0G9tRlBTmYbQWInHUFmfBxBsFEhQStEFUEqZRhB408eQZpnAkHnuR1BMQAQQSFkAkF4uBJBIl4XQe2kIEGyshhBH2IpQeLoDkHOVSBBNUQWQaz7NkF5kCRB9WMkQVIyHEGrMy9BYRogQVSlJEE1nyZBAT4sQVjfD0HvgAxB1Q0gQQt/JUF8HzRBR5oqQSGgxkC4WD1BOpsUQX3VF0EKFSBBodUaQRCUH0FxxRdB3UATQcJHDkG5OxZBF7YvQfzcEUGpQxpB22LnQP8FLEEBGfhAa6wTQVflGEHx9SRBDfgVQZeVAUE=", + "encoding": "base64", + "path": [ + "x", + 3, + "data" + ] + }, + { + "data": "ykikQNHjnkBvRbNAy9KrQAYHsEDGAPFAn5WlQIQXrUBp8bFAbfu+QDlvvkB+UadA6KOyQK7Qv0CCVkFA5PKiQKTt5UBwI7FADWG/QJ6PnkBVHq5AY46wQCMOmEA9q8JAa4/0QEjzuEDuYblANpKjQNpisUAI1q1ALo4mQFm9pUA5MJ5Aa2ekQOdn5UCEZbJA8KyLQPEkhUDzd7dApJjAQLjvskCWwL9ACa+qQJvHtUCEe9lARADGQKxdu0AXq7ZAjJBZQFTNuEDgirVARJ6iQAqbpUBNVrJAk2KjQIyYr0BI/apA0gWnQM34o0AToLNA2G+6QIF4wUCXyaxATnOTQJM7xUAZY6NA6qO1QPPDoEB/vpdA7jWrQH3rzkC3N9BAA7yRQBB9sEBg76dAy5itQIPxskB/4JZA5LCiQL3fnEAyUoZAj2iKQItPq0DaB9JAkH6WQGQ4pkBDgMZAUY0PQWO/rUCU8IJAITOvQC+6lEBYTLpAQWqeQN6AlECqB7dAhXO9QCPdn0B086VACJ+EQMZymkDbG7hA7FKkQCRVvEDbmOBAChawQEtzw0CM549A+KCuQIzay0AJRahAecyzQAGps0Acqa9AibfOQP3a0kDU5aFAwDmbQKFGm0DWu7VA/z37QE8epEC2t81AK+nZQADOtkBeRL5A/s2mQP42pECIQK5AdK2/QCi9rECVB69AP5+zQH29qECUwLJAhbazQCmyokCHIaZAgmbYQFLXmUBvMsFAa/G8QI66w0D+IrVAD/6rQEBhukBRkqlAXmywQH5rr0AddKZAIzyyQMwyb0DkOqhAvrWHQIW9fUDc76FA1nyyQGJ2x0CT0a5A4JDKQDz4jUCn/LhAZvOdQNLt9EC8HLVAAM3QQFfrokBMdt9Ax5CwQLRCrkA5CctAxqXdQImVsEDtz59ANkrEQEea0UCBl+RAqCHcQIvrmz9x/f9AFAGvQCEWp0Bn87hAR3S6QEGUxEAm1KFAcMmzQHlgn0DjKrBAGkbPQFoZrkCaFMNAkEsqQGFrwEAKWVFAOhi0QCcYtEBvzsdAf9OqQDVVi0A=", + "encoding": "base64", + "path": [ + "x", + 4, + "data" + ] + }, + { + "data": "ZyUQPxRzmj6HE20/9PQFPxHDmT6rgR9Asv8jP6v89j4yEwU/Q3s+P2GQzj6vdAY/ar0VPyjuWD+/OwDAKdmFPeAsCkA4I5g/WuL4PsZ0yT0rb2Y+BuYwPrmlbT7pz24/tlI9QJr+Uj/86yc/kJYCProCBz+PpQg/EJYQwIC6dLyhams+NFZVP2wj6z/+rQ0/ASVUvndy1b5eDnk//JuBPw9FRT9VIlM/aRI+Pi3vLT9fyf4/7ZvYPzRbBr3Obps/F90BwObIbT+aHxw/ITqlPVatmD6IQFw/Pi8nPtfFET6XHww/+SpsPrjF+zxgMza9pqs+P5INUT/CHyI/cg/WvnxneD/evKA+aFEpP2SYwT1vwIy+kib3Ph2y6z9zSOs/KFdMv1UKeT8YHaY+azIcP950nT/Z9y2+tM6CP3dyoT5Wfb++LIYTvyoGWj/L8aY/YN8svyz4Mj+cuKw/+A2KQADnVD86QaW+RcKPP+GP/b1sVhM/rJ/0PtPS2z1hjTM/9uEoP38Ekr6xSzY/VktRv4CooT7IASo/AOk5OxDjsD8yTQ9ALMzJPdiOlz9tr8q+QTWiP1EttD/29Sw/2c6DPicCaT+3Wws/uJWWP5WWsD+2IB0/wahnPi6HeD6zybg+PDs3QBpecD9EK44/GPCzP5+akT9bVZM/ppuPPgLw8j6Udvg+vpTvPrUr9T5zoDU/1CkfPy+vlT4/n4k+4imaPu0U9z7uETI/KxLUP0Hfhb3jKIk/A4p7PuXzfD/lklU/Q7nhPrpqbz8OUo0+2kQvPpoGXz8tUt8+DEvKPihknL/nKhE+jMpVv/zdNb9R3jM/TvhgPzHxqD+hvyw/gKSdPxfsXr/Lmgk/vitcvl1MP0AwFhw+bs/dP8clzD0yGvE/GDyFPjCIMb7qp6s/6NL7P5RsnD/IUBM/j/PPP3Bu6j9Veg5AxKb+P8W7fsBnmktA35VnPwTO2j6OI+4+J9CRP1zegz8Gjpo907idP2/wCj9K5Hs/BUOdP1mLhj8LxNM/gagewDeqkT7G6+u/4DqaPxUOTz/UrX0/yOwzPzThFz4=", + "encoding": "base64", + "path": [ + "x", + 5, + "data" + ] + }, + { + "data": "ZF+BwGJdicCCIoDAyJ6LwLJBlMBN9kXAaoiAwDF7jsAMWpHAdRSUwBlLocDCO4jApdSPwOdRl8B+BcDAlCOQwIVSWcCLiWXA44agwMvqksABv5LAkxqjwDs8h8C4UYvAVn4JwJa7jsA4A5PAOhOQwKs0kcDwBo3AgNfGwLNGnMCtw4vAn9t1wLEOgcC//5DAAKeSwC8dl8CgM3zAY5mRwNH+jsDArZHAbXSbwFKIjsAMHE3AZHJNwFZSsMDQPGLAhnjUwN25isC4cpTARwaPwHRfj8DBbIfAcQWPwPR7o8BDhorAIxCPwIlSksCFB6zAIMmSwN38kMC/4YnA1aOiwBwDk8BqS4fA2GyQwCeRjsA0/6DA8WKLwL4gRMDvc1TA2b23wAoRb8D2i5HAyRqKwLj9XsA6tJfAFWRYwHxShMAjyo3ARjOfwJfAgsB/ZYrATKK0wNiegMAcl3rApFtQv9tZfcCFLozAA+FcwDqtksAWLprAto99wIQ7gsB+GJLA9/OZwNB7osB4pYLAVXOpwJt3gMDqN5HAffORwLJQYMBDEjXABO6YwH4+h8AaNp7ADeBWwKhEdMCC03/AeAugwI+5fsBf147AfXyNwKZ2jMBfuHjAXDuKwNQKh8BvY5vABAYmwE0CasAzApPAeU6SwADFbMDmiXTAyKWRwNXChMCspY/AkIyhwFhMjcA3IIbAiWqPwG3/jcAzk6HAYDCewGdhhMDKGIHA2Oh+wAPBlMCUIpHAGW2pwIwBkMAB9o3A6+2MwF9oicBr7ZLAuZOYwCgYhcCJBorA25SWwNvWtcBi9pLAgLytwN5gosAFp3rAPtOGwLe0hcCf/YvAYB6DwB1KtcDqc5fAXQSjwME2CcCBGqXAjK5nwARHksCH1W3AXeabwPEcqsBUGYDAD91gwJWWWMBR23rAyMtFwPjrU8Ak/j7AL2VcwLwx+sAZKwzAqOGHwHi9jMAQ9prAMKxxwAFtjsBM4JDA9RtcwG0sgMBXZmzAOeCFwISde8B8Q07A7HfHwOQgrsCpQMHA9+ZowLi5hcCweZLAXqGFwC93ecA=", + "encoding": "base64", + "path": [ + "x", + 6, + "data" + ] + }, + { + "data": "lpT7wBKP78AIIQPBK8UEwVCqA8EoxgDB1Mr8wENm98DZNgXBON8KwWFfD8EppgHBZ0YGwV5iEME5ru7AuNf5wBpNBsHwad3ADTIUwccBA8FzawHBek8UwZdD6MDMKhHBLXfewJ27C8HZCwnBDjH8wBoyCMF2LgTBGOb5wPPoBMEDxNjACfr7wEgnDsGOtg7Bbp35wCmh8cCGUQTBV8oNwZ1wCsG4fgzBVmsLwUbVBMF/h/nAbAbxwMQUGsHXwvTAawQQwUMCCMH4HAvB/Ub+wGl99MA6RAfBgOb9wALLDMHLkATBapv1wBEo/cBZCxbB1IAMwYffAMELzwTBeBQBwTvoDsHjuv7A0/0IwdGq+cC5gwDBcRcDwcXo7sC/LPrAABUQweaFzcASKgjB1o8Cwfwk8sBQePzABm7UwMJd98Ad7OPAPk7/wPXWBMHcKwvB2HQPwawBAcEiIQjBG1q+wHQ888AL+O3AHpq/wHmT+sCphQzB7LX3wBMq7sDOAAnBc5cOwbPCCsGINATB6M4BwcBf7sD/cAvBbxf7wOXi9cCQfvLAF9UCwb8xDcFzdubAVKTVwHG7BsHJCf7ASqcQwcqg+cDXAQXBF4YMwUy/EcHGcdbAL9b+wAxI+MCmOQzBJGn0wP0Z48ANNRTBRLIVwehZ+sBOAAPBfZn7wImGAMFM8wXBu04TwUC0AcGnZATBKrAIwW2SA8E4DBvBzzUQwQMS/8CH8fvA0vkMwfEi9sAUQRHB0esWwcsXC8H9GgnBXn8BwcgcCsGCpQPBhbsDweTOBcFOeATBvXUMwfulA8HvAgDByowHwRaU/sDHefzAV14IwRG5DcEfOAbBqUAMwYycAcHWgQTBAT8GwTSw3MCzPBPB660EwUDc+sDXjQXBZ5gGwQWYDMGS/gfBLYj3wA1w18Bw6ObAgmrtwCnF98DVU/zAlhYFwXICF8EaDuTAu6kIwY6KCsGjCw7BLMH/wDSCC8ERU/nADMrqwMFV/cD+DvbARWERwfchAMHs/O/Ab13uwKbcI8HCrvbApfX3wLRb/cDSmhPB3OUEwTKoy8A=", + "encoding": "base64", + "path": [ + "x", + 7, + "data" + ] + }, + { + "data": "0SgdwfAyBsFUQyXBvqggwf32GsEYDy7Ba+odwYkxC8HUSx3BiT4mwWT2J8FlVB3BYA4gwWhALMGP6efAS5gSwRiJMsEmWffAOZkywWGTG8El3hnBAp01wWwa/sDhqkTBIa8hwS+EK8Ei8yPBWw0TwY3NI8El7h7BryfxwMOJGMFww9zAj6oewXTCM8GHTzrBVz8RwSdZAcG+7S7BDEgowYm1JcG2/SjBz6EiwbpYHcEJ+CXBF2kdwcUnO8GeiB3BwXIXwfCzIsFIyCTBUGoZwdyiB8EfTSXBEmMXwXZOIsFc4CDBc2cJwRroFMH3JzTBer8qwfmbFMH1RiHBEyUMwbRVLsHAmB3Bu6IkwSKSEcHi1gvBhgwfwS1JIMHwrCXB0XsewWdk18CZGSjBjukdwYEpGsGXBBDBnZXswPXKFMGGlvLAo4YOwQOlJMFaiirBwYgbwQFeIMHvHSzBUoUhwSkHD8GSRQjBrfTAwIaSD8FYZSTB4uAawcJ2DsGN1yHBB5kqwbKDI8GLqiTBQI4MwXs5DsFF/irB2l0UwWlTHcHoiS/BdxsYwS2RMcFyFOrAfDXtwHI1M8GTsB7Bp7IuwcMjF8GeVx/BhuspwX+eNcE36ODArYUYwbvmFcECTyjBwi0uwfvpAsFatzrBpAE7wV1kHsFttSzBOLINwfR1H8Fklh/B3GkvwW1wGMGtkSPBTLslwYDAH8HZskzBK7YuwYDDHcHEAhjBluIywbeOB8E67DLBZbs0wVxnJMHDgCPBnsgbwch1KsE2cBvBq7gYwQf1I8G/dyXBqSgtwXpzCcF0SRfBCToUwQd5CsEhhR/BSAYowRxiNMHDsCDBW2U6wXrJB8GcrRnBYFwVwSRtG8GvkC/B9O0rweAlDsE8GCrBg64ZwYJZHMGfSirBOdwZwXO88cD/qwLBTMYkwZ1MIMEgIDjBLa4vwU1mFsFLXSDBsiYlwT8CN8Eu3irBaeEjwQ2PJsH8Iw3BDYATwVIRH8EJshvBc85IwQZvHsG2ZBzBjP3kwFVMVME85/LAjTwfwW0cFsErTjzBubIjwf6ty8A=", + "encoding": "base64", + "path": [ + "x", + 8, + "data" + ] + }, + { + "data": "AqolwZrQ+sDeUi3BczkjwZGeHMFQ/T3BKS0lwZGQBcHQnhzBFkoowbocI8Ga9yDBJCcgwYilKcHj9sLAH/4SwV0BQ8Eke+fAD+g0wQVnHcHCyR7BxdA7wdNN5cD9117BVjA1wb+QL8HFUiXBkMESwZo+JcEGeyDBgvTFwJJ8FMHTj7vAMXElwawyPcFZ6knBMz4NwXV/48C8+zzB7Kcjwe/DIMHLcCnBorMcwQLXG8FH1zTBAX4lwQTuQMEh3iLBKssMwfljH8GDah/BYQQgwe3K/sCz/CXB46wawXAkHcHegCHB2WgCwbVMF8HTVDbB7C0swfR3E8GW3CHB4bQBwcAhMcHcTiPB5lkkwSODEcFq2gHBC/4gwR42LMGtYTLBJoYUwT+LvcCxcy7BTNgfweAcIcF0GwvBkO3VwBtHGcFcOc7A6SwFwfd7JcHLRy3BwVkOwZjqJsE7rjPB/MBMwcK6DsH0+wHBnDqewKh5DMFk4B3Bu1wjwcX3EMHKkx3BoAEowdh7IMHwziXB80EBwfCsD8EgajDBxC4YwarhJ8FRj0rBZ4EawQoEO8F6HMrA0xvYwLQ0Q8GIwSHBO9Awwc6eGsFG6R7BRWcqwc1nPcE/YcHAg8EXweAzHMEIvSnBlN9EwRQ//sAj30bBt9BFwZHVI8HZHDnBvmQHwWTBJMH+5x/BEr4uwcrGGMEkvyTB3t8mwcWAIMEg+GTBGc0wwQ4CI8FPohrBcyY9wVs8+8AZ9zfB+e82wYiZHsF8cx/BRLcewVsSLsFX9RzBBnUawRrgIsHwJinBsyoywdKN9cClVRrB310LwWUU/8Ai9yXBQVYqwfoOQMGjTx/BK75NweR798Ak4xnBqM4MwSuwKsFPVC7BNJ42wd0/CMEFVzHBnzYSwVJ2E8ELEDHB99giwTpJ3sBQZfLA3Vk1wRKZKcFXK1nBlGs9wQ2eBMHLozHBwFshwQ/DR8GZhyvBOvgqwcyqIsFh1gTBgRAawcP7JMHhjSDBkeBmwex9I8EdzifBFii/wLOya8EH5s7ABzoqwRgWGcFCcErBA3skwXzRoMA=", + "encoding": "base64", + "path": [ + "x", + 9, + "data" + ] + }, + { + "data": "oM0bwWG6ycCQySLBc/gUwWtxEMFa5DvBYvUawXXd5cAu8AvBjPwYwVlUCsGOtBLBsrgOwf3aEsH2Y4rAW1IHwTh3QsHjxb/ANsskwRT7D8FaDhTBYasvwaTjrsAWzmTBjcUywaiEIcFyJBXBYeoHwdg9FsGc9A/BZreEwOcZAcFe8YPAVxwWwYuOM8EPRUTBh1PywMifpMA0AjbBJbUKwfDVCcG2KRfB7g4HwYl3CcHipDLBqn0YwaTrMsEvoRTBI+TrwE2pCsHwdAnBVrAWwT/x0sAKeBDBel0RwcIfBsGIHg/BMFjcwCz2DsGPcyTBWrkZwUCeBMF24g7BaivTwDpoH8EsBxXBnvgQwVWEBsHrYtTAVKUQwQfFI8HW2CzB7H/2wH4gj8AKCCPB0RUQwc1HFsHVi+7AvVGkwEHMEcHILIrAHZnawGjvEcEmFxzBBtDjwLEvGcFRdirB9XlewfLmAcEWNtzAarVPwOau98D7GwbBjBQZwYWuB8EYggnBcPcOwRQCC8GxMxLBrAzNwKVhA8Ef0CTB4EQQwajCH8GKtk3B/HQQwVndMcFGS5TAA/mpwO9pP8EzNxLB5v8fwRX7DcFfiQ3BP4oXwfrhMcEaqYnAX2AIweYpFMF2/hjBLElHwY7h3cAN2EHByag+waWIFsGI3jDBHOTkwPVtFMGBPRDBl94awdJmDcHxwhTBEx4WwQXcDsF4CGnB+l0fwTYTFMHttA/Bstw1wcUbycCkFSrB6hUmwYmWBsG5PwnBR3IQwbhoH8ECIw/BBiAQwTfwDcFhahjBYBcjwUzvvcCABRHButLrwMHZycAzwRXBwKsWwTvMOcEebQzBjhNOwT1px8CGyQzBEbfrwEFsJcGbfRjBVzwuwQHP5cDnniTBGR71wJwD/8C6mSXBL2sdwfaXsMCjnr/AOpIuwacnIMHy+mPBbCU6wTjrzcC5aS7B3rIKwfzNQcEMlBjB54sewQjMC8EmbdvADakQwa4LFcGSrxLBI5hvwbtNFMGPaCDBAi2GwMCmcMGm45XAdB8iwSEADsEv80bBf84PwZxgPcA=", + "encoding": "base64", + "path": [ + "x", + 10, + "data" + ] + }, + { + "data": "MyAEwepigcA+HQrB0hj0wDJ378BWPi3BY0EEwcAsrcB8YOHA9ln5wP4uz8CHPezAV8XhwNPY3sBgJArAC5jmwJD9NcFDOonA1n0IwWjw7sDQyvPAKrEWwU46SsASLVvBsTIhwblDB8GQF+/AXhzrwNFm+MCWheXA39nWv2JIxcC9vfm/l2TuwJeqG8HMDy/BCcK0wCe+IsCY2x/BYHXRwG2C1MAOnu/ArijQwGKx18BbASXBegX7wMoAFsHxjvLAiaOtwKkS28CzodXAIXn+wAo2k8CbA9vA1vH2wLfSw8BvU+HA6yehwLKp98CfiQPBASrzwLwK18DLEuDA+xWPwIZ6/MAh6e3A2pjiwFoJ6MBUw5DAzBPnwAtRDMGq7xrBqBCrwFE+KMDVoQrB33LnwF/u/sAPQrLACyJEwPQX+8CNzM2/DsCYwL4H48D7+vnAGl2VwD1898DkHhbBeS1cwaVu18Ab/aPAOo+av94/w8AI08fAgfj+wKzk7MCSedjAZUHUwPSg18D89OPA2HaCwN5G2cBTqQ3BZCT4wE5fCsFIuz/BH4f1wJ4UG8HQNiHA6ChZwKGbLcGR9OzA1tYBwYVb6sCxI+PAhKDtwPQiGMFf3gbAd47fwMZ4/8ARsvbA2lk7wZ4KrsBj1DDBeUEqwfhB/MD24xnBe8WkwABy6MBU5OnAMc30wEIR78DUyPTAoLbywHgc48CpoF3B6oIAwer37cAeJfPA/C8iwbmggMBbNA/Bf3sHwfzExsBhctLA3fHpwM3kBMHGxerAuK7ywO2I3MCQvPDA1Z8EwW0GaMCQ7/XA9D+wwBIOe8CSs+nAJ5vmwCf4JsGVSt7AVYdAwRXFhsCNCerAxPKnwM6qEcH30+vAVWYYwQQrpMDTYQnBkpWxwEHqycAz1gzBFGUMwXSdZMDf7G3Anp0XwSLGCsEKoV3Bh2crwdX+gcBB4x3BTWHXwMFUK8Eam/DAu+EEwaB50cAHaZnANWL3wDgZ7cCtdvDAsi9owcGu7cAnVQzBVsEAwOqNZ8FuDR7A6SIMwYxf7cBnKTfBcs3dwBrjBr8=", + "encoding": "base64", + "path": [ + "x", + 11, + "data" + ] + }, + { + "data": "qQTEwF6QpL+uGM3A0kaqwHpFqMA1ORXB91jJwGsjScDLAZ3A4nmswHrjfsAFz6DAQ5uUwJvFi8D/lV4+uD+twAyMIMFWdBPA2SbIwBE4rMAbdabA4DrpwOGNAr8kPkXBcr8EwZhqycD0np/AEw20wCArtcBbs5rAh+l4P9QKcsCEytw+25mcwFlM8cCPPA7Bw1lSwO7XwD4JHv3AP5qFwA3ejMBvjJ7A4duGwDEDjsDKPQ/BzVS1wCNc28CdeKrAOhNFwHHJl8C1Po/AsNe3wOX2CcDW2YjAKI61wC29T8Cd4pbAPwUwwNhwu8Dg8q3AbtqhwEGAk8CIHJXAeBD0vyEmo8AYdZzA03KUwLrJscBzQvm/dR6cwIqs1sAbDwDBM3IbwCKvEb8QttHAxfycwJXxwcB7d0/Ax4kzvxQ3vcCAfqg/2IwYwGJflMD4safAw73lv3OTpsAE6vPAvLVKwf6bm8BnGETAhutyPypYgcD5mGvADki1wPYltsAMJJPAKSV/wM6ekMCqOpXAWXyrv+EDm8BcD93AOHG2wGqh1sABGiXBUfWzwPVC9MD0+Cm+CZmZv9G3EcGRY6bAHt20wLwlpsBEB53Ao3mYwABo58CB5Js+1EShwNJAwsDULanAueEkwd4ZacCwGxfB+rULwcc1vcBQ8vDAlToowMtrlcACPaHATNejwJnhr8CzTLLAhx+pwNZCmsAmFkbB3FCxwDjPoMC0CLTAmlsFwcoUpL9pktbApOa9wEiDZcBNs4fAwACgwJ+sxMBtVqPABRCtwBQ2k8AoUZrABzS1wGDkcb8SebPARTtUwPHpib+XcpXAVUuPwAf7CsFSppfAUoAowdPB6r+2zabAShkowPW26cDZw5fAURPxwG0SJMAPKsbA0/9CwB55jMCb8tPA63fjwPmTp7/s14G/ZX7qwAcw2sBEyEnBilsUwUxJqL9ikwTBb0GSwJu0CMEsr5/AgA7FwAR5eMDY1hTAhAm8wHBrnsA1F6zAdzZUwZu9nsDAX9/ARl3DPp1UU8EYQEq8fF3XwOoIq8CDcB7BTjePwMd0+j8=", + "encoding": "base64", + "path": [ + "x", + 12, + "data" + ] + }, + { + "data": "haRgwKEN0z9yv2vADbgiwNr+H8CMCOzAAbp7wGcSB78e+hzAwQgjwBJ3q78EjhTAGvTwv+O+1r/KkCFAxu1CwJslBMGejj++ErRpwLcgM8AwrhDA+nSYwC3hC0BQhCXB6nHBwPK9csDD6QnAebBXwB3OT8DLtw3AkKBaQCOWjr8hWy1AHG0BwCf2mcDTzcnAehIuv3X2TEBUrarAsf3Wv69VB8DjigbA4/Hdv5+Q8r8YDOfAiUZMwL55c8CxaC/AgUfkvh2hGsDG0gzALeo7wDroCD+Lt8q/GQVIwGCgmLvvewzAbp9FvpX+WsAnvArAna0NwAlLBMBg7gnA5GxeP8Tl9L+jcgPA5yz2v6N4VcDd7Fw/Rt8PwPIiicCWIL3AVCxGPx0uwz/kloHAADEQwN7CdcDCeyW/ZyzcPxjdXsBCPn1ATf8WPqZEAcCG4w/A+DmeP1u5D8D1crDAd48twYBXJ8Bpq12/M0I8QF/x2r/ZQWK/lkY3wIVKWMD4AhPAJaOWv41XBcDXwwLARfDDP0VVIMBs6ZPAoBxEwDU9isDFGwHBZt49wMSDo8DHYAtAQ5qKP3pB3cC3ly3ARRo1wMSQKMDr7RrAsLjbvwXrjsCsISlAt1gzwI+SacDHLyDAB4sGwdnp0r+I6u3A/MjKwKD1acCtWKDAYLlJPtA48r+5GxjArscSwD3mQ8Bly03A2sgqwFR5EcBO8yTBHdkswDBuEMAUXE3A72/DwLKbzz8iioLAJzY/wGC0P7/1fOW/MfQUwMaHacB2nRvAr/gowGFOCsBul+m/Ep0mwGa56j9uFT/AaEB0v7MT8z+Is/G/L3fPv35/0MCXeBTABHgIwWJYOT8Z9ifAQsmOPgdypMAko+2/n1yiwLi5lT6ngVLAPiivvraVE8BV933ASoSewOEGiT+lwec/ASuWwHwAk8CsOivBTDruwM6SyT+SVsrAuCkSwCW+usDhGQvAybFqwHDjeb+A7a8+9wtnwA1dC8BjqTzA90o2wScRBsAtNZrA5j4qQFMcNsF5LRpAEKuGwMp3M8DpNP7AD/Luv6H6gUA=", + "encoding": "base64", + "path": [ + "x", + 13, + "data" + ] + }, + { + "data": "XSsTvxnge0CTEiS/w33+PvN9CT/FsaLAIsWqv0FbCEB/41Y+Pyz+Po0upj+lqQo/b5aCP3Lqcj+JH4BAqK9pvnKrxMBf3PM/d8ldv+KFQz4U50o/lwH/v0wvjUC5KvzA6/FewKgbjL9MgUw/Sls3v5TeJ7+ixvM+NJWVQH+w0D9p3YFAUdVMP7zk2L/KG1fApVn7P911pEA4VBzALgtJPywYLj498js/x3tLP6TFKj+c5qbA56MPv7pG176olgs8xH4NQDA2yT1JAwU+AgmjPuUSRECb94E/Lmxjvt3sS0C8bcc+d8kWQAJLFb/545w/b2VBP0TZOD/Cvr0+UBlbQB46pj9Fqzs/qYJiP8daPL/28VlAJMnyPhUY1L+bVmHAo/BxQLjiVUC6qai/Do8CP60zt78V0/4/r1x0QGXONb+JW6pAeiIoQLE3Fj9OsW4/A5+CQPYhYD+Pw0rAqHQHwSYAAb7/1KU/IeqDQMepPD8zRPg/3DF4PqxyML+WLf49VIXRP9ds7D7/RgQ/POKDQNXrhD161AfAhtZRvaxG0L+e2KzAIx8QPjqsEcA9IH1AqDpMQPYejcA0I7O9/vsmPokvMT7MhGo+Zdi7Pzhcsb9qUolA2ujIvomXWb9cDuM+i7PEwMQM7D73Q6TAI5JlwGHWnb+59A7Adls7QL2zQj+MvPI+RvAoP4YKq74iTjS//F7bPbErzD4PpvjAvy2cPvIVGz82AAC/lONkwB6ZgEBPFp2/JmAqPuyVBUB7lwg/z/T7PloSdL99EeE+k2T6PlV0rT6ONaE/j3AgP9kZhEDuaow9+Ji1P2MVjUASA0Y/7YqPP/9sgcDounM+Yc7EwAz0RUBwwYo+TdpFQAXAL8AEq48/FF4SwFIGQ0DJkKK9EqMWQMIqpL3ga3y/qgkbwD7aT0AKM4NAMiTiv07TB8DSQwTBUIiqwOovf0AdJYPAW+MDPuqdMcALgkI/WlV8v5Sh+T/WKjxAy9yGv5QMLj8MRry+KoQQwUrBbj+neBrAdCFvQFyXEcEa7oBAkvarv2BAvzyo1bXA6JsiP+ZSm0A=", + "encoding": "base64", + "path": [ + "x", + 14, + "data" + ] + }, + { + "data": "1HoeQHPlbEB6jh9ArLNbQJy7W0BHMCPAC6ytP+eYb0AJqDpAuAhfQBhucEDMD1ZAeDhxQOdeVkDhJEdAgdcyQCjbccCPN2xAtWr7P6vUT0DrO2JARftiP7CzoUB3r6HALc0/vyvl1D/HG2lA+DUJQPDS/D87d0RAQu9mQOhwhUBjOjxA4xlUQHSIzj92PGC+7fCKQLsnn0DJ0Rc/JeZBQHzaIUAwalZAEBROQOWrQUCBYUHA6kYGQBP8QUB1kjBAcTR8QEvbL0C93SJADr9kQLCihECPBlFAtN03QCSHp0CmKjxACQaEQLBLH0B3eo9A74BqQCqWTEDeRzdAEVSPQOy9iUDR6k5AzbRiQDTtAUAcQYNABeNFQHxChj97mXK/SwatQJpfeUDe4r4/fUBMQFRVhj9N0IhAmM6SQJ36DUBwf4tA1+aZQGd2QkDRVH5A2EvFQEbHdUA+Ty+/a3O1wIMQF0D8kExAp2I7QCBqRUBl+49AEd9WQAlhCUBY9ihAe6iIQIA+PkAMKDxAnoixQBhmJ0A5DPQ+6olFQJejmj9Xnx3A+jBWQP0/NT+h5mFAGYSPQOJI279xvyJAWV5JQBVcO0BzIThAPuGNQIob6D+v6WlAmjADQCU6CkDjy1ZA6QBowIgEH0CckyjAWIIev1txnz9IBSg/uDCJQFdDSEATH1BAZSNkQA/oG0A64us/8hI4QO/bQkBgPpzAdotSQO9XUkAiyhFAEStcv6ARjEC7T9k/6AFUQDTBlEA6Uy5A3oVOQFc45j+6eVBA2NhgQEq1NUB4HYhAve1zQLD3jUC1rlJAgZFmQB8MqUALiUhAyx9iQA86sb/YDTdAsi9gwKe3eUBFq0BArRKYQNuicb7/yoBA4m8rP7hWkkCtY0hAxAKXQHmXEUAjeAhAWz2wPlRNikCRoYZAmmeiPwzD8T7m6K3AKrVAwOVwiEAa2tq/oaYsQOue5z5m+2hAAcTfPwOkk0CWyJ1A6YLSPzJ0VEBm4g5A2GbJwIlmdEA8JfE9SOccQBKIzsC5OkpAu1zXPyIANECLf03Am9w6QApNUkA=", + "encoding": "base64", + "path": [ + "x", + 15, + "data" + ] + }, + { + "data": "5B2qQK175j9LBK1A9fi5QJgCuED+v/I9Lfd8QJCIO0CpB6xA+mXCQNF3uUBgXLhAzGm5QHzCp0BnZ1Y/qCezQDZYn79hAohAcQyWQAehukB/qbNA9cBtQB+kakCLz/2/0ooBQHaAikCH08BAamWcQP19j0CdlqlAiLejP89UwECAjOs+PGarQP8rmUC6+ztAdOS6QPgyQ0D1H2ZAFuieQKmCl0DBva5AsaSpQL9CokCvOje//MmUQDcHx0CLfapA4KNEQIFhqUCT3JdAuEzFQCBOOkAIGKFAG7+3QBHBl0AOQahAmGJjQJ/3rkAobOpAdI3IQL9BT0BKOaNAL/JGQIhw2kAiHqhAMrS0QKrwkkDEnSVAxHSqQIlRbUA/Jdc/C/yTQIeC7j/m2YZAE/qvQCF6XkDAcahApu86QLRKoEAfQ/c/9D3JQDDCo0AprMlA9BnNQDVaxkCWS+o/IT8mwL8ahUAq5JNAFdjBPVFanUCyEclAfSe8QG/2l0Dc1J5ARfHOQCUtqEAuc6BAHDSTQJgmk0A5a0NAsjW6QEDUe0BnHBo/HPO/QPNFaUCMa5I/dpRRQO3Ihz/5MaFA9BW9QIcamkBzs6dA6uPQQM3gm0C1IIs/TlyKQLasoUAX/L9A+v1xv/X7cEA05fO8ZhMZQLqxakCm42BAGq9MQNKmo0AwFrFA7lzGQE5nl0AUWIlAcH2tQBNrr0AiPuK//fXAQARDrkARJJVAt+fzP8x/OEAxhJBAWz3GQNOkz0Bwg5hAa96wQJLTjUAdb7VALtu8QFdhpEB+aN5AxebWQGZdLUB36r9ANgKpQCqkiEC1B6NAyfyqQB4orD/rmahAFU0yvwbjCEBMFW9Ae1tkQN9CEkDenNRAptNkQJNcY0DC/bdAfwPDQAaikUANVKJAG+9EQNSKKkBKLBJAn1eHQK4nQkAEbxXAHugSv0TBK0AGqj8/QPukQI3paUD5bchA1W2MQFVu0UCS651AwTGHQFaorEAJ2ZZAuGJSwLJfwkDcLilAGMd6Pst5YsD8kFY/RoiSQLF8k0AUYR6/YS2dQGr+7D4=", + "encoding": "base64", + "path": [ + "x", + 16, + "data" + ] + }, + { + "data": "fSPqQGm3Bb/mTvNAax/eQLZ420ABlTFAdDLFQE/iij/r4tpAgmv1QH5x3kBhduVAXtS6QN06vkCsy9O/5AntQGDhrD95jwFAL7PjQD2I4kBkFdBAED3JQFZAmD9JT5g/NdyVQD191kDc6+hAr0vYQNKr1EDlaNBAhQ2rv8kExUDY+grARcnNQK+K40CW+rtADsOlQDSUvD4AO8tANDfDQE/vwkDyX8pAuMnPQOD6yECkGc8//JbdQNRfC0GIGe9Ak8aHPxjL2UDRdL1ANrzrQOoGQj/ztr5AkSfqQMBCM0DdYNVA4o7CPzHT6UC0cRVBtOECQT1IvD8nlc1A/rBIP6srBkGPrMtAf6LOQOE+w0B1vr0+zqrRQFXTxUAt2YVA0TYjQN7kg78LnNRAWi/bQN34tUAtqoJA2kkOPneN3ECir3O/0CvHQKtNxUBWz9tAvWyRQHQM5ECc4IdAIqsbP2qgZEBGwJpA1Nc1wMQBpUC2nclAMy/jQFUYyECoD81ASyf5QN844ECCL8BA+yYJQJ75kkDvsq5AiUfmQJsywUAecGhAnK7nQHTHx0CZP8y/LqudPg0EckDmD+dAMnkCQeach0Be1NVAgebRQKyc7EBg7um/j/jBQNYI3kC/hABB7p/jPy/5KkCaxSRAxpClQEGdvEADbsVAzCCKPxUwyECpKM9AvLkDQTA/p0AC8M5Ac7HsQChP7kBS2bc/aHEDQZwJzUAaTq1AOgaRQNuBLj9rZd9AgCIHQXYM10DAU8FAqabWQJYH1kD/s+BALUPhQFFpzkCdLhFB+34QQYYZlj40BupAET25QL+ZCkD2DsVAIxDBQOeSf0BxHddA9yoJQG+vtb64PBVA4luFP1FmlkDtEAtB5VjBQA6vpz/grNFA0s2kQJlywUD+6udAK4mdQHPNTr56YIW+P8ncQF0mqkAMbWM/5pHxP+aUAj/BFktAH/jUQPVp00CwfAVBfCvYQNDD2UAzwiNA8f/BQLPKyUCw4dxA2GkGvvro10BslJ9Ak1QCwDhh676i39m/F5jYQAk0f0B4uP8/qJzBQIN+IMA=", + "encoding": "base64", + "path": [ + "x", + 17, + "data" + ] + }, + { + "data": "RdruQO3UMcCDVgRBJU+9QMsEuEALlqVArQbuQJ5XeL9flMVACZnsQP1ExkCERtBAT5prQNThjkDCe3vA2n7lQKtqdkCmpJW/qnIPQaPbwUDY2qxAQuUEQYntxb/8ColAyrTgQIrnB0GysstAlpzOQFWFAUEvO7VADylxwOg6iUAZeY/A/GKyQJ9e6UBcDgRBPy0kQOk+GcDPBAlBz82qQG43r0D1YZ1ApGazQIHRskAF+ndAEukKQT0MHkEiEw1BEWqTv/eBwUDz1ZtAL9HGQHQfxr9Ld5xALhTRQHj3uT7Fn8BAJVxavxbk2ECWgh5BrK0LQXV+Ir9JhbhAzd3Yv+qVAkGr4bFAtfelQASnsECE5fW/OAa3QOm2BEG8usdA1G/tPCHAccDLtQdBWsTFQLPg7UAlddo/RIwtwKxXz0DdgWvA7rWBQCcooECo4K5AUbHPP+DKt0AC2ctAl5dxQPgOuj+bJhtAwlOqwPrAS0CctIpAdnXHQGvHs0CHVLpAYi7tQAT49EAUm5hAoLdDv0YwI0Bjgu9Abo3GQGSmzEBrd81AIxXCQBEKAEFBs4PAxoQzwLDtyECehQ1BZ6QWQUtXBUBXTsBAPwWSQFB4C0FMD4/ANzHMQM/j0EBriA5BSaqMQNmdhD5sVqFAbADnQNWL90DMXgZBSeufv+CDsEAfb6lAzO8RQTqcZEAdjAFBaHECQTX5B0Fsi5FA7NMVQZq4qUCikX1Aa6PWQNZF0r/BQwtBw6wXQRTjlUDsbaxAZPq4QNffAUGuZMZAYAi+QDhkskDDjSNBCgolQa/VC8AotcdAhKaAQJgysr6MKadAN7mTQFnDykDSTsBAzyCbQKOCNMBXqL8+eevZv1Zu20AxhRtB9zjoQA5tmb+056ZAdhcRQN1bsEDYAPNADWaMQPgGRcCP7THA490PQSHM2kD7pIFA9dWHQBpj37/cxK1Aknu+QOQuEEH39BZB3IQJQYGumEDLKQy/mwa5QNZCokD6ughBocdBQCTHpkBcn9tAOsSBwE/tKECIt4DAGE/mQPuTBUC5l5BAhtGoQKXyocA=", + "encoding": "base64", + "path": [ + "x", + 18, + "data" + ] + }, + { + "data": "6Qi8QJI0lcAtMOVAET1MQJPeQUDp0NlAYl/dQOk0OsAqa3RAsO2tQGz3W0BmdX1A4eAqP5lE2D9Fr7fAlk6nQJjzvkDPn4bAsqscQfO7WEC0qEFArE4UQSN/gcCTu+BAT5ALQW1vE0HB+GNA6hWIQOvLAkEd5FZAPJ+2wH5Brz88EsbAUmpRQDw8ukDZqhhBupQsv4bWmMBcmBxBHTpTQAqoWkDM4wpAaatBQB6DWUCO3LxAsnkYQUg/E0FwswtB7JVPwLK8YkAGLx1AOwJLQKUQasAySB9AlFN9QGQiCMDN+WdA2MdHwOSJjUBOqwlBvgDoQLcgK8A8RmRAM9t9wI/dv0BAjFNAWXomQH79YkAf237AoeZTQOi1HEHC2eVAlCYgwC+RwcA99BNBXoBwQFldBEEvIH6/V+KlwAOThkCdZrnA5sM+P4guFkD090BAUnvJv+sBOECX4/tACH7VQM/sd78Wxo6//ufhwHfzsD5mY7I/vQpuQKyvYkAqpmVAAx2lQFjyy0AO0wdA0tFkwN54Cr6rqQxBuWJVQAXxmUDwxApBEJBCQIvCAUFBgsTAFFyxwGrPBEHhNhhBrFYPQfBn975sbmlAeYTUPyGoAUFu0NDAat2JQBXrikAL+gFBLKLVQCoYEMDiROVARuvxQMEoDkFO0B1B6ARbwG/hW0AGEzhAoFoDQWCBiz9zNQtBiG3ZQNj2+0C9uOlAessMQZG8O0AB1ss/BGX6QFByb8B7YBBBOKgJQTn0tj8UuFpACkBVQDUU/ECHB2BA23RGQO9aTUDF0RxBjPIfQYy2jMA1glRAAEVJP038M8Al1UBAWv3jPzOF/0CPcGNApALlQPsGn8CaXdK/auWHwEWUCEEHShFBBSzNQOebY8BvMTRAplCSv8hgZEAb771ARBMjQOQLssBdQZ3A9lYhQQSi0EDXhNxAA4rJQOswdMAAQOpA305hQPkxJ0Hn3Q5BBAoYQT0ZxT/lI2bAIZ1oQLQvI0CliBNBvYW/QI4OHUAKLvdA2rmywCQYsUDFBbzAdoW6QEmzLr6ZvNhA70hHQLXW2cA=", + "encoding": "base64", + "path": [ + "x", + 19, + "data" + ] + }, + { + "data": "EZhYQBR9u8AUB51AHv8WvvyZrb0zI9NAWFGZQKiPkMBo7iw/U7UkQLbum70QOxg/UTQcwLK+rL/PhdvAxDoeQA/J4UDGo9jAoCoPQarwWD2CyZM+qEsHQao5vsA/hQ9BFb0TQeCYA0Go3iw8cdiTP2qVz0BRius+Yw7bwMDC5L9D7d/A4MzUPupRZEBUMBBBumd1wL9Ky8B7TBZBfNc1PwR2Lj/tbV+/+kERPYgQET+8Iu5AGZQMQUpa40DX6dlA496gwB7+dD4c4IK+ZIPbvug7qsDn4Ca+5u4JPwFMjMBrvt8+KgShwEzrlj8SQ75ATluLQDZjjsCaZBQ/Uei4wGcKMEAV2PE+8FTGvg5DXz8NQ7LA2G2bPimEJEHM28JAuaCXwGGw9MCoygZBEssgP9CZ7EBaYmTALdPfwPICgz94sNnA1OctwOr+Mr8mPC4+H1eSwGjfx76wWwFBTkoPQbAHUsA4f4/AfR35wKPpIsAfuN6/OvfRPvHgTz+qxhk/NAjzP17iYECYa12/Rim+wD/3M8BbfAxBuXtHvvauEEA71x5BwlvuvnW4z0BjMO7AXgX1wHTKFkEunwlBzK3UQJgdQMCiSS8/4ra6v9H/vkDp3fbAkr2HP1+PqT+rN79AKEgDQVi8j8C4UwlB2Be/QMloDEHLayBBS+ClwJu8OT8qgAQ+vQm5QNRfxL8qSfBAOOt2QDL6rUCdgxRBZl3SQDQZDj5J+Xm/akjfQHmZqcDlUu5A6prEQKg2A8A4u1I/fl6PPmJStUD0EcM9Vvg9vro7oT7i7fNAWhoBQaOXwsBIGWS+xfUpwPwam8C4L9Q+BlOvv6ZRA0E9ma4+t9cJQYJp08Bz8l/AgJXKwN3lFUGNXthAZfeFQFGWr8Ds+RY9aQ+NwJu+eT9uaFBAksmrPjaF7cBs48rAASYZQYwGhEDU+w9B4n31QGWvr8Bz+AdBkaquPoxtJUHXJdtAVwsNQbIo9r/WS8fAdaNFPzCpY77PdgNB68AGQYp3E7/8u9lA9UHMwPpF+kDmEeHAuuRgQMZAGsAPxwdBgejTPmnT6sA=", + "encoding": "base64", + "path": [ + "x", + 20, + "data" + ] + }, + { + "data": "mM8GP70jvMBJBwVA3uxcwFbsR8Cow5BAeDfvP/ZKssAzjCrAuIAgv2WGYcA86DnAoyaowFxVhcBHwN/ArOsPv5vuwkAqBQvBohfPQLwPUsDT9yDAyN+/QF6X3sDaGhdBYxT6QJXptkA94mLAAGMNwFPwZkDQ3STA/2TawBMWl8CJLdPAwEAiwP/PfD+oHNlAXSzSwIG72cCgUetAYNoFwN6DD8DW/G/AczI9wP4/GsDfSP9ANNrEQMV0hUBqVGlA66bKwEq4SMBxbDfAjwJ2wNpKyMDC4CvADpZDwBioxMC6GDnAN3jLwMXEFsAcwSNAMMFYP5uoucDYiCjALX3bwCtIYb8sjSHAfZlSwA4d/7/Kt8zAJj8ywMj3EkEsZ2RAKh7MwIDbBcHQg8ZA43cnwDBNl0A1ubfANov7wDdMHcCDRcrAEOW5wNMgZ8BNtCzA5SnhwP5ZY8C0ZMhA14UhQZ7EqMD1p+jAC/vpwDsUpMCDG5TAsQhDwFMMBcAg4yPAWAPVvwBXgDqOimzASNXxwL6BpcA3x+BAq7JmwOAxHL8G/hdB5CpywF9RdkC7dvfA3xgPwenPDkGSEsFAscpQQGdWp8BV0BfAxjSMwJffQUCHYfXAZjoZwPhH97//YUFAU9cCQSv8yMCMlglBOwNYQLmE2EA41QRBskfIwLvfDsBmuifA2MYhQEcSfcCvB5VAxlyePnbD/T/cIx1B7oNXQFEWK8Dq7ljAIiOSQMpHvcBNipJAWrw1QEt5p8D/bALAjV82wFTBGkCZGFXAmjJYwFXvKcAAMIhAjVGhQAav3cCSMWjAmwG3wGf5wsCQzhLAlJ6JwJ4Z00AcDT/AySIHQXO+8MCh6qDAhnH2wBECC0GT5FpAT4muP53D1sCu+i/AhBHmwCak8L8HsEE+Nv/1v4TIBsHipdTAxcvrQATnaD/u5xtBHhfyQC770MALgARBn0Y8wMUDCEGdMHBAop/LQF+Vo8BrFAPBfrQQwHgeOMCzwq1AYw4dQYTQW8CX6ItAua/FwATQC0H83OXA7xxOP5EMjcC1hxJBLyIYwDyAzMA=", + "encoding": "base64", + "path": [ + "x", + 21, + "data" + ] + }, + { + "data": "IUAZwBhMiMC9y3K/8SnNwHtWvMCUSNI/ReCkvz7Nt8B3yrrARst0wLjT08BwAMbAG+DwwLXDz8AUdLzATnplwAZYaUB09xzB8BJCQNhPyMAWIqbAqf8pQILm3cAC/QNBHxGaQHV2F0DthtjAY9uuwHDMaj5h6q7A9XKvwF1L5MAdyZvAeFWqwDHz1b9+WWdAmjoKwV7Wv8BbO4hAtBeZwP4ooMAI1MXAzsu3wD6ap8DtG9ZAZlQaQM5zWD88Txm9TlHewLT+xcBrNqXA7pbawF5MxMBBdqDAOynMwLlp4sBZtr/AKOfZwF37uMDKJYu/9UkxwHc40cBnsLXA4pXZwLU5j8CU1qzArMG5wLFflcCZtr/Aq6S1wBnxz0D5wgI/3V/gwDjA/cCA7kdA/Bu2wF5glz+lqejA0uDvwLrSucB4UozA6JgDwfLWwsAOBKvAC2oKwek3ycCmxkZAC3QXQYj32MA9QxTBjhKywCL65cCr7N/AfmHHwCb4mMDyrbDAG0CkwNi2Y8A5UcLAv5EAwfIP4MBgDIFASeLTwOMHXsA9QOlA2mrVwBIpQz/uBdTAGVMSwXN+0UB2OB1AAjAFv59N38CuH6nAIM3awIxYY74KZsHAwiC1wDJDosDWd4a+UrHEQKEM78Ah69NAWPrJPgvAV0Bm5KNAEA7JwDYkpMD3MaLAbLaBv42GvsA7qoE/PW9TwBi64b9PTglBd2Buvv94psDAU67AGFu9P6Q3qMA75Y8/fAdFvx6f+cASCpvA9p63wG5skr9jhM/AwXHIwNCwrMD4kbA+PEK5P0Itz8Dd3NLA75MBwW2PysAfDJvA/u/WwDuec0ADEcHAGGbQQM8D7cAax8HAxCUAwWstxUA4hKm+EiHPv+3k2sBkranAZf4TwRj+lcB+DDvAidWBwHzYA8FA/LDACUWCQGQsHMCY6gxBCn+vQEYj0sClH8NAFsG+wP1Mr0DeGVY+Ops2QM1A98A7shPBwjKlwLFip8C2p9M/xTMXQfo4vMA4YJw/KoWZwHZT9EAbcL/AMqT+v35uv8CvPgBBt1ifwL6bgcA=", + "encoding": "base64", + "path": [ + "x", + 22, + "data" + ] + }, + { + "data": "WiWmwJjVkr8WWXvAKWwNwQKSA8Fe+7e//7KLwKRulsC1kgnBw4jZwEdEFMHv9RDBWKAQwe6NAcGk1VzA0YbNwCLnKT8I9B7BXIVCv+pmCsFLm/HAjJ16v/N+t8D5jr1AVdeLP6nKoL+lmBfBs1oFwYiBTMDAp//A1T00wEdDDMEcJeW/WYv4wEX8h8CcRIc94yYdwVqUdsAyGS0/rB/kwP2o6sBgTP3AmiYDwVx698DJtXlAkaDUv0SJI8BZW2/AfxjQwE/aCsF0O93AJVQUwTR2l8BwtODANbMSwW0o1MBQxgnBoUHBwN8vDMFPU5XA7kTGwC29ysCGrATB+i+lwN2H+MAdAP7Aeaz1wGLX2sCofH/Ax8QCwRIHNEC0nCfAZqXDwNzFxMDGEJy+zwEHwQJoIsAasfvAGHq5wKQNC8GEMaW/nokbwZm7+8BjJPDAZHsQwdPABMEipf++RrHpQLlm9MDfniTBvlMewDnVCMFJhwnBy+0Owdrq38BBEwDBrCQEwTI828Ap/fbA0CPewI9SAcEn4/4+5IgRwQH0w8Ax5oBALZ8PwT70GcD5lH/AxTj9wOJLRkCl7rm/L++IwBezAMHpOv3AKLkJwWNbXsBb/zjAPrkIwYW1+sAcx2LA/9RAQLoX/MDb+1lAyYkowALUC7/G/p8/SNCfwE3k9sBMRN3AzMmPwMCM7MCXozHA2OvVwLTvq8CtGcRAeR51wDZT5sB3o+LAVaHiv0OnTsCT+BzAa86KwKSUF8H6O+vAupACwTYslMCgbxPB/04Lwca59cDDuWfACq8SwNfbjsB0XA/BXuQYwQIarMC4xt/AbAoGwRLIBz++6gjBWIxlQGtSvMCI9cnAbTPTwFZ1IUD/VILAojOQwPvKscAm4+zAh5UlweDq5cAb0rvABxu+wC0DzcCanjvACAqSPlS+s8CEhNRAFscVQOoQpsAj6ixAErcHwaDv6z9C7FfAZTiDv7UZGMH+kw/BPf33wG994sAsdhfA8TzuQK1W9MBZoQXAztYGwAAUqEA2sFTArK6VwAPw3cDlZahAYmXlwItDIb8=", + "encoding": "base64", + "path": [ + "x", + 23, + "data" + ] + }, + { + "data": "m273wP/9G0CvrdXASFMpwfXeH8Heuo3AQGHlwMv9EcAHMizBdR4WwW8XNsHZSDbB7wMYwagzC8G/BPo9nDMPwcFyGcAh8gvBfDiQwOskJMEkaRbBNamRwBGiTsCTgz9Aqe0wwO9lmcAHtjjBGgMpwcCxzMCqIh/B+uI+P8CBFcHGaP4/hT0bwYn+08AgDmDA5W4dwVZPFr+AoD7ANYEOwTh8D8GOOArBWm4jwRUOHMFYsAA/s2azwKmJucAzAOXAuxqQwBy5JsFxaPrAWhwxwfGR+79V6AfBeP8zwaD6jsAjvyjBgVh5wKGpMMHCJv7AB7gTwfs5mMDiYCTBGRsBwG/sKMHJwh7Bfi0KwcqdAsGkFCO/gJEhwS/fnL91mLLA2blnwE6tPcCqT27AtAQswcMQwsCF5ubAG94vwP7vLcH/MQxAVP4gwUv5CcGqUA7B4Y36wI61E8EvqoLAW9KHQP4H88ATjyHBMKTHP2QtEMEEwRHBa2IwweueBsFYXhzBtdItwULpGsH+hgTBD1KJwECpAcFfsEbAZlwuwTr7BsGIF6o+ykgpwbSKrcC8x8G9b1OjwDlaN7847KfAlQD4wBIKAsGBcyLBTlwWweR10MA6Fpw/qN0uwRoFIMFeu9LAhe33vm0f6MDAoXy+GSuwwDHyjcDk1DDA8HsQwHUSHMHhmfnAPNj1wO66AMF3bsvAZmkawXOMCcFsakJAOxzlwM1cBsEgcQHBOxGdwGiaBL6dvrvACi30wC7UHsFjSxXB3LYewTo5+sAtXzbBH2MpwbWXFMFj9OnA4uS7wJhQkb/4DSrBwFIdwS5ESMAz7AfBTQEQwfniM8CH/SXBzpeMPrdSM8AWcKrA5pJCwO34ur/yBfHAfSTkwMJRMcCMjwzBOJIiwbPgEcH7BQjBmgjuwLo3OMA5uDc/SLliwLo7B8HaK3FA9miNv3f5FcD1R4m/nkAlwQ20+7/5D9fABJmawOlKIsHnPN3ALR4ewXq5AsG0K8bACZuQQKkvBcEcBqjAoO65P6dME0CSpPU+FNLjwAHf3cAeJOA/ZGYLwXAxPkA=", + "encoding": "base64", + "path": [ + "x", + 24, + "data" + ] + }, + { + "data": "1HIeweAmqEBuwBDB66M3wVFPMMG7eeXAMtUYwZ2EiT9DhULBHg03wRn8TcHIIVHBUE0HwQNc/cA0mGlAlQgxwR0uqsD6SMDAXsf+wIHuLcEqgyjBX9n6wLwbrj6y0ja+P6LNwLNYAMEtqU3B2Yo+wUgwE8HPATLBaUqBQBVrC8GGJ55AQBcvwf0AC8E6FtvAJh4Iwbv/N0BFvM3AwdIdwdWNGcH0h/zAIyU7wTNtMsEv+z3AybUSwekNC8HhWSHBLDN8v8hiM8Hg7e3AJ/FBwdY3yj+DuRLB23tHwRq5ab/0oznBPB4Gv9IkR8GdjyvBoqE7wbzsyb8CzDbBneDqP/ILS8HR9DHBs54FwY7LAsFnCz9AfRc0weCTpcCgqQPB+lY8vedyoD8oiNzA3KFIwYotE8Hun6fABj6aPyVqQsHp351AnpQSwTk6/MBeiRLBPiKkwPW2CcFCIO3AhpFJP/kZxsAPrAfBSuaZQE58A8FUggPBahJGwU+PCcGjAinB+gtNwXcZPsHlUOnAnooFv/ZD2MCy6M/ApQ8+wXCdJMEG2FnAlHA1wYX2AcGE+HVA8pNdvwG4j8DooQrBqvkrwbDp3MBnkD7BUOMLwbbKEsErtZtAnmFLwQZwNcElShPBpXl9wG5qrcCAiHnAdDYBwesuAMFip9LA1sawP1PjL8EzxejAlJMmwZw78MAgihjBDQRBwbIvNMGh/Ze+vXIgwcg6B8H7TALBMoj4wG36QUA44Q7Ba4UnwXohDcHxjSjBjdYswTz/KMFAo07ByE88weZ6H8G07SfBkQERwftcJUDdfDfB/4YMwVBL3T3y0BDBHCYDwU4+v8A4rzTBE5ZEwBSxrz8CzDDALIjVP2fMqsDWQCjBw5cVwerkgT+2FRHBqTQEwZUUI8GYDivB+h0GwW0Q0z80OINAQo3jwLE+LcGrlxQ/eW6PwItmqj891pjA0UE1wSSMtMBMJRrBCtoEwVTGE8F1VkbABr42wShkAsGPUBnB5vWXPxYy7sDWWgHBhyyOQBFqVL+llYNAFhoTwWApr8CgJfm/0goVweuerkA=", + "encoding": "base64", + "path": [ + "x", + 25, + "data" + ] + }, + { + "data": "wYE5wfYv2kCPOC7BZLw0wVYKMcHf2RjB9ks2weodgkAWbUnB6WRNwRpDWsGPa1/BGtm0wKqNs8BkY8FAJqFKwZcS/8DZFNy/UFcvwaQBJMEegyrBLu4qwZByc0D7JFbAkR0bwYGOLMGG/lPBiUpCwZOJN8FahjTBnaLGQH4C2sCeN9VAydQzweYqJcEJrxzB1TK4wEk1sECtnxfBHn8awZigDMH2bK7A1WpIwbsLPMFMD8jAPxlDwQnmMMEQ7EXBVJI9QFawLMHGXKrAu25EwdNQkkCaygrBazhKwY55PUArojjBNAhEQAPTTMGXUE3Bk6RYwZ8iGECI9zfB6tGkQMQrYMHC6zPBt3PWwKt10sApNrhA8jQ2wUVIDME5PyfB1mFkQBPanEDnKhrBC1Zbwbr+PMEvPQPAqxCVQDb0RMHN4MtA6mngwJnNrMB5KADBR26ov2GdxsCzfSXBjB0vwA1hSsA3HqzA1xPXQK2kvMBI5bzA2p1NwZka5sALQCDBIN1fweX5VMG/S5TAD5JZQMLdfMDEJxjB0W89wVHcOMGcvd3Ah/kwwTPPJcE/ZdBAqqVrQCLj/8BZkDjBRwNSweuehcArU1HB9mHKwKLVNMGm3d9AbopcwVQTOcE05jPBpqnmwJ0jEMANXerAJ4gjwXPLMcGOASDBCHGRQBkzMsEjIKfAzo5IwSSCqsDDzkLBvcVcwdmsU8GswmfAU1xEwbdq4sDmjNjAZZMjweN+qkDf9TfBAzlLwepFxcDcUCrBM08owXnQS8FZ8FnBUUVBwXfqFcFC7U/BY9g6wThNskAIwjTBzaXLwO5YVUAHvwPBlzK6wDADDcE83zDBlMnHwB+WoUCaG3s/PT2+QKfgDcHq703BK4swwWu7jkCgofjAKwaVwCaTIMGC7kTBWTcIwSFjs0AOQMpAQ0sjwYg8SsHV0inAJm3zwN1qlED27wLB+3g0wXFTD8FcST/BFFk0wZZ71cBIdtQ/9ixDwYcN08CrHEbBR+YOwCzAnMBhaCfBdbDMQAwGe8BEZtBAPnEswVWkHMDJ0LDAka8IwdH5z0A=", + "encoding": "base64", + "path": [ + "x", + 26, + "data" + ] + }, + { + "data": "RONKwYH76EBVoUDBq9AcwRsVHcH/uTfBeQ1JwYaWwkB5hj3B1KRWweOhWMGzZF7BQui0v/Ah/r/vuutAlSFawRFGJMFMXE1AbPFVwa5UBcFXjhfB1EpPwYCIy0D40srAOfNGwQZbT8GEPkjBW2YwwRKHUcEMRiPBDOTpQOmLasDuAexAYgckwQNCNsEW/0LBTrjZv8OU40BfXT/BkXAAwTr8ysDCd9C/zbJIwVYVNcGmWhPBzwtpwXVXS8ETAF7BJp3DQEMCEMHuLte/KB81wXZG0UBzqtbAxFQ5wW0FxECuWyHBwdW2QBgDP8G4cGHBmVxowVLRsUAHviPBefzmQH51ZcHGKSDBZ9dxwDB3YMAayelAtzcjwcZwPcGcdkLBJL/KQL6h4kCvDD3BlU1iwVnoXMGNINw/jy/ZQAg0MsFmKNVAEz9rwC4yvL+n2LDAPMUzQPpaF8B2lUzBOj/DwL0DgD9czWm/CMbyQLpSC8A6zhfAlzNEwQDUh8DcU/zAJQdkwQVPXcEiJTG/MbPNQPxSCT0BX0DBEygowdsyQcFEICHBFNQXwbQbQMFK9PpAgADdQHlhMcFYy1vBRN9rwS+BAb7ZtFjB2pAZwBvMS8EJufhAXCFgwXhTJsGIpkjBeIwhwQ1s5D/0NibBpQU9wQIcWsHY403BwsPVQI9tH8GzzPK/VaFewZ0pzr+q5mLBXn5rwRX2ZcFRUdjAT8lbwWjSiMABcnXA6MFCwWe81EDaEFfB0rNiwTf6DsDcvBbBEsUMwWKvY8EYJFXBL0U0wYAT6cAId2rBw7xYwSWL6UCEcx7BzbQnwKNQukDfw7rAUaEEwH1UM8HvaxbBxJ4RwTl/7UB4U45AtOQOQbSPPsEwUWfBcINAwQSK2EBBxpnAdGwAPv2ABsH4LlPB9pfswP62/0CfFe5AHYVKwQZlXMFuvLfA/eolwe2j3ED1qDLBJqEfwWC5O8GppljBN8FZwUx0LcCpc75AIZk/wWnvX8A5rmfBgzyxwFHjjb86fUTBvnzuQIK62sBUY/hAeZg7wV8EuT9WDg3B4xjEwKgNzkA=", + "encoding": "base64", + "path": [ + "x", + 27, + "data" + ] + }, + { + "data": "9AJQwUt32ECYrUTBoCfcwNiJ5cC+3E3Bm6hOwZCb5kAbjR3B5vVPwXLRRcFcs0rB7SxPQLAYDUCgS/lA7CVdwQQTQsEC6d1A8mZxwV5ypcDtndzApItowZvw/UBKVBDBXohowa7oZsHloSfBo5AHwRA1X8EEkfrAAlvvQD9juj4/aeZAdob5wLA4O8FrEl7BYpE2QH2r9kCsv1vBgByfwEtPHsAdgipAZAk4wZ1fGsGFFTzB3XmBwVrvVsFhPWfBSvUAQfi/u8B0eiFAnqkRwSej8kAA11XA+GIUwcysAUGnK+XA1sLoQD9THcG0kGTBF9dnwUkt9EBV+/DAulgBQcGHV8Gz4+vA4FnbPEWh4j7zmflADzzzwCVqZMGYllPB98D8QA4PAkF52lTBAQ5bwdppccFP059AtLr5QADOCcGqpb5Acub/Ppi8OkCZSQLAV7PIQMNqBUC5hmrBWkgSwbhGnEB/cHVAfLPxQLS7C0A4y90/BEAowd4Agb6FLojApVFXwT4kVcE1LV5A/VQAQTmugEBjCl/BtKr4wOU/OsHQBEvBubHRwAZfTsE5/gFBqHMJQQJyWsGwn3LBLRl3wTcwgED83VHBYl0KQDCaVMFN5O9A5ehSwSAL+sCwvk7BFXRIwWOho0A0AlDBRExLwVDCd8HFDXHBi6n7QBu57cAMbvk/yUdmwZLOKkAAR3fB9mhqwU/FaMEsQBnBPPNjwTmZzr6GbCE+WApYwcHa4UDEE2rBORprwd5WD0BimNvAFnmzwMl1bsEYQDzBzWMSwXVqdMD2AHXBXeZnwSbS/EB3VebAULvxP19s7UDq4wPAwjURQHH8UMHgScrAeJk4weT3CkGhOdxAKdgkQVnoZcE3BHLBOFNCwQkYAEH3hCK/gROcQL5srMCifFLBpn+WwCeJDkHuWPJAAv9kwetrYcHejQjBBBNLwX7fAUFbLlrBCXrrwBjeXME71mPBXERzwUbO9D823wxB/y8mwVZoGj81ZnzBO2cJwZ81P0Da6lbB4g32QAttF8G37QBBB2Y9wXAGn0CUWzvBb/YNwDysr0A=", + "encoding": "base64", + "path": [ + "x", + 28, + "data" + ] + }, + { + "data": "lUlFwbd+qkCzHDfBxjAlwKmcU8Dwd1nB4YVEwaKZ8EBRDdTA77E3wXI1H8GWZyLBiiHjQEwruEBMxOxA1VtQwYirV8G0ChFB091/wa4lhL9WE0TAJIZ0wU6rCEETYDTB1xt+waw7ccFAeeLAYg2SwCtWXsELlYfAA1nZQJ6aiEDKC8ZAZt99wC1RL8GrMmvBKnPQQLvH6UAOU2rBc09Uv8BfAkBMD8hAd84RwSKe1cByKF3BzZCHwX1fT8EpFl/Bty4PQZIJ0r9+sMFA7pmzwMJ4+ECfk1s/lGi5wF1ED0F1DzzAn/78QBqw0cB8N1PBDWJTwVtHDEHyT13AjgP+QMPsNMHsuV/AiRd0QPF2iUBGoutA3qJuwG+vf8G9dFjByswFQRIuBEEMbF/BmtlCwXfMeMHFIONAlDH8QAtBm8AL6ItAv0KPQMSoz0A3Sew/TOwFQa64wEAx9X3BYI07wWxJ80CJXOJA19PVQH3pvUDolaxA0T7ywHtEdECBh7k+tPY4wYK2O8FiHdVAep8FQYVA3EC6pHLBAcxuwH8eIcHshWrBY00bwDdzTcFJVvBAceIRQV+eecG+SnvBx6VwwTsH40Bp0TjBo6rHQORLS8Ehj8pAhkkwweWXgcDTUkTB/KBmwSGF50BEVXHBgSVLwfexhMGK04PBon4CQT2zaMAmUalABMlcwTaVyED0MH7B8LRVwRR9WsE/Vz/Bt51ZwTNuZUASmYRAXE1hwTjI0kDQfW7B5NRgwQh0w0C7b0nACCybv1FXacGFdw3BbgS3wApFBD/hCm3B64JlwfYw8UAWa0/AQP20QJZIAUFz+RFAAbi9QPBWZMH7fwPASUNXwdkSEEGsdAVBZkgjQZ1PgcEaVGvB5HUywaqOBEEL7W1ACt0GQYmTrr8d+D3Bd0grvwQhC0GknthAFStwwaEDVsGuai7B6BNowVbTBkEoUXjBpSlgwDofcMGmt17BUP5+wReGwUAW9B9BTOzmwBawkUCiQIHBu0E0waWvy0Ctw1zBMg7kQKt8O8Gv7e9AOowtwfw17kAIA2LBn5cVQMi7ckA=", + "encoding": "base64", + "path": [ + "x", + 29, + "data" + ] + }, + { + "data": "/T0ewRDRFkBBxwzBdyFfQJB0DUA9slXBR5AgwRFH2kAx5rG/lB0BwWKCp8ASeKnA0XcdQUq9AkHHPbtA3Awnwf2xZMEtZyFBVLp8wZ7bhkDr3RxA3BdtwVNJ/kDTVFTBXpqCweClaMEYUai/3Y+wPyReR8H245g/e2WaQK5i8UD2+HNAnl7hP0wtAsHFKWPBEiASQahjrUBdRWXBrkeNQFAO2kAR0QpBer2IwK32wL+XxnnBQCiEwVuzKMGzHTzBJNIMQRYweUDswghB0EIhPCOn2kCu9LRAqtnHvt2iCUE/PT9A4zXxQF1pp79wqSHBliQdwToeEEHKHiJAhv7QQB5Q38A9iAdAGqngQK+X9UDIyLRA1ZT1PyV7h8HqM0nBGGfyQHyQ6kASDVjBxiAMwWb4bMFGfQNBpz7aQAqgVT/2WbQ/SV3xQP/5DEH7ScJAcEURQV5dD0EAg4LBePpgwdRrFEEMIg9BD1iPQFSqCkGBdAJB1NUewPH/8kDCDLlAptb3wIejBMHsvAhBJRrrQPELDEFxCXnBlhkLQD6pzcCy0H/B411OQGXdM8Ff3bRAhJAHQcsBiMGPfnDB14lMwZwiFkGE0fvAJKkYQXDHI8G7oHVAG8LLwI7etD/RliDBxnh9wa/VCEHUZ4bB3WowweAihsGwmYfBVLzpQKhb/T9KMvdAg0Q4wQ9cD0FBU3HBzwwewU35MMHpu2HB2/Ixweae5EDsIftAe/RXwRJbmUC2dlvBA3s3wY2bDEGwqwxAVI2OQNobSMFW1WHAgJ0zvqGmsUD3cEnBJWpJwSgKvUD8wSBACPcDQeBD8UAMcthAetQFQfMca8E0+2lAFA5vwRBvA0FWTw9BHKoGQXqvisEdlEnBERcEwQ1E7ECzb/9ADssnQenBdUDLCQXBjq+PQFv05EBTOJBAlfVkwcUmKsHscVDBvMh+wSTC9EDzVIfB64QKQGxccMGiZ0HB6kV3wRu1EkG2sxpBvq3Bv+GZ+0Cm7nPBaTpewcovCkHedVDB4rKpQCdWXcGCgbZAufb8wGmUD0G6nYLB9xPhQGG+Zz8=", + "encoding": "base64", + "path": [ + "x", + 30, + "data" + ] + }, + { + "data": "rrvQwCBaWb/fm6zAG2rwQDexzEBm9j/BVaPewG2zqkDaqk1AmAGEwPx7cb5aaIC+YGUoQY+TC0F1MG1AtuzewJ3aYcFn/h1BVzxnwXnx7ECVZs9Ah4ZRwd2+yUC7zGHB5xp4wWz3TsEv1nJAa/LAQHcSIsFq4a5AFKwUQPZhD0EfvW0/k33GQO9qisCAN0TBLEIgQXjZLECojkzBklv3QDoiFEGM5xFBPyhAPyU2SUDvCoPBy5ZuwfFC5sAwvQvB0gL4QCmf7EBHzxJBohuWQCKzokBbuAZBiy6FQHGk50CGKudASuXKQI23UUBzvsnAIUu2wHaaBEFS891AZpaOQEqJF8DqO8tApw8DQXkWEEEK0VRAZUjIQJiShcEb9SfBf6q8QOVpt0AkyEDBDeSWwOinUMHs+AFB1cihQEoBrEA+qLe/qpoKQTmFE0FPgwZBFMkGQd1TGkEJc3rBixxywQmrGEEkDhRBfvbaP8BjF0Fdxg9BqQ8RQH0HFEHyBA5BzihkwDnvisCUUQtBlYixQFfQEkFn223BS13TQAfmCcDH/n/Bv3zlQD4QCsEdaFJA0X3gQOeTicGhuVXBeQ0Ywcb+IkHPj2DAb78qQQtv2sCHGIk/1lCZvyPetUBVBuPAoS2BwWTIC0FHUovBvH4BwdsnfcFY7oDBSh2yQOHHxkA9EAZB638GwWF9HUFN7lPBlZGywEFe98BHS3HBgNT5wCXWCUGxnBhBvOo6wQ6aEkBqBjbB6mX+wMXYFUH8l8VAT03+QKgtFcFrpc0/eZSPQIaDBkFjYxjBpakewUbea0BKzdZAsPkQQf+kvEDQ6Q9BfgsOQSk5YMFIzOxAHtR0wTMN1EC80ghBfN+4QLKwisFEvRnBBdiQwHcftEA9cCFBXcEpQRCK60Da33vAGQn7QMV+n0CYZsw/b2NGwdCR1cCaVF/B55KCwbrlwkDNoonB5dvMQL88WsGS6xbBfgJdwV1PIEHLcgNBsIlnQMiPEUHtVlXBRNB1wXNEEEGcIDXBTaQxQP6EbsGb11VA5yCFwIWuEkFoTYvBlFgWQW1z2L8=", + "encoding": "base64", + "path": [ + "x", + 31, + "data" + ] + }, + { + "data": "w28JwEplXMC7xJm/WPghQfN8G0GZvBbBIxU5wMiCO0BDsulAjdnmPn4/mkBcMptArg8hQf5EBEE7TUM/y24dwJeCT8EMSg1BxUpAwf+pEkGR4hRBqhwiwcp4YUCK32DBNMNXwb9DJMHPOwJBA3gZQQze2MC8fAxBsPFKv1JtFkHsrg/AovobQXzOjT6WQA/ByP0eQdaUWr95myHBk1EcQf7JJUHdWQdBcI60QFs550Cgd4PBpSVCwTBsPMCkjJfA93K8QJAAFkEC1QtBcjkHQQGvFkDpJB9B7TgAQY/ynUD3eCNBLY+KQJVp6UBRAt2/o0JAv3bH1kBnpCFBNZLQP2DKJkBkcRhBdBkFQfUmE0HnBoc+TCQbQRwqeMEgnuXAbhJWQA0gWUDs5hnBB0vOPZbEIsF17eZAeD0gQH3lDkF/fmbAodoMQTyTCEFz4BdBvvraQIBXEUGxNl7Bozx0wX4MD0H6wgpBx5HTvzTtE0GhggxBJpfRQFr7G0H/+idBP3iSP1lLkj6l1vpAPMJAQO98C0Ep/FLBxdIeQT+4JUBlF23BYvoeQeWjncAXDYU+Wx+ZQC8Bg8EUzyrBmVSjwJOqIUGAXcE/2p4pQaXCHMD7wfS/vAWIQJlYEUEkOVXAfB14wSriAkEvlYnBS2V5wGo6XcEgvWDBKaYxQHE8FEF0LgBBOpKKwHCdG0HL/iTBQ/jGvp/4XMDGyXLB129kwHQfEEH7KSJBhO8IwcJ3dL/0FfvAT2NbwJUgDUF23Q9BRzofQTyBncCBb85AFhUGQenGHUGr66/AVp7IwGAARz/ayxtBbqoOQd1TQ0CatB9BW60FQZT4RMEINhpBPWlrwQw9hUDDP+pArHIQQDfegsET0LPAqBn8PFruOkDVPzBBF/4ZQflmGkEpapM/2W0iQVnIBkA+fu6/jKQVweQgvb/qeV/B6n1+wWWLbEBSxYTBnzkYQbo8MMEqtrrAba8wwbeZGkEGqrtAFSsCQdThE0HwqyXBpsyAwZG8BEEcNAnBYcU2vzP5c8Gw+2A+wOGjPivtB0EaFI7BelMoQRkVVcA=", + "encoding": "base64", + "path": [ + "x", + 32, + "data" + ] + }, + { + "data": "CWwmQP35mMA8mktAQvU4QYYFP0Hc/7HAjRrWPwyM3L6dqSVBp6aeQIW3DkEzWxFBMuMJQZdl3kCH6RfAktsdQL9hKsFTNeBA3WIIwXBoHEE3ZC1B6mvBwDwOpL6bvk7BctUjwXnu0sCzvjJBBP08QXS1JMARYi5BE5RdwMZND0Hp9IrAVk5CQbaum0DudJDABrsPQaa7g8Arb8zAT9sqQcJOJUGFm9tAq7wZQQmhI0GNbXrB55YDwSdh2D9AMty9VjlOQMt6IUFxJ+tAFLguQZB/m78AiyZBIrsqQR9U4D9AOz5B4BO/P6uAIkGa+URAswyKQOrohUCw8j9BtyfMv4aY5UAr/jZBYzfyQNTcBUGxiy7AzL8/QdW6VcGwWy/A8Iy+PeqDsj7MusjAHOWcQLsYx8DvurFACXkuv37CMUEe6JPAf8gBQRq53EAovRdBI4OPQA5X70AOyC7B/OVjwcXy8EALyulAZGKDwK+sAkFvD/ZA2MUaQZU9E0EQXy5BSvm0QCcJm0DdCsJAeiknvc3A7UBZ7SfB4w8/Qasn20Chv0TBAdE3QTbF+b6vQinAxPPrP0nMZcHHF+HAgA4YvFdxEkFg8shAbZkXQfqME0AaAWjAytsNQUe3M0H3WF4/sSNbwfuZ3ECgz3/BLsp+P18MLMGxByzBEf1+v3uiMEGGY9dAKMCmPukzC0HpJ8rARgOcQD+CrD+CwWLBbw6SP3R5B0FkcxxBuKGHwNQLccA+3lXAg3nJP64r60DhSihBhpcrQQa1gj7UeiRBb5wxQeV8IkHW3FS/GtH2v5JqEcBuTDlB4JH9QNHUSr+Pmh5BkY3eQBlOGMH8lyhBhJZPwX2GSz/Dk6ZAho3dv+N1ZcHVJ3O/QxuTQIjfIb8j9C1B+pH2QOShKkHgS8JA6QE4QQI5mr9AvY7AFNOqwI9JgUBNQU7BoidowcZsAj8+ZW/BC8w2QQxB6cCVeMa/Vb7mwEHXBEH7QjFAsMs4QbcMB0GBT8vAWO9+we7S00BF3ZnAoYt1wCCeasGXoTPAhouYQJyy30C294nBySYpQQYubsA=", + "encoding": "base64", + "path": [ + "x", + 33, + "data" + ] + }, + { + "data": "iTLfQM14psDuIeRARjVAQdyoUUETSC6/Rye+QIpcYsA9uENBlLoLQZMYO0HQkkBBHmjJQEFDnEA0YI3AGurgQAeb4cCjrY1Ax+SDwGUjF0HBVTRBMc2Vv9hegsAKWCrBw3u7wPRSCMAIrk9BaQ5OQWgbAUAmrz9BgZKgwPLq9UBDWKzAQWFXQZP9DUHUmws/MKPmQPc1yMAVzva/Bn4pQfzjFEGpz45ACf5FQWUTQkHa2V7BzFJXwKAIxEAS65BAlMInvo3RHEHvkaJA1j9EQcsbh8AGDh9BS4FBQcFw8b+jVEdBObvmv/LSO0Gozu9AAwUMQVi9CT+NG01BFP52wPefK0HeGURB4uDBQOpK00D3w43ALmJTQdXhI8FO4w1ATmpEwHKQJsAybw3AWroOQXROs7/qIExArvVZwAMzQUFN0ZXAk+3VQIRRjUALighBIiDEP+sCoEAELdjAYkU/wZTHqkCl6aZAVlGswB2HykAlR7pA9ps5Qa9O9kAZIiRB4SIUQb2oB0Gxd19AA28+wPmhqkBAKdrA/oBNQQdiIUFvAwjB6JZAQTMOgUAWtYPAdubBv3+hMcGbDCfAf8WiQAQQ6kBnlyJB7tXsQOSd10Az2YDAFyxCQQ8MQkF+Q55AbBwpwVExm0CIKFrBIsy3QD5M1MDCiMvAWESKwBAMPEHsDpRAl9edQIg62kBQZb6/aOYVQeHCvEBN5j7BgSi2QEzL4kB25whBqhRLP0HlsMC9n9E/6YjLQEFbo0Acey9BcJInQXagrEArEU1BmO1KQdWhF0Ej93tAL0cpQC4hhcCiKEdB5MnEQCs8jcA2hA5BhnuZQHbvtMDK1CVBpyMgwX0sMMAW4QVAh+SVwCMKNMEs/3VAX+kGQfgXdMBcvxtBSeCfQOtTKUHNGSNBto4/Qa2GZMD1fbzA+AIyv2/gDUH11yrBafk/waZ7L8DnlUPBq1lFQX5wMMDE/jtAZm0iwFkHw0D5d0q/y4BbQX8b2UAfJsa/fSlqwR/Eg0DveJK+f8i6wHO/TcF/LJLARiIJQS1DlUD5Z3vBYnQaQTRoVMA=", + "encoding": "base64", + "path": [ + "x", + 34, + "data" + ] + }, + { + "data": "VyooQdXcnMCGeSNB2n85QftyVUGsa4tAuYAUQZTascAWWlFBe9M2QRpMVUEnFV1BzNdNQFjiC0CuRq/AgIErQQb5EsDkQJE/9etNP2IbBUF37ytBtrx3QAeS1cASdujAC+8tv3kQKEAqSlxBXVhPQUy0yEDpkkJBK2m0wHEftEDMLLPAHiJdQcaaQEGYObFATcGUQJIs5cA3/jFA2K4ZQY897EAwdrY/I1hgQa9TUUF93TLB/Lz7PzY4HkF4RAdBMaRNwAKZCkFmCgJArflKQRyiw8B4EwpB/thHQVDsk8A4T0FB7U+GwDYGREHYfTBBgTFBQe5LU8BfUktBqNuawP9eT0HIQ0JBbMB4QOzzf0CkYKTAiyVYQcNLx8BSBNlAtX2hwNjVhcCZNQlApKs8QafYaUAUs4E+a0CdwNyfQEGfi37A4kuTQAg6nz+BidhAZ4bVv4Hl6z/Qjc6/0kAHwabSGEA1Xh1AxyC4wD55dEBFllJAsJ9IQRjUqUAKRgtBcZ45QWwhLUHFhpw+hC2SwDR6HEALJhXAhPxMQQD2REGbLGzAW5k7QYQx/0DoypLATe1vwPg81cBRjgpA2pUXQXMykUDJt05B4pyPQFBDJUEI5GvAKfRgQQB3P0GKmQVBGyXFwCjS/T+1HiHB+LEbQchY1783A5q/6hnPwOHeOEE48Og/bJQNQar+g0B0wmRA7+9JQYPsFkFPnAfBR9UXQeIankALDdFAyIO2QDl3ysCFMsxAGHElQXIHEEDa8SdBR0UVQUulG0FrA2NBpMpUQdV8/kBXcwJB6DjcQClKncAyeEdBaElpQBJU3sBJheFAGY4AQGHXeL8JmhRB6Fq8wGztn8Drcea/GQuwwJLB48BnpQFByjkzQaJsucAR+PRAqt/VPwmHGEGillNBM7o5QfcYhcAEyMrASBGBQOUhSEEv/evAWcEEwc5Sm8DClAXB4hxGQc6pBkAsJuBA6cseQHFoTEDDGnrA6EVsQYw3i0AEVV9AZvI/wXp8ej8tDolAFDjcwOwZGcHAtqvAu9E2QSw2xj+zzVDBMIn6QAaEGcA=", + "encoding": "base64", + "path": [ + "x", + 35, + "data" + ] + }, + { + "data": "uHpQQZrhfsCelERBluQlQYjdS0H1QwpBFVY4Qcxe1cBJkVBBIWpRQQ6ZYEE/xGlB69XBvpI0Zb9qz7jAnJBVQV8cO0Ct5hXAqn+zQMX0z0DnxRVB3xIGQQwB/sDFDEDAcz2TQIWY30D2uFpBNMRCQc8XGUGInDhB06SvwA0FNkA4SaPAcO1UQaTpY0EiwB1BxVixPx6i3MBUxuNAQ+D4QCHxlEDhD++/NY1rQRsIU0G0ZuvAbjTfQA6fSkGgmDJBshabwOFW2UCAiLu/pOlEQdgh4cBkJNFANDZAQSeNw8AV+C1BgB2xwIzFPUHxFVZBIVJhQQfhu8AGETxBcD2fwFecX0G5UzNBRP+XP+q6Oz+p5qPAQopPQd+tw79ljSVBqa+9wEiHmsDf5cVA6C5ZQZCSAEGQQinAFA+vwNpXMkFCWyrAhu76PxKqCsDJ4olAO7OIwEQP0L8kkHNA0Ut+wDVcjr8D3Um/eYGrwDWVRj+vxI8+Zw5KQT+eCUDVx8pAvxhNQQUTQUEJ/DXAtkCcwHVwg78tRh9A8W0/QUpGWkGE5M0/JGYqQcLCLkFq2IzAXsuRwA7Zrb/Yl9JA3AxLQR9oSz+tx2lBfUNrP1PbTEEz+zbAuCZuQcdiLkFKeytBn+lQv2mdwr+LIavAk55KQdppYUDlnINAKF7ywKy+KEFVSa6/r2s6QfhDNz+SQQBBa0BoQfeJOkE7nIDA2DFCQfjAB0ChOnFA7vAcQQ9UyMB+jCRBlIZSQepacb/3gRNBZlDsQAKUTUEYMGlB+xRRQUjmtUBXRzRB9lckQfWFnMDlmDtBiaYEP2hcA8FLC41AZjyRv3rPd0DUke1AEqdxv9D/xcBjjZjARjakwKBECMD4ADVBmYRPQUno18AgMZZAfdf0v4XV80C2h3FBYrEmQUPfdsCQir3AdogDQRBDbUGCKk3ASwpfwP74vsC4rVzAppw6Qd231kCW2yFBpNDjQLU6Jb4ZzqDAVkdtQSDQoD9eifxAVeUAwSgUFcB/OQFBpbviwGBnncCiOK7Ad5JUQUJq+r8plBPB4M2kQOYfkr8=", + "encoding": "base64", + "path": [ + "x", + 36, + "data" + ] + }, + { + "data": "Cp5pQSuwIMCVo1ZBmAUGQbYHNkHvqTxBBOtMQQ1w38Cs5UJBK41dQVMJX0EtlGhBCBJuwMLwXsD/r63A/dNvQYeA9EByPIfA4BoaQUGTgkB/P+ZAruM9QdXQ/cDOo9Q/gN8SQRwVJkGge0xB8sIpQb8vO0HqCCNBB52VwB2G874Fp33A6MQ/Qdb5d0GmFVJBEjUKwPUHscC/8ShBkmilQOPPoj/VFIjALWdpQWVWSEEUiCTAFvAuQUt5ZEFLX0lBX/yxwDBiiUD3cIPAbHYzQfDz4sBgd25AlnEsQR1P1MBTxg5B9bXBwHsQK0GetmdBFD9uQSl07cA7YSBBpdyPwK9yX0HGyBhBSzjbv72AKcD2vpDAM7Q6QU5nV0ASBExBN5u+wFKamsCYzxVB5ChnQXefMkGzoY7A+wSpwLk5GEE2X2S/RIaBv+HrjcAh76o/n0SswOS0jsA0dwlBf1OBP7xKcMCIDVTAvxWJwJduF8DAIi7AMHs/Qbb1tr/uKFFANbZRQfmDRkFfyJLA9QGMwFl9d8AzKt1A5j8mQSCuYkHnZNZAECgOQZ/OTEG4DG7AwMGRwJuzhEApRB9BxOxoQZt4SsDyOXZBpWoywAy+YkFWI9m/Vn5sQX7LEEGruUBBKIWVQO/Jg8AMRyI+eWZnQWHhAUHn2A1BLnP3wP3iDEHPJnrAA2ZUQTZ5McDP3TNBod5zQeh1TEGWfnU/QSdYQVWBjb/K1tI+6JxMQTQ5rMApKlBBMGlrQVOsccBRS+dAIxSXQPa2akEAiWFBTSFBQf1pMkDUTFBBgr1HQaLhiMAreiRBJtoowAZKA8E9UI8/NlFqwB+QAUHPA5xAS6aEQH2C0sBb/tPAd16CwMjHSkAtsVNBCpVdQYNy2sASFH8/6YyVwAuNnkAux35BmUUGQZDqQsDQCJfAQMw1QcL8fkFStK8/Mbv2P0PlycCzG/8/EvIjQSymKEFY10BB1d4rQVRWWcDFyZfAW/tfQX0YBcCPFDBBj95GwHe3k8C7TSxBZQXQwCfqBD/4m53A9AJkQVr+jMAa+IrAFwjbPzrIkT4=", + "encoding": "base64", + "path": [ + "x", + 37, + "data" + ] + }, + { + "data": "kjB1QafXEb/eD1tB57C0QO3oFEHbSF5BszdUQWKz0cAamSlBFMtcQX/6UUHy51pBP02swO1akMAe9Y/AaDZ8QedCNUFyoZ3AYllHQZE+mT/DwYpAm7dhQWHF18Db3MNAjLdIQT4RSUE2rDJB8IkFQT9MTUHY6AJBflpRwAVwY8D1fg7AHH0eQS0BfkGBiXJB0PSXwE0MTcAh0ExB53vxPz0BFcDb0p7A0RZbQcATMkFeQilA1N5XQT2AbEHKRE9B0wO0wIz6pj9oHKjAuawXQYy5ysAxjrY+9BUOQZERzMBfMcpA1Ea8wPSSDUF+1mdBkfNqQecDAsGlMvJAYqhhwOowUUFi9+dAC6R2wB9WoMC/HFvAKpkaQU9p90AQZmJBhDGpwJdZisBuUjdBeJFoQVNJUUGcp6fAxAqPwCng50Cpa4g/kupgwAWRpcDeyem/jsOpwIMSssDKSkNBSfO7QIhGn8AYvYfANS4lwNHghsD8v5PANRMqQbM0jcCCIJC+lK9JQRuQP0EsFKHAh/VTwGUKrsCUXiVBxp8CQWEWX0Fj+i9BdtrPQDa1W0GgAynAhUaAwCn/EEH0cEBBGoxzQeF7vsAevnVBS+GqwE/uaEFY2qW+kcVdQREy0UD1cEdBTa0XQaGWtMBBgLRAm8xzQYOtN0F6XEhBwPvfwOy5zEAFXqXA8S9eQadAm8BVV1NBLLZvQUK3T0HQbLpAqnFcQc4vccCztjzAh6tpQUXybcAQT2hBI3hyQTzFocDvtpNAGDy7Pxz8dUE1d01BOPQlQUDdA7+eH1lB3pVYQa84TMDn0QJBnCKTwMTm3sBvPBfA5F6RwLsCNEGPDuM/FuAKQbBmycCqvPPAn+QkwIn//UCc0V9BrrBeQbbZw8AzuDfA0ZCtwGjo2T8+GH1BGTWwQPg99L86hjHAT/xSQTQjgEGGMblANyLgQGD3v8Aes+JAmPwCQVvgU0EPOU9Bg5VQQa6gp8Dgxm7AJ29FQbHgisCFa01BR5MQQGcVrcAY9EdBhWGkwKEEvUAVS3jAvW5mQbK5tcAYpJM/iOoEwASi0D8=", + "encoding": "base64", + "path": [ + "x", + 38, + "data" + ] + }, + { + "data": "rFp0QSRTwT9y9lJBsfkOQIgX00ANk3FBnqVPQURirMD+0wVBbFVQQXRiOkHSx0FBcJS0wKLdjsCTr0HANxV8Qdh3XkGEAp7AbVthQR0V7b8Gy28/t2pyQdhSkcDDeR5BNEVpQR0XW0HvLw5BLLuuQOrfUUH5sbJA2Watv/dqscA43ZG8RuzjQAbsdkEz9n5BTKPBwIxemL7EG15B453dvzjXncAUPZTApXBBQRvrEEEYquxAGF1sQXaYZEFOK0dBUTelwP0K77/FWq3AFuvkQB/TmMC4VUDAUDXNQM1nrsCJj0pAahujwAy+zUCewVhBYqVZQZ8VAcH9dY5Au0YKwL6tNkHx2YxAwGCVwN1Ww8BfrvG/uWvgQBdRL0EL+WpBDNGAwAKMWMA9YUlB3MheQdNIYEE1Z6jALqdHwGdajkA5qS5A2JCYwH9knsDrp4/AXgaOwHd6q8Dz5GhBNz0hQQDcq8DdHInAevTLvoq1ksAmhKbAQsoKQThiwsDvS2nAsrE2QfjHLUGVw5TAJIDvvx15wsBhYElBlY2rQI0VUEHvqWJBXiFkQAccXUGn2J+/FatDwAwITkF5O1BBbfJtQScV88BmgGlBbkbKwB4FYUF0EYs/HUJDQTf3X0BOY0FBGMZSQUaCzMCw5iRBsaFxQV2AWEHIVW1BTDqswDgGWkBIn63AOwRaQW7rtsAOeGJBONpdQRd5RkHs9SBBOctRQTIQo8DFyZ/As6N2QQ0qqL/Vx29B4A1qQVTbnsCNasI/Th8CwAAcckEaFy5B0HMAQQL/ZMBQGFJBvl9ZQSD83L+ttK5AkoyrwCMNk8AnoZjAnnWLwAitVUFacsu/btZDQYu6rMAyd/vAnRVQv8yIOEEmcVxBtr1TQdyklcCkoLTALvOcwAo25r9qwW1BuBHkP9sUE7/wFGu+OMBcQYUmc0HsAxlBfhAxQVtmo8BwrTFBQT+xQHJ3akHZZ09BzfxhQWCnr8BS5xLAh34eQbq0psCQU1pBt5zrQP8MpsA+V1ZB8Aw+wHIjKkG14xbAL8JcQUtqxMBLOc9A3EacwIizH0A=", + "encoding": "base64", + "path": [ + "x", + 39, + "data" + ] + }, + { + "data": "8fNnQXtBO0DTPz9B/ALLv17oVUA9JXhB9D9AQfrsXMCMxbFAfiE5QRf8GEFoCx5Bs9uhwBRiccC2+oa/O25wQYlneEGuqo7AI0RrQWYshsCQmSXAWf1yQS3Y1b845UtBsM13QbfTXkHq6r9AmZQEQGuzSkE/2h9AWxtaPwwQzsAmJgpA+T1uQMFhY0HX6XlBfCXMwLCNKUAPk19BNcKUwIcEwcAsrGrANBcdQe0hy0CAMTFB83FwQT5sTkGAPTNB5OeHwIRlicDqo5zAZ7+JQHMbGsCACaTAb9VeQMuie8BiZa++2AFvwF7tYkCOcTxBFRk8QRq06MCoEE8/gKcAv36GEUF4CZM/CAKSwGK3xsDgeKq8jblzQMY+T0GIRGdB0t4QwKxpBMCSEE5BZNJKQW8hYkFQTJbAhDaov/HfoT8vh2VA0K+fwPilgsCOoLrAsgNDwLfIisAbjX1BMJ1UQeXapcA/5nHAAY/sPx55hcAu35zA5R3FQInu08AVmrHAQxkaQTxqEkE072vAtLZXvtb2v8AlcV1BzfgFQOcGNkFofYBB/vl8Pq9FUkHIgas+cWbmvyVvdkF92VFB8WpaQcPhBMHBW1JBxIzHwF9MTEGRbAlAyfMdQZSDBj4tCDBBIDB6QT/jz8ALblxBrjRiQbp7aEHU0n1BLZE3wAAMBbq9KJ7APKFJQWpGucB9+2NBz+Y/QfpeMkGVuVVBPF46QQhyrcCfzLjAIZp1QR1wtz+S6WhBeAxUQYiRgcAta+O/2wWTwDAIYUH3awRBAlqjQAEBpsCW1j1BHUNMQQhe2rtcdQ1AJdOowOy0u78k8LjA4/FiwDbuaEGqtYnAg6ZqQcAHe8Dk0+zAogGFP3UIXUHK50tBcGE9QbW2IcAoQeLA1q5swI1wmMCQv1FB5SkWwCk4Uj+DOxZAWGtWQeUPWUE2jUZBh9JeQYska8AGUl1B+PgYQGBebkEFTkNBkKtjQQdnmMB4NiG/szLYQGw3psDNpFlBsIk7QQwIicCbAllBXKINvpW8ZkGilt2+VqtHQcPPvsD49y5BxKvIwJawIkA=", + "encoding": "base64", + "path": [ + "x", + 40, + "data" + ] + }, + { + "data": "Mp5QQWYUU0BAvCBB9k2SwKAKiL56E3NBdtcmQRJdPL/2qhJAdwgYQczp3EA/GuFAROl6wKUTKsBDtpU/ggBaQWaPgkGYHmbALINnQbM8osANF6XAorllQWgpuz+dQmlBGTt3Qf1CVkG6zyVAUz3Iv48iOUE7ZF+/YmUyQAY1zsCYq1tAFT/TvariQ0Fuq2VBEOO+wN17m0BeaFNB6uDGwAyOwsD+zRLAkVrdQCThREDhvFlBlOhmQciPK0ERPhVBNEo7wPYko8C2k3bALCiGP6r2Bj99UL/AnEN9PmAy878RvW7AcSLqv3aitj6IwBRBUeITQTQSt8AFLzvAFQCdP9y9xkAPlA7AVVp2wMqhscARNuU/1v9cPprsXkFXW1hBXNQNvuLv5r7HCUdB2XotQVCSWEGa6GnAcVI/P/oWA8CKKVdA+vSPwPXeMMBOKcDAYeSpv/YCM8D6/YFBoot1QT08kcDRCjnACj5TQKVKUsDN7X/Ap5VKQNfuycASm8HAlEjqQC0s3UDQ5BPAGNe7Pw12qsDwEmRBJlO0v8IjEUGoCIZBEPNDwFU0PEFDuuI/rDCsvvfohUEVmkdBtNQ6QXdKA8Ei/TBBJkOtwIDmK0H97RVAoqLdQGW8TsC9qxRBCPKHQQrtwMC+VIBBPolGQZ6sakFSXH1B4IyVPj0wVcBW4XjAsHkuQS7VqMDqzFlBuEIXQQG/FEEJT3lBKwkYQQUYocBv67fAuAloQSkua0CPfVVBVhUyQcquKMBpjJDA/cyywHFCREFMVaNAEWbbP/gEr8AmiB5B+h8zQWRN1T/Ycau/F+KRwJpK9T9nCLvAQIcVwG2Db0EGMarA1DOAQXWo8b9uIsjAQR8sQN1KcEHeHTBBsh0cQQiLLD7kyO7AsWcGwPhTysBo8SlBJW+wwIZgA0BV6IBAyJdCQaQoM0Gj22NBE/J7Qe4037/xZHdBYJ+Gv3xbYkGIgCxBTjNYQdkBXMDqf4w/EmY/QEMsksAUZk1B3GZxQQw7OcBZEVFBn+QqQFJhiUH4Wco/DbcnQdIcqMBqhWNBym7UwP4Q3z8=", + "encoding": "base64", + "path": [ + "x", + 41, + "data" + ] + }, + { + "data": "G+EuQZIkNUCim/BADJLCwJlccsCCGGNBqCYEQaZgDEDFY5q/uOfbQKP9bkBfLWpAyF8awOP8or8W+DpAamk5QQf9gkFxLRvAT/RXQbMjncAF8cjAQ2tMQRgFh0BJEnhB8aZpQVnwQkGiDI+/37yYwDdKHkHlj4DA9ONwQF04t8ARXFdAJ5F2wOnuGEG0JURBM7SewI/Pq0CiajtBUt/WwEuprMA4Gi6/ZAJdQEkvEb9BOHNBO81RQRlr+0CRjd1A/g+gv2cbmsCELRrA3bkUwCmGTkBxWb/AiYo/wHvX9T4Ht77AE3v2PjyQNsAYTcdAZU/FQMRMVsDa4bLA2s8cQJz4OECO2KLAEf0twPI0icBTxDRAApNXwDUXYUFlCT9BCMX9P+2lnz9DpzVBvnwHQW/lREFmpg7ABMAkQO3MncCYWQtAthVgwCcEkr9scqvA67MJPw6rc7+ZC35BBFiCQVLuYMBxP92/hbpIQAw/BsAuiyvABt4cvoUVqsBpV7TAZVqSQJ0Wh0A7Iyq/DpQxQGGLhMCrF19BNLuRwERsw0CEVoNBUqSswPLMG0EP1RxAP66UP4+hiEEJPjNBcuIQQZDn68DYCgZBLPyBwCj/AEFj7dE/48RcQGjYvsCULOFA8T2LQY+qoMCFVYpBH4cfQaYtYUFBpG5BO4tSQCm5rsB8XBnAROIJQfxlicCaW0VBjcnKQAqs3UCHGIZBjzjZQEqtg8Bbn6TAvhNPQW4QlUDs/jZBjMAFQXXacL+v3LrAfLqxwP0ZHUH3xb4/zWbwv+PWncAQTuxAfrMPQX2xLEBKrIzA66JWwG1gmUBdwqfAV+piv8WxakGlBqXAUbeDQRrgEj8WgYzAAmRWQHRodUEXxgpBO/3gQIg4MUDJneHAOD6cvmj01MBPp+5AXS/vwM37IUCUroZA8m4jQTeKAkEeVHJBUI+FQYk8DD80gIFBaxCFwM69SEFAaAxBJIdBQc094L9CLytAGU2SvxVWX8AzIDdBDuiKQUARmL88VD9B0pSJQBD2lkHQeDtAe/T6QPpbgsDBroJBwwbIwBfa3D4=", + "encoding": "base64", + "path": [ + "x", + 42, + "data" + ] + }, + { + "data": "dk4DQdRS4z+dbY5Ao+DSwOUCy8AJskhB0wuyQDMPhkBA+47AG7twQDIbPz4cCKy9ns0tv6W5eT7xd2NAyEQPQXvme0FRBYK/ghc+QWhyg8CFIMvAl5woQeNmr0BGt3lB3a5QQZ4lJkGIp4/AW5nRwIph9kCWL8HAk4pjQD1CjcAmTRNAPeLQwBadxkCnKBdB9HdewKD7ekBUNRlBcZDNwAavhcBI14A/1q3NvvZlgMBdA4BB978yQWP+jUDsFoNAiDYmP5lMecA8Yy6/4QKfwHh9lEDs2KvAwAS0wN32KkDV1tXAh58lQGVHsMB6TS5ASiEqQJb1EL7D29nAtEkuQBEyLL/0adLAcfGnv7l6I8B5LDxA6uDCwA3JV0EU9htBdEBcQGRHGkAaFBtBHmOzQPAgKEHHkQa/vZBcQPfizcCJZNU+NXwJwN0DHz/hcYTAbFMUQI18fz/rEW1BXxiCQY/rCsDGace+KsLqP6A/Or/lFoy/yRFZwAp9ccD1T5PA2mfAP0MQmT/3g4g/2O9MQAunIMAa309Bi2nIwAHGIkAT/HJBuGTIwO8I5EDbDg1AeV4RQFV+hEEvNBZBdbu8QPYOu8C2zaRAbkQVwCg1mkCT1vA+bZ7DvsZn6MD1iopAW+SHQf3CXsAxaY1BQ27cQFiLTUFwwlNBZcadQEMEx8DLEhq/gI26QKZoO8DbzydBjwYxQMYQhEAPGIhB+5FoQH9uMsAhXYPAxasrQZV4iUC+zA5Bh8qhQCDuWT9Gfr/AWFubwALQ2UDRDBLAOPSewCBGd8A9dY1AeI/HQL7+MkA05sDAzqzjv9OywkDbfoTAPCwoP+9rW0GewonA17mAQdkXMEC97d+/cPcQQACGbkEmLbtADg9uQNbUiUB7tb/Awv3BP+F9w8CA321AwkAIwYMN5j9GR0dApNL1QD9EkUBfXnNBcBCHQRujJkBFHIFBJMG9wI6VI0Ey38hAw0EhQT6K3T1womxAcA+ewMLbBMANFhhBtWSUQQP3KD86biRBYxyMQCeSnEFRKU1A/sqTQIVfHsChuYtBL6OowIqgf78=", + "encoding": "base64", + "path": [ + "x", + 43, + "data" + ] + }, + { + "data": "zZidQKY8zz4mBnw/8/HMwF/078D1OSRBh1gbQExxm0BUXNXA1fyiPv6iVMDPOXDAOVKPP/Gj2z9cCEtASc24QC+HZ0EMWgU/wzwbQdotOcDi/7XA45j3QLYljkDkTW9BFa0tQecTAUE8as7AlYjgwDbuoUBXZdrAmHAbQNEeKMCIkkw/D5j6wGwPE0BdZMFACczPv3h3vj9LwtxAl8awwP+WJMBRFiFAs6GCwBf9yMBb4oBB1C0LQUs7KD+EpXs/2lULQP9sJcCNqpE/9rrCwLVfkUDslYnAdxDbwAese0BJIs3A+1BtQIjX2cCd/n+/RjWJv4DyQUAoI+HAfToPQDophMCoftrAuVZvPrKVAL9LMhpAhlbtwKqVREFxnt9Ai2d3QHjmIkCZ2/BAf9oVQOUuA0FOGKA/Gz1EQGkB0cDLh7i/HZoSv7zZDkB2DSLAeZJnQASBMkCeFFJB+891QXPoE79obH0/8o0qPqf5ND/VUBs/ABm0wGFL6L+dPknA2MrYvwm3+L+OCiBApu4oQN26Bb/ZgTdBumnSwBiWsL/uylJBBUPFwHRdgEC5JLE/ROAbQL6pdEEkkeNAkRUWQHmqacAueb4/IPW+vqqBlT/sb06/JReCwBry5sChXKY/zh59QfFJtL+EZIpB0OpQQBz/MEGmei5BCa+bQP05wsC5KKM/K+gpQDijob8sNQJBsXmGv3aDgj/iYoNBJmBXPqt2lb/1xy7Ac4z9QO/gO0CFxrxA3XqwPy7rIUA4+arAxZtswP+rVUDa+q/A1BPUwAddHMB/UpU/7tFFQN4XDEAQSdLAnAPcPHBMpkD5XyrARvgFQEVvQkGjfUHAfcNvQY2kcECX1rY//c65Pu01XUG/RSpA8GRQvFjIjECOz4zAMQRKQCnsncCGmcu+dA0NwUItzT7MY7A/2xqWQCDhAD/+ImhBPxuDQQxqbUBQhnZBJHbQwK3W6UD2/FhAdbbxQA6O+T/1iFdADMbmwGlO4r7t5OJAjQGWQS90F0CS8QBB0b5ZQJzwmkHW5ylAQJdxP7veB7+QB45BEfNzwLFpEMA=", + "encoding": "base64", + "path": [ + "x", + 44, + "data" + ] + }, + { + "data": "9HqaPwmvg7/WKCXAoDa2wEEn9MDMF+xAGEl2v+SHjUBo4vHAs6ZIwEDitMDX6srAnd4uQHyaMkCYwgdATYYJQLVOSUHKMu8/wF/hQFaCtr9JNpDAaGOPQGX8B0AIw1lBeOoBQagIqkA+FePA2ULTwHK8BEAPEdfAK0JVPyv3Ab/xz1C/F+4BwUy88L9kcA1AelTiPhnXmb/XFHNAGbSEwM3oNr+2CVVAP3rLwDzr6sDVlHlBFQ+5QDI2S8CLMg3AOsovQDFIhr8zoSNAyFbEwOlkWUDnMDjACOPZwOX0gkAm4K/ASoRvQNdG2sCrNpPAZJ6UwOv2m0DJhNLAJJSnP1py2sBB7MfA7PPdP9pTzj8Zxbo/wMb1wCjIKEFtfW5ACq9YQMGL9T/w451AgUmSv8IbrkCsVCtA3QrnP309t8BLNEXAnl6IPxihSEC48jG//tF/QKk+fEBx7y1B7gdbQY+Riz+u0AdA7PnDv1/SAkD4Ig1A0UrRwJiMxD7uF7S/Ff6TwH+olcBL2EVAMHizP4sixz919BZBIDfBwMHPmsDgvSdBxFquwDDJCj8z9JQ+G3PYP2aiVUGYrY5ABTGyv0X4Xb/IMBXA8z/PP6MaJsAMv/m/M33KwNKCyMAXvuu/3odfQcXdgD8M5IFByg8xvwqbDEE5dgBB8t1pQBMEqsCowzJAtw47vya0ET8HV6tAXdqVwJcfC8AxJnFB2QNOwP/JGD/99o6/EkmTQALCiz+y2x5AFIEawFadcECeloXAFEoOwIyaz76cD+XAX83iwDeyT78W8ArAmPWOvq3DlD9YwMzALZPoP+YpP0Bif2y/MDNBQGFfIEGqlb2/3mpTQbgGakB29npA0JvRvwyzQkERJzi/KF1rwP4nV0Ao3hjAcqKIQGE0VMA40ozAJrQHwcJGjb9fwg+/zh2yP8adY8CWoFFBCEV0QVtkdkB2A2FBKhrKwCgQfECq2YQ+l8WTQGHoX0BD+9o/l5gAwYKPnj/Y/4hAHouQQduuWECnHqtA+Oz1P2SfkkEbqMo/S0Q1wMC2vj+IaIpBxIv9v4uTS8A=", + "encoding": "base64", + "path": [ + "x", + 45, + "data" + ] + }, + { + "data": "mM8owD9gE8BiJrTASzqSwIaX4cCvfntAcfWDwEwmUUBZr+7AuSi9wCCaz8DjS+/Ag0xnQJc7PUAFWUI/xMPYv6yXIUGmcxhAcsV/QOOGJj7GGT3AhqFqP5ckEL+Q7TlBy7idQKWQDkDi3tvA9+mywAhKi7+Rq7/AKxJiv7tA1z+DWBXAjqf1wD5ctMDMHOe/RoMaQJ0/b8Bo7ts+5eMZwKfomz+mST5AQnHmwM/j8MCUS2hBIC0iQLIc0sA5AKPAlHYnQDoBEz/SVT9Av/qwwMMj3z8mipq/BUS+wD/hWUAG84TA4pc9QCP1vsBlJPHAHFfrwIq3q0Bq8rPATKwnPvV8/8DahKPADjw2QFAZVEA+no4+GlXmwIeJBUHcn9k91SIRQOcDYz/XJQFAWkyMwHGeFEAzWFJALKxHPsOVi8DnwofA+q4hQErhPEDTQJo/Y+RVQAkMfEDMegFBEzQ1QQ1yDUD4XSFAlK9DwId2PEBe3VNAz2bQwN2MHkD0Iuw+ltvQwPDUxcBLZilAsOr6vTpFRkA0V95AeOeewPvS4sDPF+dAjyeKwMLxPcCD1lq/OroCPw8YLUG4mMQ/PGmewF42BUDhKrLAA8JQQC12vMCJ5zTAgkbbwBQ5l8AwApfA3uk3QdIsPECvwmhBSp6PwKDqwkA8BZdA/m/zP3NThMBUCF9AL2WAwDtGC0DO4w5AFvLnwMeQn8BDYVBBStHGwPpPDUDttxw/vqFnP5KSZr+c6ZC/Mci7wLR/gkCjACrAC7MOv34pgsBZeu/ArSDYwHlNZD8Ls6jA3htnwBE+db3tEbfA0vhLQLLkkD5P+Go/xVo8QKbT60DW+Ds++VotQWU7M0AQ8qNAm4NawAEKIEH6d4DApMrKwM+A3j9ZcM299fiFQCfus79EVurAXJ/ywF0FHMDblhvAOZAAwC4T1cC4xTBB2/lYQZl0UUA2kUJBnZGywPJqmD6dbzjA0JeyP8egiEDHkee+cFr9wIC+I0AzMpg/WKWEQZsLVkCSCg5AKcxfPisNhEGpx48+rsq8wPv9NkA8eIFBJsSvPVP5aMA=", + "encoding": "base64", + "path": [ + "x", + 46, + "data" + ] + }, + { + "data": "vP+7wBfMR8BglPDAbG5HwDPIvsBumW091PfGwFEm2z/A+tTAaF7uwHpNzcCxdPLACA9RQASvCEBZXzG/4tClwCeZ4UCEcPQ/qF8xP5df3T/QhZS/vMEtwP4xTMADrxBBPXS0P3g/g79vz8HA13GFwLlXgsDZ9JnAIqEfwMgFY0AOnWLAaPnVwNqsAMFl47LAbNByQDTiuMC+uz3Avj3YvkQ5OUA1rNc/g3/lwDmE4sBFi05BVmtjvyxrDcExs9/A7fcDQNWpCEAZrB5AwvOPwGMu8b1giRU/BcCRwM6sCEA0LyLAdaPYP/3RkcB8yhHBunIGwWO8m0CJgInAq1GBv9ZB+cBNaWbAATtMQCjlg0B/SHG/+MfFwMEPuEAdgl7ADwxEP0qzjb49Moe/w/TNwEgffr/D3j5AW1a5v48xKsAgpZPAfa1fQBpE8T8MSjxAePryP4hFM0AEjptAMr8FQda6FUAXme4/7NKGwGt7MECQUGNA2Uu7wPtFfEBuphBA10HgwEnEzsBZnr4/soDQv6Y1Y0B1oIJAhgtjwDKIBMHpP2FAC+85wHWBu8Bx8/K/ElVGv9SG+EBgaL+/5f/1wEN3iEBE++jA1+J9QBtQ/cCr81TAr+DMwB1ZNMBQAdfA3zEHQfhQbUC3hURBZoLlwA6cQ0CKZo8/wZWXve2pKsBOh01AOYjTwMHPN0CNKoi/+CsAwXBd08DVhSVB50EBwZpMTEA1mwxA8sc3wKxFMcC66pLAL9gDwYHXUkBMpW2/vDOUP7rw3MC1ld7A7RK8wLN7HkA8p/PAjJ/PwM+ro78JgpXA+T1jQEu7HcCCjyJA3tHwP8sRiEAAhuk/7Cb9QA64xT+tTqhArzuYwJd+7EAgLdjAGUT5wIn+371JBwtAjH4sQIxBIj/ydQrBTEnFwNfZWsCYhn3Adh6mwGsn+cB2lAZBluM0QVo8DEAq+BtBl9GOwCzfVsDs17PAu5j2vxyceEBodiPAe7fkwAZzPUBrSv+/o71lQc2aGED975G/ot7Avyg0X0FBQ4e/5+30wNTEUED6Y2dBLYEGQF0YXsA=", + "encoding": "base64", + "path": [ + "x", + 47, + "data" + ] + }, + { + "data": "KLj5wJqTOsBX+gTB9kG1v6tDkMC3bm/AZWbkwJ6SD73eYavAYj/9wM3UuMACEd/A0EP2P+frPD9ESwTA20/twG8mX0DXr3A/EfcpwMlmREDeezw/SWW/wEuBrsBpUb5A8PsNwMiYhMDJkZrAi3kewM2DxcCDRFTA6y5ywFvRkUCFNIPAlRipwKN+EsGfvAfBfEF/QPzF3MCcO7/ALrDMP/LgckDgsna7Ni7SwFTWxMCM2ixBOIGGwJW8GsFV3+vAMiGfP6Z2WkBQ2bU/vaNLwGtf+79tPBBAgX01wI/sDD+KvkC/UnxXPkdYM8AZ2BPBneUAwYuYcEDN0izAR1kDwIw91sCtk+2/uHooQBrQd0C5LQLAE9eYwOawNkCOAcLA9gVav2rctL9ASn/AIozjwLD8g8B5cAFAaYE7wNaWRr8Fw27AqShmQO/Sxz7++YNAzhOWPTVtej9Mz6Q/g8ucQEAu7j+cwBM/yxmWwLJUwz+4BTZAXkeYwHhTi0B0uGdAJQrPwKG+vMC0uZQ8OVA4wO9iQkBGJXI/Kfr0v0LXCsEPn92+i4Cov1vV78CCpS3AE5z7v21MiUDKGIvAP/AMweBsnUAIr/jAiKBgQFEcCsH4yFTADiqswHt3Nr9sdPHAWDSdQLRZYUDU1xdBhsQEwUI9Pr6dcSPAEpECwGz9gb+6HA1AX3v7wC48J0DgQIbAxODvwN6l3MCdpuNA7GEGwVS+TUCfsEBAxGfBwKXShcAI++fAWY0QwVtm0D9omF8/mv8rQOpOAMHov7vAw8iTwFcsZUAGgwjBs+0EwT0cFcArTlbAqVkoQCMmncDMo1lA+36gPi0aSj/Atk5AUM2QQIqD8T2PwZJA0IuuwHICjUCIqQPBgd8Ewe73+L/Zh3hAn+LRPplyJUCPYA3BeqmIwBygfMBM6JfALJz0wB4b8sDTuahAyo8IQXhxUz+rHNxA8spEwPFX1MDX/+nAmJGgwNFuG0BdV4nALSG9wNk6GkCQ95vAnIc3QUvBaD+U24bAgLBCwONXK0HSURHAk8MFwYFEPkCR/0JB7lthQIunGsA=", + "encoding": "base64", + "path": [ + "x", + 48, + "data" + ] + }, + { + "data": "gwEKwScSh79qFwTBfqTWPoklM8C3C8zASxrmwDq34r/eh23AusPywJormMBP77vAIFgYPl6nUL/UD0vAjRAGwdrq3b6UuEy+Lzy1wJcWdUDB8yFATF0CwSEG4cDbgxxAEdKwwIOS0cDGSVTAYS0gv3gc38C0v86/pn2OwFTniEDoZ0zAJtdkwDrLFcHcwhvBB4c8QH3hzMByg/7AodJRQJeEZkCR19m/3u6xwFt4m8DDvQNBvaHbwNe0FcGVf9PAIeqNPvsfgEAfKfI9CpHXvyj1YsDpO1JADr5vv1xyjb8gv4k/+sylvxJvXL9GzgTBhkTawJKYEUBhkW2/1wc0wHXdoMDIsJM7ryK1PysMMkD4gzLA8klGwLSnYb7n0ObA/A8XwGewGcBDYMfAOqDcwOALx8DX2jE/nxWCwGwylD9WIp+/EqspQGMcl79eCItAd3Tiv1Wihb98MBnAOTqNP2Zdij/xoFu/GhlvwE0J8b1vEbw/0VpXwE6FbUA6V4JAshqpwD48mcAgC7u/8ShvwHsv9D8HqRDAmxYuvl0vB8FDcYrAI7+0PsBPAMFMiUnAy208wGhXCD9tjs7AnD4HweptiEAjWO/A89EMQGb0BcE8ICfAxfB/wIxguD/4yOzA5wWCP8L5LUCcUMdA1l4FwZbMWMCML77A5UNvwDZbNT+Qu0Y/qxT8wEGK5j+haM3AK7/GwNgCyMBuPFxArwbywFuGGUBbkDBAKpb1wL8lkcC89gXBwIwJwRq+1b43QCVAqghmQKq698AZ3YzADe1FwM6dbEDo3wDBjfAMwThZQ8BfYOq/lAJmP0mz1cASsE1AG/Gpv6tIL8DWU39AcTdQP4wCqb93R1hAKsapwJ0IlD/OqQPBOtYBwfheYsAsoZBAcxr+v41BgkDftQPBg6L5v0SlfcCA9HnApfgKwTpr0sCLVOE/qH+pQNwJIr9L4mdAYePAv+RrD8G8I/jAGZfowAg3xz73Uq7As62KwPm3pj9OIdXAaN7/QGfHOr82ScfAqiSBwKtE20B4u0rAIeEEwX4SD0A1kxZBmsR1QNx7nL4=", + "encoding": "base64", + "path": [ + "x", + 49, + "data" + ] + }, + { + "data": "1IDNvqO+pT5RdIs/OBlbv7j4/D41bCi+tBycPjmFkj/mza49tt8PP+dYEz9NKF0/jNy5vRE4OD9yuAu/aHAqPlG8Aj99PuU+R+qyvYAsJr7WOqu99+mTPwuslL/Qcou/7NK8P/OYoj1PzWU/U9YEvwFvRj9Opdy+nox3v8vYMD+Bzm8+jhnzPteGUT+VGPs+Ve2cvz5uf78opzY+S3SDPszYNj6UjKK+M4d+vzanf76sI8e95pKev+s6o77WKKo/JRvaPQZDJb4XjG29nHiSPHVTEz/vmPa+7DGTveBXojx74JW+IewzPz+8uj2u1vi+mBmHPoeivz42yhm/jGNXP5+VST8lbDI9u1pqvqTEXr9N0Xw/dGk6vhHgur6/AlY/xA7hPveCnT9R+Pq+kKDqPrn70r6WB+4+G2S6vR0/MT843Gs+eWFav5AFl767L0Q/BCuFPvgLvD5kqEu/PSO4vR+0gT/ToCm/Tjs/Pj0dqD7gpQ2+dEQhP8tHk76aEby9dlpdPVuUsD51yZG+6Pocvko/wL4pmG0/u6YOvlVAPb9/JNQ/tBK8PRRWoj+GMxs/WiFgvTbrRD/lXxI9oSlhv4/Xvb/18j0/hAHxvuJSMz+nxHE/PECEv3DPiT62gjM/gFOIP/jIMj917tK+YrsMP6LTnb7Bro4/eD6yvfMQAz7E7PC+2XTOPftQOL8EANq9SHHivi3vXL4wyae+LO5+P/DQer5y/b6+ibRTPsv/Zz+Z+gO/WF97v15juz6Qy7q+QQcZPab3eb92Xiq/grywPjpNwL1ztIu/UgM+vj1ys762Nca+Fgd1P0S0AcBef3e+P9UZvt0ZJj8igCw+iy7rPiagtj5SuYA/l+dQP4286z43r6y+V2KbPJmAW770rr28n+Aev/DhXz7SM2+/YekAP0T1zD+Nz6K+x+0KPj80uz9XFMS/6x8kvT3Jlr+fVm8+wKY5PtD9AL/PFYq+GzlnP8yhtD5wZgS/pLTSv7RQNj6ujaW/8HplPyHyxrz/Rgo/gZQsv1On2j+zY12+dF5EPeXzhT8evYq+kLbGPnP6lD4=", + "encoding": "base64", + "path": [ + "y", + 0, + "data" + ] + }, + { + "data": "0YSuP8CN4D9ueRZAGVsmPxr33D80/qk/u1QJQI6f+z9NKdk/V6L2Pxn/3D9GTM0/46A0P/Oo4T/xug0/CXGWP2wz2j8Nmw1ARFeXPx28Yj9knqU/tD0bQITl1T4wuj0+S7xLQNNM8D/kAg5AzuEqPxU7FUBzE5M/njzsPv5alT+vE6g/iQClPwJlB0BOBfk/RhQUP4zfGD8OlKs/R5C5P7pgyT9P420/BrJcPo0GkD9jdEc/cZoaP3SPgz/VChpAsA8lP+Qqlj8yI8I/Ozi4P5El7j9zBIw/tau4Pz53dD+coL8/H64MQMQ7yD8ZYhk/RGaOP8LRoT+qpo4/QtMHQHe2lT/+lcA/Ti1ePzk9ID98Uts/TGCeP24NwT8mDAZAiYquP1HRHkCEPk8+u6WxP6N8cz+2hfQ/JP+pP8Am7D8G36g/QfsqPp70kj9bgRpAopmuP6v1vj9v6X4/MWeuP4rpL0DonIA/ViziP8TWCEB2CAZAJfCZP+EaqD997WA/oRisPx4enz8lQaA/hzC2P+JHpT/23Po/eaaUP7wwIj+8eElApTSpP34YAkBDb84/YMfaPy/GLECIusA/7Kw6PwqY/D2kdwlAoS50P82toj+6qw5At/ttPw33aj9ZguY/70sZQN/LC0DVt48/0qIMQC9nrj8/ETtAjsyQP+scmD/C9Bc/S2e0PzHCvD/3+pI/JxkiPxjZBD8Vg4c/H48nQCbPyz+vvNg/ZOfiP3Cy9T+3Un4/HJkFPxXY2j8z7YY/tzDIPyKDQD+0EJk/NSbFP465jT/JWz4+EEHNPuKL1D4w9b4/BYLTP16Vqb5EPJg/p5DiP0tgnj8OLNU/9PWOPzEx5z8IJvU/AHEZQHeI/D83voU/0V2RP/qtYj9QRJE/X7PMP7YR2D95UoQ/SP3tPyxaKUBr+Hs/+tOyPyPnREBZBCs98EG7P4zQPz5Pxtk/CWuePwVczj9zdsg/JwoMQPfMsz+k4u0/p1WLPsi34T+79KI+6f8KQB6qpz/S8sE/u48MP8TiLkBmhFo/UrzhPygbK0A1qZw/voetP3iWpz8=", + "encoding": "base64", + "path": [ + "y", + 1, + "data" + ] + }, + { + "data": "q5c+QLgyKEC4JD1ADwkiQNn8F0C0oC5Ar3NTQDvjDUBSty5AdhgmQGtPIkBESgBAZYnpPw4REkCcA9M/neQSQFDQK0DPUmpAcW8eQG9uB0BrwChAHwVLQKY0DEBaadY/JUePQAfxRUCjRTZAvvAQQMeiTECLGjdAikzrP/5c1D/m7A9AZoAKQBKHRUBC50dAoo4iQNPaFkBmzhdAvEUbQN2JIkDjTwlAdTLgP74kIUCpRtE/VxEjQMxuFEBZjkZAnNOuP8BTJ0Dz/y1AtkMoQLZsMEBwczJAgvItQBYZB0C34zlA6nFRQCS8KUCsnO4/ixMGQC0nDUDOiD1A4JM7QD160z9RKClAmC0OQE0SIkDhoABAFc0rQI9CTUCwFDtAThsMQDDJVUC6NZk/TBIKQM4cEkDkFDpA3TgnQLleHUArzxVAHNWnP9QBLkBKyF1AKWUVQMmjF0AzNjxAcfsrQMPDekAI7CtAuudEQBsiX0AlDWtAWI7yPxdrNEDbXBJAqqIhQBEbBEAmnDBAszIzQBvANkA+TRpAnWMkQDpDAkCkFIdAu4kfQFweDUA/Pg5ADNJNQEbEg0AYczBA/XAnQGwW/z9VejFAfJodQBdU8z9TLDtA3kQ/QCOo6D8hyx1AqSpbQKPqUEDyVDRAftRVQHgNN0AadoZA2q8UQHy6GUA4mwRA3DoiQBseXEBd5xtAPcUCQKddvD+OYxtADYNpQJtyQEDcVl1AXc0yQGJSGED25ylAlycNQM/+KUBDoStAmGcqQM45NkDBSkNAIfwZQKNXIUBoztI/ifmrP5Ejqz+PK0JAYS0IQFUOvj+2/itAB+9EQH7u6T8YFSZArB/pP9IqOUCtah5AapphQD/3SUBJ2CVA/bANQDjaB0AbnhRA7DJhQManMkCHAkVAkPQ/QP4EUEAe5hRALTkfQL2ehUBm5d4/weQsQAKSxj/DCDdAWhIaQNcYUkCxJTxA4HhEQGeUEkCwRWtAVIUTQF2jMUCdORBAEwVLQE+oJUB4rRFAQIXeP5aVW0Drqu8/rDZJQC/TbUBIsCpAaXEOQFjNCkA=", + "encoding": "base64", + "path": [ + "y", + 2, + "data" + ] + }, + { + "data": "FI2AQGpkS0Cj9T1AnDGIQMNpSEDbGHdA04xyQGEAJkA2ElJAZYA8QL1vSUCzJSNAzENBQGzYPkAPTiVA+ThhQC2KW0DoFZRA6WRmQAWoZkAruGpAowBVQH0Hd0AhyU9AfCeqQHTRZ0BK5ztA7V5/QJ1cVUC7tHxAXzw+QE8IGEACWEBAxhNVQJFgbkDsZnVAsviGQLFheUBwmVtAmm9aQAxsVkBh4E5AH7BiQMnmb0CQ7RpAYtSEQDQUXECAQFZANnwEQKZDcUC5oFtAArJhQLkJVUBk3HlAYKliQEsqXEAnfmJAS9F2QDbFV0DZrUtAhixXQESaSUCqIn9AuwRMQAcoGkAO6VxA7Ot0QPh8h0B2Eh1Akd5uQDAKkkA1Gk9A9H9CQGTga0BzoxVA0hZCQMUsXkBNuVBA95NnQIUzPUDH5E9ARssdQPAQeEDVCnVAFkJMQMjnSkDrZohAe+ByQML7jEBvJIFAtM97QPYNhUBRy5BADms8QDKkdkD/mHdASKJjQFMlOEDPMG9AiKZnQCNvb0D0jDVAZApxQOCNU0AEVJpAT8hlQJ7fI0CbtS5ATDGIQM8cn0Ady2RAX+aHQGXMeUAcVDtA4P50QGEWMkDB+UpA5SWSQGN6QEAkITtApfeDQMJmekDj/IRAk7SAQLMpdkB2KpxAb7ZcQPyPbECk7XZAksheQPFClkDonWZAop5pQMuVIEDvk2lANOOBQFc+Y0AXmpRAxZpXQKRdNUDjsXxA9pJzQE/aVEC1dXlA6q1YQEhXjUArXYdAy19UQCUjckDc2EhAAZEbQKraDkBZmnBAicg4QM/pTEDW6HJAPBRmQPUVK0BFoVFAES4nQOZaZkA7jD1A6fGEQMlCgEBPmnhAehFMQBG3WUDBIF1A3VaaQPw2YUA2fpJAZh11QBbAV0BeYl9Ad1BYQNrJlkC93FdAwFRhQFx0LEC4PG9Al3trQIMaiECmE2dAaS5aQOufS0BQqpdANm2EQO8VWEBLAYZACZR1QCfvZ0CzvkFAIwguQDL/bkC/ySxAtoV9QNZrgEB/RHBA9DhUQBdZNEA=", + "encoding": "base64", + "path": [ + "y", + 3, + "data" + ] + }, + { + "data": "OICKQNBaXkCVtUVAl9ikQPIRg0A7MZRAAjRuQL9YRUApO3NAEJVQQMKbaUCp60dAKPSDQATjfEDsKktAvtCOQE1AekBukJtA4reMQJ4XmUBPHoZAk/VUQBc5oEAoApVAFi+1QJZrbUDhc0pARUadQDHXVUBXFoVAi6JqQP49TkCr7l5AY0uLQBZUgECZ0HpAbG6pQBZtnUBEWotANHeIQNp0g0CocoNAr7agQAldjkCS2kVAI/6aQD8DiEDvm15A8y8kQGbmiEAICntAWg+DQL18dUCj2odABBV+QKSsjkBV3XRANRd9QChddkCuaYtACuqNQKc2dEAd4oJAYgtVQOurTUBj9YBAHfObQPYMn0CmAjhABu+FQIpKr0Cedl1Au5VsQFM/ZkCsdGBAXXyBQGN7i0DBTVtA3ceGQLnqXUBARXhAWCphQCHAiUBCamxATe5yQO2Ic0DiYpxAO2CUQEStf0CHY5tAubqGQJnCgUAds5BA/TWCQAEYiUChspdAV7iHQIEZcEDnvYNAX2l+QPBpgECu51dAjQ6LQD2yikCUCp5AiOeJQPRQRUCFikNAQ4WRQHuxpkCdf39A51qnQIznpUCU3lNAPs6XQP0/Z0DGKk5AveysQLUnhUBxhVFACquOQOj3gkDpEp5ADeOHQIWig0Asr51AnSeLQEKOjkDROaFAdD6FQCtepUC974tA72ObQBGDZkCJIZFAP4F1QBDKa0DEnKFAdo1pQGPmWUCF/I9A9k6eQJ9ue0BOVItARtp+QAgCokBHnI5AauqFQDtsjEDImY9AaD9mQCRwPECvhnZA8XtrQAwgkkB8UohAN1dsQHXuZ0BAfIBA2I9WQD+3c0Ab7GVAZQ2GQHNvkEDspJFAVTJ/QHgSj0DdE4pAgqutQOeNfEBQU6xAeuaIQP2zTUBqcohAbomAQGmmlEDP8JhAxfqAQAjuV0ConYlAGuiNQCgKl0DdGndA+YRhQD8lhEAp8p9AORyqQCdVakAxIbBAQNuEQA2sh0CW029A+LtRQMLfaUAGWkpAxhOBQJ3IYkBvU4pAVtqLQLJYTkA=", + "encoding": "base64", + "path": [ + "y", + 4, + "data" + ] + }, + { + "data": "yc53QCAAWEA4yklA/l2hQCyHkUCs8ZhAUCJfQMS2U0A3oIVAa2daQMTSgEDm0GRAYQWWQC/xkUAU/D9AmLCOQD4UfUCRDYBAI8yRQM1ro0DlnoJAXt1MQEfRpUAhG69AhhysQMaHZkCtfFVA8vaVQHcdVkC/bnJAoPhgQIZ0ekAH0FdA9PiPQBALckAr3WRAJvmsQNsGoUCSkpdA3gSPQJNoikAQ9Y9AOuirQB60ikCQyF5ARnGVQIk7i0CVE19A3dQgQPWqgEAin4RAuW+EQK2KfkBCtn1Aos13QOIvlUDqeH9AfkptQME8e0AHOpdAHxiWQPi4dUBsvm1AAfhMQPiPckAo84RAu9maQIMUk0AXtj5AazOAQL1Qt0AUn1tAIYFxQA8VTkDddoxA1JiTQI0HkUD/H1VAW/+DQLl/ckB8UX9A/E6EQOuUfEAzAEtAb2l0QP+QgkDwsZZAgeWhQJUrSUDkcZtAGCRvQElXWEDtj2lAgMSTQMJ4gEDlk45ALLKHQNFji0AkFntAKLNxQF8ec0AJqm5A1weDQO+SmUAf1ZBAXmKHQJxLXkAIVTlAIDZ4QGoMl0CP0H1A/u+kQLELq0CpimpAKj2bQEmYgUAdkUFA3CinQKEJmEBqZmBAFG+JQLvCdEApk5tASDV5QBDadkAGb4pAoXKOQFXph0BINaNAChWKQOEZkkBa241AjjyiQH+FkEClGptAD01VQJEZbEB5WopAaABhQA7ubUDmZYZAr/+hQIbqg0DPY4JAQX2HQJtnlEAlKnhAcxOOQGUyg0DWC51AaUqSQHWoSkAG8mxAmy+BQGnIokCvNIBAAX1tQAn/iUCGL4xAWMNzQN1LTUCkEHZAnVVfQCH3kECdQ4lAO++KQFBJlECxEJJANLegQKNZfkCg/KhA4OWEQB13OEDTG4lAFymIQIwSfUA/ebVAeCqCQBreSUCO5ItAbjWGQP9JlECTSXdAwZNbQLU0kUArIodAM1ivQIGWZ0DrCb1AQPyAQNiEhUBmUYRAE9A5QKcVU0Ag+DdAAaJoQIe3OkBXJIhAu72SQEaPUkA=", + "encoding": "base64", + "path": [ + "y", + 5, + "data" + ] + }, + { + "data": "Mzc9QMTKKUBlvjlAKVZuQLJDakD6enxATUw+QBg3MkD1G2xAmNpPQAp/cECME2xAFIN+QH1fekD0gss/IhhTQK01U0CogA5Al5txQMP3h0CnD1NAqJosQBPsgEC44K5A0fuKQPLVTEDh/E9AaaVLQIFkQkClZkVA+uwKQMz0dUC3rwxAIthXQKgoNEC8gDBA1hSIQMU2ekBe0oxAwpJgQHaIXUAiJHtAtO6NQDK7SUBV9FVAQYpqQJP4XEASxEFA0efPP8GvP0D0WmhAQKxbQN9NSkDCKkhAdgZMQC1uaEAL0WZAmSVAQPLgWUC1nnhAarplQFe5LkCtlEdA/t8gQJ3Ra0ApX11ADXpZQCf6RECooRtAaChOQDZ0o0BQcTdA7S89QOTeAUAbVo9AbVh6QGaCdkAF6TVADJFGQAnKaUC6F1VAu4p6QCLpPUBNZQtA4uw/QKchaUCR/GRAKt6dQJSdAEB+xm5ASOIKQBQWE0ClHBxAE1NyQHVpSECPsz9ABkJUQLCmgkBatExATVA6QLtaRkCES2VALs5GQGdniUAoo2NAOiBPQOfBW0C9bOo/b0wXQKHJXkAvwlZAp3NyQGYRhkA5sGRAt7NvQMkoaEBVYQ5AlN51QNvDhkCZHV1AmBZfQK9GQ0BgNWZAgtc6QGv3QUDHlEZAkqtZQKlESUDKp3ZAD/1nQPs5M0Df2WlA3W16QHPcikD8no5AHmUkQBoPWEDP7ydADgc0QO/sUUCyOEVAhO52QCjwWUBjWklA25xhQHhzSUAJxjBAOqZkQOGOP0AbjoZA89CLQCOsJEBLgE1AOkZpQMnCi0AMwUZA5AxXQBRGg0DxeGdArEduQIpfvT+ouEVAXz0DQAjhd0B+JE1AOV91QC4jY0C8xXBAaR9VQD4tUkCQw3xANDtGQJPMBEAav05A8Q1+QBZIKECG1rpAFiZYQD4v8j/oAW5AEfBDQEiRfECWp19AZ2o4QK1Yc0BZHSVAkEuMQECoS0DgY6dAFYpZQCnTTUBRK3VA0EKRPwBoIkDioro/7ukwQBOo+j++qVtAJudfQA/AMUA=", + "encoding": "base64", + "path": [ + "y", + 6, + "data" + ] + }, + { + "data": "c9C8P485mT8VrgNAilWbP9k1uD+kDOY//nnsP4G7nj/0Reo/ydITQDITE0D8fCNAtO/hP2yq5j8YuiG/Y36hP2E92T/Awrq+ZEn6P1Z++T8oQNo/58/ZP2e/sz8ld5FABLMcQHJgB0DukRhAJh94P1xjB0BWR+s/ykuxvbRcIEAXP8i9BCiZP97smj/6Qro/W6/NP9/Euz81kU9AB/GvP5e1wz94TvM/rTgHQHNzkj8SURZAmZniPyUV3z+bRvc/dt37PQrPtT8+4Pw/+uTjPxymlz9h7NQ/rYnpP42HtD8HG/Y/kAC0P7SO+T9uSgBA8hemP6eI6j5HZPU/PEmRPzMCEkCVGdc/Vjh4P5DRfD94Io0/R87YP0yAWUAOfMg/LRqnPyFhWr6Hj1pA1eDeP9cSDEAR7fU/VS1tP1sCEEBcY9Q/9sQbQBKmwD+h4EA/NDm1PzDp9j+DF7g/CYOEQEmP8T5HJ6Y/47savxaiYz/tMGA/iijKPy3UyT/pSog/JDTKP+UjLkBUht8/xom+P6+W0T+mhh1AD77HP3roG0BzYgFAPVXCP6+xFEBQIei9ROB1vEKfwz8BBwJAZ4iuP4XAyD+sQw9AnROuP0/68j9l5wo/adSuPzA6DUCFgyRAZ3D2P5mRnz/8faM/SbPFP7JOwz/91qQ/6JiUPwrdsz/aaaE/fpL5P6YOHT/9BfU/lTOxP4k9N0C+m1VAHtGwP/+yA0CPXOo++yPQPxzL4j8jfbU/D4LFP8GKzT980cc/kjXMP4JqeD/NNqo/SDPGP751sD9fgyBAWtY3QNejjj9i2P4/2k8PQFNSEUDPyLw/aiwDQFjzG0AfAcA/KVU5QOKxdL9DlZM/fhz/PbilFEAKjbc/WXAAQDaAoz9Hoc8/311GP/c45D81J5w/8B1XP3rREz+Ftoc/HuZCQPxCLj+UZKRAKRfdPwBeczs53AVAXsG0PwbPKEA9rA9AKZrdP4363D90yxg/KZTsPxBh/D9WuVNAhTgPQCVkpT+Jwh1AjAGkv9S9qj+suC6/dsykPxCGGz8Apug/AIKhP4xTnD8=", + "encoding": "base64", + "path": [ + "y", + 7, + "data" + ] + }, + { + "data": "/ienvnjMDb9MOrk+Rmyev6G/c79H3Xa/0bsFPSyyLb9gsjm/TND7PvB5ZT2KM+Q+vUZ7v5dRV7+mtC3A6bZZv+Lp2r62hzTAt36/vkG1jL8LrOO+uEm9Puw02L+uKTtA8glBPTjipz6EKw4/SWKOvzZHyj6y2O+9C6AUwIS5Qz4PExrAWBh/v31B9r7wtJG9pQzFv6oBtb8hvbw/nf1rv/i2Mb8W6ke/teFxv8PbN78Ibw0/ZEAQvyyOkr5q9sQ+dqKyv66flL5Gq9u+rSAAv3tMk7/SCIW+0tgvvklljL8Vbh+/UB8av+S9dr513py+ykaWvwRZ+b+OWPW9o4UCv5U8lT2laCG/tQiuv8ZTgb/xYQO/eB69vkyQXz8ijE2+Xp0Uv7SMHMBfJLw/M/SAvyCX372F8q0+tgLNv5onRb2sMBK/lDzXPAXaa74akx+/NazPvq2AAL/BaWS/j7MwQC/Ggr++Ire/68FOwGXf/L6Suhe/duWCv4Ti1r4NIS+/zrn2vgKBIz+U6qK++Cc2vn9IrL7AUPY++k2wvvTXsL4KFEE+blj7vhCTpT7GJAPA288XwNsTMr/88mU+jmulv4Bjv7965RS+peudvyxK2764P62/PUWvvx8pL79DsGk/DAIqvfYdfr+3N56/NHW9vcp7r765qD2/0rGwv84N+74AXqu/FEGEvkMIsr/NyuS+MuGyv9DIDj/s/t0/OGI5vapccr6Rjsa/9tn3PTZBmL7e9eW+TpSIv7ClGL9kWMW+MrJBv0NXj780Eh2+fLNOv46yor6pP4E+0fUhP4kxIb9WL9m9SVPavbziA7+ySOW+8p0dvoc/sb1Mb2G/bUS/P3f8ScBssYy/FgnOvz7hHz75zBO/NL8av4nTob9w9HW/hnDPv+IygL427Mq/kYPXv+w3jb8KerK/MgrLPx0voL9sWmtAHlD4vliV7r+d2BC+qAGxvvX4bj9clKM+o8M/PpJXWb/h7KG/caKlv5Cgxb3rigI/4ihFP1arU79FY2E+fYFbwKCWY70ZvyrA1bO7vkpuLL/xIze+QfB4v3iiVb8=", + "encoding": "base64", + "path": [ + "y", + 8, + "data" + ] + }, + { + "data": "58UUwPbiDcA6Itq/6kNLwP66MsBTHGHAB50OwFQtIMB0JkLAb8TSv2bUH8Ae1gPA7dxQwIUDUsC+PI7AjqEswG0SJMCod5nA1kEuwDRsasBhgCvAHSqMvzSpjsDRMGY/55QZwMuq378lmNO/fusywE9B3L9rZSDABS+HwN3EH8BDMYrA5ScnwAPfB8BtFs2/6PSIwLoCgMDwrBO/ETA4wFKaLMDbX1PAprtowKoDFcC/Js6/h/M0wOGQE8C0rKe/7o0vwJNBDcBrEzvAHDAzwCL4UcAnpxjAPs4cwDBESMDAR0HAG/khwE39J8BRYyfAkRFWwETZgMCEbCfAXOgFwEwpE8BCQTPA9/JKwPpaLMDQVwTA8r0mwMyU9r+MNAzA+uUXwDkvicCER1i/dVNUwDB3J8ADosG/haR0wPJJJcDZji3AAtEjwLrhD8CNOPK/0wERwHFnOsC1GUDA4bt6P7OpEcANlXXAv+KowPoq5r+QqP+/iZhFwEGTGsCuvg3ANbohwA1p278ZZSfAwff0vzVBFsDdsuW/PtwWwOEDTsDDVNe/xHkgwJ798b8ARmvATv+IwKZcNcB2P+C/I+BtwDCUg8C76jXAhyxdwD/PL8AplEDACUxtwFI7W8AS04m/LIYCwFhgRcBSXmTAQe/ivzM3FsCscSrAdf1mwBiuGcB0uVbAY7siwIQ3OcA+pznAFI9ywDPLA8A3LdW9PhfGv4dDOMDxy0LAn5DDv8OMF8APvBLAw3pgwO0+LMCEOx/At080wDTwNsBVd/C/+UkzwA2vDcDPagfARxLqv9OXEsA2iSPAXaAtwGwXUMA5cRvAgqwlwGolLsDEezDAiikuvvRkncCFtErA5lk3wNAACcAqnSHA0YNLwP3qXcD6A1HA2rlkwD8cIMCT1n3ABz98wBwUJcAqv2LAM3A1vtEqKsCR8Nk/uvwswNanYMAYFR7A0twRwMQjbb+SXPG/O9i9v08ISsBrEzLAUVqCwCKRKMAgziPAzkNOv2BDI8CvSh7ABNekwAkZur8nhInAsZcHwBL26b8x6wzAdNguwM64L8A=", + "encoding": "base64", + "path": [ + "y", + 9, + "data" + ] + }, + { + "data": "gmiIwMNbZsDG+XHA2VqUwNhOhsBHY7fAMXaOwHjmgcDdvJnAiaRzwOhnnMDG95XAgw6cwMwCpsD2k7bAnhSHwAhmkMD6mMfAou+awOZIssDSSpTAHhciwPB808BvSJ2/KcuSwHvwcsA0w3vAztKDwKypdcBzjJnAXiK0wMvJnsBaGLbAeYh8wOR8Z8BBGj/A5MzNwLOvv8DKzibAdueLwHhgjMCoBavAyem0wDAtcsDK/W7AyKyWwI3fg8BudT7Ab8Z1wHj7h8BrGJ/ADO6XwAyQn8DRTo/ARhKVwJPxlMBY45jAgLCFwOpLmMBDjJXANOSgwEcbssAgHp3Ajr9dwCAUkMAW25HA4pKMwLSIgsBCsVrAhmGUwE2+k8DwOoLA2958wNqftMDWBE3As/6hwJLxncC0xVPAnwexwHt1nMDZuo3AdEibwCjLicDm10jAIa56wEwpncC80JrAEGZwvwSIVsBVArjA/P/UwKXvQMAqtmPAIiyRwM1Ph8CsrnXAbBuNwCplgsBBnpbAFdlcwHkLhcBJa4DAfFeKwK4MtMC94FfA+/GLwHZFgMAjUJzA6R21wKWWlsDDKHPAw0S2wMsKxMDdK6PAZNSmwMg/msDc1ojA0bmtwLEfsMBG/UfAhPl2wKHRmsCBFbPANe1VwEOmisDDBIrAD3iqwD9WicBDcpjA3E+UwO4kfcDdfKHANGKzwGXklcDHtPm/90BBwAaGosCvvYHAET1HwBqkhMDsxH7AjheywEIdj8BiT4/AIMqOwFKZicBalG/AjZqLwK/Rh8Bdo4nAGBiGwJvUbMBmq5rAzpGgwH36sMAbb4vAtROawJmWpMA7PYfA1Tjtv/3mxMDCY5fAesdtwFkHisCV/ojA+KCtwPBtpcB3caXAr9ufwL5lksDuyLvAu6y4wKJQb8D2oaXAydv5vxWdcMC6Ve++D9mWwCmBmcDlrJPAJVuKwJAJLcBNbIPAl0BJwJm3n8BrdHvA7RnIwAgBn8DibKvAcIcUwCKggMBpQ6LAyJfKwF8aMMBY1q7AisR1wHlbQ8BGQ4LAUmGEwJRLiMA=", + "encoding": "base64", + "path": [ + "y", + 10, + "data" + ] + }, + { + "data": "i1i+wIvLkcBie7XAEc+2wBLArsAzPPLACVTMwMmWp8Dze8DAeeq5wAVR1sDqhtvANpy+wAAFzsCUo8zAYkmwwKCfxsBOLOTA1izUwNTh2sA5rsPAUzV2wC6t/8DUaFLARELNwDyhtMA+scLA/6ypwEgvuMB/pNDA2/fMwH1z3cAFhM3AcSKmwO5UnMAAD4XAivr9wL+N5sCs1o7AEhSywKzWuMCTetnASrPhwKn6ocBuIbXA5OLFwFpVtMBelZHA2AWVwAMdxMB0dM7A9cjHwFn4xMDp0MbAnSjNwE0mtsC3wL3AkZ6twLvly8AbHcvAUSHHwCAB0MDpVNHAzzKQwM//ysANIb3Amm+pwEMrqsCT843AiCrGwNHY3sCm0LbA3g+kwGrbzsB4dK3Au5XHwILt2sDZcZvAq2bUwLdl08As0bDATVTVwDdBxMBoyYjAhtmlwOP7y8A3E8zAF1oywC4DicD0EuTAPK7pwFkpgsCN4J/ACH6zwNxousAYEa3AqRXAwF6OyMBOK8vAqiCUwB1KtMByNcDAtSvCwBlt8MBqj5nAj9G+wCg7vMDAI7PAmlLPwB1ByMAVK7jAkNvkwOkA8cDIkNTADMXOwOBN0cCkH6LABnDSwOff3cAvnKLAzrCtwLVsxcB7QOnAcAqXwNy6wcCNw7TAuqbOwBy9vsAgArbAsYPMwB7MncB0QdrAyCvbwJcR28DRlGvAWP+LwOVM08AsnpzAkx+RwBfwrcB0+63AybrkwE/vusDp2sLARfy3wP4Tr8Dk4rPAY3O0wGS9w8Aq/sTAGHDIwJRyl8BcNNDADJ7awFxa5MD84sDAAtvPwIyn58C2F7DA1fRbwP6g2cC6urfAccqGwC7axsABvbjAl1rowDh4ycBA49PAkLK8wGwMyMCIqOjAx+/jwFHqkMB5tcXA33llwP/vlMDNcCfAEpzOwAUBtMCxrs7A4MnEwHLKiMBq58PAtQKWwOqpycAqOZbAPUj6wMnM1sCqrPDAxiVswJy6p8CxGOnAf2rbwHOLecCGfcLAS8yrwEIUhsAw1LbAbv2swHElp8A=", + "encoding": "base64", + "path": [ + "y", + 11, + "data" + ] + }, + { + "data": "go3owIepncB7Z+fAh4XPwNAK08AnLRDBEo79wGrrvMC9/NfA+/7uwC0C/MDO2gXBNr/RwHTn4cAcE8zAqwXUwA6Q88Dxi+7AsK4AwTL17sCkX+LAEx6fwA0yB8FXjqXA2Ov6wKY15sA4hfjAi8LLwO9y68BGtfHAM0bMwPgjBMGqI8zA1hPKwDKbu8DZqKLAeRQMwRmr7sAJ6MHAB7nPwM2I2sCLVvLAkt77wIpTw8BhferAxWvpwNEb2cAUwr3AaqOjwH8H8MDuROrAyd3nwCxW1cB2T+zAXCTzwIKXxMAzKNXAAwzFwPZ77cBTqPDAp8zfwJAM28DuK+7A1reiwGNq9MDB6NvA4nm/wNW1zcDwXp/AXHLlwFXaDcEY8OHAR+i3wESy1cBTKuvAMZfbwH1LBcFZQsDABHzhwLuo98Di27nAlDH9wBlp7sD+WabAQ0C+wOzu6MDFQPPAsn6OwHANoMArNP7Aqb3jwEl5nMBSzMPAWGLMwM0X48Cs5tjADUjmwGa2/cBB6ezAA0CqwF2T1cDqFfbAjnjrwMDUDcGNnL3A3w7lwD5o7cDK87bA0WXWwMcQ78CBp+zAWCMBwfS9BMG8n/HALwDlwGfY+sC90ajAE87nwI2Z+MBbENrAN83WwMZy4MBlJwrBjiq7wFF17sA9B9XAUrDcwNgT5sDxcsvAkW73wEHRtsBQOwPB37jywEI+BsH0DKfADtmwwIMi7sBt+LHAfH23wD2TwcD8W9PA/TsDwQyO18CkVubAKzjYwF5Wy8Da2ujA487VwKCL78DPre/AMBf8wP/Hp8DQG/HA0TsBwe+M+8ACyOfAOF/uwO1BD8G/G9TAhkGbwMZq2cDB+MjAFLaJwJax+MCK693ALCUKwXry18BJzvHAdmHJwMcD7sBJeALBP7H/wEVNnMBqWM3A4QSgwDEvqsBgvJPAr9f8wIfWu8BHAP/AoQ7uwPNYssBdBfjA2BjAwO4P4sBsQaHAS2sMwb/R+cBR6BHB8sSbwKxgxMBt8RDBSf3RwMnDm8BGk8DA/UrTwJCUosDABOPAtbfPwB41r8A=", + "encoding": "base64", + "path": [ + "y", + 12, + "data" + ] + }, + { + "data": "DPsBwenPjsBKXAXBbO7fwJx978AzfCDBahgQwQv+u8AC0uXAHfUIwW/jBsHR+xLBiALVwKb65cBEFK3ANMruwIQoC8Ggi+XAfMMQwW0878BlJvDAi3m7wNXV+MBH/9nASpsNwdoVBsFzkwvBR0HkwIggCcEVafrAG+iowGw/DsHcMarAvzzowDdnz8DlbLfAgU8NwUqzz8CjWurAu43iwOHn78Ap0fLAUO8BwaxW28DUPgvBSpkAwYFk8MDTP+DAZdOhwO0MA8GGdfHAwY32wK6RysDKxv3AugEDwVlRu8BlYeTAlwnHwKwt/cDjIAHB9ILrwLTn0MCEjvPAVdigwJEIA8FYI+7A9+LMwGTj5sB3KJvAA5bxwHDcJMF5FwHBhQW0wNZtxcDLGw7B9VfjwDZOFsH9k9PAO9vTwCpXBMF4VaDAUk8IwbfSAMFNvrnAtuDCwC0h88BA5AfBu+a7wKYJrcDPqQLBKCG9wLtFrcDnHtnAfXfbwOG2+8DGZ/nAFKX9wC/FD8EPg/jA0iGswH7I5cCpNRDBLRMBwYwzGsFUe9fAWqX6wO68CMGnTKLAngrIwPBWBcEiQQrBI6UHwe+0BcFqQ/zAiN3nwP15CsEni5fA2HbvwPJTAMEJmgLBMST2wP6s6cCv+BnBF8DVwAH+B8FIaurABOHOwBH4+cAv39rAd7IJwRoZxcAzwRLBpo77wMLwFcFig9DAEanMwJuk88CTU77AiD3VwP7YtsCt/+3ADy4LwYQm48D9g/fApDruwDh33cCOCQXBxwPtwIIkAsFfkwTBq8MOwRDDoMD0x/3AFRILwb3J7cCmi/rAEJv2wNz0I8G2ifDACpbBwNMRwMAJ18fAY8Z5wI5pD8H+3fbAc+MXwXrdy8CIqfzAiG3FwAHZAMG+3gfBUpkFwWiolsBDv7XAFmXEwCA1t8BNNszAC28Qwc7lqcBiDRLBqw8Awfmx0cD/aw7BBrXgwIMT6MDJv5zA+JsRwWKCA8FUFiPBoGW6wIDM08DSzSXBRcmjwMtVtMBu86HAdpXuwI7GssDRDAPBtI/pwJp+mMA=", + "encoding": "base64", + "path": [ + "y", + 13, + "data" + ] + }, + { + "data": "5ZgGwYEUKcC2wQ3B4fHnwLkf/MDtiynBeDAZwTn0mcDyGenA28oOwY6GBcHAOBTBC0PGwKek3MCQSTzAxS76wFf5FsGIxcbAftgZwfiW4MDHsu3AvMHOwKPFs8C6RALB5doWwQlxEsGpkg7B8cLtwMNWFcEQUOzARu8jwNJcC8HXJC3AZu76wGwY1cD6acLA2VkBwSa6ecDPGgPBCqjowMoj9cC9IOHAXp/5wPm56MB1IRzBdGgGwVMm+MAUePbAa0+HwNluAcEjY+fAIrLxwEnwmMBpwPnAorwBwbE1ksBxUOvAt1SrwC5u+cAOJgDBZYrpwFpSq8Bd1ubA5cqAwFs/AMHIj/HAXhHPwPK378AH6GnAK3DswAoyNMH/EAvB1jKPwKiXlsDFHx/BPGPiwMUpIMHzkM/AFIOjwDIwAsGrVi/ANnoGwUU7+8Azw77AAjKvwIpn6cCnfhDBMN/fwPGKq8AIs/fAJ+VQwA/qscAahNvAdsjfwN4qAMHN5gHBixICwQcEF8E8Ku7AV/2SwO8b4cCX7x7BpkoBwXc1HMFsqubAZOn6wKUaE8HWLlPAOrafwEpfDcFoORfBJzUGwfsT88APEPXA5/bUwETQDsEO00bAKlzpwAAl9cDBtQ/Bs40FwSyB3cBi4CPBdBrlwD3IEsFCh/TAYzyawMqf98CVZt/Ah2wPwbp7xMBaThvB1Nn1wM2VHMFJv/DArSDdwKjg58BLB77AO/TowBVRe8AYcPzAFgQKwaKW28BxRPTAYZ71wDxf5MBc0gjBr/X1wEfQ/cDRGQnB+vIVwUQ1bMDK+fTAjZcJwctgrcCDV/fARSDrwOpMMcETb/3Ar6nfwOVthMBDI67AnZo3wDZZHMHfBwHBM18cwXsjnMClD/HA/ECvwIQIAMEo3APBvDcCwUdsdMCczmPADwHewCsau8A16PrAWv8cwdZDX8AnvR7BPnL3wHZ75cCOSxjB5mP2wI5D2sB9c4XARBYMwXZx/MAv6ivBySzRwHqi0sBwgzLB3lTjvz7VxcByDC3AaZT6wKJGscBouA/BoFf2wDsoKcA=", + "encoding": "base64", + "path": [ + "y", + 14, + "data" + ] + }, + { + "data": "ver/wNjeRD/t3QrBZYXgwIe27cCKqyrBDeIYwUQK9b9uHN3AnFkHwcFn8sAe+wfBWb6hwL4uxcAfCZY//DzvwLSnHMEk44zASlcbwTI5xsDofNrA84PXwDdmzb9KoRHB2OsYweJVF8FB/APBxYDiwBdXGcGiac7A5JG4P68u8sBIqbs/stj0wGIkycDomsLATRXMwNb2aj4v1AnBe4nfwHCH48AKA8LAw1vcwERH58A2cSfBptQFwcrz7cD8Uf7ARfwAwJQZ48CtZ83Ao3vYwF1uqr9yfN7ABAPnwPoc87+uhuPAOddAwCAH38ByX+vAI3jYwGJeNcCshM3Ac9/Av7XD5cBb5uDA/NXCwL824sCT4j+/3hTXwCl8O8EhCQ7BlZ7xv/aH3b+9jSfBW6nTwMZXIsFLOavAN10CwDw558Akpjs/K3TuwPW+2sDxla/APjZ6wN/SycAm/hLB/Bf5wPeblMDlU9PAvweIP1tVpsDXx8XA26LYwEIs7MDmfvDAETX3wAMHFMGS/tDALDUowBLDwcB3gibBuJ3nwLQkEsGspOrArTbhwIuKFMFf6q891m4nwDdlD8GEmxzB3VT5wHWqucAuC9vAOaaowIlICcFwagw8pk/UwLws1MA5vRLBMoEKwZTMtMBslCfBSC7nwKooF8Gv7fLA+m+pvz5z3sB5wtHATvYLwWlVr8AcVhzBOMbgwCeqGcHSLQPBUfTfwFTmzsC6DKzAvAbxwKRFlL6XEP3AN/7+wIYDvsDZ+NvAhZjowPOy3sAdIPzAIHXowE5O28BUHAXBQDETwYsAQL/eI9fAsO31wJnJwb9nEN3AAWfNwJCLNsHAxu/ABzL0wPRUHb8IQ1zAJZh1v1PTIsFB3f3AoC8Wwdod4L/XL8rA4hqEwHSL5sA9/erA95XnwMGY6L8TcYI+QCXrwLC4tMB74A7BMLEjweRm1TwoOyXBW7XWwAVp7MAPshjBv9n/wEpFtsBOrSvAmof1wAdZ2cA/GyzBk1ffwMd2vMAlOzbBT1AyQKmLz8AyCZs/lDvzwJtHlcBcLRfBC8HrwCDBQD8=", + "encoding": "base64", + "path": [ + "y", + 15, + "data" + ] + }, + { + "data": "/EvWwI0ggkDh2fTAFmK9wK4/vcAr3iLBX4QNwWGQFUCFgrnAHO7gwLx2wcDql9fAmOdDwPG1m8A6/KBAlBLGwDRwG8FBC6+/uX4UwaHYmsDJrrHAsRfUwJc9R0ADDRrBIWQTwQvCE8E13dLASVq6wMzWE8F3EKDAOjWjQNO7p8DYladATsnLwJSapsDr2bbAkM5fwJz/i0BDZgjBsMy8wHc9tMBF9JDAYMapwBRmx8BmnyzBn9z8wAJPz8APmfXA25TFP0rtpsAGhZ3AcgqpwALYQEDKSavAOHGswCAb3D8zN7/AYAV1P2NYqsA1bcLAc162wJxkvD/QFqTAOsn2Py0YtcBEcbXAmEGjwIVCtsBHbDBAWUquwEE3OsHt2AjBnLbMP9wNGUC0JSbBPPGwwNgSHMHpgC/ApfAHQLBLrMB4rYFA7GWvwOh+ocDATYTAZMSgvxMpkcDGxw7B4yEDwUs5M8D/iJbAtQ6jQGzSgsD6wJDAcLm8wH36t8B0V7vAzFLTwFSlBcHrg57AaHjgPmRwesAVDybBjwWtwCKq8sCu0OLAIpmrwEx1C8EMZGpAWoGDP60UC8FhnxnBUSfVwFGTJMDZJavABAA9wHP58MAstlNADyuuwMium8CzBQrBHnsJwdsPPcChqyTBOUnZwOSKFMFUEOXA7olEQDBurcB//ajAey78wAxCeMDqERXB2866wNtADMES6gfBW6bSwD2apcDAVH/ACG3rwMbkaECs7e3A2x/WwDd9hsBahqzA1pO9wPqqysCEvsTAFmi8wBy5oMBqGvDA1sMFwTrFK0CdDabA5pa4wI2eQEC3VKrAx4CdwFm5MsHHpb7A7Lr9wMCZYEDBOtQ+ZdLBP7dmIsEGWOjApFIDwYgqGkCJPIHAeF4AwKNHscDN9LbAZ3WtwAPhoz+r54RAMC7qwL15osA3ThnBl/YjwTVSb0BBFCXBry6hwMww5cClbQ7BG6T7wCyjccDxFIK+vci3wLvXocA0HCPBAxDkwCFqi8D2xy/BdzTTQAed0MAsO5tA8rzSwLRrGsASABnBUj+/wJENf0A=", + "encoding": "base64", + "path": [ + "y", + 16, + "data" + ] + }, + { + "data": "QnKJwCCp0UDPorPAYVtnwFA6TcDxsBDBwlHpwGhswEAMF17AS6KOwIbUaMC9gnHAIlsWvk+pK8DKPv1AtSJvwG5AEsHzZiBAjVUEwWmyK8CyXFLAonDCwFf+4EBhURrB4a8FwWNoBsE9Fm7AUb5TwAgSA8FUrjbAOIb5QOOgxb//Qf1A7IBuwIGiTsB+2p3A/CoMP+Yg8UB6bvvAJVFhwJvNPcBm8w7ACB86wPgsesAK8SrBLjrfwF8YmsDek9nAqpuYQLJnIcCeDh3ArNM9wAuk00AIBDbAndYrwNdmnkB0jV/ASU6YQAEaNMBbcoTAVwKBwGUIrkDKakLAk5mdQJi3WcCgAUzAe4FLwHVfQcBCSLVAMDlOwNWyL8Gpr/PAp9iXQHF/ukBZUxnB2WNjwFA+DMFAGoI/nES2QPJrJcAQitBA+9cQwKCoGsCyU9q/Vg7tP7qn8r83AwPB9PkCwegzBz8ocN2/Rrn8QKkn5b9u/Na/njN2wJJjNMAArzvAodqTwGvv08DQSB3AdjhdQNaXh74+cRzBb6wrwGFIm8DFds7ATiszwL5+68CAqc1AaNeMQLP1/8D5PA3BONOewGG48T9BZT/AoptWPr6KtcAMQLtAkBZnwDqaFcCN3ObAjOIBwXhyuD/vkhrBoKq3wOUjCsHGPcrA5BrWQFq5PcCSzDXAy4PIwHAbd78zagTB2/eBwC3u5cB6sAXBaV+ywOjVQMCuia+/gGDVwIFW2UAIk8zAKxiYwJY3xb+N6TvAuu1RwADlpcD6DE/A1JRYwBmKG8DdiMLApZHZwLnisUAYoTjA0DYnwHkv20A3dTTAQrsswBGHJMFhcEXAU3j6wEAp2EAvMI1AjCtlQHR4GsE+Ob/Ab8zBwG48vkCChRy/jOlIPyU8McAmHlHAp9sPwBOPgUDZNuNAVFLZwOwKgsBdhhvBnwwdwTP+10BlqB3BUzQpwCx8zsDb8e/ARfXnwCaygL9ZiRhAQbQzwOMoJcAOFxDBGlnewGJj57+Pex3BJy0UQXbwx8Ag2vFAGAuRwEMXjz/UpBTBiu1QwAh4y0A=", + "encoding": "base64", + "path": [ + "y", + 17, + "data" + ] + }, + { + "data": "xtpNv4EgAUHfsx7A9V6FvaD9+D4f6uPAy9CVwIwvC0Fg7ME9JWdLvx4Lm75KIJE+Ad84QKvl4D6TTBtBRUBwviYJ/8CkYbRA31DTwKjNPD7A5wM+SvqfwPehGUE37hDBLBnewHcy28BZiY4+puyzPpg2ycCCjpE9M+YVQagVLEDZNxZBgruZPriWo76ZnGzAFMePQCTKFUGM/9DA+i8dPva+LD87yzI/gHOnPlTwOr5kZSHBZDixwKyHHMA1zqbAl1noQAlvNj84vVo/9OwAPuTsEUEVJBY/8P0hP74w7EALoJY+HZX1QPF7wz50Vcu/hSndvyFWBkEES548VXjkQG2W8b4mMcI+xgdRvl6lND8Cb/dAdP/DPSIIG8HxCr3AOxzkQOOtA0EGMP7AIC4Ev9GD4sCWn5JAlugCQdDZQj9XRvtA1bLaP7MPZT+cp58/T8ySQObCnj/n+9zAz3z2wOy3dkBHVgVA71AWQYAsqD/Xjtw/bTIRv0Unhz9Eg1U/VPbVvw0secCA0Fc/P+O6QNOcaUBTHwjBNeInP50ZSb9ZxqzA5kbdPqulocB/3ANBmgzbQMoB28CaLOzA5BMswKrmu0DhwmA+HqlXQB7qO8DaJO9AHWOCv1tlMD8cQ5nAlczlwC34r0BYfwjBnIh6wAm07cCkraHA+C4TQRQwxT60lgU/2LJzwBJiHEDctdHAiCTUvy4CmMAK1fbA6lp4wM1O8z1xfvA/1eyqwHT0DUHOF5bAADcKwPFmzj+utO0+w7j0PgjOWsASwBs/EcdMPo6ANT+uioDAblKPwCyJ80BdFxo+Clm/P92FF0FecQo/aO+5PgcnCsF1ZTg/yw3owNCnD0Gvb/FA74ahQG00CsE2QoDAZAcvwHspB0HcREVAvMJXQEssZD+xJ4C9WB4AQJGZwkCwUQ5B/Yy2wKUcIMC3ExTBuN8NwYMXDkGsFw7BheWkPkz/psASS6fABHzCwPmtBUAiVY9Acal+PzstHz/NzOPAnP3MwGdQqT9kzPnAMC0rQbkTtMBK1RNB0tqov05XjkA5YQnByRYfP4nL9EA=", + "encoding": "base64", + "path": [ + "y", + 18, + "data" + ] + }, + { + "data": "2HY9QMcxCEH0wZw/tUVzQDusf0Dl94bAUvN6v9rTJEG4oXRAYSRIQFATTkAs7YpAtIGqQPHJX0CSmSVBeUZbQP6jwcD1VvpA2o2GwFthSUAN525AvK9TwNe3KkF1D/jAETmdwEjMjsAX7IhAP9l/QIIrV8D3IU1AfHIbQUFLykDihBlBNCCLQC+xMEBl3/6/TPrvQNwnG0EFDI/A1A98QOU+f0DGz1pAXpdkQJzQe0DGjQ7BX2hiwN/+wz7S0jPAYT8PQV1EZkDmSnpA5F5WQOITJ0Fly3hA9hBxQJWQDkGBfINAzwQZQZtsYUBcJaI/FSl5P9lhJUHvoFdAY3gHQWKEJkAimnhAFEBAQGOMhEDWyg1BovhoQBg19sAfa03AYrYJQfhMGUEweKrAsf04QMbokcAKM+xAfgAYQeshdkAbXPxAWfmnQOfueEBZWH9ADq7TQAjKeUA5GZ/A9ezVwAHr0EDtbadAYzIZQXIBhUAo1phANphFQM3JkUB06IRArLneP/SWXL6J/XhAF/XsQId72UDkIM7AFHdvQGDraEAlFXrA6lRiQAoA37+n9xBBm2gFQXLmpcAv9aTAVJYxPSeODUEnkmBApBO9QEG74z4CvQFBk2z6P4hcYEAWf7y/Ide2wNa/CEH1vtrAg2CcvxBbssCJnlXARVUoQVo4a0Cm5HBAurgcv2f1q0AV/oDAYEeTP7Qitr+vks/A8Xm/v6n3WED3vJhAUMJNwOOsG0Ex6xDAMWVaP9R8i0B3WG9AuvKBQOGGfr/W/IdAtal4QDDmXkBTPK6/ln69v6qmC0GOG1RAwZ6kQANPKkE0DW5Ak/pXQK9xwsBXoYRAO03DwBvbIkHfvhtBe728QBz64MBM9a+/E/WvP6hfHUHUWsZAOTipQMuch0CSC05AnbG5QNln6kBGORdB8Nt/wFqGqL6rNAHBXcHpwH7xIEF/UerAHVdRQH0NXMCA8gXA53OIwJfRlUDzAr1AwgqQQKIeaUAocY7AkIiuwBg9hEAscpXAsZQtQX0fk8AHjB1BQO0TQHAz40A4dOzATzeJQBg490A=", + "encoding": "base64", + "path": [ + "y", + 19, + "data" + ] + }, + { + "data": "6E7LQOH19kDh/JhA92TgQOR210BqBYi+u+g/QIHSK0FajN9AEhvUQIWcyECI9fNAUJPgQMxPvkBSGhxB+DPVQKqpSsCw0xFBa5qOv+Ybu0CdZ9hAclSAv6t7IkHOLrPA1N0PwO8bor9rC+5AQGffQNTzlz5u9cFAUGoLQYHLDkESvQZBvlrvQEk1sUB0N5w9Vv0WQdOnBkH5pti/K2/fQLfqz0APGLJALgrLQE8F7EDymeDAGsB6v1JkS0DiBD8+/8gcQYXyvkCLF8hAeJzHQADwJ0EMVNFAUPLKQDKRF0HQ0+NA9bQlQe8rxUCqwXxA8KdhQNAdNEGv4MxAuRoNQUvFqEB36dVAi7G5QGnT1kDBNg9BqG3VQOeYncA4p78+K1ERQc/aHUHnSOe/wovAQGWTkr9pyhNBt7kZQee9yUD5DM5AZWf6QO0UxEBh8sZAK+X5QD5guUCFcBHAnESiwLguB0FeEOxAOzwGQdqRzECA5uJAEm3OQBES5UAaK9RAf7WcQLgXZEAqSMZAEOIAQSuzD0HxpFzASzLGQK9R70Bh6P2/RUXEQC94/D+7GQ1BTUMOQX8UP8BKegbAk1AyQPZiLEFh/MtAJfz0QK89ckB8mvVAQVmRQKv1ukC5UwdAdnRowB2wKEH6z4/AmM7pP46fPcBzBZq/Kl4pQY03zkA2HMtAqF0uQJCV8kBktja/vuBvQJMcEEA28pLAs0WYP1w6xkA9VOFAWFqevuM9E0GJ/iM/9HZvQFTwykC53c1AkULZQCTJ2T+h2eBALrncQLBMuUBw8MU/tZTiPyblDEHuUsZA3h/3QMVnI0Gcm8hA/Xu4QLB+H8BFUdZAOTOIwD5TJUHxWS9BnqjDQDHil8C2rMM/tq6oQC7GIEFFwQdBPaLPQIDA2UC0/sBA+UsMQa7f90BLkQpBOUfWv9BY/z8dDcLAVaGfwB1BI0Fqa6LAjuK9QGBSlb/QpbY/XZvhv9rQz0CrutRA6pzkQFKGwkCy2oG/Ym2BwG5Rx0DMDvu+AnIZQT2uRcA4vRRBwse0QFliD0GBy7PAvFviQJfrzUA=", + "encoding": "base64", + "path": [ + "y", + 20, + "data" + ] + }, + { + "data": "LY0SQSourUAHnfpAI/IUQb10C0HK3HVAeJ7RQD0DHkFzaRVB4SIXQQUrC0HslR9B3SX+QGsw9EB1wvhAQNUUQZdcGT84pxhBp5AMQKqX/kDdrA9BMF3CP8L/AUH51iPA4XBcP1zHC0BxRxpBr9kRQcoQfEDnNgZBewXIQNRmJkEo0blAqKoaQVmu+0B3owlA8BslQT6mtEArurI/9u0RQS0vA0F/0eBA/XcIQQJ0HkH2NYfACdflP/8GtEDWTEtAP6EbQcFr+UDoffpAVUcIQU9CEkFBnQdBUcAEQXe8D0HmABNBXFsfQZuYAkHJ2MVA0ni0QPHbMUEi+gtBpSABQfUh60CRPwtBxqD7QLJoBkF2uPpAqu8OQQYTtr+RW3xAvfkGQYZkEEEb3wFAOaAJQaWgJEDp+SBBJ9wGQShQAUHmimVAgTsVQeRG8UCmrftAIKYBQT3J3kAEGHw/0DY1wBsuGUG27AhB1Vy9QEjW/UADpAhBrPwRQU40DUEMUARBROXvQJ3+2EAG8/RAoVP2QHOmIkGQr2s+87gAQbW8J0HumYE+gsQBQeh+rUCHfuxA2NIHQRZanr4Gya4/GsyjQAd9OkG2+gpBnSQJQSAo1UAA5MBAzHvSQDhK80CYXq5AzoNpv4m2N0EO4Lu/htqTQBpCiz71x5I/KUYUQR27CEFWkQFBlsu2QJnID0H6gTJA0526QInssUB59ADA+2BuQPOUA0GZrAlBhsItQFMn4kBi1l1A8QTFQCS770ClRgdB5jIKQfZchEB4xQ9BqucRQRdx8kDqhYdA956ZQE0L9kDZFAhBgNUSQUUEAkF7BQJBuSjsQBG91D94ngZBmBHSv9HtFUGwzTJBqfK0QHMW3r/DU4dAJhsIQQC6D0F4uh1Bd7jfQMxuCUGSywNBiPAtQQX76ECNmMtAYJJ0P4Xbf0ALpkrAAoTjv3/4EkGg5wLA8KYBQTiDpz80bphAkgKNPyQE8EDF8NVA2d8PQZw9+0AD8ilASewJwLnx8UCK4HVAfszaQAWkib+iyu1AFhsHQV9zH0EADkzAqM8OQWaJdkA=", + "encoding": "base64", + "path": [ + "y", + 21, + "data" + ] + }, + { + "data": "ACQ1QQso0D8uxCNBZRcrQe6yH0FHqetAIq8WQRxC70BuPi1B0Ao4QfLZJkEaFzdB76YBQeiGB0FbzY1An+80QdnLiUAplxFBd8qmQDTXFEEoViVBXSR2QMqZnEAccHM/7Rh1QHgwq0AtXS9BfcElQZ8R40B0bCBBdOIlQDaeK0GxjAJAgmQvQWMaG0G+2HxA/6kiQQO86z+w3IlA39IlQc2OEUHYCfdAAcwhQUkPOUFlrAG/9xyJQCOV8kB/brhAe8MJQfyWD0F8WwlBAJYhQeUFyECX5xpBnr0ZQV296UAUjCVBQFwDQWkNGEFpZPtAkW7nQLfwHEGGKCRBNzXAQCGXDEHmNR9BhHkQQUBtEkEEwadAKeclQS5UFUDYCOBAXpjPQMdR3kDGorNAjygpQUUmvECfSxxBWwq+QKhIE0Hqo6G9bO4bQYN+AUF1Gg5BkuTtQOhZ60BI0IJAC2rfvdSpHUEnBw1B5X8bQMmsC0FqExFBsZYuQbOiGEGk8BFB+1MXQdajE0FYXwNB2G3GQDYXJUFVdnlA5lwUQREeSkH6Sh1ALOMWQVHWBEGXlpRAOybiQMuLHEBOTpRAZ2jcQHOaN0FbwiZBK7UKQWKzDkEwyklAFAwBQVrVC0HN5QNBnwcDQFdJNUGQz/I/TDveQEz5XkAsTVRAREvNQLplHkHXZA5BrBQCQV3iGEFdFrxAhVrrQOnpAkGUOXA/H7W7QO61FUE5LRdBFoSsQAdcW0D2drxAFFr/QGE4+UCa4htBhskaQSqaw0CD0CNBdzYpQTeUC0EphM1ASF7qQBj6pEDDcyFB5pEYQa9rlkDMiRNBNIUCQTJCskAxUxZBg4WrP/qB5EApmCRBTdyNQAr70j/oDc9Ar4IvQdFAz0BNuSRBEenZQFO2GUFINB1B7g1CQUnDuUDIPy5A9I9dQKiVskByQ5Q+79b0P/8U2UDdobs/eWYaQWyZZ0B9h/JAKPFzQMaT9kC5Yb9AMmYiQRfZDUFwi7xA+KfRPS3wAEG10/NA0rozQNCnmD/n8oVAt+EpQa2lIEHE3iG+su4dQcLh4j4=", + "encoding": "base64", + "path": [ + "y", + 22, + "data" + ] + }, + { + "data": "SjxNQeZrK8At+D5Bnh0zQbWMKEHoWyJBcHs4Qct8YUBMcDdB0oxMQRSeN0EK00FBT0vvQLhABkGD5vg9WOlKQZv17kBIxvdA58D1QBohHUH3LS1BUlm5QA1RWj/jfYtA393IQH32/kBPdjdBSIYrQeh1GUFozi1B4GTTv6YjHkHqLA7Ai3s2QUsKMEEvx6tAwZ4PQdVXFcCydNhAN1YrQUzLEkGnOvJAypoxQQtkRkHB01dA2WHIQLGtD0EyEPlA1qbGQPodF0HmFQdBJW8vQb+TBUCG7yFBCfYjQTbTh0CKgypBqC2gQFLPIkEt+Q5BGqsEQSDQ40DDZS5BaJEkQBKKGUEU6CZBo1ETQcVnDkE7baQ/pmwvQeJMuEA81RZB3YpJQJYebUCH9QlBlbk+QUw/CEFmvwNBz+wZQL7cGkGgH2zAzEkRQQmr90D6wRFBTRO3QDyT3UCk09VA4sMpQMRrE0ENcgJBzuTKvyuaC0GSxQlBjkg9Qc47FEHPOhNBxv0rQaDrLUGDg/lAmGNgQLsFFkHhAeNAxbUdQRImX0FjqopAUU0hQQEiKEGPUVo/JqORQMfomkCSQOtAyi4BQVPdIkHLVjlBjRX+QB4xKEEflPu+wkIQQcuUE0HB0iVB9CSWQGkBIEF1s55ArtULQac9x0AeWKJAThcQQNxTJ0FmXQpBR2seQa8ZFEHNTAVByVIFQZOtIEEKNHJAcEfwQEVdGEFg+hhBO1nyQCVCiL+hYflAywYTQcmw5kDEDSRBCB0fQajW8kDJVy1BC6Q0QSaQEkFs7f9AeU4TQV14sz8nZC5BQQUNQTaG1T735BdBxaIAQUtoDUERHRtBJOSEQFgTZUALwQFBT+cSQGfKmECBeAJB3EhKQTTYKUA45xxBVfq9QOx9HUE97CxB4LlIQbXgS0BGl8y/e7GyQHGv10DcrG5Ah72pQLq5PEB9q5dA6rQnQZuBsUDPoBtB3LXCQPg040DsfI5AUo8qQehwEEFeiQZBqlMXQFYg9ECcpSlB6gD0v5XyUkDWXym9n0lCQT9YEUFl3jtADsAeQS+AQsA=", + "encoding": "base64", + "path": [ + "y", + 23, + "data" + ] + }, + { + "data": "lM5aQTHmvcBqfE5BLVAtQayyJUFhFENBEflNQaDLsb9UWTRB3MFUQZnbPUFx0UBB2zDAQFc16UALsYPAstlWQeHrH0GRGqxAiFAYQUmRF0FzFidB1k3pQLpxVMDBM+tAqq8BQR0nH0EmbDNBZs0jQRD1NUHgLi1BduSowBSE+0CfVa3ATzwwQfhePEFa8stAzXDXQPaXt8BGUQpBWykiQdpDBkG4Gc9Ag+g3Qaa0RkHfp9lAHPP1QJ66HEFw7BJBjL8WQICkEkGiQOlA5qoxQSpTJsDBjhtBZPUiQcyx6z2SsyJBaD4yP6ZTIkGAsRZBhzENQfQDO0DjpCpBwd7Jv3OYHEGpMCJBI8UEQdvd8UBsvkPArm4rQSqFCEGJQTNBX398v64EsL4grC5B4V5KQVEJJ0GCDq1A2SXSv26gF0GPXcPATPDqQO7JzEBGqgZBihdBQLzCs0DqKwtB3JqjQM4R8EBVSdFAcQqXwIge+kDFqOJAp8A+QQT2/UBg8AdBqao1QTRGO0F058lArgofPWMT50BTUBpBZXgcQdgpZ0FGwbhA4asgQaMWQEGycEjAW/CSP6ca10D9TRZBtykLQYEG9UCVuUJB5JvKQGfgNkE/TnnA0BYXQVl4EEHu9jtBIrzaQOzd60B2sO5AJM8fQSnWBUFiQMtAd/kewFH3IkEKs+ZAghMwQdWP/0BHyyFBWJwMQTpIMkFaashArsYJQTg8CkGsDA1Bap0TQbFTpMAGURJBzbYcQfvytkBkJx9B/EsXQUwKCUHguCxB7Uo0QRIYDUGKAA9B+WEmQY9+LsCUXS5BNWDgQBsyesBiCQ5BmR/eQHK+NUGN1BRBlvHRQGbDX7+hD4xAFDAQv/a76kDSCBRBWX9YQV4j6r+L3gVBp/CKQK1DFEFcJzNB1JBBQZFwf74V2KfATYzmQCiI70DDhdlAEtsBQTrK1b/KKe5A92UoQVX430DkdjJBWlv6QNQXtUAMLgNA75ooQTm9A0FnjSJBwXCLQEf3xEDI+0tBVXW0wM9NokDH3YTATRVQQdiw3ECj6bRARvYQQaexrMA=", + "encoding": "base64", + "path": [ + "y", + 24, + "data" + ] + }, + { + "data": "YMhdQWbf58BiAlJBYaEZQc51FkEYbFhBiCdXQb9PtMCsNyRBCslQQZa6OUHyrjRBFsdmQJ8/oUAoSdLAU8ZYQbZMPkFXCgVAuo8rQXZ/A0EUsxJB5CQFQceCx8BLpBxBoCcVQTFBNEF5tyNBEmQPQUvaRkFC+R1B80zewO9jmkCAyMbAKZccQX2+P0EM3d5ATc5kQHD63sBhhR5Bw6oJQV/z1UDpZIlAyYo0QfbzOUGDtRlBUy4JQVo0IEFgKh9B7qwOwG2AAUHxWp5AkQIoQReoxMAUPAZBKk0WQeqNgMCjjg5BQN5vwE4IFkGA8xRBv2wNQcRhCcA0zxhBYuWkwO/xFUGQrBBBKYbGQN7BoEBjMsnA6awZQT7oKEFJW0VBXt6ZwBq4g8CAKkdBCBRMQU+4OkFYHs0/rBmgwJwfCUHSy87ATGyWQI4yfkAlhNVAw2OCvrmkWEDEUyJB4d3jQHgRj0ClaIBA47+owEfJukDhKI9A21MzQZL4rkCNG99Ax140QVDrO0EcCGpAw1VawJ85d0CmIThBcSQQQW9MYkHbfNhAGzoUQXCDTEHcwbnAQJIgwAM+AUHv1ytBcZYMQWwLe0CJz0JBV8FxQP63OkEVlbjAc6QVQQkJAkGvzkVBhU8HQSXXYUDJ1BVBGugqQRQ5HkF7HOVA8d/DwN/YEEFQfI9AsgI3QRrJsUC6vTNBPNgLQcEHOEHcWQRBgHYSQZjq0kAtNOFAu3glQZjO6sDWCB9BrAAdQeKvVUAYhAxB+OwCQbzJEEFqEiJB3vgnQRi780BiBhRBizkuQQ7vvcBGuyBBtKGIQCvQ3MAV8ehA8keYQAAHUkHaAANB/80HQfVkm8B0hRS/hqxNwEg6FEFlKRxBgjRaQRn9scCB4bxAVSMCQDls+kC1/i9Bx44rQYpHYsDq8djAi3wEQfpX+kA9QhVBv/YkQaSJtcAUSBhBr2EbQbss/kAFiz1B+h8QQR/uV0DBcVq//IMcQYqqykDFxDJB93m/QP7AYkBfG2FB3BLcwL6Sz0CMeNHAYf1SQdKPUkB/hPtA/kTnQNyEtsA=", + "encoding": "base64", + "path": [ + "y", + 25, + "data" + ] + }, + { + "data": "Z/dVQa7+2MAoNElB7zfvQC5u80AhxGJBvAJUQVMz9sDNFAdBe6dAQUEfK0G8tR1BNivyPlJ86j8Wo9vA/pNQQT/sUkHzOtm/fNQ0QXlewUCJMN9A0Q8OQWhV0sB5CjpBgVkfQVnNPkEkfAhB9jzdQCgrTEGcVf9AO4DSwAHXjD+3bKvAIUf2QOuoOUF5suRAaXIfvuKrv8BgqChBEPrBQL8VgECQdpo/1xknQZO+H0FsUTxBi0MPQYruGUGmOCFBYea+wI3WxUBMBL4/vOkRQUmm6sA2pb9Ag/f6QPqN3cBP6dtA89XWwL8f+0Al5QlB0nQFQVxZxMASJPFAMRnkwK7ABUEnqONA+oxGQEqmwT8DPfXAfifzQCtePUELNU1BbZrowM6BvcCEO1NBka5DQfW6Q0FFOiLAV4jHwOvG3UAZSaHAyAe3P+MULz8kBHpAA9tcwEZq7j7ivjBBdwEKQWXSmj4RfE0/IfyGwI8qMkCMuYw/7gUbQYMxAEACBpNAjSUoQfBEMEE0fD8+0wa8wBrql769/0pBir/vQHJvUEEwYepAmAr1QCdITUFluM/AHDCiwCTxDkEebjZB+eAFQfpyHr/9UjlBln31Pu+rM0EuV7nAi94LQRF8z0CjCENBhzAZQb3Xjr+GPStBivQsQcMcLUEaxPBAAdPswEIS4UDZ2FQ/O0MzQe/t9z95hDtByjwDQVBOMkFscBxB3AUSQaf7W0CcY4FArbYuQZvo6sBr4SJBrCcUQbb4xD41y9ZAk17CQDXBEEEkUA1BmSYPQQykrkAlXQ9Bi+kqQfod7cCqkARBA8RgP8sl7sDlEpNAWj7WPziMYkF728lAPaEeQfka28AsmKbAmD6dwEwzKUEV7RpBVlFPQXRD58AD2RtAE7EtvzDSrkApaCNBwsgEQXx0sMCixsjABcwMQVYi+ECuCzRBJn8+Qdrd/cBSvy9Biz7/QED7BUEZ4DxBskEaQas5/T4u2F3A4gcGQUyJUEBj3TdBXQ/nQNxFGz5IX2lBX7LMwEdS8UB9ddzAZJVKQeVDm79dphhB9TaLQNQMjsA=", + "encoding": "base64", + "path": [ + "y", + 26, + "data" + ] + }, + { + "data": "wf1CQRKDpsByoTNB/5GPQFEbnUBZU2JBI2REQRa4+cBJxrpAAkAkQRujEUHq9/dAZvQvwDt/478hvbzAtv49QSkKXkEZEpXAbmo0QfEjR0DXInxAW10PQVp6pcCCe01Bv8sgQSjnPkGWc8NAFGmEQEbtRUHx9KVAjG6hwEGbMsB732rAP1iXQExmKUFWot1Ao4NywF3qdcAzuihBoAcpQHtgFz+NTQrAvNwOQXjn7kBk91RBTKgNQYDCCUFwFxlBAzMAwdSIYEBNshfApTDdQGfc2MBiWSVAx1WxQHLFAcEshoJAmt7wwHWhskDGb+tAf6fqQKJK/cD+BJVAcfzqwG5Y2EAsNIxABBQSv3orFMDaAezAycCWQNB1RkFDw0pBSRL/wAklu8C54FJBxdEwQXRxQkHOcrzA0HOywFl8kkCi4SvAhpADwD0iMMChm/4+7qS5wBS/IsA5wTZBWdIZQduHesA1lyLAP8AewBUGZ79uex7AW9brQKwf779+d8E/zu4QQQGSGEF67lLAqMnYwHogicDyJFNB+oalQLYoMUFJJO9AUUekQJQ1QkERjrnABi+3wMgkFUHBZDZB8NXuQHJrm8BgxyVBnxQ6wNafIUFbPpXAMQzzQKvNg0AeYjNBR1wjQaEepMDuHjhBG6olQVPnMkEmH+9A6LncwCnChkAoyj/AaN0kQfuaDMCHdzlB/9DlQF5yIUHBVCxBGE4IQUr4xb40SxA+J0EvQb90vsD64R1BCGoCQTb4J8A0oXRAbARLQILzCEEjZNxA/x/SQHhyHEDobAFB1KgcQQd35cDaGLNAOYIpwObSxcCAD4Y/6knjv7KgZ0E74mtAQ2YtQU5h38A5uv3AwuSwwOLJNEEubxBBh4k3QThT3sBvpcO/j9dLwPVBFEDzNA1Bml2VQE5EvcCvjJTAjTUMQcmo6ECBqEhB1t5OQYqTBcGo/j1BUUuqQOfBBEFLjjBBNbsbQSDOHcBaJaHAeVLJQOHDDb8ufzJBhCIBQdJtUMDzEWVBGOSfwMvnA0EhTb/A5Dg2QWHUqMCFaitBp/4oPzPBGcA=", + "encoding": "base64", + "path": [ + "y", + 27, + "data" + ] + }, + { + "data": "QEkkQVIVO8BivRBBH1deP80Qvj8fHVdBe/UnQTHv18CbcydAjWT3QCJV2UBl359AbnalwFl3msCkdYbAAZQgQSDCX0GhbbjAbJgqQT9HiL6Iysc+aPwIQfMHPMAp0VZBjvAZQcakNEEdjkNA9x5aP2QPNEFcWdw/s/o2wHWuvcCinMS/lreMP3vwDUHT0clASDnFwE95kb+2xx5BrC2cv/P9OsAvQpzAVFTVQLpfhEC4BmRB+LkEQQ0s30CvvgZB0j0Hwfgbrj7vHq7AdPh7QCq1p8AcCKu/wD8pQAxK9sDtIUM/pDvbwAFYL0AEdLFAPxe6QCHZAMGCPpI/MgTKwEY1k0BW04k/Uy+CwABZscC6QMDAIz+XP4bWREEAzT1BxgjkwIzvmcC9J0ZBeOMSQZUbN0HD2u/A00N+wBzH1z8LcJo9uoyfwDLCqcB9az/AgqPYwH8bnMBYkzRBJmYhQcex2cDU+JbAcE7ivmD5iMB8CK3A+GaLQAATqMDiPeq/TQfeQEYB60BaE7fAE07EwKNv18CkyVBBkFAKQMnzA0F0dOdA7ozpPzD/KkEPO4rAGJehwG9HFEHBDSxBFyfDQCSA6cCUaAdBiLGwwLJnBEFDUTnAEEG8QD7Enj9uqBZB0RsmQbDR3MBN8TxBwJIUQfntL0EKAuFAiHaswM/AWz8/a7/A2dALQaDVssBK1S1BI9O1QHC+BUEsATRBLE3qQF40gsCUznHAM+QmQQYkb8A4BBBBkxXQQJYLnsCAkds+PCxivgGU8kANlolAE2dbQJRBgb/RW9VAEMkDQYnmucDHDQlAwWOnwDFhfMCrxi3AyuyUwHl/YUEdKRE/HRs0QXF5wcBPxwvBrlmkwI17N0FSl/lAlVYSQahZscAgrKLAmLqYwKaCmL9mLtpAjg2WPcKVpsCZsBjAh8sCQQVfy0B14FJBeGtWQQuG78Bke0NBLMz3P8ol90DZshhBjbEUQQUTmcCmzKvAVyNgQJNkhcBUOCNBT7AIQbz6uMBFV1RBcqJCwBGiCUFTVYrAd/gUQXI2+sAKajZB729JwCa87bw=", + "encoding": "base64", + "path": [ + "y", + 28, + "data" + ] + }, + { + "data": "wVfyQPxRgL4m6sFATVg3wELuDcA97EBBhY79QOeUncBemWu/ZXyRQMymc0DFFN8/ABbJwNsYzsBGEwTAkovvQEIEWEEOda/ALJoXQU8cY8CiS0nA3pr1QMS0rL6W6VVBVyMLQSwNIEEk4sK+a80iwOt7FkE0jwDA7lWwvvpz6MA7HUY/G+0swGy3y0C5YKlAxz7RwHDO2z+N4ApBV5CYwPrMtMC31cjAT3FoQDyNhT6/x2lBz4jpQHwjl0AQldRAeqT4wJUDNsBbmN/Aoc/WPtq2RsBJlZzAU9oUv+AvxsDFUijAXTWpwKVb2b74Y09AklVzQGL55cDjRCPAYo2PwIkYAEDR1RjANFzNwEmY7MA16nrAOgYiwKkdOUGM4CVBNtuowA5fTsCmIS1B9UfTQKvVIUEoWenAGuTwv/EzuL80bzRAul7JwLVuysAdo7zAYRDIwL56v8DcTSpB6s0gQaF9AMEMDJ7AtoDSP5w1zcBX093AjblaP+cR6sCVYJbABxCIQHDnkUAAH9DAwWSQwPwD58A2EkRBlk+bv2j7k0BT7NNAYgDtv9RGB0EyIhfAwIprwE6xDEFdrhdBZZ6JQKEN98Dnx7pASanawMgEuEDlOUi/3SZlQCWC6L+Z0dtAnZ0hQdxS3sBkDjpBLAPyQJZrJEHwK8dAft9QwGc5JsAnPuzAGcvQQAgU78DpvxhB/I5tQEl5wEAAcTNBnhKxQOvs0cB/59bA5kMVQRQHh78NZ/JATvmKQHQXvcDdeT7AS3ZgwNwqw0C8Hpw/lopEvjtHhsAGz5dAovHBQMrobsCuLNm/O5m3wAuLmb9XurbA7C7DwCtCUEE/IybAKbEyQVZOjsD/dwTBQCaAwNCtMUF6dMBARNu/QM61XcBqauzAYRylwGtbjsAeuIVA4ZuPwGkcdcAKrSg+vFHhQD5bn0D4ilJBB1lVQSq+uMDhi0BB5vjkv0JG1UAx2+tAJD0FQaFuu8CJh5XAIppFPoHd0cDvgQpBLVIKQWxK3MCSNDdB91RFv5vlCUEKOQ3ADPDLQMvaCsGT8TlBhmfAwKf/FUA=", + "encoding": "base64", + "path": [ + "y", + 29, + "data" + ] + }, + { + "data": "7g5UQIKyPkArbMs/tDfEwCSNxMDUFxZBKmd2QBp/AMCUhJ/AKRCSPTCR776CjR7AJRO9wIiAyMCzzFI/3iVeQLFAQUEiq4XAt2XoQMQVyMAktsvAtw69QEB+N0AelUZBFDndQPHx8UC7SYzAaOW8wN1jx0Azt77Ag70vQCtyysAmZVlAuQfRwHsZD0CnjmFAMJ6iwBo1mkC1aMpAyU3uwBE84sDx3MDAs4pIv0TWjcCWXGRByw2wQOJlqT9uIW9Ajte7wA7mtMDoG9nAGD54wAz6Zb2f4vLA2dOKwH8TWsDc67zAexAowOe0hMBAagc8nbxVP1cppsCyrcTAsrDJvw6juL/Oj73AYarewDSz7cAB0kO/917LwDLPHUFMTfFArnELwH27Xr8y9/1AJN4nQE3U9EACbLHAEYxuPxfumsCBW6xApGyrwBC6ssBpgP3AJFCHwFpLsMD0oxJBOQQVQUTh+MA5zmzAPZ13QPC34MDU0dPALeRgwPOk88AWotDAVGDiPlZ9GT/sp6/APL/jv2eKwsBLciZBZaudwH1ICL/frKxAOY+3wB+yl0AlQLg+2he/v7VB9UA+9eNArK3OP8v50sAg6+E/EdrTwOqV8j8xMvM/ZkAaPmUco8CLFz5AiFgSQZapuMAVWixBqtyPQMTeCkFbnZhADFpSvrFiv8Ca5NnAO1BGQDyh98Aun+RAk1lMP9M9IEB5bydB+BcrQDI76MAv3wbBF3XkQN91F0AdQKJAOFqVPxhtpMDa4cXA1bDDwFBOZkDMJy7ASi+PwMG408BxiPE/UQQwQBcEIb+l/LjA7GqHwE94FEDYquzA3cK4wEzzK0GRNa/AkawlQY4B9r8+JNLAROr8v15pH0ExI0xAPNijPwLT2b6ccwLBDJeHwIcg5cDK45Q+Rh8FwY3+y798akxALQOeQBLgJ0D9fUNB2l1IQQfNOcByxTFBgai3wByQl0DcuX1ALOnNQJubqsDnTD/Apq9zwM8y6sBAQMFAlWAEQbnex8BlowNBYp4FQGi9AkE1eC4/lgHnP2tL/8D9YzRB3FHrwHVHlEA=", + "encoding": "base64", + "path": [ + "y", + 30, + "data" + ] + }, + { + "data": "ObUiv+fUjUAGchPAXczdwGXeA8Hp6MtA/EsdPXDJJj8neuzAs/JmwNUrd8DzMq7A2wmUwNV9n8BZuENALP2Jvss4I0EYSSrAG/KcQA+L18Cn6+3AtC17QESBokAEJy5BF3+eQLd2nkCZKNPAp7fowMRNQ0BbCvzA1Q+YQNVOjcBQKJRAnsYFwRj8yL+lNtk/BSJJwD9ZyUAz0XRAedP7wNN41MCQwpbAEVCHwMAB6cDZwVVBpBBnQD5p0r+r43U/mQJswGMLzMDqiq7A6GzOwPOqHEBOswLB9r7SwKK/ML95d+jARiwCvu13zcBckSnApozbv66bQcDy3/HADlyEP3m5gcCmCfLAiES8wIPwv8BqX/g/HyoEwanQ+0AOVI5AdEYqPz+elD8WBZ5Ab9+Av2b6oEBaHVrAXZBHQC2Y0sDVxrVACQ5hwOxYf8BHPAHBWXb8v5RygMDWLOxAnmYCQfYQ1MCsiwnAYtWZQOM4ysDrvKTAi2DKwCEay8DkDs3Aq2kvwOloLsBS5G7A4e80PxMpi8CBMgNBgPrbwD+4lMDS4oBAzkX1wGqekj9hAyJATTPwPgn5yUDBJJVA8DBFv42EnMDTpu+/OvepwLZhw78l6G1A+iIswFVL28BP3A6/pbz7QN0IhsApAxlB3dqrPxnK2UBkBE9Ao/8UQPo96cDpX6PAUGg4vbgF2cCqwJNAD7Davyx3Jb9sQRRB/GqLPIz8yMD7qQXBWnyUQN4klECxtSBAYKjKv8hoYMA8WOvASd/RwG6cjz/ifqzAzCrgwPO54MDd2CS/fhZyvv2XAECiB/fA/ksRwOu1mkC1PuTA8AuOwBcwAkF3rMvAs4QRQdwwvT7QpY/A9p8LvTSiB0FQkw0/h80ywLb+B0C4xOnARKU0wMNK/cA7FD3A7T4bwY1c4z7W+ZtA+PkvQMmgiT73/CpBwSA0QXN4S77qrhxBF0zzwDa3LUBM4Uo/I6SLQNfEdsA59Z2/aePGwKhw0MD4n1tAYivyQISMk8C9/ZxAJlN/QMVT7UCoqTtAdukPwGI9zsDc7CdBkxvawGJRn0A=", + "encoding": "base64", + "path": [ + "y", + 31, + "data" + ] + }, + { + "data": "leyOwJJpPkAlGrvAJBDMwIFKE8Evhy5A7lZwwPyrSUAzQwnBJ8LWwCNeysDz3ejAaKk1wG3CR8BIYZBA6MZ8wHYp9EDrxWu/LX8LQIpjvMD+YeLAflDJP5chykBrsQpBtSUnQHRW+D8Wue3A2T3pwApV2r5a4AXBcjumQO3eAMCxmExACiAPweT4osA5o6K+DJ9lv96KsUDl13w/QuDewIpcp8AHmTTAFvzXwGf4C8GE0z1BCSW4P2HUjMANAPW/DySQv+SVuMANPl/AYgz3wD4SjUB96vDAnZH2wIV2BkDeoezAKbkXQEoX8sCTJp/AGDGAwASqDb/8PvPAMUlbQIPCwMBIUv3AaIyBwOs1c8D2I4NADRoPwWfArUAn+VY/NrhYQK1fQUAftMU/DzCOwHj9/j+rZG6/LueYQPAK48AUO1VAHkeivw549b9hpuDAvxgAP/Ax/78/h6JAWH/PQJf3m8CiXMe+nJNTQHf6ncDm3kTAZ2n5wIi3iMD/yqbAd5mvwCutssC1GsS/mGhFQMS+DMB0qa5Ao9v0wIVD98AKORdAtU0FwYApJcBVuoJAPq0XQKnRkkDqrew/UpdDwFzFMMAocKTAU45ZwA4Gl8BRQoVA0XKcwKSL8cCSWYDA8iLEQIsdEMAayfxAvG8AwN9wj0B6Gro/v2SLQNcb5cDniDHA0A9LwNhApMAPQNs/NB97wMjJbMDa9vBAP5sowGQ+kMBKBurABG3QP3XXn0BtFJy+X/aDwB1Mub/j5+LA4Oa3wP7ivr8vkuDAsL8EwUe8x8Afn0bAM2tMwEyPhkArFgTBcoOAvbZ2yUCxvbvArDAlwG/9nUBpib7A5cXoQCDFJUB3yP2/yXzyP/xz0EAenAjASHfKwOeTiEB55LLAPTKOv94W68BnNrXAMDUcwR1qGUDnLIZAaNifPnunB8DwRQdB3vEWQdaUIEAp7/5ArPYAwSDY5D4Z1hzA3zP4P91L9L/n+SY/aFzwwA15ncBn+A0/FQDQQAYxGsBvhZI/8dmBQNmOyUA7pItAwZq8wKeyicC4WRRBXZerwA/2KUA=", + "encoding": "base64", + "path": [ + "y", + 32, + "data" + ] + }, + { + "data": "uRLxwKJcMj5j4QfB+0aiwKbWEcFaHKK/2qzbwKgPiEAMewjBc0QLwdCe78CkofjAi+hFv6wqb782KFhAAWvewIAGjEBoMmU/hUE7v38kicBV/LbAYJJyv1TrrUBiYrlAil8ePSd1oL+N6uDAE4bIwNhDdcBWf/XAbKA1QGtlFD/4BIS+oUgHwQUs+sAMYxLAYJi2P343IECL1Pi/TsmnwGWvT8DLER+/WRUCwVkEDsEcShxB5I1cv0Pk0sAvf5DA5n/IP5rni8DPVpK/IBf5wKb9iEDcbsLAIDP1wLSmjkDba9LAmMOKQNb078B2ldTAJCW1wOXR+z++5NXAQiiTQCc+4cBoGObAkmLkv339lr/E535AUccIwSrlKUAr8TfAqhGpQMD6g0A4Xv6/VmPhwLqBn7+6ctE/jOmdQOPxz8AtrmC+SyuNP4Bhuz5cwKTAHC86QPxtgj4lBRZAo6eKQE2nK8BkorM/p9kMv/MERsBKSDG//ED7wPym3r8U3FnAMEvpwO356sCQaFc/96mbQErcHz6MXRNAESPtwEZQFMFukPk+bJn+wFfjvMBaEVhA7Tl4QGouIkDejY+/NiqdwK1KzL6XEO/A/CWTv8vh5cArmPM/89zCwOpC5sBMcN3Arch7QICP8711EblAgb6fwMQq6D88kea+z2qMQCe5wMCKgwO+gm+7wARdQMDEta2/XOStwL3UxMCoL6hAgqOdwN73EMCNobLAkn7Mv0AdKUA/nkTAbnjCwKRlQz85ELnAP+aGwECYdsCifvDABIYGwXcZl8BfCqbAoje5wOV5lkDK2PfAu5cJQCLVr0CsjH7AN//nvhiipz/9uZbAYnKcQHPKg0CZ9j4/Ib5SQJl2hEBipJHA9FUKwRdXm0CNRFXA4+Q0P43EucDPx+3A+CIOwZdna0AVIo8/IrwJwCvggcBSNrJAyArhQAPDkUAd07RAykjuwNdC7r9weazAd4sqv8zAcj59RxxA+aL4wA20NMCMbRfAkj2iQOcZij1k2i7AUKChPyaomUBNLkdAhcQIwRc637/COvNADQBXwBn9V78=", + "encoding": "base64", + "path": [ + "y", + 33, + "data" + ] + }, + { + "data": "HmEXwZdOLcDdHh/B5YtVwAJNA8ERd5/ABocLwapZE0Dw2O/A/DMWwf908MBlZeTAQ6GuP3JrrD9Ewlw+qeQNwTeOHD8NcyZAaV9jwFBYEcBMwnLA8mRVwOPUEkB4WRpAbschwPcAicA50brAME+UwLnr08Ao0MbAHpgkv15ZR0BYLXDA5m/mwPBZGcH/DnzAgDJnQAp4qr9TYJTAxE1CwKp0c7/7Y9I/hLMHwUhrAMFHyeJAPitDwJ4h/8Be88zAf6xwQL54IsDm8qk/gOHgwDpCwz8Sg4LA8fDWwDvKpkC/9aTANUWHQAn2zsCWxu7APDHPwATob0BPqqXAnMtFQO5m4cB3YLjA0wYoPyJtyD8GQNM/xT/swMQnnb5PZMDAoXyfQAlmJkAtzajAOc4HwYT+iMAHY35A0iQOQNbApcAJWnHAUbJXQHH3JUA69DDAkwSdQCbWHUAgXyO/Qk/mP3CPYb4gGkNAyuSMwKN5d7/XweA/9AfdwE4neD/aIqO//A/9wMXL9cBvoEVAO32iQGDUHkBuq4e/EgLPwGk0FsFbkLe/PpfbwB1vBMHgKPE+VxSDQKl5hz4m3nzAzg3BwAX2/j9dlAvBQL2aPxiuCcH1MqC/eTHLwGPxwMAQkA3B/vyuP5fDAECMfFBAd8HkwLjSgr9CXBPA+1/cP2gfisB1ZSFAyI71wCnkFr/tJYfA9wXCwIaO78AariFAMczQwLIeSz5V8VbAbziRwJMVG7+baqzAt3blwBXXOEBzlXjApDESwBelscCUteHABXX0wA0UMMA8YdLAxEf1wKdMKUADyNHAEZKEQBsrKEBRgdu/7dHbP5W0HMDyZz/AwAADQDyqQED9L1BA+CtCQDHduj8ZvsrArMYYwYkoI0Dvika/HHEcQOVBa8DFJQPB3fXpwAiKLkCGvxfAmkmLwGa5qMCfpAxA2A+DQPCGh0CtBTtA1NHEwMJOfcADovLANJ5LwOqgFkDCp29A3MXlwBmu477NuZ7AITVSQMiPIUAVS8TA9c0GwD5kOkBQPhY9CEYgwV20gD8de69Ar7mGvzYVh8A=", + "encoding": "base64", + "path": [ + "y", + 34, + "data" + ] + }, + { + "data": "nK0jwTNFp8DT7yLBwE+vvyKv1sAcA/TAUfkSwa3aGr8aOLrA7DQOwZxx2cAuabnAu4dUQO6wW0ABqUXAs6Uawd0pTsD1qXRAg8K8wIwUir02e8e/fHanwGr1zr+5HZu/eU6XwHXT1cCsyIXA8+wpwCnKBMFkf4jA3bWBwPg2qkDbL9bA8q+twMnUJsEVoKHAC2WsQAIEnsBdwdbAUO4Tv8Kjtj9jTWlA2+EAwVse0cDG73hAK/eYwA2DB8Hc/ejAIqVjQDOd+r5gy2NAgkm3wEBz5L/DXd6/cRSmwEzzVkAYTlbA35DIPzO1msBgs+zA45LOwMLZHEDfB1PAWA65Pq6LxcDya3jAX+9AQP/+gkDEmJG/hw22wD3MTsDJcQDBLq0iQPi6TL/coPrA7DcNwfqS0MAYErBAEvvFv+5oW8DBHtfADnepQALgi0DQpvW9FUi+QI05ikCDUGDA+ldpv3yHD0AkyYhArGTxwFJ4oD97UX9Ak3GrwEFlY0BeK3Y/29jtwEsd2sCVA5dAnHE+QI+xjEAj2YjACYqhwGaXCMF9WUvAXFeowIX9FsFp4ynAt+fDPxiMAcAsg8bA0p/JwPgcg0A+/w/BOJxaQCP5DsEUJofAyKG8wD+QisA7/BjBUVetvz0vb0BGOeY+X2EFweRRbcBNa3fA+v3Jv1K6EsDNDZhAh28GwS6y8D/GjcvAEBq8wFN88MCijOi+EQrowHNIKEBEJVO/6l7WwIMlcsBLCd3AavDqwAPElEDpedW/KPEovozezMAbDL7A0O7IwBgnCr8GK+HAJAkJwWAFhL7I95zAsuKzQGsHer+WXzQ/PuhoQHM+usDFFYK/c9eCv57fXb2AeHJAWSihP7ZTrL9RcOfAoH4TwWoRSr/NLuw/Lup2QO7fm792MQHBud+mwJQcJj7Pxq/Aei6/wDSluMD6+rG/KFdDPyNh5T/Y4I29SxeNwDNissBz9ArBjnqnwEQFhkBb+WpA2eW/wKp//D/F19bAePaZPzOXkUBRVQXBREalwGegMT9WDkjAENMlwb69YUCKeT5AEASsP+XJ3sA=", + "encoding": "base64", + "path": [ + "y", + 35, + "data" + ] + }, + { + "data": "MvQfwUTF4sDgRRbB1vQtPzojmcAfUQ7BBpwIwSPYXMClD2/ALT3ywIj/ssBU5oDA+kuVQPBQmUD9hr/AXeIXwQIdzMB2QVBAKEzswN+mCEB89Uk/FcrMwOnBp8C0ppXADkbFwKEfAcHcBhDAtLkAv3kVC8HTmAHAs6PdwE+R2UDQqQzBAKtTwM/4JsEQSbHAvOnIQGTf98C9H/zAac71P9eWaEAmb5hArI3iwBefk8Dc/Kg+PVy3wCTYAcEvNuPAwFa4PwAYzD9ZBJhAk9+BwDTxmsB7L0E/iKxSwJhT5z7h2qe/EH3Pvx6JNcAWAdHAeTu3wKQfkr4zvJm/Q0AewO3DlsCQkd2/U62dQNIfvEB1VXLAW9ZowHrbuMDHYg3BzKYHvz3Hg8CH5xPBZ2EFwWwL8cChhJ5AXVWiwMv6tr+6OArBgFzRQOYmnEDv0SFAFJ2kQCSgqUCwXbfA1ZVgwFYxfEAp3Y1AIhMbwaLKUEDdtbJALt1bwGevskCPOkZAmBzHwPnDp8DvOJVANTqEvSl+nkDr0NrANiJTwG/T4cBww4/Ag4NTwCB/FsGFna3A2LLyv1sRgcDHK+7AdwG5wEXhpUAiYgjBvG6iQDipBMFq89TADyOfwAfoEsC7OhHBsWl2wG34YUB1SRnAO8gJwX+tuMCWfpzAw+yUwN1M/73pw7hAbAQBwWAPfUDSIuzAZqqhwBA9z8DT1FfAwgHjwOhnlUD71+Q/SJX8wOJ/zsD1JfDA5MjVwAaos0AJkyo/JMr6Pw1EzsD+/4zA0WGQwF9s2z8RXNHAPXcGwUm1ScCGlDzAHEXBQPK/jcCE9kFAn5uYQC7YAsG1voQ/qNJ7wEpyTMBosNI/0XBWvzkZfsB38OXAUMYAwUUPgcBTcIdAVF6QQHHaqz8tlefAwU0vwAtTIMDdDfzArUvZwOrntMAWwZnAuYYpwLzVjL9PEkLAtbIYwDlF0MB4gAnBP17PwCvPq0BQhdU/qRiNwKJ9gUBgs+fAKICAv25wrECM1w/BMT7zwK6ozr9ccrzAZb4cwcPfk0CMSFc+qOdkQGaiC8E=", + "encoding": "base64", + "path": [ + "y", + 36, + "data" + ] + }, + { + "data": "5HEQwSxK/sAF7vvARJEqQLCIJMDrgw/BtYDlwLuivMBxP7W/jBq3wFkpgsDWMwHAIeiPQAnZh0CHgwPBiL4JwV/qBcEx0CQ+oID6wCcdhEB+vkNAce7YwJSqAMGGgPDA8ozUwPNABcE21T++PePWP64bAMGkMbI+eWkPwf1b2kAkbxzBDbl7v83fG8EI5K3AooanQFAaFcHuwQDBe7SGQG0hqUDHgnZASmW2wMCfGsCpxU/Az8e5wDFx4MBz1sLACnCBv+Y8YUBlEWBAc5UJwJj96cCAX0lA2QqXvwTrI8CBZ1E/zB2TwD9dJb/jkaHAzQyQwPKRQcDqTHk/kGygwDF9OcCLTQk/WsG2QNNyv0AHUsDA+USvvz/178BwMwrBTxVjwLUb3cDZuhXBFwjpwAIy68A/HQtAypz9wNP/Kj/HpRDBo4nPQH+3PkD8MZtA0yAeQB1CkUBGFN/A6Pq0wCFEQ0DFh/Y/MbQpwVecikCR87dAct2mv6GhyUBs0JtAnbaRwMcGUcADiw5AmD5IwBvlL0AO0gTBdh+sv9XvpMChpabAD1eQv2AFB8FF/fLA2EyhwNOjrcCeye/A83eUwPYbZkBTVvDAeX6uQFhx3cCN5wTB9jZvwML6tL3BTvbAIuW1wJ+8Gj8Li5vAv70BwQZn2sD1jafAOhblwIF/AkCoRI1ACancwMAQjUBMXOjA+AR0wFbdmcBaI7vAJOHFwEmvs0Az64FAVL8Cwc2NBMFEiefAd9qrwJ2Zn0Av/ztAcjJ4QPGNusAZ9ibAMn0ewOGmcEBg5KfA3rjowIehtcAIek6/mSKFQAag5sCMjZtAicB6QEgjE8Fs+z5A1t7HwPckvsAk9IC/R6E1wHq3vsDH58nARzfKwHGR2MCce7xAmjJjQMqGcEAJm7zA+CUtvW+Vm8BUSxPBtpvXwHo5osDaMfPAWQyywBGzd8BMQK/AHapcvrHp1cD2ou/AO2TZwK46p0BEFmW/6G4jwJ5tnUBhDdLAlwJFwLpwgECOHAbBeBYTwYNaasCBLwDB5AIJwQMqREAXMyTAZ12nQIFREsE=", + "encoding": "base64", + "path": [ + "y", + 37, + "data" + ] + }, + { + "data": "8vTwwOFL58CBKbvAdc6MQP3mR77fswPB/7iqwIDL9sBAb30/MFtiwGQUFcC2SM89/ogQQDdK1D8gJhnB6h/nwD1aE8F2sknARlDpwJW6s0BNgaBASxPOwL5CGsHJWBbBSFnHwOpW88CLlPE/oNFvQHsG1MBtwyxAZ7kdwS9fjECYIxTBi5izP8zpB8Ei8pnAp3/jPwgZFMH6a+nAHge9QJiatECeV6Q/q6yAwLrOnr1qPcfApxWkwLiCq8Dd4ZHAAgRXwCJfoEBiaEU/0mLrvZEVD8FLAKBA1OSAPxEWqcDo2jhAHOfhwCJQyz+Ah0vAt989wHbTrcBj3kRAzVrgwNwcZr+LMjFAZJGHQPxxcEBGEvLAMbJ7P17EAMHn9PfAnw7FwNCoD8EF5QXBDoa6wHssy8ADTpq/QY0dwTM6LkAHRurA5AiCQL5e9r0JD8tA9ppPv+UY+T/K1+fArtPiwFXJPj/TGvK/7B8fwTnbSkAGAGlAvHtnP5kSlkA687pAL8omwClFir/2G3a/Mei5wIkRGb9UzQjB2CwyP291PsC/gKnA8s2QPyLg2sBGMg/BKCzzwFrowMDGddHAMNpGwHiAkT4rNMPA/sprQP4QosDJgQ7BYs8SwExMCEBKW7fAKSzVwARbKcDMINDAbODgwAR72sBoqp3AcGgNwUUzgUAgIrg/EjumwLH+HEDC+MnAjLMUwHpxMsDZx/LApWKYwLpgh0CdaKBAEV32wLU4DsHC/cjAEW5pwOoeE0DGHZ5AWJSoQOx3mMDNayq/wgqXvmvKpUCcQl3ABImuwJRZ8sBHbrE/BLguPstUDsHxWatA8XuTP8WLD8HdIJJAvlv2wCxdAcHQTmPAYjWRwEFA3sCB45vA9e+GwC2cC8HIIbxAwNB4P2RftkB2fIbAw2IpQMOe1sAr7BDB2Lq8wK8AhcDLKRfBZZLuwEXnx8AgA97AtRb8P72FxMCQS7fAJz/IwAjDQUD8W1bA2sMLv7W4V0APNqPAeraXwFf1mj8zMuDA0swawVOlpcA9ZhTBK8/awMmdCj+Hf57AahytQESm9MA=", + "encoding": "base64", + "path": [ + "y", + 38, + "data" + ] + }, + { + "data": "kcG0wPptgMCtPV/ALgeyQAdIDEABmN7AB5hMwDqACsE6aFVAc8CUv05r8r6/3A1A5vErvxUftL/kDBzBbzevwDAWEsHD0sHAVTHBwLcGwkDdlclAoI+xwLq8HMHpmiPBvZ2kwBZRx8AvSXZAzfuwQBGumcANR5tA0IwSweq+4j4P9tXARe5rQKnU2cBbVHLA/7wTwLiE8MAQ2bvAuFvJQP97cEBoR86/uo4IwAHyEECWNAHBCgZ9wCLbVcBc4i3AUsSswOM/skCU6gnAf5H2PynfFsEjb6xA90BIQNaG7sC0bZZA74EMwaAGbkCtwoy/i16gv5ii6sCOz5xAk2oDwfvUkz+MNJlAnCGUP7KP8z7CJwLBSidRQBGy7MClQMzAnDUBwXNkIsHZLNXA3fqCwAGtm8CXC47AHC4pwfxjkkDsZWfA9hYKPa7gT8DO1chAPuN/wGiClr+WNNjAX9X2wIJh3b/+3azAAaDswJeOPj/CTsU+Vs9DQOEfwz/yAKZAqcQDvwamlT+W3IDASZf6wOIaecB24vnAot0rQEv9JL+rv5rAFJtSQL8imsD5jxPBjlIWwdtevMDp0p/AIoyuvywdSsCmr4zAjVg0P2yVOcCENQDB4Cs6vxSShUD6E1nAcf/awE7sscA5vuXATMGwwP8SwcDMpoLAzz4WwY7itEDtWO+/zHVKwKG0bb4Qr5vAmgozv++xGL+gywfBROlAwDVnlD8hiWxAPx7WwNb79MDI2pvAYBfYvxrvjb9KiMxA5V+vQAbOWcDwPag/P7XzP5bHpECuerS/2G1OwIvyCMEXHF5AlXB/wCowEsGJH2BAtqr7vzCN/MD3CapAE2wEwXUTF8ETFLjA+3+4wHBz3MCH2kXAUzLxv7L5GcEhn2VAHFj0v23d1ECPIRLApN+bQKRu+8DdO9zAwTeQwL2BQMAE0yPBhtwDwS5EAME7herA9kmAQCbWn8B/bmTAZUCkwMycUL5O+63AqF+/P2boEz8y+U3AJFS6wAKq7r+ID6XAT8MJweoEw8DBFhbBYQ+YwNPDBcBsEtLAWgtIQFJjfcA=", + "encoding": "base64", + "path": [ + "y", + 39, + "data" + ] + }, + { + "data": "rO5fwKOZeD+ASW+/yDqtQJlvjEC99qnAkPtjv6FqBcEWRq5AgvGiP+0KtD+Cs4ZAHxdiwPh9icAsDwTBt4VewLitBsGx7gXBBA+LwCxekED0H8hAOyCJwHEHCMEDHiHBddlpwHEjjsCOR7FABx/ZQLhGLcDrE9JAeXDLwE/VacDL+gjAHmW0QBjVmMDu+x/AdB/CwLw6iMBYuYDA+n+MQLC2FD981InA5mgEviIojkBfrgvBhPsfwJV/jr8aJDa/jtTewMC5h0DmYZrAGYV0QM5nBMEz1GFAf56gQHXsDMHSLb5AOQYYwWFsskAIUIY/9U0IPx74CMF3TsNA4QsEwYIPSUA/C8tAWE4NwHC3OsD7nuTA8BipQCeOvMBAzpXAYogPwTXlIsHgOJDAINoKwDPWRcAy8eXAAW8bwdx0wECMZpE/srKCwC4Yv8AIsopAgDTXwLCshMCnnbjAJE7ywMf1gMDR8wPBPUVCwO+t7L8gkT7AbXKgQER4/L/C6htA3lvNP8KvVkA4XdPA6JgOwTzE18CKD87AAL6NQFUw3D878HvAo/OhQAebIcAOwP3AFuojwUm8pMCAP0bAhGTsPkhkx8CvKx/AS/IbwBeWEb93bpvAQhJhPyvDuUAQh1q/hSPMwJ6O/cA9SODAL8ttwMNimMAESTjAxHIFwfCv0EC1Ip7AhOxzvxNkOsCDzUfA56t2P8iZ0D+rcAnBD2GKvx8IDcDeiKs/bKKpwNmuicDCnUrAPMO9Ptvfi8BsDdpADDNeQJRk7b8rw01A/G19QLI/QUBNnjo/t3xJv4QVA8G9P6ZAuunxwL2d+8AcvvQ+3IaawFW7yMAecolAf0oBwVtnHMFZJu7AXL/JwOb6wMAk6Y+/ebMMP/iDEMHcYKg+LJmRwOi4u0CO13e+b96vQBwKAcHjczDAzhoywL5m2b9PbSDBT90BwUnfDsHqM9vAb2S1QKZ5XMA+Gpm/GltpwLhlXMAQdN/A4RhbQLjLFsBNxJC/n7vJwFK5lsCCkUHAkZuxwNTvzsBk7vjAy+AawLN8kMBlDenABHpuviZffz8=", + "encoding": "base64", + "path": [ + "y", + 40, + "data" + ] + }, + { + "data": "gZeXv7z+tkB41dU/zC4zQLePwkDwn1rATR27P2XqwMDxF+NA/ONoQCrCTEB/Ar5AIqfAwN7y1sD+4JDAQD2pv7wZ6MBBex/BeXkZwD6Hoj/tH4JAH6UxwPhaucAZzxHBPvH3vykOGsDwg9dAJXbjQG/F8b42ge5Am/3fv3+b6MAHTU1AwHbcQB+jH8C4oYe/nCMSwXIumT1ep/a/UQ+IP+2zL8AtC9HAy5bwP+StxkDMbQfBs9Jmv2p9lz/H2ao/xl/7wMCfmT95jt/AeIGqQKChosA6LzA/Hl7OQAimD8E3FsJA3MIMwVXB3UBXo0hAu2ISQGlADsHwd8BAACXNwKPPnUBtkuFAOaGpwHzevsB/xWnAkjDXQAqXesCcIzDAAjwFwS85CsFT8wXAhFUVvslplL+ZRxPBhZrawMb41kBhsbFAmcT0wFCfAMETvLw/v6YLwR1A1MBqkI7A157YwNhVv8C0OiTBF2IXQDnyh8BCwb/AiBTSQJFrp8Ccr4S/aapoQAMDq0DPGQfBvp0KwRLiDsFElZXAazmzQMamfkA6Py/A9L68QGrbyL0x44jAWAYewawrgMCx4YK/UswQQPxBC8GfI+q+JM6pwPux5T8E51A+JmcbQAK61UAW490/oqWuwE5uGcEC28bAXmXavzIQTcBZbr2/382qwBZWvkAvXe7AcJunP7PMqcDKr5u/c6AkQNc4cUBY7v/A83hqP6WTqcBsi52/0+powH/+6z7cBKW/iywaQHaj48C2lq1AGSjfPfIWVr6bcZxAqz20QOCAsDxr7TRA54TZP28utcBEgcJAC8kjwewhpMAboSrAEyvlwMveicCK4r0/zFbpwAa5CsHp8QbBx8e4wIwrlsDa+Wc/G8o8QEiMzMCYyEDA9B3XwIm1UkCD4ec/x+JsQFT328B/XxVA4aZhv1Tnl75yxw/BTA/swE9zCcElK7rAgBHRQBq91L/tOp8/giD5v+WryMBXsfnAo7+gQKTioMA/coI/AebHwJAG4cDCvT2/pZQ2v0fhy8Du9XTA/LUtPak20cDgp+bAJU9mwMHBtEA=", + "encoding": "base64", + "path": [ + "y", + 41, + "data" + ] + }, + { + "data": "rhCYP5UXEUFga4VAR1txvzzs10BZ+K6/PcRuQPNOxb+4Yf5A/iW5QKHUl0CQguZA9yb+wP1HB8HrzVE/orBkP7xAuMAZRCvBCBynvmw1E8BNnxw/XFiPv9BX6b9GqPLAVlPuvUMjgL5UX+FAYL66QLq15D/vQtxA2ANcQLA+IcEK9etAaNnaQAa9jb09c+I+Nc00wfJ1ikAcMo4+dvEfwEhJuMB1FAHBY09uQICP5EAGXvPAwjY+P2LIWUCOf1NAojP4wPvZCsDPnwbB5Py/QJjrcL72AhLAoCfiQK+p6cC3h4xA9r++wBsq7kATpqBAt595QPwa/cDL7nVA09IIwBrEy0CyTslAgX76wNzXBcH/07w/ob/iQAoZ2b9kzjC/xjKtwLsbm8DU2Nw+LRnxPzLKUz+e8CPBH/UHwFtaxUCTbwZBxNwlwVFkE8H2x82/9eUbwUtUBsHRWTvACxavwPak7cAN3zTBQ1LUQCpeyMBpQgbB4nXsQKbQ/cCvdIzA6TyuQENS30AfWRTBkv7NwKcQJMHN0SrAYi2zQMoJvkADQa+/FRefQAlUFUAB0ZA/gOf4wPC7J8D+kI0/Ov57QLdaJsFYJMw/2y31wOZ0gUBAxKhAfA5yQB5nykA/9YZABl2HwDtBJsFlr6DAtGvMPv8Fvr9Yj6A7OFMov4r/UUBzwBHBWwNgQDxh58BkZT8/QK+AQGtMtkCssdvAP902QNvp+sCrDmzAGzfmv1Mmo0A/mic/0smJQNWkEcHh5xBAFmRVwBo6uT+RysNABTLQQFDIQMBrbJhAqtSCQKiugL88AKZAcxg9wa0Cmb/bqLDAzBcMwYrFCMAP5d2/fprCwA+orMDWEwfBs/RUwL3GRMD5zDhATr+kQBci7L8jVsHATkoEwagW0Dx6vG9AG7N4PzTlWMCwLdNA8kSJP4WFjz+jYOvA2DLHwJwyx8BwHI7AfW26QJCkYz6HfmdAUrwTvnYtB8HFLfTASY+9QDyY5sBUuUdAGYa3wN8qCcEB5sk/um6NQLNAvMDY8tE/seUfQBQS/8D0B9HACT/SwGlIC0E=", + "encoding": "base64", + "path": [ + "y", + 42, + "data" + ] + }, + { + "data": "bFdfQFUCKUEUe8tAPtWSwK+HuECwej4/PSq4QMVmaUB0GfBAi4zwQGp4uECBDvZAAdMRwSZuFMFdgb1Ao9hDQICygMCWziXB+XnhP9EQs8CPkD/Aa+kXP3GyKkCkvrTAK/naP7ed9T+KnrhAcigyQMDefEAGy4xAlfHyQOZ6PcH+IRdBTdOdQOCuFkD0efU/hPhFwV194UBZ6B1A7CO5wGhYA8G0awrBqeiiQJcr0EDHFcvAHpYWQOsRrEBvN6JAwaC+wLLxqMBlCg3BzH2gQKkWl0A18qDAwEPLQLW8U8DqxcI/TjaMv1TE00CSg9FARnenQMMMmsDU7ws/bQ5DQPaU50D4UnRAPOsYwaNuHcFw4sdAi4y3QNjLHD/IybM/rFA0vzIWRz8/xTtAkTJzQE6kMUC1Xh/BNZVSQHMHe0CEphFBPn9AwU/FEsHq5ZDALN0WwV7rEsHyx6K/qu51wHD6AsGKkDLBKuQKQcxK98BvJR/BUE/dQOkCHcHW0ejAzm3bQDqWAEGVAQvBBLEMwMo/J8GdPAq/FdJ2QCwR6UBQzpo9+P8mQHjak0AVgcdA0gJYwLEyjb+FmktABg6sQKy0McHFX2JA2tcUweE8wEDdhQ9B1pGWQAaTjkDJnM1ApyczwKQ0IcHixmTAGWceQDcEmz5sxr4/qh2JQIzXpb6QWBnBAICvQNgPCMGeVCtAKIulQGh06EDJL6vA9YCTQLGpGcFjwLrAhloHPpvOBEF2CCRADZG9QDjtIcGNNLW/RMbMwGciQUDfTNFAwwS8QLKAt8C4N81A0XzHQCCagkDXZSBA1U5BwUBqREARUfvA9QEWwZxIBT6L35fARDeSwDgKub0ED9zAcMRiP4Xppr9dhpZAr9fcQH1EWECNUAjB5FsQwSwaUcDCG6xAuAT0v0aH3j8R4w5BK709QBQVHUCVEqrADTWZwBNbzL8yYTbAZSZNQBYIBkD1ILlAGiXVPz9uHMHzG7/AVoyvQKj7CsECVKJA9I6bwMdMEMFWcHRAlJ4AQfOiosA1ndNATEKYQMUOCcFEqq7AXsQOwTuuGUE=", + "encoding": "base64", + "path": [ + "y", + 43, + "data" + ] + }, + { + "data": "3WqxQAm0I0Guaf5A0ZL4wBO+XEDLLjRA2sDpQOBv+EBFIapAMLoIQfwOtkASQttABMEUwal1DcFCfBZB7hShQLnFB8BhlwjBRwJxQHt5BcFnt8jAMoYRQE7ywUD9JVzA7iJdQLZwf0ByCSpAcFVmv5Y7vEAM2XE/I1MdQXwQRcHNCB1BmgH0P7uLkUBTVVFA7bhBwZDmAUG9hpBAx3sIwZBNHsGmGfzASraqQPmIe0A7+ZnA0md2QHzA3ECk9M5AUnzBvynp+8D66fXATAsaQME+A0EIJuvAzUCBQNTq7j+l3M6/jWGHQKNshUC7pfBAVwnDQKh/sj6TCjjAQY3vQOGG50B8RxI/lbUjwaOkIMGTQBtBdytAQHI8OUD9fVpAt8CIQFFExUCpB6lAJsOtQBrLkkB4u/jAkhfyQNzYQT94SQFBZ95GwWPu68DQ0+DA2OPowEpaCsFFCuA+yH4AwCqm/sCUihfBeUUSQdtOB8FRUSbBjNOPQKN2KcES3RfBCKHzQBi6AkEKjMDA3hIwQDZmEcGYd84/1TaXP7dj7UASJsI/KEhJvhVJ0kC1Dh1BzTwXQMRa7j45LaNAqk/OQL9gKMEJHaVA2wcgwYML7kAA3SxBpzeXQBRQ3D/OOQJBUlWfv614AsGLfPy/qgqLQGPuBEDryDlAovL5QLUUe8DxewXB4QzjQGITDsFYP49AsGu6QDtUBEHTamTA5DPAQDleJcE2G/DADGgDQEUKGkGkRIpAd+XiQGZJHsFT3J3A794NwZAljEC1MrJA+uVgQHsF/sDlQfRARyX/QHdyA0FztDK/0UsrwZVGyEBtfhfBqZwKwXkJGUDydunASlM2wJ3tqkAwkTjAX7GeQJJOBj+6E8dAXcL5QMQU8UC30iPBbSUMwZFxx8Bync1AGhWUwOFszUAUQhhB2LCVQCTFYkBwUEDAofxJwKfnbEBzh5G/OegLvtv8dUD/2PJAUfNYQARgIMFARw7AN1JWQDpnE8F8n9hAf5NuwIMG/MAYe7tAftMcQch5gcCuMB9B453QQMN8/MBoz4PAf2wnwX4xC0E=", + "encoding": "base64", + "path": [ + "y", + 44, + "data" + ] + }, + { + "data": "inniQJ5RBkE9QghBMxAlwVvUID8D3JZAjSEAQS54IkHbwAFAIeMGQX0ZbkBnZoRAzKsBwaEa0cBdcC9B2SXTQKj9Br7K8I7A75qyQKG6JcGhuw/BWEd0QB3O+0CmIIm/HMSgQDQBu0CCtYq/FyWQwGyw7ED+zirAXUUkQaMJM8EaRg5BYFazv0DAw0DqT4xA3YEiwRn6/EAmEMlAKJQowYFqKcGJ+KHAQ5pxQDAVBT9j0EXAH8akQKp39kBvzOhA36ZzQC10HMHUUYfA6pUuv1DIHUGp/RDBhQRwP1EJ00AeqpPAcFUGQffEYj9LKvZA36bGQHVasEAuS8HAJvMnQRsfv0DYdzHAwK8XwT3+BsFW7jdB+G5NvgGYoUC4VKVAV9kEQUUnHUE5cOpA/3rPQBqUxEDw92HAoRccQaz3IsB8j7lAJks0wTVhVsAn+w3Bv5JSwM7ex8C3HwhAZMKRvVGpwsBgO7bAKvgGQS16AsG3mRXBK/9rP+TZHcF0wC3BA/zpQMcq2kCgaK6/GvzhQINLssDbXWxANLPWv/z+rkAdRzhAKzBAwKYW/UC4cDhBWF/rQBXjAECrzNdAuyHfQIrOAsF0sMJAhfMWwSfB/0D9DixBkghMQKQvoL9v/xBB0Py5Pjdxf8CVaJW+M1O3QNmJcEAnaYVAbUMZQSmj5MAaRJ3AurcBQWut/cDMEsFAuTe1QKepBkHnqM+/GGDaQOatGsGb3QfBJmt1QDKwFkEQE7lA42PyQHjn/8DJIP/AHTIpwU1Oq0Cv+z9Aeu3oPnMfF8Hr5wNBhMURQd0kLUHFpnbAcTzwwGi+/kDqJyLBjK2/wHA+kUCFdxPBvj+AvyyjFEFCASFAbfgBQQw6FUCSk+hA6qLlQNkCHUFaYy/BBSDjwOIqCsHjBs5AlaXgwAKAHEHEKAxBIHPCQDwYg0CRigy/laWzv+TjAUHJDh8/6K5fwDZAq0B2Mg1BEqydQP6RDcFeQB1Am4/tPgXuBcG5WAFBxLwawJr+kcANAvFAbHMiQWFxNcANMTZBzJLoQMD3oMDr2CbAi2wvwaagz0A=", + "encoding": "base64", + "path": [ + "y", + 45, + "data" + ] + }, + { + "data": "e0f0QE2EqUD4P/BAythBwbwgEcC/nsdAlxXoQOHZLkHEq8e/QcXTQH/VJT9BzcI+kZmcwETbCcDrli9BC7/sQJtL7j+M37c/17jiQPmRN8GpQS/BQsiiQKalBkHgZ6w/i8nJQH1H6kDORpfA9CP3wFWOA0Ebs8HAXA0VQQWjBcHcDd1A1S2TwM+uzkCuaaNArUHNwD+c1ECx5fJAy6o5weiUH8E+BfS+SgqjP6kCP8CE66C/jaHEQLd070B+ReVAqnYEQYBfLcHyPl4/BUxuwBNvIUHIiR/BWnATwH4BIEGioejA/F0sQe93IsBVWtlAfhqnQJuSE0FTMwzBo8U8QRcWV0C/Z7zAGSDYwGOKmMB8FzhB5N1ZwJtq30BKHcxAB7ksQb/+N0HgCQ5B3RzOQCDn6ECA5+I/sDAjQczos8DaHyhAHkEFwVRh6z+cKR3Bu/zGP+kRAsBnl21ADSjvPyb9zr9aw9q9XOnYQJ3Px8CXLcrAwwk1wHH648CzvTLB+4KuQOfAa0BfYHJAsv4fQeR5lr7aAbNAwe+MwJfjAEDoqIJALviywOBhA0G40jdBwmEpQYAxXkAmAv9AEN7WQIdNesBAKbVAsbXhwFPa5kD5HBNBrH8uP0/ig8AvtwxBYh36Pw7f4j8qNbM/OE7FQNg1qEDgoqZAW4YfQWvnHMHY2ii9bzgDQYL2mMC+VuZAfxKJQI7G50CIOsw+YXPYQPdq4MBPFQjBMgOpQPqo/kCvA9hA1XviQNx7hsAsgyXBLpY1wVr4tEA4nkO+IZwrwIfJIMGvPgBBjm8WQYAuOkEcGdfA5Q8twJSYBkGiLBjBsHavvwc6zkA/oyXBrNhjP3gONkEBHOdAa0oiQZBLgUDXmvNATr6SQHIxJ0F5jiXBIsJhwJRWJMGBH55ARSsPwetKOUHvqdxAzrLfQNqGaEC4bfc/cwHOPvrqMEHprxZAoGTSwA1Vz0CSdxNB8MbEQBUeucCjDtJAnj0gwLBercCKjA1BeACAv7dcQz4KgglBqrEVQX1swL9NsDNBs1zKQMhiw7xPj36/kjshwe9eVUA=", + "encoding": "base64", + "path": [ + "y", + 46, + "data" + ] + }, + { + "data": "GsDSQMC1nD9ISp1APp5QwYRUoMCQweBAhymUQGgLJkE2maDAFVFXQETaI8C4YF7AMP3yvLeCPkDzrRtBiQPcQJSxb0D3S91Ar90BQQShN8HXOEDBz428QCxo/UAedGxAtOzkQHxPA0Gxhv/ASkQmwXTz/UCP/A/BrcznQI5CgMAM+IBAoWbvwNe5p0BRiqdA6fWbvzpHkEA2QQNBB503wRbP8MCrXYpA77S0v0UayMDtMB8/fifWQIJmwEDS6rZAwUA3Qc5uLcG6YrlAkLzPwBdAEkE0rRzBtmyrwDKHO0ESJhfBO7k2QYjRt8CM1ZVAV29DQCBONEFhsS7B34M1Qdw6Dz59YwnBMMgOwMhaNz4TRh9Be77LwLlVCUE35NBARL83QTV9OUGF3BpBXp+WQGiM90BfVtRAQnMVQaxuBMFTG4C/6sR0wFXU0UC3qBjBHyPCQKV9MkCDsqJArTxtQGa1cEBhGLFA7Q6KQH2uB8BJYtS/yn7KwPiWJ8An+SHBsScXQBOmer7r7P9ATVMzQbUrpECC2eVAu7vawAEs5r+rEKFAkXb6wPGf3UC1fyBBjl8+Qb1cmED3LAlByZKsQA91zj8e/WlAAaMswBh0nEDKaM1AZtL6v33S1cBz8d1A4YVcQLXt3kBkSEJAgjKkQFmXzkChWr1A7WoTQVSCPMGBNJxA1PveQOCQsT4Q4vdAsk3nP1sTjEAzjxlAMTmwQPRcG8C4it/AATrCQCA9rkC9zt1AqDqqQGCpNj8qRD7BczwvwcgbnEAH0ljAY7uzwNU3F8Fpi9VAPvMIQYT/K0EvoRLBdys2QLpg+UAY9d/AUrlvQGrj/UDXHCjBMwgvQBpHPkGogSdBcfQtQfYmskDAc95AUx+FP+J7HEEfUvvArtqdPxGWLsFS0xNAtkMkwVgxO0G/G4NAXE3mQLYiBEAg7olAOzMMQJ39REEPNX9AWHsTwS6/4UC5WAZBECLcQPwblr+4FhhBufiowJtgDL+G5wxBSF/sPjQ8nkAsSwpBWL/xQNT7170bThxBVKd5QHJspEDxvSc/IKLnwJ4Xvb4=", + "encoding": "base64", + "path": [ + "y", + 47, + "data" + ] + }, + { + "data": "omyAQJlxRcBkicg/z6NOwe157sD64MtAZCyIP+6qCkFn2AHBkXXUvqb1scCk7ODAz1edQG7I7ECFLO1A2ySWQHLpqkCFBixBtkAHQSLZIMGxPT/BRqW+QMuG0ECGabpApWTrQOzyAkGeZyvBvUlGwfkxwEDR1jXBRESIQOzmnT/Ou/I+nYsewQuiSEDVxJFAmbGJQC531z+QFvpAyvUbwdyxR8BgOgNBKNx/wCPAEcE5ch5AmovSQHh4YkBYWUBAh+BSQQiXF8GYQxhBWr8NwTk25UCFeQDBVJcAwU8DPEGbdjDB6b0qQe96CMH8iOY/MZevPkHcPkGkVEbBeDwWQVe2R8C4ySvBSo07QIB1o0Ds/eFAMAcPwXCYG0FEUp1AH7YoQb2zJkGv6hVBDHXyP32n4kCydiFBgdjtQNkWJsHqwYjAQWvIP+z9HUH6ZPHAmaYWQaeV30D2k8JAyEyqQK/mBEHV0BdBag+ZP4AoOEBFJV1AO/IVwT2YJUCX1efAX/SNv1awhcCZoClBse4pQS3XE0GHbQRBv70Nwfq0rsA5ebNAom0ZwVykg0CxAOxABB86QZIkuUBCJwRB2og8QFTf00Cg6ns/xSseQCDV2j/SYyxANyqOwCWFDMFULHVAQGKXQDISJ0GhPpFAGWI7QCwe5kAQUsVAAQHuQMQ0T8GwyAtBt9SJQMrgr0DFOepAZQV/v1EeEz+vlohA6FlLQF9hOUD3zUvA7gO2QHQ9BUD8or5AlCAhQCPirkCRGEfBn9UPwbZSOECSdcrAPyIDwXVt5MCzFoNA2jnLQOQnB0G3MjHBujnsQJBCx0DZLx3A49D+QMTmC0GiGRbBUkGNQGTjMUEbBkJBjh8iQTHi2UDRf6BAzooqwBYAAEEkc1rAL+62QNoAJMFrgim/K4wsweMaJEFOOhY/UIvNQK64zT1glc1AxBR4QAUVQEHBxa1AWfQ0wVLj20BohcFA4nrbQALWcUDQLTFB1A/3wBmAkkB6bvJAyk3zP1YYC0HjN+BARxCbQN3dpT+F4eVAyHhnP9ySFEE33BFAM9ocwFTyeMA=", + "encoding": "base64", + "path": [ + "y", + 48, + "data" + ] + }, + { + "data": "PbBTP6vXr8CTM/u/JY03wSCfF8GtB3BA3YYqwIrFvEBSLivBEZmFwItOA8G8miHBLOcNQYjHJkHGUIVAJ4bSP+xpykBRTExBeRD5QM2g2cB+RCfBqsaeQFvuiUCpaPFAZ0LTQMl02kBK/0zBhuJZwX3MMEB/cFDBN6QdP0x7w0Dn+kLA/0Q8wVcUMz+X8j9ANpsIQUJgvL8Yo8NA5THCwGjhC0Bk1ipB9Q/LwGXlNsHhDodAwAmwQDFUID+4H0++dZhVQTfVyMA9kDpBj6grwRKTiEDnFoTAbXEjwRV/JUEpPz7BHsMLQTIkLMGgQae/SjMbwCFoNkExDlHBGEPFQFMfxMA3eEPB5DntQNl3D0HJa0NAQhMwwTC6I0EjVANAHf4DQcePAkH9X/BAHSSYv4AsmEBvAzxBZRqVQPkdPcHpNrPAPpHPQEXaNkEB73LASrAyQUn6HUGH3c1AjtfRQNgmOUEaEDZBEV0IwA0X6EAA7/lAS109wZaD5kBd9iXAQ6+PwPvY98DecDVBgBQJQYtjOEF+nQlB6wImwU/aC8FAxrRAkyEswQC0Jj9wwG1AM4YhQbQ3zUBjcdNAoN35vD38HkF8due/+2njQNPj17/pHsW/U3jUwOWeJMGa2lM+0tO0QOpGQkGEBbpAPmmfPul45kDm2rhASVeXQJOkUsF4Oi9BFuNvP4UnGUEDIK1AKuFtwEnmVcBsqLtAsPbGPvrV8EB6nOg/L5V2QKKc2r/2CW5AlLsnvx10EEEIZDzBvmGhwAyxrj5A6g3B4u0kwTmcOcBfrFI/ZhZHQKEjn0AAi0XBPVIcQRaDdEA3oDdAScIqQS4qB0HBKM/AAkS4QEVrE0HQPEZBnGr6QOX480DU0glAvhvFwPHvp0D8Nvw/138RQSQR+8Ch1mXAkCkjwcCS70DFEz3ALF+PQATb8b+tEgFBhfeqQCqlJUEx7dFAi+lLwdNHt0A5ZShApaC3QJ16/EB2PDJBiZEbwcjIC0FdOZdAiGFPQKdEL0F6Y2RAfpOsPxObJ0AOrGhAtU8MwJwLQUFgqnNA4XZGQF9Yr8A=", + "encoding": "base64", + "path": [ + "y", + 49, + "data" + ] + }, + { + "data": "PboPP6g74T6Bw9W+XkQkv/ehD765aQ4/ukzFPdOAiT4rzde+SuYTvwswnT5cVha/KKCbvpSJC75D5t4+GzEivpQPmj9oSL8/89PDvthWdb8lWVU+S9FJv5r/Tz9egHm/zUuvvdWAFz/D05S9I92RPo/ruT2X6e4+7MHrvqZUcz598OA+3UqivpN2hj/tpgrAwhjIvcJ0SD4v/bO/jdv+vqBKYL6nDmE/UX+SvgEydz/Mmbw/4MUHv1bZ/j7eB8O/9XtNvnbJlL5i//E+B5kKP/FrtD45IT6+P0VHP7KrnT8//9g+5k/RPdgSXz+lQ00/SThPPz9gjD/ke4Y+4iMSv8qlSD6lMje9rMc/P4pKhD48NNU+MwSlvqIIrj+j9Nm+UEFRPwcIsT+ydSa/93DKvngCl78Td1S/1+cOP4tUpr6+stS+PHqYvwAZHb5lBwI/7nA3P8GNTr++ITi/G+uKv/nwAb/itxm/R8aHP/azNL6vSAA+/2YjPpXh6j5B60K+NWoPP/6AeD1FPUq9ZffVvpQ7Y77m9uS+eU2VPoMfSD+j+me/bgoPPbhUwL3m3Mg+kld1P9vvBr8WNZG/UqnyPm+uNzxeNYO8e80jP2pKij5UV6o+H/prvlStJL/dUm+8VkVwvo/OOz5Xn9E+tesTP0f4lL8mQFe/1wwrP1jl9T7GP7a+sIeiPQa7UL7TbV++lBNyPwyJ2L4bSaa/0xXCPcGkuL3GRDS/fW4dP0owq75lcCk/mWw1P5IdSL7Qizi+IszXvh1s2j7IoFO+6VmQPuaMjr4qzBu/OkBWvcMrm77tek49zsShvnV/PL7mr4i++Lm4PaiKxL46NoY+P8UCvxVCFL4zOGM/1E4Gv7v4Lj92UJY8BVmWPv2tg755FRU/sx0BPx86Fz8Dnl8+KRsVQOr2dz2I7/k+C6lwv62EWj69M6K+QJ0Xvw6HSL9yFZ4+9JWCvnQ4kr/N8Tg/KGOhv4qJgTxmXLs+yIjzPu76lj4hb1m/131vv9Qp4b5SIoa/o9fAPUpJxL94DJ++ZM9Yv2KK2T4RSJw+lzg6vsOstj4=", + "encoding": "base64", + "path": [ + "z", + 0, + "data" + ] + }, + { + "data": "6lU7QHccRkCWsjBAC1wuQPflSkCPjVhAnFIvQEJCXkA/yy1A1RU6QEB4d0AjbENAIFFfQNPaP0DXg1VAU9ZNQPYPjEDe6JFAnE46QJIvJEBMvVlAdzkWQEPzb0A76ihA4XBCQL4uU0B/LD5AzVdXQGT1OUBE9UVA1PstQBr9YEBdf0ZA3tpCQMWZcUAL1Zs/FI41QLaiTUBk2Pc/r5gsQCGnVEBhiotAG5JAQG4gfkBs+JhA8AgmQOKvRECK+N8/FFweQDkZWkBn42FAgj9bQITMdkCCnSZAKPpvQC4/b0C7cVFAWI5qQNBBZkDbPWJAk1BnQK+sVEBxbEpAr9I7QPhYWEBCS1RAiMxtQK4tTUBIoUpAMFZFQM1CmUCv1zVA7rBLQKXRjEB0+zlATQZcQD4r+T9f+SNAlhGBQA7qMkAF0VNATkH4P1aJWEAj3GFAtZM/QIGvMUB7wTVAHYEVQDF6KkD+qCtAavdtQNgUJ0BKTV9AZYJKQDi4N0DeKE1AuSRsQK3aLkCKc1ZAKpY1QEPrQ0BQ9ytAsadmQEi+jkCyDSxAPWdgQNBtRUD1LldAIYqBQDtaMkAKWwFAqpI9QGfDYUCm+E5ACmp7QC2aWUDwXlxAh/EdQNecLED0qRdAJyw1QF4EdUA6xUZAKAZeQJHI+z+WVDBAs1OCQBtGV0AiJTRA1KQyQEsUW0C7rRlAFuVgQC9HFkDvvBFAJ18wQHzlQkAxog5AdbpCQCrKTkDuFGdAv6pjQNxDW0CsUytA7rYuQPCsSEBbcyNAObhPQB4oWEDAyQ5AK2UxQFjfNEDqd1dA6VU3QHsCOEBlc0FAE/g1QOmfR0CQsDxAbTQzQA9DB0DC2oNAVh8AQDc3gkD5siVAGRODQMqeUkC1sXZAvi5BQFTqckALTG5AKz2lQNuQQkDOB1ZA/zZaQIEDZkARokxAdms9QOj6GUCl/lVAwWRCQJYeKkAzhFlAZWP+PyFsZ0CkPUpA9WhPQGRYQkA3gjhAqtwtQIbTO0C0fChAPww6QI3Q4D9ptSNAyTQOQKTlWkDxYD5AbkpcQJ+ocUA=", + "encoding": "base64", + "path": [ + "z", + 1, + "data" + ] + }, + { + "data": "aj+gQPmvpUDyBrJAuEK5QDc7ukCh5a5ADx6iQF3quEB4ybhATKa/QFsZ0EBuscRAmsnQQATutUDhP7BA/ZO9QFUz2EA0UtlA/DC8QLeAu0ASYrRAY2mmQGkuvEDgXrtA2xm2QEkYqUCNbrFAUOe2QBDyqECdCalAajCmQESjvUCtLaRAZJa9QAxku0CUCI5A+bCoQP9SskCmJqZAOMa4QE4Kv0DhVeJA6Vq5QFf5u0DC6OlAYYCpQAEfpkD5QZdAYtKbQArLxUCvVrBAw76sQBSEzkAT1qxA0xWzQDD3qUA056xAqRzRQG1nqkD08bJAFmeuQFCom0AO0q9Asjm/QPAQtkBMCrtA3DC2QM4gskAQC6xAzN69QCvG60DjZ7JACxOgQAhQ00BuC8BAI07KQO9Hm0BEg7ZAUIPQQAHTtUDcUMdAPWWYQMVdv0BHaLpACFWbQLeexEC8scBAAxOtQBWCrEDWvrFAnV+zQH6TokC398BA4S6yQOLKoUB9ub1AWEi3QNceokC/AbxAhs62QCs0u0CsFLRA7ba5QEfx50CUUbtAH2q8QN61tkDsOrBAWJXJQEaotUBkr6NAahahQF5fykAoVrpAaVHGQG1XtEC7DLpAIKSfQMNoukBCyJRAbTivQCcy1UDxvKlAZi22QH2Rn0Ah9LxAFNDQQOwerUBARLRAZjasQHbTxUCgHaFARM2pQBmInECXQbVAMeafQKBqt0C0tZxAxmGhQEOQwkBRILNAYYK3QE0Wx0DrQLBADMe6QMQ3q0D73KhAE0awQEjtw0AwF5hA6oumQFharUAic7lAT7+1QAgNqkD6artAe1yrQBrPwEB/EqxADUK8QAV3hUB288tAn8eIQF0i1UB5maJA7CbcQE06x0B8OcJATs6hQHHqv0DyiMVAYQvmQFTDrEB8yK5AvITeQJaTykCwHMZAtG2+QHbLnkAhB7hAu527QLdWyEBDtadA5mqfQI7iyUA/JqtAmFirQH1hqECuY8NAmMK+QP3vvkDkAb9A/BuhQAp+mECu5ptAp52hQFgzuECYHadAMb7CQOpuzEA=", + "encoding": "base64", + "path": [ + "z", + 2, + "data" + ] + }, + { + "data": "/9zaQF331kBJ6/VAeMr9QHk570ARrd1AxRfeQEBY40C8Ef5AwvQAQdJ2AUGw9AFB+d8HQSuw8kCOH9dAn8PzQMZQBEHnygBBUdsAQZaKAkEGE+ZARQjzQNzv4kDbTwRBrJb2QCsF2kBJlvFAmZvpQFZN6EDrhOlAkkzVQByZ7kAYR85AyqP3QPkT6EDBkOdA6S7fQPKa4kCOwgBBexj9QI376kA9WA1BGQf3QFec2UDxSw9B9UbvQC7g10BKMOdAbZTQQCwF9EBeb99AIqneQJT390C+t/pALWDZQNsTzEDlKudA0wMGQYce10AoXd9AbEDXQGqOwkAld+tAFSL8QHy65kAnKetALrreQAnF60BRSOBAXxXyQP4NEEEbqPJAeOLPQGht90CJwANBKn39QBaf6ECSYf9A5sr8QFbc+kCqCQBBfNPcQE/b6kAixupA3vrMQFQlBkE2BAFBZuT8QAA57UBBi/JAAl/VQB2w4UDqMvZAjHvoQA7G4EAVovBAac3dQNhy3UAgeuhA8V34QJ2F80BAyP5AREzjQL+YD0GaQQVB5/XlQHvR8EBVodtAWTzyQBz1+0AfhPxADkDXQHUi/kByDe5AodLrQCil40BPPelATN7gQFI/AUF7ANNAsYrwQDJgB0G/UuFAmZrnQGM+9EAtlQRBVnT3QDp15EApTfZAgYLzQLLa/UBoRO9Agm3UQKuR20B9EQVBmiPXQGaQ8kBrtN5Acw7YQPsM9EArPd5AKGPmQFrn9UCFVPtAA3v+QDsz6EAcdPNAovjoQGT570C0H9hAYM3fQNls5EDp3OpA86X3QKdv3EBpd/RAOdPtQMDf/UCYSfJAgfoCQak1tkBgn+tA/wfBQGTNBkEkE+hA2XYIQSaiAUHiselAr9zSQJ7c6EBGX/FA5iQEQWEJ4EDMvtlAQCUVQSHMA0HyuQZBZ8/5QENnz0A+3+9Ah1DzQId2DUHldtlAhkTyQFr390Cab91APCTZQG3Y3EB3qgJB0sUHQebF/UCAcARB6+XGQCuV50Dcp8pA4U3qQL/Z6UC1iulA8LDuQChH/0A=", + "encoding": "base64", + "path": [ + "z", + 3, + "data" + ] + }, + { + "data": "MFUBQV5j7kAmNQpBbMcMQbZWAkEHK/RAZjIDQX1j8EDIuQlB0Q4PQWvBB0GVxg1BbyUSQYhSBkHuJdRA93YCQdkhDUEZxQJBoI8RQTU3D0EEnAJBd5IPQbXc6kAlnBhB5EEPQShc/UDG7QhBC4kBQfrwCEEl+QhB8i/ZQBHL/kAC3NpAZWcEQazm+kC/wxNBwBP2QCoF8UCR0hhBwPgIQZGV+0CC5xZBZCgGQc/m50B4YhlB+QwMQYKM80DNDA9B7C7fQEVL/EC9xQBBerMBQafI9kBiFQ9BKpnxQFf42kCrqQZBSLMMQa+d9UCuUfZA3tPwQKev0kCDIwZBQ+QFQWdn+kAE7/9AGzn4QIoHBUH5B/VAXhcBQaPXGUFm6ghBYSjoQM7t9EDMvhRB428CQRflDEHrgw1BBZsAQTIEDEFkcAhBeGgAQeiT+UD9CgBBGEPpQHgYFEHAqA5B/yQbQaBfB0GlsgdBWErdQGEFBEEMUgVBCbkAQbPYA0F96wBBWkT1QERFAUHVTvpArzsJQanLAkG/mRFBo4X7QL0eF0GH/h5BrJ76QF9cBUFQCOZAn2r5QPu7EkG6XhZBN+D4QE5uAkFvuABBLtL0QNVb+EDHC/hAhQcDQZ48EEFozvtAzLEMQZ9uD0G7pQBBbUH/QBODEkF5iBpBaVf1QJ1BBUHt3whB/oUNQTOXCUGujQ9BIO/vQGAXAEGL8xtBdrf8QFlHBEE1pgJB6Oj4QDx3/0BOoflAL2n8QAJp/EAfTw1BaB0IQQ8aBkGQSA5BTCMFQSIf+kC71AJBLbr9QIEy9UBveQFB8c4JQVOC60CxTQNBOi0JQVTpCkG3sQpB4TEXQWinyUAr2+tAwA/hQGu5FEH+ngpBezsPQQddB0F0vPVAMcLrQBWi+UDbhv9AnD4EQXFB+UBjNulAvh0pQTYdEkFKkRtBeI4JQUiEz0BpQQdBb4wCQcDiI0GUZP1AkT4SQZgg/kDnqPVA3IHvQIpM90Bqig5BNK0gQdq6B0G2hxNBU1bBQHQ7DkHk0NFATqMKQTYUAUEXhApBa276QDM8BUE=", + "encoding": "base64", + "path": [ + "z", + 4, + "data" + ] + }, + { + "data": "+EoAQXvo2UBOQP9AARcCQYAd8UC52ORAY8YAQdv7z0BAZe9At00DQQkD60B/Y/1APqT9QI4U9kBIbZBACR3rQLGsAEG4zN9AIjgHQUkHAUFXk/pARl0KQRiryEDO4RRBVBkRQf5b+0AN1v9AUazyQDcUBEHbdQBBz3CeQGgm4UBbILdAW+3rQHWn5UBzeRdBi2jgQMoH0UBgZBZBXknyQFWx7UCmKAZBu5LyQJNR1EA3Jg1BRA0JQaAy70BHtw9BPqmuQFfS4kCquf1A423/QM/6zkAT8wFBrZvmQOrBwkDaIv9AKQ7rQGzw70Bnuu1ARnnqQM8guEBtMPpAPePmQM1X40DYPu9AeJ7uQA99+kC9q9ZA+OPsQA/+DkFuRAFBAKbRQHZmykCwKQpB+HniQLSmCEG0u/9A3hbeQPTZ/UAIkO1A27LyQGYT6UAZcutAilfZQIYHBUGLgwRB7wgnQVk5+0BtcvtA3VO9QNlg/kDoMPFAcCzxQPW+/kAvb+xA43PtQCjh+0AjF+tAalf4QIWC6UA54ghBypPxQJ2NBEF7xSRB89bwQOmh9UDaL7tA1WrdQNCzEUE0DRJByQv0QA2C4EAkUOhAji/YQKRx5EBrSdhA4VL/QH2dAkG9k/lA0BEOQV8L80C/r/lAm8TuQBm9DUGzOxlBGSnQQBIeAEEepvxAFX8FQfzd+EAjhglBrsXoQAk0+kBivhlBQgX+QPwO7kBOcP9A+PjwQNMy20BIXPJA4aPsQGSN3ECZHv1AC0zqQIPjAUFWVgVBHTr8QAas5ECs7ARBXpH0QARJzUCWUPJAA+v6QFHeyUAAruxAyq//QAgL/EDAzPpA5HMTQWJqp0D/38RA3d/WQAMoD0ETEQZB2t37QNRB5UC7vtpAJ8LdQM9X6UCxZeZAfMzeQAj55kDiEtJAxiUnQVqQCUHEXxxB0VMAQaTpiUBmsANB/yPuQHEcI0FP2/xAfBwQQZao3UCFvOZAvsrfQN+o6EBrnQNB628jQe9r60CGWQhBrypsQKvrDkF3T5lAeWcDQWWu8ECSxAdB3uTlQP4j4UA=", + "encoding": "base64", + "path": [ + "z", + 5, + "data" + ] + }, + { + "data": "66m2QNsUiECU3qdAFrGxQOP+pkA+OJ5A/Cu4QHl7XUAGw5RAk4uqQEn6k0ArXpxAAu2WQNYLpEB5khO+NO+dQOo6rUBbsIFA2ue2QJrzqkCW5KtAVpPJQN2qXkBIrO5AkbT1QBzwtkBeMapAp7moQAY7ukAIU6ZATaZWPyxnjUB7ARNAu62bQN/JlEAW8PpAZrmVQJ8Ac0B8H/BAq7qaQAZsrECx8adAnQOjQOu9jUBXw8ZAjEDSQFYJtkC6xOJApiXCP/LZl0DyLrNA/yW2QF5lXEBpj6FAo+2mQCuLYkAk8qZAbyiCQP5xr0CvZbBAmx+wQJ6hNEBf5KNA2qCBQDcMmEBm6adA40CuQNoeq0C/fGhAna+kQJJy1kDv87RALwh5QPo7NUBctL1AwSqRQBCiyUCw9KJAvPKGQGsZn0A4e5BAZ9WoQADTpUByd5dAPOeMQFG3o0CYybdAnJ8dQSXUpECNTKxAgkkxQJwss0BH05tA0dipQLuRr0ARLKRAJ8KwQIQmuECHuahAe7qgQGkWmEBihrtA/SStQK8oqEDRJRJBGY2vQCPgoUBBWwZAjEmIQLxJ6UBdGt1Au+m3QCPch0BHS5pAn0KHQMQumkDaYGpAOMa+QOWUqUAGWbVAbyzqQETmhkCLAbdA3LijQAEW0kAzEvhAOkxrQNGbq0Bz2qxANRu0QKWBoECnuMNAsUitQPYYtkD9PPlAXnK+QC9Zm0DrsLNAiFWrQCBceUC6yq9A9haoQBbeiUAkZppAOZmTQCLzuUB4GbFAHYWrQMHynkBGVNBAUBuzQDGNQEBeRKVAsN+lQBzrXkC0c55AHnynQLW8pEBHh5xAxjjkQLID2z+U1T9A2WOOQHqF30D+J75ASgGeQH5CiEDykYdAuOmcQBhuokA8e5hAgLdzQHr5kUAIg4VAdxMMQXLYxUBa3wVBcKeyQFAsQz2gyMpA84yiQD+fCEFHcrdAa+XdQOnuikDOyaNAa4+bQIUXokD8vb1AlyAMQQkDkUBVMb1ASwyZv3to4EDkZfI+Wv20QOjDnUAidsdAls+hQLtvcEA=", + "encoding": "base64", + "path": [ + "z", + 6, + "data" + ] + }, + { + "data": "DGZ0P2TzkL4yiKg+wIAqPy6TVj961SI/7S2FPyQHw79ctak+MO+LPmDlqj4Yu+A8ygYVvrL1Mj8bwqHAZWA9P2jXCj+O+Jy/bnJtP1TVMD/kNhk/4dH0P569i78ysoBA0N2MQEl2kD/mROM+5jJEPzg8fD8SD4A+AquBwF4yVj7jHD7A4ffgPiD/Rz6KvItAUZklP07rHb9B93NAthX/PnaVhj9ZghI+sHRaP8skGz+8t68/XiUdQFUeAkAhK0ZAP6dkwJBsLj8Gh2k/ZItpP6+Atb/w0+c8T0WJPxzgLL+Zqqs+jwt7v0Guiz85zuI/vgC3P/E2AcDgzcE+ZMZ3v/cvUj9Y01M/NOGPP9g0Dz/45au/mEVSP4b4KEAItGE/qIXvvu6VNcCLz6U/INTEPvFG9j8SnYI+MPw0v64OpT1IzPa8vXuFP1iLZD9Ai/C7+8SePoDaAr7CLF0/H7X1QPgxEz5uaDM/GuIowOiEgz+UN38+ftdtP8R1Ej+ftl0/u6ewP1qv2z8waHA/hDflPhO1sz718l4/qExqPzlBWT6YX8dAeuWOP24J/z6L21PA/1JSv4ztYECwpidAckntP9AQl76ZhUE/3inCPcqTUz8Mr9i/eaXgPz8L5D4iy6U/g7puQOMTm7/2dLA/pD1FP8srBEBLLIBA2V5pv3FuuD6vMz4/7l1RP47KfT6ofbA/Wly3P4uGyT+n5opAQ97qP98ZAj9u4mE/9qZdPygjS79jKIg/WayoP85nMD6Y2j09BMLfPjYAiz88Huc+Rb4nPyvfVD9kKDBAirnTPxDhA8BQ1TI/HBg3P9AZcL9k6AQ/JaWoPso6/D4/A4c+3xxHQDQVUMDYGPi/wt9GPn78PEB4RbU/AKY4PZS9bL4nY2a+GD2PP8cYgj/zyA8/q+a5vzzGFr8kChu+jvSpQPlzuz/R2KxAoDVbP54OkMAf3BBAEsc0P0bApkDh8qQ/s7IvQKjCOz6bjng/NaVAP6G6Sz855eo/tUGzQI5A0r1oT5A/il21wPieUEDTVJDAyVU+P8rzwz2pcOY/FW51PyB3zb8=", + "encoding": "base64", + "path": [ + "z", + 7, + "data" + ] + }, + { + "data": "nPCQwHhBkcC/HpTAnGiVwI9Hh8B3doTAaxGPwPORtsBEcHvAcdOZwHo+gcDgAZfAp4WRwEJOg8BSJQXBlQ59wOi8lMBbkL3AMluKwDMei8BdIY/AiTBSwNOansCHgbW+ICKivsDrhsDOTpPAPEyIwIdckcBLRZDAqzPtwOgBf8DBOtjAw/eFwGUriMBltYO+6q5vwFpFkMBFK4C/i1mAwI5PhcA1d5nA1I58wB60ZsA5uYjAoR01wHivG8CIIQjAZxPuwNE8d8B6xIzAxf+RwD6kr8Ceg5PAICx+wKJDjMB9To7AfhmtwB6RhMC0EDDAfghlwNVevcCbZ4vAeTSswJkBZMAKx4jAJg+AwOBkkcCQ4rLAy9WFwBWGHcCpzJHAXKaMwMXF4sAk4HfADVB1wDuvXcC6YY/AtxWnwNqHlsAhCI3AyDdzwLSahsDWupXA4hN2wDB3oMBIt5bAZWyEQBm6nsCRvY3AUm3SwPCUhsCBsYzA87eFwMHclcDSZYHAm+RowAKmRsDnbojAurGFwDUqhsCKL5PAzBiKwFV3m8Aslf8/OmyHwBcWicAE+ufAdCuwwKdguL+3IjHAGIE8wJ8ej8Af5XLA4gZ5wKVWaMBcEcTAd4NfwC2YkcAya3DAAZuXvzu8v8C4Jm3AmPl/wKssYcCqZn2/Xa+cwJ/ck8DLfI7AWNWMwKork8CYJ4rAk8ZjwIP5U8BEZ2+9jTRLwHpIgsCE4IzA9U6JwFvinMC+kIHA+P9QwI2RdMCqe4vAoXZ1wH/Li8B6UJbAf/CMwHQXgcDqMAXA8ElCwJ1HxcDj34bAsZ+DwFsTl8Cw9IXAl1CSwMx+jMBe4YTAPtb0vyb+3MAISr/AGE6FwPVJGMB3CXXAvkqUwNMZi8Do5onADiBZwPA1ccDpQnrABD3BwAC4rsDxkYrA4V8QP613hMCQ2qw/9UeSwENH+cCSuT/AZqOFwN8gPT+7FHjApIAlwNy1dsAnKnPA6XR4wOXqgsBXP0XAKSSrPyUJjcAQRIrAbnkIwbPTr78tOP3Atk2UwCvfl8BlxFzAEOR+wJovwMA=", + "encoding": "base64", + "path": [ + "z", + 8, + "data" + ] + }, + { + "data": "AqYLwRN37sC1mwfB/cgMwXmgBMEpPgHBe6YNwXdtCMH8pu7AdKQMwdW58sD6TwTBxl31wCk+AcGu0yPBjN71wPz6DcHhKRTBfJwLwZGeBMHuQQPBc777wAXH7cCP95bA056iwNhWC8ErSQnBvNgCwdGsEMFf/P7AdG4Wwe7S5sCo2xDB5l37wKR3+sCtRJ3A/SvkwMMs4cC8DLTA6o73wBIzCMHRhAjB0N0AwYnv58CagBDBWZrzwJMJzcB1odvAugUiwST6+cAFYQnBDAgLwUkwA8HqQf/AsMQCwdbU4MBEL/7AvGkHwQcABsHeFdfAeij+wEWDCcF2t/7AS94GwTKn58BwUAXBZwEFwcVjBsFypQfBOREEwWnS38ApDw7B427lwPReHcHMTQPBmeTpwEvoA8EAa//A7u0DwXeRAsEbROrAOBH0wEGwBsHBfgPBqvvnwB4kB8HYJRTB+FO0vpXFC8FZPQXBru0OwUp7BcEpC/3ACy0FwZ4nCsGROQPB+N0AwaGj58CeTAjBDFrzwMkU8sDWtBHBtLEGweDGB8ErwjbAqUoJwUEbA8HCNhzBL/ELwZG/xMA06/LAU4TlwJPJ7sDeoPfA0kLhwGtX7MBYOBDBZQ4AwQbRA8HLJwDBu0O9wAUEFsGL9wHB0VUAwdsFCcF1wrrApdDywEXvAcGy7QjBRkoLwUGzA8GQ6BDBdGz8wHtU78DRr5DAXQ3zwIrU+sCSRgnBpN0JwT2k9MA/UwbBbPbmwAGG5MDYfPTANoDuwOdwDsHh4wbBHMQDwWThAsHnV87AmaXiwBPIDsFBQwHBBWL9wPuc5cDE2/3ALzcFwXBwBsEmyPTAdmvSwPJbFcEe+wvBdpDuwNus5sC28wXBHgwDwTRs58D8jOvA+gbjwE5e/sB23PHAkaQWwcORDcFpw+XAwq+OwEIyDcFV7UbAaAYRwdiwHsEA2PbAUcECwYSrgMD5bgTBlunswPZq5MAjlvDAvDjxwFITAsHDvOnApw9UwHPk8MDQIwvB0kMhwY2nucCExx/BjCkKwXJPA8GmfAHBpzQDwQl+C8E=", + "encoding": "base64", + "path": [ + "z", + 9, + "data" + ] + }, + { + "data": "Jw06wRJUEcF+kTTBZOQ6wUCMMcE01TLBz6k/wc6fIcFqnCTBNo06wSw6J8E46yrBIR4fwSqCMcGlOi7B+mwnwZyWQ8F4VTbBXlZCwUFpMsE6JSzBlUE5wQRPCsGunAfB7doQwZrQQsEp2TbBbgMvwQxARsHgfifBjT0hwfGhGMF56x/B0CsrwY+4KMEN/g3BLZQXwZA3BMHTJRfBG3crwWHeN8EbxDLBCrkywSJiIsHs4kzBHr05wRzYGcFsoCrBEwE6wZTiLsESUTbBGEs2wRLJGsEPkybBMn4zwXWuDcGkRyjBEyckwVn9NMHKeh7BZmo2wQG3IsGbMCrBTDsjwYrDIcGlPDLBurc3wQtFMMGVbyHBHwMywSQJK8G0i0LBbKUQwf5ZNMEkDznB5jkgwWfnPsFspCTBUN0ewbu/J8HHMwzBHZAkwYqmNsFi6ivBf0UawfOsKsFtw0zBeTeawAf2M8FumjDBLskeweFTNMG72ybBOdE0wczUNMHHqTPBUog3wU8FKMGL0jfBQoscwbZwHsG/OUnB/z4zwaoZL8FEa+bAs2w4wehaM8GBVS/BWi4rwVLVIcEszjfBu2kpwQ3gF8GiYy/BOCsWwe5lJcG+qyfBQdw3wXblLMGDbzTBaWEewUowOMGs+jvB0XgzwVEbR8HcgB7BRUMSwayMKMGROjfBz+4+wSsQK8HvoUjBnd40wWChLcGCpwbBFg8ywXcQLcG97DbB/JlAwTfEEcG+DT3Br+olwadDHMH+gCPBaUAnwc6iRcHcBy/B6LAtwUKQM8FSyx/BUrokwR4YJsEW5y3BxYgpwbSkBsHWryzBEqAvwQXEOMFi1ifBNccnwSDPKcEvvSTBp+kawWVeM8EYQj7BLF0twUAZEMFaehnBIy8dwf3UMcHJxCXBhYw7wckILsHETgzBdcYKwXBXRcGx/OHAUS5KwZTYLcFgkTnB58MwwWXUAcFWeTrBFyo1wVfGGsGBJyHBOdMjwYL6McEm/CzBSfPvwFgvH8GWpz3BgzgmwQNFGsFCxSzBZXw3wcjfJ8GzDz/BNtw0werfHcE=", + "encoding": "base64", + "path": [ + "z", + 10, + "data" + ] + }, + { + "data": "ap1Wwf9bFsHCplHB3JVVwXVxS8EwnFfB4PZfwRJfKMHW7UXByJpWwS1ISMHXI0PBX/A2wfTYUMGTkyTBffVFwZYqbMEXrEbBxH1pwbvJT8HbS0bB1uhlwRWJCsFhuTjB0zRDwXEIasFuhVHBXp5JwXhPasGxREPB1Q4XwVp0LsFw9BnBM+hJwXw9RsFqf0DBE9wswRomA8FDRUbBG31MwapdUsH5tEzBxvNTwedRQsED6HrBySZowSO+P8GaM1fBYTc/wbaIT8FLv0/Bu5pOwWyJH8EFEkLBPoxQwdc5G8FAOkXBpQ0uwY2lT8Fm/EPBf9FcwR+CLMHrXUfBEKsrwdFkQsF2TUzBfbpVwd8SSMFIPyfBF75MwQ7xV8HQBWjBGvYcwd6jN8FJ9F7BINA+wXaiZ8EUFjfBSKElwazOP8EZhgvBV9g8wTbTUcHrhUTBtv4tweGuP8EHn3bBrcMKwV+0ScHqXUrBhh4awTCPUMEECD/B7UpSwfuKS8EzFFHBDYdZwRYGTsE1/VLBBwErwfCqNMEdDXHBmq5LwfqnR8E0By3B7GxSwcFbVcE34S3B/BQ3wTibVMFt8GPBAARSwTnUKcHjqVLByxguwbc4R8GSJCnBqB9ewQm+RsFxBVjBWJpRwW77R8GwamnBkxxZwWN2c8FKIlLBoVwZwYBzQsEmHFHBsw9hwVnfQsG0RG/BoolbwVIKVMFGUzrBm7xawbaoTcENPlDB4RNpwUO0FMHDjmTBWbpKwcFBOMGNj0DBjYZLwfpNbMF5MUbBvXtHwfjfT8GyfUvBgilKwTPHKMGSiUrB7gFDwfkWB8GRYEvBr45JwQ3JXcGs7EjBDqNZwQNILMG71y/B/kEswXRyZMHpfGTBEv1JwYagGsEczy/BsHI4wYtnUsFoAkXB/AVRwfjEOcFJkxHBHmk/wab2bMFhliXBt811wf4LKsHlT2nBhAlMwcdTNsG7XF7BOd1jwQPANcH+/jbBZYlAwTZvUMG1t1bBDw4xwTv1OMEw6F/BNlQXwZBSTcFVriXBXIxUwXTUO8HT1W/BeTRSwQAjGME=", + "encoding": "base64", + "path": [ + "z", + 11, + "data" + ] + }, + { + "data": "bZBiwexWBMFxE1/B12ZdwVx3VMES+G/BokFwwTgDHMFFelnBd4dgwYCyWcETVk3B3rxAwSW4XcFPzgXBXERWwRYlhMGpp0XBTNiAwVimXMHt31LBLdSBwR4k78C1LV7BXxBoweLXgMESGFnB5fJTwWIBfsER2lHB1lDtwARHNMGhOvzAMWBYwZAqVcG4KmXByBEywXR12cDg3WbBVRhcwd2DWcFcs1bBnYRkwTBVUsGv2I3B7iCDwcdHV8E1rXLBgJ4xwV8sXcEYS1fB3k9WwfWyEMEuqlDBVhlcwc90FsGiKFXBkd0kwTbsWMHsHlvBGpVxwWmiJsHy61XBIyYfwdZRVcFTJFXB66lgwQARUMFlxRfBc/RVwW1FdsH8Tn/Bnk4VwUdKJ8ESKXXBvhhRwf5jgMF4CTfBiUwYwTo+SsE/O+TALY1DwQD3WMHtqUzBZ/wtwe1mR8EhU4nB4QU9wWnMTcHQWlPBmbcAwXuPWsGRP0bBJmFewZdIUcF/nlvBK4towaPIYsHsxVrBxjMkweSmO8ElGoXBXodTwcM0UsG6IVrBLppZwfAcacGyFRfBkc8vwbVlesHqo37BvIRrwXj/LMEsGGTBvVU3wYglW8FgARTBAelywVYGUsE3GWrBkDB4wemARsESS4XBlv1wwdkliMEDcHfBOpgNwfuCUMHNRFfBXEJywdcZS8FfPYPBba1xwTlQacG4jmLBQ99ywbp+XcHbIVjBXb+BwRK8AcEx4nzBVR1hwfRiRMF2mE/BJP1ewZGigcGEfE/Bep9SwdLOWMH8A2fBt4dgwVihFcHIpFfB7thLwWH15sBtjlnBaQlUwaLxdcG7OlrBj5x+wYoVHMEWEizBumEpwVdug8GrVXnB7Q9ZwTglEsGQ/jfB6mpCwej4YMFaT1bBQQZYwZWYMMEdgQHBKZpkwe+WgsHklU7BxFiKwQb2EcG2tIXBbfVVwarCXMGEfnDB90GBwUyzQcFcKjnBUgZPwWDTXcEbH3HBLEhfwSP7Q8EEvXPBOjjmwNx0dcG4RgnBQvJhwQHmPsGLDYrBVUxcwXq188A=", + "encoding": "base64", + "path": [ + "z", + 12, + "data" + ] + }, + { + "data": "pRlewa2DrsB+pFzB5rRSwREUTsGPB3zB+FdxwYdI9MCxrVrBno5YwdWlWsFTvUjBFYs6wW6jV8Gv8J3AEVJWwXQbjMGb6DLBP7iFwYquV8HOflHBdjaJwT0OocA8i3fBAkR/wW8whcHV2U/BPCtOwRoYgcHXOVLBKhR1wCumKcFrQJPAcjtVwWR+VMFQPXvBzdEmwUDmfcDxjnjBOoVZwfHCTsE9vFDB3g5kwSJ9UcFK+5fBDaGKwWpPX8HLKn3B9fgOwXshWMFMTE7Bw0JOwRgZ2MANOVDBbQVXwdmT+MBwMFXBouUGwcoRUsEmQWHBkRh1waWqDsEsdlTBwlX2wJa8WMEEdU7B90BZwVmmSMHk49/A2lRPwQxdg8FhW4TBj6rtwG72AcHxL3zBy8ZVwU/BhcG+tCPBOWPrwNsVRsEhWHjAsgM5wZanTsFjMUPBVwEZwVdSQcGVq5DBQQljwee+P8HEyUvBCU+hwFkWUsF+sTvBXNVYwaIsSMH09lLBrtRlwapxZsFiYFDB4IQGweRmMsHxsorB8jdMwauiTsEP5HnBKs1PwfpxbsFN19DAAFUUwR2UicFJy4TB8EB1wZldIMERNGPBQFYwwRGHYMEE28vAgsV2wYJTTsEEPmrBSROJwYcwNMHu2o/B6q16wQdcj8GGFIfBZR/ZwMNMUcEqG0zB8hRzwe+XQsF/lIfBn1Z3wd2bbsGZy37BizR6wXI+WsFNy07B6+yHwTkmrMA1CoPBlxdowVljP8FFoE/Btj9ewWRthcFM3UvBRAtPwcl3UMEubXDBL75mwdq+08BywVTBkmREwaIHlcDUnlXBgRpPwZ+9gMEOrVjB2U2LwbaZ7cDhbBbBf24Pwfq+jcFxj33BhFJawYXI6MCu2zDBlPA5wbMoXcFs61jBAHZQwbrvEMGEy7LAYe95wXMch8FxbGvBiqeTwZBYxMAhRJDBuuJPwWxhdMHKCnLBTdSIwV4yPcE8SibB0f9OwWvaWcHj/nzBoQKBwa/DPsGG8XnByRxXwIweicFtm6jAM3hfwZnDL8EOEZbBvLhTwXVwgsA=", + "encoding": "base64", + "path": [ + "z", + 13, + "data" + ] + }, + { + "data": "2qtIwYec/L4lyUnBsGQ2wdhCOcENoHvBvF1jwcoheMC0JUfBMmY/wUV4SsHWpDTBmPkhwWmTPsE+dKs+kRZEwVP0jcGi1AzBwXyDwZ4kP8GNTz/BeAOJwS3fnb/xM4LBHGOEwcg1gsFxkjbBe343wehKd8EssEHB4nS1P6/cDcHJUgg/5gw/wQOzQsG5AIHBbQwKwfSXwT7mF3vB9sdDwW0INcGyizrBgaVRwZ29PsFZDZzBuNOKwVZFVsFNF3fBp9GkwItiQMGhqDbBFw43wUrwNMA6ID/Bl7tAwc1QkMA9DkLBq4KhwF+eOsEKvVTBMHFnwTvMwMBqfkDBrURswNEhSsF84zjBzQM/wSnHMMGLxCfAsGE5wVvzhMHNEoLB0th1wBtXiMBifHTBXppHwasnhMFy4fbAaxZswO0pMsGey4Y/hxwdwfoFNcHMeibBDNnawB/2K8FuapHBljN8wby7HcFSYzPBqGquvhEuNsGpRx7Bqn5AwcQ+L8HZ2zjB7ZdRwW7MWcEqLjbBc6SewGAtF8FNgInBbXk1wRNKPMHs5oXBxzY2wbr2ZMGWEeS/2tzDwGRqj8F814LBsgJvwQ30AcHpRk/BkOMWwQN/VsHxy9C/BddpwdhoOsG++VjBDrSPwX6yD8HpapTBpXt1waujj8HFJovB3elGwIaIQcGvTzDBbsFjwWOhJ8Hd2oTBHX1swYB6ZMG8QofBxIpwwWqKQcGI+DLBSfCGwe/YVL9iAIDBCsJewfwUKMGDYj/BIIJIwX92gcFSWjnBmRA8wZpEOMHPEGnBhrdcwbHjAsDORUDBCIAswUpaKb9U8z7B6sc5wcU0gMF34UHBprmQwa3tXMBL69XASeGywPltkcGCfHHB6h9NwZ3+dMBupRjBS1YdwbrkRcEniUvBwkU5wcw7rsA0yqK/ey9/wRLjg8E3oXvBxuiWwQq4pb8+g5TBdnA6wUuYfMFPt2PBJNWIwQGtJsGGpvfAW4I/wRcgQ8Eo33rBA1yMwTOfJ8E2zXLBgpQHQJWWkcHwje+8rUpMwcXzC8H1ApzB6i05wZLzlT8=", + "encoding": "base64", + "path": [ + "z", + 14, + "data" + ] + }, + { + "data": "+w4hwaJRl0DupSXBUgkKwQ96FME3Rm7B6fVFwZtB5T8TUB3BwfsUwfkBKMG/DhDB6RrowNrUEcFzvqJAjpEdwV6GicGtR5/AW0J0wRRqEsHlJxnBiQqBwQ6hSEAVI4LBiTiCwfXRb8EVlQzBFH4OwZ1ZXcHlzBvBit6wQHCPv8D5AZ9APHUVwRmLHcFvr3jBDpWzwGBlikDgP27B3oIYwbyGDMFaBxLBnswrwToVGMEiHZrB4MGDwQ/KOsFNoWDB5DNFP/cOFcF2qg7BDbkQwZx6JUCBoxrBRGIXwZ9pLD9tARnBjuhLPt4rEcG25TXB2ilIwTTomL+rlRfBTy0JQBGeKMEDKxPBhNAQwTK1BsH3ClFAFesSwQAQgMFNIXHBgbjAP9hhtj+dPl7BMeojwX45d8F5l27Ag2zKPxHIDMEJ56VAAHnewGy4DMEptejA6D8mwILsBMFceIvBLvuDwdIgyMCm2gnBScGIQFH+BMGcGdnA9M4TwVK8BME/Ug7BL3Erwc/7PMHsywzB/g5/PhxWzsBqi4HBYMwOwV7vGcGIrofB46YNwXYHTMHYZ3tAao2Yv+aajsFdUXPB/ntYwXZjnMCX+ybBf0nQwDX5O8ECZH9A/m9LwY4aFMHN2jbBPdiPwZ30qsBH5pLBrVpgwSYRicE83YfBKSENQG7HHMFNyQLBYCdEwU/l7sDzI3bB0ZlQwdn7SsFuk4jBjZhVweFwE8HuLgLBFf58wa3ThEDFQGrBCnNEwbAb+sDmJBvBlXEcwXTuasGs+BXBbfIWwQKMEMExZlHBeJdCwfbIaUAqWxfB2IcDwdM6Z0AFvRTBMHYSwXiDcsFI+xXBKmaPweBZFEArUQjA4Br6PL6UjsGyFlXBSGQwwdUmtz95c9nAkhzUwPI8GsEZKizBpEsQwTclaj4ck3FAxT90wdL/cMEotH7BARCUwVCdiEBwepLBrB4UwXnudME0v0XBSE6BwXuY+MAGs1XAK7cewaE1F8F68GrBv2ORwbz6+MCcOl7BJ023QC7Qk8GSs59AofUmwb8wnsB42JvB5XsOwb8frkA=", + "encoding": "base64", + "path": [ + "z", + 15, + "data" + ] + }, + { + "data": "1wbLwFwl7UBHhd7AIpmZwMqYuMBqHVPBK1YYwR0fvUDFbrXA2A6xwPoa48AhG7PA+FA0wKEZoMAm2eZAjGHBwGP8fMGyTzo/TwZTwUlEocDBdLjAsPthwWhJsEAmh3bBVeNxwXBTTMEslaHAyNuiwKgONMGUzrvAlWPpQJoS8L/5PNdAMWKwwMKrw8BFV17BYJ+YvwPlw0B7tlHBHqWswPpbo8A0SajAtNrgwCuNtsBNGJLBo5RqwdNIDMFNpznBHki/QGM9qsDmKKTANAuwwBbpwEAV8rvAvsewwBaqq0AzYrHAi9WiQE3IqMB/tQTBhWMWwfLMikA56q/AJanOQNcE58CiILTAJnGbwCkokMAFWeBANeWxwPeCacHJwk7Bo8m7QK7itUBVcDnBoMnRwMjuV8H6bds/bSuwQKydp8Bnl+JA1Kk5wKYIp8DB8irAdv0uQHf3ksB1KX3B/NmCwSgBPr9G1ZrAMm7AQFPzbcAPGBTAvKumwPCYjMCoFKPAnEHlwJyeD8ERk6HAl2OmQMJX7781eWXBLLKuwO0+y8DC+IHByzepwHbAIsHoPeJAUKSJQOHuhsEUjlLBAQ4xwdRaLj305s/A/QgFwIDCD8EsVuJA5O0ZwZ5FsMAjEgTBhD2JwSReiz1mGovBTcw5wQ8hd8ELFHrBraO4QJABvsAw44LA2+kTwbHeNsDvIFTByJMiwWvSIcEg/ILB7PoowWCzocA2e2HADD9cwfl82UBFKkTBcn0Ywb6fcsCR1b3Ag6GxwL7mQcHMU77AU/m5wJEurcDpfinBA2sYwU2e5kDmV7DA59yQwI0OvUAx46vAlYatwJVPV8HdMKvABAyHwQdMxkBubW5AP/eyQJkphcFiJCjBuYwCwWwusEBYiybAHA/lv7hcscApf/DAazGjwMqKsEBk181AWfZYwcl0SMGWDXTB3e2KwSXI8ECpD4rB8RiywH3vXMFiIBjBc0xkwSz8b8AKVipAdfvSwEYbqsAKFk3B4ryPwRifbMBT0zvB9jDdQL5bj8GqMexAH9PawG66SD8WbJXBJ0ilwLLT5kA=", + "encoding": "base64", + "path": [ + "z", + 16, + "data" + ] + }, + { + "data": "jjumv76PAkFODxnABDQGPrguS78qyyjBqNmywD/q9ECETCC9VBkcv2n3FMDaj3S/GQU3QCxZ/T6luO9A67NMvzWoWMHPUrJAX9oiwfS4wT5rCtC+Yu0wweQ6uUD/YlrBTHdQwYWGGcEL3i2+4N19vKTV9cDc7L2+LHboQDdbPUC9NtNAM0HAvjgJOr9W4zHBHgRvQAqPwEDKGSXBPK/WPXZWl73IdL498nTlv/gV9r4My4PBWFE+wabelcAV3AHB5jcMQUBQEbtheS0+cFMhv1j950BpLtC+1q5bvpwmAEHKzxK+iGPvQEYyb75C9oLAaX6iwDC35kBsCF69yH8IQffPKcB0vxC/MGYPP3rMRD/0GApBAQ39vhACRsFVoxvBFVwDQShX6kAz/gXBL/ulv33GKcEtycBAvKHfQFTarr7B6+BAExMIQBhUhb6p6jxAxzPWQL5d7T48o1TBIq90waPfokBMzAk/xku3QPi0FEBAUUJAuGKjvIK5Uj9wQ129CYoawH79ocCAEvU9U9b/QNJXZ0AEwjnBK8Iuv/ZZ5r/svGjBEIT3vuNC0MBBjwFBQfTkQKIecMGCQiPBOunvwGWcmEDKJm2/rU5RQPqsocBVmP9A1hWlwJZndL5lBYLA0vR2wYQVokBxZHnBWa7/wAjTTcEayVTBBTLkQLFXxr5HX50/rpClwMkeQ0AkDyPBRM/BwL3z0MAwFWzBUubUwDOtpT51liNAuEMqwWrf7kBF6QzBw5y0wHuovz8UMga/iMPaPMx9BsG5BYq/tHtAv4xSrr4U3+LAwPW8wHYnC0FVAk6+ZjvIPp9ryEAgH4i9/h1tvgoRLsGSbp2934RuwYq1+kD2TOVADOgMQRoFasHYANXATEuDwI0g6kBFhy1AnrN4QEqjhj14DTbAyAMNP6K5AkGnNuJAnRgtwRPuC8F/9lrBiFd2wfNNDkHBCnbBtGq2vl4pNMFI77XAzk82wXymyD/AG+BAjDfavwsPOz6k8iDBqvGGwXum1T9v5wrBCrXPQLShg8E7Hf1AElHuv7RhvEB1eojBxzwPvnK43kA=", + "encoding": "base64", + "path": [ + "z", + 17, + "data" + ] + }, + { + "data": "0QOIQOgB7UBEFTpAGOKXQOjIlkA5ptrAzcIKvz+j+EB2s6tAwfaPQFaWVUCGuINAGXrgQFWfrkBBE85ATFyZQOV3JMHKuPpAmdLGwM6sq0CX/qFAY03cwI6MkECF8C7BuUcfwRVArsBJFJVAWUGaQMq1RsAkl6dAxx28QPnsxkD8YaRAQoaaQOi/pEBYweTA9wzVQD6PjkDpb9DA2G2pQLJQmUDJXaZAkj+IQCRhnEDquV3BjQcCwfDN2j42/WTA38kdQdd2o0AiyaVAIpaRQOD+3EBxQaVAERSjQM8rEEE4UaNAfLQAQfWLmkAWE4c/YDfPPifvBEHmyqRAoZ0OQTj2MEDliJpABMCrQDycrEDomQpBKhSaQOt5FcFtwavABjgOQdx06EDISojAc9CSQBWo18BmBgNBUNzWQEXOlUDG3axAmn27QFZxlkCIrulApzEMQfCXpECdHxzB2QZUwZcrB0E6SKZADqeDQJT23UAUAt1APXagQELZq0AKKphAGFNGQOyVWb0eIqBAk58OQdPz3kAL4f7Avr6OQKS7XkB4xzzBQTqRQPpx3r+VxfNA7zsAQXYHQ8Grm8rAi/IzwOOg6ECG66ZA4HTkQHBQZzx5JepAbn1VP7Euo0AWL38/w+xLwWVi6kA3Yk7BaDZCwDuLFcEgKx/BXwveQPquqEBFMbdAtFPevbuU6ED5U8TAgJMrv4PN9b/ibkLBbTPWv/0tpUBu5eZAzavKwGbW00Di6ofAAjsqvy/xu0AFiqNARUqnQIy3XcAzqYxAOJGXQJulmkC/0CfARdSwv8uDCUGMSaJAosaXQIhTo0BdPqFAauKcQDOo68BHAp9Aavo+wY67/kBOXQtB9FYjQYCvO8E5/+a/bbmSP54j70BnM9ZA9ib0QBj2rUBOLThAvcK2QBUYD0G1u8ZAXzHhwHD5YcBfoDLB6YhIwXpiDUFX70nBcmyfQDjS9MDk+XS/C2LwwFo9v0AlJhNBBYWBQNPMqUCDEczAeN1swUkmw0CfQpXAyl6dQOGtX8H7kuJAbVh1QANkDEFXPmnBWRKYQGtNpUA=", + "encoding": "base64", + "path": [ + "z", + 18, + "data" + ] + }, + { + "data": "FEMHQbyVrEA1OudARcr1QBKcCUFqOfK/zziUQLYQ1UBliQ1Bix4DQd5c8UB5qPZAsxkUQZrGA0GAx4tAHOUOQQ5hvMC3vAZBXpOpv3TDBUG6pghB6evOv8NJCkBFuebABMi6wOKqu747qP1AUfz/QGGVD0C44AxB1dZbQPGd8UB3yipAEhIEQWUwGUGlZgDAIbT2QKT75j/HzN6/7ysGQad8+kD1cgNBICEMQYfDBkHomiXBbzJVwH6BrEAGGug/eIcaQXCQBUFepAFBZWcDQfBVrEC8jApBKooLQYu8CkFYMgdB0xroQAUTBUGv/7pA4BC2QJRdAkG1hAVB1iz+QGuP5UBsFAdBZLQBQS+t/0D87uxA3yIGQffMr8Df5XU+7QsDQf4WwEA2JCY/UwoOQV/K6r8B3AlBGXWlQGXLAUHO5CBAVDnvQAoQ9UCBuh5BBrMSQYqv/0BKPqTAYs4iwdaaH0FJeudAPVjKP3M8FkEinw1BxTkFQfdy/0CpPvpAiGztQGiym0Av3fhAwOoEQTdIBUHaLVnAHpcBQcXW6ED/Tv7ABwcBQZkhZECw9L5AuBDvQGx8BcHKLMm/2S8pQIEgAkFPahhBQLUUQV5qoUBSAa1AWaXJQOz9C0HrBLZAVc8PwU7C+UC/4xPB7lA6QNIym8D1kbHAR16yQPoTDUGrpQJBLxyeQAKCGEFxX4m/sa2dQEd8T0Ag+QfBDC1xQA7x/UAwvh5BKrRGv9oxkkCfxaQ/02mQQE0KBEGyVQtBnPwFQRurHUDRUQZBd64JQTs5A0Hdex5Am35fQCs75kCPmwhBH13ZQE7mM0DNFQJBmhn8QGwyN8CvZQNBu2/8wPol3kAfgg5BNzQiQRk5/cCPFmFACje6QP+6y0AXzg9Bvw8XQXyYDEFyCvFAYbwMQQjIBEEJ4IVA4TMRwDDxOEDfsfTAJPsKwcDI80CvuQ7BmecHQQPHQcCIQYBAHw0owI1xB0GqmBtBu4QDQQd5BUELpOG/Jw47webGCUGOkKM+tVIeQJ7vJcH6zKVAhkQDQTnGH0FRqDLBUDf4QBw9DEA=", + "encoding": "base64", + "path": [ + "z", + 19, + "data" + ] + }, + { + "data": "BlIzQQvyEUC3KCJB2MARQYl3K0EDmW1AVZwEQf+7kUAOOClBFDwmQQh7IUGFjhxBs/keQSCWEkEKYb8/NIA5QXGQaL7V5vlA5gl5QDvNGUEXXSNBVAuDQNuWXr/OxR7AcAksvwhxmEDkMxtBwFEaQa0s2ECCPyhBbgg1Pu/L6kCiFwi/yXQhQSt1SUHqlW1AzM7rQAV7vb/ahF5AnEgcQXD+FUEbjhZBeWM3QQFrJEFn77vANAgRQBZyE0EP4NBAXdAFQWenHkHq7BRBJ/IjQckPPEBV1CVBj24qQe7Q5UAqGiJBRZKsQGCSI0HMnRZB2ngYQeuF30CKjR1BKIi6QIMIIUG8hCVBfXUQQW1cEEH+QKFAmkEkQQOqX78MoLRAt+rJQI7vdECsialAKDc3QeqlZUA2EPZAPUUrQGDXH0Ee6J+/PETrQDinDUFcty5Bo+gCQd6LE0FnXRw/t+LAwKMNIkEXCO9A4gm6v1CMIkGMahJBcWkfQSGPEEEwORZBmBkhQabuAUFuCgxBlNnNQCq1A0HGY/Y/RWYjQY3PF0HkRD/ADIggQWmj9kDfQVdAKza7QMXuWsBEOGRA2B/nQFpO+UALFkJB6KwfQfRCDEGjWh9AMHMdQSSBLEHBchFBJPCBwCIQ4kB/EJHA8Ob4QEG/GD/ljye+kcBRQNpoJ0GD1A5BFkULQfA0JEGOcohAIvYPQcPN5kBEa3HAfCACQcWxEEGBHjFBqm6gQCQZxT+61MpAmOwHQd0NDkHT+yZBZJAdQU1B7kCwiyxBqvoqQRQoH0FLCdpAGcfuQIk5lkD7aSNBbuDfQJ4Jkb6A1xlBlkkPQdzhGEDHWx5BBREuwEXVn0C/cgBB/HcMQTw9ScBjXvpAB2YOQSDDh0BZ3x1BencbQdybJkH2bytBCwMmQajxz0A9q5w/o4VDQFIHAUGx1kjAkOVvwIcdrUCafobA5/kjQbFmEkBfQPxAJfM5QF1HFEF3cg5BNDgtQe3qGUHyQVRAU2XuwAaYFkGkFaJANrUZv6nWr8BELRpA+RoxQd4JHkE9C9jAlDgTQQU2w78=", + "encoding": "base64", + "path": [ + "z", + 20, + "data" + ] + }, + { + "data": "GJNLQdNc0L/jqDtBF50UQWTSNUGFXPpAnNYlQRXtzz8VqS5BL8I0QfJyNEH9FCpBiGMVQcFCCkEiyee/P01QQamqrUB0dshA10MAQX71F0F0LChBYUwKQatTZcC8xDdAoBKVQN0JCkFZ8SNBuEQgQSiAG0EG2CtBb6VGwDdqvkA46F3AUZkqQaVvZkF/YQZBrUW/QCiChcC0b/dAdVEeQXyIGkEsIhJB3w1MQTZFLUGkqb++Q1vhQMx3PEH8uBtBNG7DQL75IUEf9hJBiw4uQS6tab4oTSpBE5UxQQOVlUAXHihBSlAqQILpK0H9njpBpUY+Qfgcn0D49iBBTT4uQLvDOEHAWC1BZiAIQWAcDEGyq9k/hkwsQVcne0AEyBVB8UJZQMaycT87dQtBmwlKQZgF9kB16rVAvAMAvxVKKEG6Eo3AWy6+QCb9CUElTSdBPOnAQAO0EEGkkcBARNNev7GZEkHOoM5Azzt9wGCoGUHZIwJBRnkkQTsSDUGneRtBUtszQTEPG0FwuQRB/4RfQIYx4ECMoNFAZNsuQdEnJ0EcDC5ArBgqQcRJJkEs8YC8InVXQJDbFUDBdPNAwC0mQQkR0EDG6VZBquIWQev1MUFYEZS/dRE9QS+TNkE9FjFB/Uv1P24KrUCJnJg/rMIxQUtGt0DcFKdAWOZxPod4KkE3wwVBvV4wQZUcHEHthQNBtkM4QbvyGEElXuc/o+EwQRUEDUGzmS5BB8wUQdTaAMAEzB9Bd94xQQ6DAUFvnCtBmBwhQdY5LUF+XTxBuGk1QenIJEF15BxB77giQZdloD8TjCdBFzy8QN/1T8D3aB1BdMUIQSp710As6iRBW0NLQFIREUCUeMdAw6DHQL3IFkCqTytB9ygpQdxZpD95NxlBrN0LQfCvKkFhsklBpessQbyxbUBnUwrAJC/wQMy6N0HrJwZA1HQKQASyFUCCGbw/FPwoQRu23kBKgyVBqeTvQIAnC0FH5t1ARoJBQZ/lGEEpd+dAOzsFwNSeDUHtEQRBY49ZwGGJIT8AV4G/NVRKQRCpCkGGq6a/OYEWQQ92ksA=", + "encoding": "base64", + "path": [ + "z", + 21, + "data" + ] + }, + { + "data": "+k9TQTlNkcAFAENBMKIHQYIlLUGefSVBpxEyQQCq5b+TfSJBS1UyQZQSNUGFmydB1A71QG533kA5kIzAPsFWQcNJFkESVn1A7XQrQal+BEGVpBtB7Yg7QRJ8rMAIAu1A62wKQZYqMEHi4BxB47gVQRcUM0FarxxBBvOowB0na0CBx6XAuh8jQTTRckEHZjtBFYRxQBCEtMB0IipBQr4PQWhiDUHF8/NAnlNPQQe2JUHOlKRAY2YkQecvUkHldDZBx4U+QLJVE0FNPP1AvU4mQRRVT8BJhBxB7EMlQbSEoD/gPh1BRmU9v0BbIUHf00pBXExPQT16DUALNhRBYBmVv80jPUH1fCJBD/7ZQPT76kBLvQzAFD0iQXK69EB4sDhBQK3Nvn3uDMD4WCtBCVhLQan+IUGcKTRAxttcwOpGHkHDoMDAvghmQA5L5kBvDw1B8xA6QF/A80Bp/hxBLouQQMnc50AxiZBA34yqwAvr/kCPdMFA7UAZQcsS8EAIvw9B+SIzQXKBHkFSfdRAQWKfvqzvm0A4YBtBFLQnQZ+wJkHbFPRAiqkhQZclPEHroFPAqkhDPh/g6UB7vCFBLuhCQVIPjkCoDFtBwLD6QNsdREGFLYfAvONIQddULUFIxztBsLPkQDwgQkDMNM1Ai25RQXYMFUGKhBVBRIY1wEstG0E2u9NAbHlAQRbdA0EHHylB8XZLQXFFJ0H599pAgzZJQZKA7kAw3xlBaN9AQcS2lMBTYUNBuptHQVtBxUAytB1Bj3sUQSQxTEHuXzpB1PEtQUuFF0G7MTZBcVQ5Qca4JcCrURpB9bRzQPMZqMD5TA9BGUTeQCNDGUEJMhpBuiQBQZuVhr9+D2hA/bkkQMMJ4ED5GkNBZKQxQWUUBcCi6QRBFOPWQASKHEE1XlZBs7AkQZRhtT3mQ5LA+1wpQepVV0ELyNZAWEnlQAfEr7+rHNBAfZUbQU+BJkGA/TZBekQpQZ+m30Bbv31AkiVEQVfiBUE85xhBYeB1QMta40B8HB5BTL2hwIrK0EAXlHvAxUpSQcMn0EDGbI9AVjMJQSHGw8A=", + "encoding": "base64", + "path": [ + "z", + 22, + "data" + ] + }, + { + "data": "RBZNQdTSo8Aw1zpBGhXcQOSaFEG5xDlBDG4tQegbi8DTIQhB7vEhQTFkJ0E77BdByjehQGBJiUDfa63A335PQTq6PUH6HYM/XRdBQXuIxUDUvgBBrtJWQaaGvMDR+ypBpaAyQUvKQEGH1QhBUa37QGnUNkH8s/1Abla0wGaePj+unZrAonUNQSiXcEHyMVtBniVzP3sArMCO+UJByybmQP1J4UB7n6FAj0tEQbSwEEGIlxFBlXRAQWhMVkE/9TtBD+9pv6y960ByebNAeiYQQfcCocA1tf5Ajm0JQXZUJMAnRARB+vxwwA//BkFYWUlBuo9OQQ4gkr9p9vRA9aOMwDIUMUEw2AdBvAOFQP9nnUAw/pzADg0JQWX9HkEY6kdBc1N6wCBHkcCEMTZBh5o+QbyAMkHvLzO/TluqwP62BEGkHrDATRwVP716l0D2X8ZAJlFvv7k2o0DclkFBAHwNQaOmj0AyQu8/aFKbwNRcrUBFFEVAEQABQW4xp0AfNOpAq1kiQVQVEUFSZX1AVk56wBht/z+rlDZB0C4RQYNnGUEoTDNBxUYKQeAkQEHgZqfAV1Q/wOVeLUFQUjJBiXpMQZ/q3T/wSFFB8dKpQJldRUFoX7PA9JxEQdtnE0EdgDRBKo0tQWF6zT3rOiJBL75eQUZFNUHlmUBBNFaYwEYt+kBPvHZApLQ+QWYBu0DKwThBOQJNQaXfIkEviSpBkLdNQdVWpEDj/utA/TlYQQNPr8Bu5FJB55pLQXs4U0BUUwBB4I30QAfGV0Hu8ilBwuUXQa1u9EBZGztB7/88QbFCp8BS3f5AqJCEP+IHu8DpPeNAuF+LQFkBMUHh3QBB0Uk4QYr7dMCqso0+gO/5v/CQIUHmT0dBwyUrQRBfkMCH18VAI4tyQFOC/UBC4lNBP0oPQW7KXcCKSaTAkA9EQaENZEF7ESJBa3coQen9i8CPDB9BTir/QNKZSEFagDVBhzBDQWpqikBuXQI+be03QewIxkCnNSdBBscMQaXTiUBCFCRB1ISWwMAAMUEY5ajA/pFLQZMhX0Ce3w9BN/PaQE6ursA=", + "encoding": "base64", + "path": [ + "z", + 23, + "data" + ] + }, + { + "data": "8dk6QacyP8CKZyVBNaaUQBII3UB2QT5Bzx4bQfMAnsDxdMRAuwUGQWItDkHHiPpAxurLP9kbVD9m/3vAcIQ8Qa9OUkFdgQrAUWNEQQm4VkAUcrNAWCFfQW8YksDduEtBgxhGQThvP0Ek4tNANcm1QNuRKkE/PqtAT9dhwI38F8CT1Na/AcTWQFQ4YUE452dBC/UGwB5gO8AlmkhB7suUQKtSjECKVcg/fgQtQfLG4EDG1TdBGrhIQeyQSkHd4y9BTkeGwKKFmEBc2xdAfFDcQKVOl8DWvqlAGIvCQDgvo8BLf75AVVurwJfdv0D5UDhBWqA+QTgmdMCzRKxAbU61wJgpF0FPyb9AN5o+P5ezzz+GcKfAsyvGQBzFLUEIN0dBU8W4wByNqMDhUS9BlUsmQeRcMUE4hXrAVmatwJezvEDe0irAtPokwLN0sD8v0i9Am0WMwK0q0z8LqlJBwU0+QSmTdT8DBJ2/7PnGvz6cBUAG7Q2/qXS8QNAVB0BOzJpAK6QEQXyT7EAuoNI+YpHCwAXRsL9GMT5BZXrbQCJ6AUFobldBKEvMQKoeNUE005jAMxmhwHL9T0GRjC9BLKFFQfwWsr9MnDtB/D/5P1j8N0Gay4zAd9syQVFB1kAcKR5BFaZSQWLlM8BXjkdBbkNcQcG2QEENr1ZBM8uUwAF4pkD+Mn0+4+4tQRTHJ0AO2zZBiZ0/QcmOD0FepFNBfCZBQdQ9AUC5E4lA+E9eQRuxdcDDS1FBVS9AQYD4kL76LaxAwqioQNwRU0GJdw1BUWjrQAeInkDmni5BcTAwQZgDtsCBFrNApAIBwJDdkMA9fYxA/ox0P1oTN0HKE7ZAWxdaQRkgncDHpkPAMMymwFbeO0Ga5zpBECUYQV31osBjnVFAmG/nPasRp0AcGkRBPAfcQO9jrcCpuEfAAlxKQY/SYEEA+ERBiwFIQTUcr8Cqmj5BMhywQJ/jVkH/NiRBli9JQaTiYD/mCWrAb8AeQZGQSECXTCNBKMRHQd0MGz8ahRpBkhTCv1SlZEEzuYHAoh44QXe/nr7tlEBBR+OJQPrvD8A=", + "encoding": "base64", + "path": [ + "z", + 24, + "data" + ] + }, + { + "data": "7iYeQWa3ZT9MlgRBRhv1P9VDc0BO4zVBV1L7QCqMLcBqQExAIkLBQLDR1kCsAbNAvK8SwB27NsAB95I9xWIfQdDDV0H4FZDAA4A4QVCDBjwxriJAdThXQeRQgL8+5VpBjFZIQdNQL0H4BYRAKSM6QJxpEUHFYg5A4aIpPyWPm8DeSjtAhrF5QITPRUHBr2NBNh+RwD59rD8gvz1BB7e9P7j/fT80vxjAZf4KQfw9jUAUHkpBkNNAQYGmMEEqbxVBVLyowIpUyD/Bisa/QOmEQK1E4L80F/c/oPo9QOrzrMDwD0BAaFGSwGxnPEDduxlBxqAhQdXzi8DelyRAgE+KwKJa40AUgDRA6fI2wGKXCcCR0jzAA7FJQJp9KkG9TzlBoASrwIQTU8Al/hlB7k0EQTVPIkHaDb7AmNM9wP8dN0AaNt0/KG6jwOCpGcB7Raa/1NXQwB8UE8AV+1NB5IpbQXcgNMAlWHjATLdTQAOt4L/VwXzA3G1MQLACyb8T3NQ/WJq5QA8/okBgT07A2QfEwGv0hcCMCDZB5pF9QB07wUDClmhBXxVcQM5mHUG/bM2/lLCfwKcHYEHTYR1BWrowQQmKfMCTihtBiG74vw3mHUGu0DS/1oQVQbY8W0AayfZA5l1lQcphmcArilpBPPFLQeqvO0HGs1pBl8Xwv5JxAUCF6FjACKQQQVhdor9+9yZBp2wlQQLW4EBJn2pBQAMmQZ/pzb8ygdo+D8RVQcqjCL0KIkFB6GMnQXr2bcAvjQZAY3cRQLt9QEFEiM1AxbOSQPK7xz/LoxNB/2AVQRyYaMB0ICtAUQSPwJsnjL+eR3E/Q3gtwFH0LkHaAStAAbFpQZDdTsDxoZbAgL67wP1BQ0GAkSBBtSP1QLmHRsCdvaK+B7hhwGzZ6D8HeChBBJuDQIxol8C6+nw/KRQ/QRy6T0E72VVB9PNVQXWBf8B7Z0tBa3QeQDt4U0GLAAZBbLo+QdZrM8Cs57vA2gv0QB9aJb9mKBFBPFhvQR9jUMDz4ARB95NDQGT1gkFr8qa+nnwZQZMPdcAj9FxBmF6JP5XiHUA=", + "encoding": "base64", + "path": [ + "z", + 25, + "data" + ] + }, + { + "data": "e5nwQCfqjkCtPrRAWgKQv+kXzz1SxSJB30+uQER/tz8kCz6+RqdOQOBmgUA1MDlA8ZemwL3Tr8DQHolA7NXyQAixUEGSU6DAFx4gQWwTU8BgF3e/qGpBQf/vWkCZ0lpBlkg8QUwiE0FJr5Y/C/movuLc20C4mJ+/l1WVQMEKycB7+MtAv7cEP+Y+H0HDclBBUyG5wOTMn0CC8CRBJnUAwPIKKsBhXqrAB+O+QEpcqT9f1kxBM7crQf4lCkF2rN5AJaZlwBAg+L99MpXAJHhxP5oFJkDkn/G/i+0Qv3voW8DurOe+btSgv+NPCL+AE99AbtryQHAd+r/KHyW/smluv5V5hUCGClW/qmmywDSmocDRC2w/Lt7SvsvxGEFjPiBBJ/QzwL/Jkz86K/JA+Gu0QKQuCEF1jMLAWPPGP3g0Ib8HFKxA54/TwB3Ho8ActZzAAYjZwDK6qcAmUUhBbzhnQaxApcDxnqzAPNfYQKHXm8CH9cbAApHlPQ0Ck8AH3vO/Ge40QNpPEUAfJ7HABYx4wN8wscBsOiFB1R8DPyA8YUClGWlB47qXvebp9UCqhy9AbToKwNB0YEFNRv5AT9EPQVuGosAarORA2uSfwFaZ8UD8kWZAsCncQCxT1r4FUJ1Au7hoQWN+n8DYhl5BR00vQfSMKUEgYE9BkUwWQGh9vb9n7rjAbhTSQNQwj8DE3AtBrTIAQflFkED7nHFB4yb9QM3Mk8B8217ALJlAQRODfUBSiSRB4QwDQbWRwcCf7Ma/EXyVv8H1IUEf7V1A9ymmP4xvDMDuttlAXevdQPUCOz4EvSi/ELS6wCyMSkCHii/A2LirwN9UG0GxZVS/w9VpQRBYMj8MumHA20iFwOKWO0GwafVAZCGoQM1eXz/+umzAU8C8wIxF/b8GLwJBwr04P+uCxb/6EpdAuu4kQVBOMkGy7FZBFMZVQdZVDr8KSElBf/Nuv7WHQEFH7LpAkb4mQd/bsMDlt7XAwd6VQJNSgsBQ6edAaMWCQeKEusDHnctASGjPQEuTi0G/xHRAvPzhQDZoscBglGhBEjYcwMhXxUA=", + "encoding": "base64", + "path": [ + "z", + 26, + "data" + ] + }, + { + "data": "zRCVQAAu3kB+JB9AyupywHRiaMCrfwZByRsmQGHVoUByZGDAuyaPPRwBej+YNyS+dx7HwJSsycClwOpAnrGXQHvyPkGJbyrAGQz7QEYSu8AeNITAI7AfQRIqz0D/iE1B60YkQShh2kDVb/2/J7xdwEK7hECP9YvAgnfvQOZ8xMA8sghBcGk/wHyn3EAl2y9Bt0qmwCEr6UCmdwBBZfaawNKyqsD7D8vAXDMuQF0hAMCpK0NBbMMLQXNzsUBzLoBA4t8fvgVqnMBt6bjACvgbwBEQv0BuGqDAbpV9wHhubjxuHXHA6N8/QGBxeMBP/G5AQZqPQFhy/j/mjWrAMA5DQG/CSD9FGIfAOkfZwAT8ycDtBJBAOHN3wKKi+EDlQ/tAdwh+P7Ecp0CuRp5AiBomQKN0ykBWE3nAWViuQMfSfMC6j/VAVXvTwK2Eu8B16OjAejmfwHve0cAzwjFBbWljQeYVncDvBZ3AugIOQfgsyMB0/dfAtYc+wDTtw8Cu+JnASbrzvvCmVL8a3LbAdNKcPKNzksA4SgJBKCVDwLFAIT9YBVtBlpRkwK0kn0AOOcVAq1oPQK6lU0EDLq9Ak4HJQA6hecC/YoJAxhzKwJmklEAVetlA7Hh3QJNvhMClS9M/O/teQdNcFMASCVZBlJwHQabnDEEUAzdBor+1QOUUkcD6kcfAuOJkQASftsDkj89AgA+jQEwTyT/9hWpBJRCaQByXxsDh67/A7GggQXR82UCKu/pAHNWpQL461cCrgJfASDyGwKI38kAay7Q9omYOwMgLp8AhWnNAQTF9QOkfgUDV/HLAi+CvwOuFxkDf+KzAmNvGwICm/EAieYHAN7RcQUH6jkDq2Ru+f7h/vyTcJ0G/IJdAstEYQGDxkUBAo7fAs/LGwHAPpcBMv6RAO4M0wGcyKEDEo+dACNf8QKbGCUGSQUpBmvNJQdaLUkByEjtBOTCCwEkoIEHaMDRALLADQdGM08AYgEvADFeWP0XGvsBdjJxAkCiGQUt2zMBw5n1A6D0LQVwUjUFjotxAM7h/QD6LlcDvVWZBsLWfwPmtB0E=", + "encoding": "base64", + "path": [ + "z", + 27, + "data" + ] + }, + { + "data": "lNqxP+ZXA0HBJH+/R0SywITb0MD1vsRAuTQRv2KS80DSWMbAc45FwDFvD8AOJUrA8zmdwI2UlsDl6RNB3DjAP5buI0H9yc8/znqlQAXI5MBoMcnApZnnQAQmA0FzwjRBWD8CQQw9fkBHPZbAGd+6wKTWhj+GGtTALXURQXSLfsD2QBdBuuK3wPPtT0CpdQNBMxIWwKcbBEFP9aRAT9jLwDp8ycB6ep/Ak6Fsv6Ghm8CTbC9BjffFQOfW8j/E3iI/iT5eQBmk1sBg64zAQ+iowNkmA0GxEtLAmnXVwPRXY0DCr8bAjWjJQCSI0sAmiD49kaFrP0g9qEAYrLvA6uzEQHKiLsBCdtXAxT29wHTMr8CjIONAnVjPwKp7rkDlxqVApi6PQBi9AUF1RPQ/1F49vyVtbUDoegI+KpABQeEr0MB3jwhBpsiRwLXNhcCAnP7Aj4W5v0sNtMC98RFB9fVRQb21DsAn38+/1yobQdKIpcAkNKTAoqqxwDVttMAGp8rAgw9swEAkcsC3jF/ATHyAQNftob/dobZAbFG8wFvNFsAXHEBBIHbGwI2J6D/wrAdBmy67QMF+O0E3tiRAAZNFQDLw+L5rPRg/SzGvwEc2oj+AtAxBOnTLPnBs38Dg8Oy/FN9JQXH7DkC090JBDCOsQGSxz0DGlhNBJ3D8QC1F08C8no7A+V5ZPjTNjMAbonJA1tzYPz/Fyr/L91ZB882dP25LtsAKi8nAsSPtQEurBkEEwppAggH3P+Fyo8CJP9vAYXrCwK/2jkA0z1HAmzOnwHxy2cB+xcY+BXwOP+MK3UBdOsPA8soywAum/kA+CsjA/paUwM1ks0BDusfATAlEQXJW50ALYF9A2qUnQGlnCkHhbqs/wcBOvwZQ5UAcF7rAxDyHwIyh4sAKwtI/+jCmwFxrv0BYbAhBbNibQNh0rkCHpTFB/lE0QQ9cyUA56CJBctjKwHC86EAxzgm/tGyvQFrdscCIzDU/AEIkwHd2scCLYAlAHaiCQVARl8ACkp4/sQwcQUsoiEF11g1BQcz6Pjja4790alhBLwe4wMjNFUE=", + "encoding": "base64", + "path": [ + "z", + 28, + "data" + ] + }, + { + "data": "b/oEwEdnAUFvhIjAlqe5wMBd/sB2V15AXlNnwBs9EUE79/rAnNS4wAq4n8DDcLLAmKDlv4WVib8Yxx9B2Sn4v4TFAEHT2qtAZdgGQKDj1MDvsdzAfgJ+QL/OCkE/ARJB08mvQK4ERT8vWM/AZ+ndwL+nC8AyrPDAbvsWQZTgGD1MuxBBZVnkwPPLX79vwJlAvOP3P5Pg/ECpZ+k/2JzAwJpzo8Aiw9a/vPyIwICd18BhWRNBlvNMQP6iA8A/9DTAZrHKQDaE2cB7IpO/6EnhwFVKFEEdZr/ACx8EwU1JyECLMOXAs0IIQWmdA8HlXmjAI40ywHhk80B03NTAXo0DQTIAuMDhuPTAh1o3wF/1MsASnQlBisn1wNvqL0DctQVAql/gQGLRHUFzSK6/IzN7wEhCRj+QJ4dAyZIYQZ0p+sC+L/tAoXDTvi+kI79BntfAUG8wQGO4MMDChNRALXs0QX2Gyz/F6EFAsMwTQR7B+r98TdG/pTjnwGpJTsATx7vAl9/MwBWax8B3itM+kYHgQCiCOkDoxDhAV7DrwPbQm8Dk6xlBQ2rowABNzL8vVRpBCioGQTeQGUGKERq/r7z/vuHQWUCDlj3AyTM1wFwnFMDaThhBdGVHwNJJB8HPqaHAbsIqQeWav0BN0CZBDHvgP+PLcECSzM1Aw5IPQRt+5sD0Vme/piRLwLcVob+r2UU/zBz8vyWcj8D+VDhBd20iwKe7PsAba43Aec+IQAXiC0FeqrM/esvdv7qdzb9/FO3AdlXEwH/1bD8x0b7AujPkwEQ+ysBySEXACU87wPvpCkHkcd7AkcfhPw1DB0FcLJvAf5R+vyouPEA53djAaEYhQRCxD0GHg8lAyo+xQJhBykDb0Q7AT8BzwJOhCkGaAn3Ao9IUv0UA6cBugAjANYOuwB7qBEFOSAhB+EavPwsw3z/Hsw5BE04WQdqNBUFzdwJB5J3lwGz+fEAtIXPAZoUTQNxeIsASI41AXhaxwPYfOsCvTFe/5+FxQdFzq780mdK/rYQZQeCqekF2/xpBqR9FwLts/D/JhUBB2YKIwLR0C0E=", + "encoding": "base64", + "path": [ + "z", + 29, + "data" + ] + }, + { + "data": "VLK2wP2OskCsLenA+ZpHwDXw5MAr6Xq+ldLSwGl5FEFh+fnAR9T9wPqt3sBrdOLAq288QAFegUAjpBJBM0SzwHIkmEBL8AlBq1T2v1z1TcCzKqHAPdoOv5ox80C50LdAIBDZPzg+T8DbztHAkJW6wGQStsChXsTARrT+QArWnkBZGdBAS4TLwI3zrcAK+1u9WPHGQIB3skBmJSLAfQA+wJDCor9qdFNAwDzbwPG928AmWM9As0FavxGbyMCKp87AJWgKQUsEgMA4m2BATp/ZwH2BDkFT2yrAin0AwcvrA0HUjbTAjVobQWIsA8Fb5ujA7irSwOJEE0ESyJ7Aw2ASQcYcA8F7z8jADcUgQICY9j+chAtB9JDVwOJXYr/xHQHAe+8JQesdJ0G4R6LAKZ/ewPIdOsA4HfxAsrsZQfCZ4cD8T5RAfKqfQONEg0BSFUTAQ+LZQNWpCUBoYENANSMCQfSPs0AWTulAM1nYQH8YRUCAymJAsHnqwF1YrD8KAyfASwQJwU3wAcHHD59AkhcSQRiO2kA2V2e/BGHQwB111MB/77tA6Di3wHo6qsCEjhVBpSYgQbtnyUAjuorAS7aVwOAO3kA8Ss3AVV/aP6ChwMDOHgdBDW3JwKl2/MBRSAHBQHHxQLMiEkE0g/NAko0/wFzqwTz6shhAUdEKQcFGq8AprH1AjCPVwJ05UkDVk0DAgya6wMx66MD1iwVBELfQwCKzBED/FIi+6lgCvr7U5EDAO0DAqIW2wAvLZkAt1a/AgvhQwD2MYcAp0PDA1DrkwP9bP8BvvdbAj8jSwFN6EkExj6bALp7KQJtv6kC4eUa/09uDQDo0Lb9hH5HAk6vVQJTgGkGJnAhBwYv6QI4aPUBvJ8PARHbPwEZGDkHsAF499HqGQDWkocA+k77AxIw9wEDUGUEXP9BAsAFIwEjmRsBHGrBAjLPPQJ3UFkEhEqNAcf+vwHD3LL9jM+TAtLfzv4k3IEDM2PZAXYbhwDzD9j/wkInAZcxKQbIQYECf0JrAx/DxQL9DUUGqXQ9BvfXPwIeBuUCirBdBllYqvslBsUA=", + "encoding": "base64", + "path": [ + "z", + 30, + "data" + ] + }, + { + "data": "w8fywFSsaD/aTAfBtexaP+I6l8D+IE/AgVP+wJ1P/kAuYb3APaAEwWou1MAv48/AlSDDQJ0/5kB8vdpA6JXywEvA0z80DyNBPLiewKQOmT/FP9y/i2WFwNs1qkDHjSBAT2nUvxnDwsBmro/AZVQ/wNWs+sA21kXAVnadQBin+UBk3RNAhFl8wNUC+cD0z4DAfUkJQTHB/z8LmLbAT19hPzOUJ0B01s9AF/7awMfHnMCxuXdAjHuBwM5BCsFiigjBdOUWQdZHBj6SYM1AYjyLwH6q4UDvC5o/9vq7wPGUCUGWCCHAWAUVQSCGx8CCyxHBWqMHwdYdFkFtzN6/S6cFQdazCsEJ61DArk3GQLI0qEC42eJAPBSCwB6McMBJUJ/AohEIQd5jGEHkDfHAqHYCwTi4sMCXqhpB8J8CQbZ9jMCwYR2+qvgBQTwJ3kAwfYM/XAIPQfElskDacVm+smmeQK2b/0BBXxhB9kY1QLs+zkAqkttACDSrwJcImEDEK6w//IEOwfqYBMG06PFAv5YWQe6uDkF9D3nAju1wwLZLy8AkFRFAzzokwGbT78BD0+1AObYgQYj/R0C7Bd3AhmXqwAnwDEEuMfnATi2gQDNn/sATIrNAKLTjwKeAscC/KhfB3feOQITvKEHcaZtA5dfEwD4dQ8AH756/W4LdQN7C9b9jDt1AfSsJwSSjx0DsZbbApoD5wDpbCMG0l6VANrcMwX1htEBNqllAF9BswGyceEBmUcPA5OT/wKi73ECO8APA2p47Pzhbz8BI0NnA1E+hwIraiz+LEQ3BFc4LwWh8/EBlSeq/agUMQV0enUCpf0dAb63nQLWUYsASZkq/BzpZQIjeDkEy7hRBaWEFQRnRqr0LFgfBEHXowG748kDW1l5Afw7mQM2r2L8jgvXAZR2qPge/E0GFvDZA41bKwD0ox8D75A5AQmZtQFQ1D0En2A5AG90JwKJni8D1vw/B4zyiwMJnvkA75hNBWCnEwHw8rEDKQdTAbKEfQTRO0UDMx9vAozWBQKEkJEGsT9VAgmD7wJDy/0DXndxAjkNgQGSXHD8=", + "encoding": "base64", + "path": [ + "z", + 31, + "data" + ] + }, + { + "data": "h6X+wMR2kcCihAHBecaTQAjupb/RULTAI8P7wBfZnEA6aCvAF7bhwDcuiMA614TADLIFQUR3FEEuMiNAYrwBwe9W1L/E6itBeE7uwFZVqEAJUhJA7dvkwARL1j/PYoG/1oqXwCT3A8EZeHi/gAtnPxJ3D8GCA3o/aW4Vvn0VGUG+XVbAvnQMvwPkBcE8gujAueEeQacwJ8AIpwLBl7SPQNuLukCYUgpBWTecwGt1xb+3mYA/T4LXwGjZGsFWtBbBJUYQQZkcikAtVgVBkLMCv/oAXECOdJhAuqoUwJ5V8kCFoL0/1BvvQEjKMsCQLxnBdMoNwWEzBkG0GgpATzW5QOK178CJCUI/jiwNQRRe9ECPCVdAJtrvvpJkycA0uuHAlobaQAu140CiYRPBDMD0wN0z78C9wyRBOgSkQOg65b5LTJnAu98hQRVJC0E3DZtASfIdQWBd/0CO4VrAsn2qPy9DF0HCjipBK9gtwLdVDkHUYRJB9TLiv3Ol6EAhPJ1ASRvzwPmg2cCcNxBBRNkCQRxiH0GEC8/AmwmzPQBIh8BScdG//xK5P6IdB8E7wGFAmiIMQRLVtL7hrAzBJIsNwTXSG0Fa5enA75XvQOBQB8Fa98A+I1y6wFpu/b/c0hfBGQKBP63iLkHEX+M/o43/wMVguMDqBpXAPvhdQJkkE0A4FQxB0R0Uwd9sBUEzSPfAY9ICwcSAB8FQnMo/mn8cwZCKA0E4Ac1AbjbSwD/Csr8bJgXBZSYQwf/eEUEA1AtAfnqRQAmDBMGq2YvA1+HPv0AEnEAEKh3BPTkdwdKal0D48Q9AKqkgQb8ghT9Cc8hA7GsUQRsTv8BAyFdAfu5rvup410AF0Q9Bc6HnQL9vRsADABvBqnvKwEP8lEB6AcdAOV8TQcvFD0CmF/XA+7tlQAvF50BjtyDA38cLwdIK+MBFIqe/4gQkP4723kBmF1m/IBcBQNSL7cBitxvB5C/0wDC/BkHLwhhBDCttwNyg/UDyIATBieXWQGNeCEE5AwHBjUHLvzsu20Bs1BNAmTjvwL8CFEEF83tAeLHMQHUYlsA=", + "encoding": "base64", + "path": [ + "z", + 32, + "data" + ] + }, + { + "data": "bnrUwDpY98AKE8bAD2XyQGcJH0BKx93AN7DBwOezAb/+g6Y/gQGKwB5w+b479hO/KoAZQfAfI0G8Y1bAQJ7dwEUblMBO5iJBDFQRwXwcBkGsxLZAaHURwQZOMcAaHovAdjPlwIk5FsH2vj5ABw+UQHFCC8GzTZtAHR2hwGwGJEH28dXAGVhDQLXs6cBuBhXBlM0jQeY9sMB4PRnBcbzpQG+TAkE/4BlB+HnVvzUAF0CaWfu/q0sJwY2kE8FRPQzBlaziQJRl80As3BFBp2hmQPlhBsAvB/JAL8T1P1XImUADqaVAaLlyQEMwvT8XlAjBy5nxwNs8vUACd7JAtxhiP663mcBKHJVASgUlQYEAD0EkPCPAKwlUQIrYBMGPnfXAZyhOQK95LkCxDB3B1fyqwK87BsFLahpB3C+1PUuUbkApMunAyaQvQV9rFEG1tvpAJWwXQT3qE0FEqcPAmgQewA0jHkG2lCpB1xPAwExTJUHSBSVB12IgQMyTDEGNnPRAjdSUwIWnZsALKRNBOCSkQFf3HUGzGAbB4heAQKJSQ78jRafACLqlQDNh+sBVXyPAuh67QPAccMBvJhvBfAIOwYWjGkFrvKPAkj4QQVvN68AOtqTA3O43wLa1CUA2RADB2mklwGyKIkEQlL+/6NEAwYET+8AZp+7AaLXyvy2fvkBXEBZBnb0GwQGCF0HWqAvB+CfYwP3+2MCksg3AHU0Twe7qG0H4oQlBChQDwfXRtMAV0BPBcrUHwXHPIkGZF7xAJEvwQC8FB8GxolK/o0oUQOMO+kCuIBfBCrAZwQoJO7/FQ7tAFCQjQfqPVcBnRghBKCsiQfho9cDmA9hAlmxywEyDJEA54OpAlyl7QK2yuMAlJxjBnDNxwECbvr56OgJBvV8iQbJXtEDh8cDAXgfJQAesQ0D8VMLA/XUgwTzr58DqxZPAj98fwEZvP0Cw7HLALje4QBaCGMHjexHBauwTwYEBHUEHCwZBAgHQvl8mF0HOoQ3BkA4+QPKtFEHiiwDBmM26wNciOkANbWfAkHuvwERkFkFmoTA/0qcGQUK/9MA=", + "encoding": "base64", + "path": [ + "z", + 33, + "data" + ] + }, + { + "data": "YYt+wP5uEcGRJEbANFMbQcI9vEB749DATQQvwCe3r8A3BaFADi4Mv/ynYkDwjlBAWXkaQXLVHEEwAOPA0D+KwAR318DC3wRBNGAYwfQOKEGWRgVBXi8ZwehOq8DywOLAaakIwX9/EsGWY8xAxa/2QBQm2cCsGwFBym/1wCwGHUEsEv7AoTbGQAp/osBfER3B9OwWQWUTysArCRrBKb4TQQccGEEYtBNB+wsCQMxAukBj6ZXA390SwfAR7cDdcs7AFMA+QIPXHkEnGglBTwHkQG6RwcDByhdBd1u5QNNXA75BggNBZGr/v1hHrkDiy8TA3tGZwOlVoD8EMwVBDc6XwJQfir9P1f1A/zQpQWxNEEF/p93A8afTQBz+GMFf0c3AFMMMwE25W8DX/xDBDPfhvyv8+cAX/PBAQBycwO2d6ECihPzAwtMqQeV8B0G3Vx1Be8bwQDwkE0GbzPvALC+7wAU5EUGWrBZBY3TgwKcEKkGD7CNB/3fIQCLREkERKhdBTLMNv+uzQz/l/vxAaCuTvNbpB0H9yhTBHlvrQFvPQkCwcQDBMYQEQfpAtMBs5d3AFe8zPx1408CMjRTBPa/pwD1rB0GhoOm/vQsXQYntnMB7zATBCtNsPx/gu0BIIqTARSi2wNLmAEFW35DA7BLOwIUxD8HjThTBi4m4wAUnDUGH0AlBgs7BwNuEF0GLdQTBarF4wMo6YMCjFbTAKWriwP28IUEUlR1Bk2cBwYwq+MDlygjBNEjPwCVmH0HBuwtBnt8YQbdL2sC4xEBAAy67QJLUHEFczPHAGxz/wC2ouMC2iQxBa4ASQT87ucAJVBxB/tYaQRr9A8FqkxNBZvnXwHTNVcDxrndAmkPuv/Pm+sB2i/jApGsrvpqcocD1/hFBrH8dQXVhA0FPaVHA/lEFQeVBTsDe4vDAc2kewYv/ocBC/+nAQj6owGEhN8A3HMnAZ+sMQaDNJcEqZN7A630YwSgPIEFUhqpAEetCQKD1HEEDpgDBhs2Pv951CkE4Y8zAVXn4wK5Btr8FHuvAYV8ZwKpCA0FyOyjA3ZYXQUD/CcE=", + "encoding": "base64", + "path": [ + "z", + 34, + "data" + ] + }, + { + "data": "HC0Dv5DxDsHGQS8/CeQvQXePC0GMPInADFK0P0xtAsE1qAJBcgVbQDeV4ECbOtJA7PgEQR76+0Bgdw3BSvtYv4gI68AlzZZAjZ0HwZAvOUGQFSFBCmkGwdBHucABrw3BwT4HwanK6sAJTRJBhyIhQZZOWMDcrihBpV8IwcTOAkEAZvXAHx0MQQTeB8D8lwvBjE7sQLi3rsC+jgLBTzsjQfHlG0Ea9+ZA8vesQA+tCkG4V9zAdpUCwffikMBjtzHANgNQwFODM0F49stAFYwfQVc/+8CwyyZBPRIQQaueocDFQChBneHMwIa5C0EqMDHAIM+Qv52CjcDbgiVBgDcEwSi2PUCCkSdBdoYXQWM59kDIrBXBPw0VQfbEHMEeA2XA+rnMwGRK6cBjItrAJDYUQNPjrsD7WWhAvbftwEoPIUE/utzAojwSQQOVv0AYLStBRup0QI6m80BqewLBQGkGwYqa1UCXXNZAhMTPwKdDGUG/iwxBOyMVQSl8BEFlvCNBMxZxQCKzn0CHz5lArEOmwLxjsUCftA3BPacgQdF9ykAiyBnBvI4qQf93EcAY0hPB20SewIg+CMEGRunAsMOMwGknvUDXHvU/sAIJQRhgwb9j/xnBUT+SQLSADkFGhZu/A/n5wDc7h0BR8N3A4SVpwDxPCsERTxvBbpjvwE2ILUG29cZAqN8gwKF5AUErlsPAMCEbvs7bUD9MpAPBDYdtwIeoEkGuoR9BQB/IwN64AsGL9MnASqNWwDcEBUED5ipBQ9spQQTxdMD3V8xAZo8MQdm/K0G7RorAgyCiwCBPDMEI3S9BkjbZQKmTyMC4TR5BM5f1QE0d6sBWcitBMJUKwc8e48Cr//+/Zp/WwLSND8EI35TAuFZjQOeE78BOghBB9O4AQYOHHUHJGfQ9paIaQR2/9MDapOzARZkDwf8c7b/qkRDBQQXowAe04sCbBP/AHtAxQeeaG8EzcGDA9ycDwf8/DUHaJ8K9a0rCQHwQDUFOgbLAX1KfwPilykAkh0bAJHUBwZ5TrMAeaBLBmZadP+Gyp0CQybLAhkoXQWll/8A=", + "encoding": "base64", + "path": [ + "z", + 35, + "data" + ] + }, + { + "data": "Ac1GQBYf7cCceItAuys2Qf9sLkHuh1G/N/GoQH1/EsEPySlBTF/cQMXvHUE2VRRBo7emQLSEgUAVkRHBeng2QNuZwcBJ36W/8GW9wD5POEEykC1BN6m4wJDuk8DGxhTB2ZXWwPEcg8B+OjNBHm06QcH/bj+GWENBI3n+wAGKpkD9W8XA1HYqQY49lz9G3snA0Z93QOHrVcAOSqrAY7MhQf8pC0HmZUtAdGsEQWJdLUHONAPBNCGwwEmBc78iidE/4Xn3wK5lNkFJ3QFAn0pBQeF2AcGytCNBeWs3QYUyAcHOsz9BjZQLwfTsM0HtU5U/eHk1QEPN9MASLDlB27Ygwc5B0UBNLUNBjCXZQNXxlkBzhSPB0U81QZ14C8GjjVY+Jb4MwSYvEsEvMFHA7B3BQFvm1b+wKQPAxccCwb2fQEHM5ZDAWWrHQHNNtD8bSyRBcGvFv5yZhkC+XNTAkL8bwcg3+z9pogFAkVOawEOe20AMd7ZAEg06QSwNvECqDh5B8XnwQKHsB0E83O6+s/AGwcqDCz+13NnACK0/QVscEEEmlhrBeKBDQV201D/JgR/BMu8CwcllEMHCR3LAL3ojv+MyzD8+AaxAtivDQM3tD0DHPRfBVjH2QFgpMkEbdEJAUG8GwbDz778pZATBI0krvmrN08BewwjByTD1wCizP0EZnvI/ccHRP2TPnED3OR/A59JqQC6An0A7qBnBuA/RPsb51UAQzQtBxbRLwF9R5sARazvAhWHePoi6n0AmiDpBfJUpQfQS37z04BJBlbowQXWeJ0GV3iu+4hGfv6inIcG4wEZBYRA2QJx/psAPKQtBaTZwQL3UmMDUITJBwSERwQhUD8HXIdDAK1ccwU8fDMFXQR2/5BzYQM/eA8HfFPVAx5aNQLONJkHwVGFAr9siQZ8TIsGZXr/AD4qlwNCX5D9wUhfBcIn+wNyCF8GPPgbBwv5JQRdr9cBRfEE/LNSpwAF+wUBshbLAdvMIQYqpxEBwJtm/2XEAwbKIAEBn+Zo/g8flwL+8A8ELqBfB7VGVQGXWAb7Mp/rA/+sCQWklvsA=", + "encoding": "base64", + "path": [ + "z", + 36, + "data" + ] + }, + { + "data": "Qf/KQLFQksA/CfFAFdwsQWYgRUFB1T1AmZ0IQbNsDcF8uURB49UbQZLtQEE/DjVBAKjFvGmb57+c9QHBNwvGQLSJTsASt8rA80ENwOWUI0FlDylB3jcJwMtSFcBlEQTB9TJlwDhVhz1pOkhBPSxGQb6pokDjD1BBqpvFwFKSPT8nTGfAs8E8QTupikAmMj7AXQikvzq0lr6hcMG/UMAMQaOXw0BlminAqCgpQTw+REE8MwLBzZTTv47/NEAeu7dAsNwmwf56JUFC6mzANU1WQXrX4sBJEgtBCoBRQah3GMFtUkhBF6EXwR6TTkHIC51ABo3MQGo0E8Fm4j5BtswlwbHUF0E5clBBgFwPQDYTtb3ydBvBy0dJQTC3xMBiW4BA8q0awTtNGMHQ9Yk/+HYTQVq7LEBi89DALzzxwGm4UUFHUnm/RpzgP2cFhMABrAVBfZzDwOLwjL9CpWbAEGwZwcMTicDzanvAZIwPwFcV+T9PG0U/IlNSQV8R3D9xOwNB0kcpQTmRM0HKxq7AloQfwYfemcDGO1XAtmtRQS+2MEE5yQLBDC9OQcvmqUAd9RXB+rUawQZI/MAd1TY/EoNTQFucbMCK9QVBbUzcP+oYtUB/cP7A7IIjQWIcR0GYp9lAMGPnwM9m0MBBBwHBShNYQJB+RMC8zr3AEwfUwFubQkFVg2LAZziwQJCzKb8j0O8/a5/gQGSlB0EsxxfBY0yPQGyxFUAgo7dAqzoOP7q/oMDZbYk/9laFQH8KUb5SXDlBMbIVQWbQdEB3LDVB/vBIQb9IDUE/WoJARlE5QJIZIMHCGVBBtOIgwNaoPsDpZrxA2c8IwAZTh79jdCVBwAb6wFiqFsEXiBDBbPw0wQJV3MCXEGdAT64VQW6d9cApDZdAPyGjv78FHEFe69BAWaEbQcD+MMHeaF7ArVKUv6gVpUCM1AbBtWncwFZFJsHAwuPA53xUQchEj8BKeZxAISqovyxJsj8SoRHBr7UmQT72qj/XyzFApNwcwdG9YMBE3qhAiJqnwApBF8HA9AjBRqL0QBCwscA1uQ7Btd6rQFB/KsA=", + "encoding": "base64", + "path": [ + "z", + 37, + "data" + ] + }, + { + "data": "L5ARQfES1r52qiFBPbARQfrhTUGFoslAGfUxQerm68CqUFJB67s+QUuVWEEMlkpB7XWqwBDs08De9MHAQ90QQXIT0T6j4xLBaSMDQDRQ8EBLOhFBMZr3P4DYLD+XsLzAOnC6PgigiECZYlBBcQxDQWDjCUGMlE1BlNJVwMJ1gcBRxRG+1lpBQUjg40A+018/SSmwwO8hN0BvsSpAVcDBQN8G1j8xQOPAm5pDQes3TkGzscnAyv0pQLMyx0CDFBNBpi07wbo/+0CskfPAM2xdQYj+oMDtZq9APBNdQTVNGsE6L0BB8AAPwbWHWkHZ4AFBgwsWQYW8F8GM1DRBDrQVwaKhO0Fg401BPzhgwP2Nm8Dfr/3AWnNPQcEFEsBOZupAaAsTwXonC8HYSKdAT8g8QcPT0kApWRHB5bC4wDUAU0EF8T1AUCJkwMv69sAotJhAMP8OwagjusAb05Q+atT/wEwYCMHGle/Anf9+P39XiMA4W5PAlzVdQUKbWcAdCJ5AfHBOQaxKUkGM7gbBllsgwc9i/8CL0X4/zkhUQU56RkEOoq7AIj1IQRGMBkFFTPLA7o8cwdSAqcDXLaNAxZLZQMWS3MBOUy1BRZhrwH+OCEEea6bArVNBQVtyS0HAbB5BCpqUwNp4D8GacsXAEtfQQOkiqj9TdBLAEXeSwDOuNEGnEenAScEMQaRWvcDFl7xAoqIcQburM0FKxv3AORcAQSI6VMCO8wY/gjaHQK/747+2DZ1Anm3tQGusqMAmmyVB7t3UQD0a50A1+UtBW+VTQXVBsEAanvdAzYnSQHOYCcEwW0pBPbHEwKVSnD1HM4w/ZEHZwMsdQUB8EQJB+xSmwFhjC8GtGiLBuz03wedkYMDgmupAPtU0QaOtv8BYV+e8PmnJwGHf9UCdmxBB9kMBQSYeKsECiAS9IupJQB4QAUFfAsPAmGGFwBPZIMHjmobALvBPQfVJC78NsgZBnOBCQEz8gcBv0S/BBeY4Qc6GjMCbO9dAEG0gwX+S7cBn4ApBP0QZwLk4EMEEddDAIDwhQbpHEMGlywbBWAQlP3+Lxz8=", + "encoding": "base64", + "path": [ + "z", + 38, + "data" + ] + }, + { + "data": "Kcc0QfuDcUBx6T9Bp37BQACDRkHfmhFBIsdPQdb9msC2O1FBExFWQVUIZEEtGFRBrLsMwdvHF8FWEkDAhRI2QaRrgEDSBijBThO/QKaNSEDufMVAHU+3QAzqW0AVmyfAJfKIQFPE/UBHc0pBkj8vQaNiN0EsPjpBTqPPPrD23cD/D1JARy42QaUOF0FR+pJAk7z2wK4coUCt681AKnXPP9prb8DWphvBo31SQSHhSUFZWzvA45PRQLYIEUE/Yj5Bp2k7wZv3aEBebxzBohJVQUfpAsAYVok+XbNYQUvGCMF6sCRByT7owO1+VkF9sypBwB07QVwbC8FQXRhBcKjiwBnRUkHemTlBWf3xwDZ8/MC3upvAoPJFQXwqD0AYLyFBaPruwO/j2cC/IAxBbbRbQSxfHUFeDSHB7IFCwOXEQkFjM69AdUbgwLD0GMEkbuG+NekiwREDDMHQxIVAqQmowLWIMMHIRxLBHO5uQJVnCcGJmgLBqbBZQcfv3sBytSC+/uxmQf2gY0FKqxvBG54LwUd5F8G6D6VAQSJGQX+wUEE2UPe/ig0vQcUDLkEYz5PAc5gLwe+d4b+6VQ1BtFcbQZLlBcGyDktBrO/wwLp2LEG4Yp2/DGRTQQsOPUHmBERB8k2av1TKHsFvJkHALq0SQV/zr0DpPus/BrbTv1aOE0ExTxTBka82QY45FMESzhRBaFk+QQ44U0G+bKjAxMYtQZjW6cBAhqTAfKPuQEsbB0CE0wNBdTEhQUcPB8EukvlAGVQJQBzgIEE9ClZBVPFPQaRRcD4XKCtBMAMaQarwvcAFQzNBvXz2wFC3RUBG7ozAfccXwVvn00Ak7oVAJtLZv24A38A0wCDBn5gjwSvrRj+VjyZBZatIQcc+VMBnrpnA7rIXwXFigEC+WC9BnHubQNutDsHprVRAR8XfQO2dJkFBvTTALarkvr/nCMGoKIK+rmg6QY+lYUBF2zNBLjfeQJFS+cBRNTfBN6o9QTuQA8H2oR9BM5kMwScAGsFiHTZBBf6TPz556cAkqlnAUSs+QSr5LsE668nAPXWQwN8Xm0A=", + "encoding": "base64", + "path": [ + "z", + 39, + "data" + ] + }, + { + "data": "rRxOQQlar0BbDVJBso+dP445LEHTLTVBIFthQQujpb802j9BePhgQdEQYkG+elBBbj0rwYXfK8GAOXA/3rBRQX9A5kB5nCnB6yUVQdx0KcByes8/LxgQQdsZqkAWpJE/olf2QNkxL0FXpjRBRUkIQesQWUFs1xNB3uZ1QBMeAcHPZp9AbIAYQdINM0G1OvtAutQFwUMft0BVnBlB4WhrwOB38MDgxizBmC9UQUlNNUH24qA/aZwdQYuGM0EawFxB6bIowfC9DcC7vCfBrv06QfRezD+8naXABJBCQQTjycDmsORAYKmQwNPcQEGdV0dBlhVUQRC73cBVOstAVoBiwH0gXEGSIhFBud0cwV97FcHYcfq+TlkqQcYCy0DFPkNBX8qRwNlPe8DDUTlB6WFvQWJrRkEYfBvB9XP/Pm/JHkHcJbpA4twIwSnyHsHPWK/ALFQgwROSIcGRivNAEFvgv/zzQsG6ZRbB+ISdQBURM8H7nSDBZ1VGQeiEDsEfiaXAAuVxQVj0ZkHEjhnBDBnFwNrfGcGG8gtBewIkQUlaTkELPvk/baT9QExGSkHvGwW/OuXSwCmyCUCzcz1BoBg/QWUTCcH2CF5BTu0cwXXpREHvsUxAajxYQTeMGUEOjVxBO0wgQDAgG8G+Yko//j4zQQ9JEUElHbZADWnnP2+Xt0Cz7RvBMtFUQdNzMcHKnkBBQypUQQnAZUEpvvC/GCZPQVdAGMFEJhHBFoIiQdoPmkD5bi9B655AQU0JH8HWkG9AcHRiwNvaQ0FIzFFBLNw6Qeb8psBp8k1BWgc/QbBiAcD0dQdBGIX3wJdFpUCTwQHBRFwpwf1SGkFG+cu/3C4IQKD8h8Ddag7BjnLywDdWnkDiLExBazJQQWLDbT7R4/3ANfkxwWYcl79vNENBdv27vnVXvcAItqBAptMiQbK9QUFaLXU/7IxcQBg/vsBAR3VAABsRQYyQ5EAFtlRB4ZYjQY9vHcHKgSnBwo0yQR/wJcG77kdBwcLNwLUxJcF14FVBeHqAQI1Ll8Am4Dc/J9FPQX+wOMH4jkHAdOr5wCMnvUA=", + "encoding": "base64", + "path": [ + "z", + 40, + "data" + ] + }, + { + "data": "8nBcQVrnkkBXxFZBE0CJwNY590DF8k5BgM5lQZNgLUCVKxxBd2deQSXvUEEDOD5B/Rw0wWDBKcFncIZAWbNiQSFIHkFIGBrBUWdAQVZ/48Ag7m/A3KQ6QfuGvUB4hZdAuX4oQc1JVEG5cAxB7BWWQGhCbkF0fK9AteavQEIR+sDr331AQ9bJQFoaREERNyhBXhP6wJ2ljEB0G0FBFXLswJKzGsG7syfBsGxGQYrUDUEa2qdAGONHQTczSUE2OW1BnAgDwdxG3cCtLh7B6uULQUiBikDOJw7BaGkYQS3rPMAF0RZAsv5Gvw2pF0EZQVZB8nVfQQM0h8AAgMA//yicP7AXVkHZlKNAQT0owR21FsEKRnxAb0jzQC67HEEQhFpBX+v9vtKgs72AZ1pBX8d2QZ0ZZEFfFwPBVi9tQNu1yECVF3dA9MwJwVIcEMEBdBDBj0gJwXiNIMH4HyhBsgMEQIjJQcFiOAjBQoNfQGioRcGvjCfBvh4hQUYwF8GDmQbBtExuQXBeW0E24ALBK/wXwMALCsEgFDtBVtvTQA8OPkEqILJAqOBMQH9CWkGRp2lArodbwC7buEDuUWFBlcJWQbSV98DL5WRBU5ArwcN+UEFkb7FAidZNQTB3vUD/BWdBofq8QOcSB8He6Y9A5I1IQSZAQEFbdBBBAuuJQB2GHT9+KQ7BqiRmQYTfOcGGKWFBAJ5cQaqaakFENeg/N8xiQVXvI8Fv7TfBwvBDQQ/5p0CZD1BBP5lTQSwmIMEHG92/FmPxwFk3W0H9ID1BtZsRQWI8DsEvLWNBnylXQe9VK0AneIRA/SXTwIg+u0AQSiPB4ukkwf+4QEEy09DAMu21QK6lE79LzNfA1ABXwNcdCUHzBmVBJCBKQb2EYkDsDRrBNrU2wYLUusD7d0pBFR2vwAGYx78IiYZAC7VJQaDEUEGbRZNAmIzdQIn9DcAbPO5Aj32gQM1pIkFqcWhBgPpMQUgWJ8GOSAfB/iYUQUaUMcGuLmRBPktVwEqkGsE14WlBvHOZQIw707/7pYZAy6JUQUVTL8EiOV0/S5MYwYJijkA=", + "encoding": "base64", + "path": [ + "z", + 41, + "data" + ] + }, + { + "data": "ImleQTEh/D89fkxBiff7wOzgR0A1Nl5Bu/VbQRlXnEBsEshAxwtNQRoMLkE0MBtBVU8pwTpvE8HVcqRAG+NnQfbzQEGAY/XA7nRgQTN8HMEzVfLArfJZQdvYl0D4/PxADnZLQYVibUETxZxAROwbv68zdkF+pZY+9IyVQIeEzsDpnRk/AevHP2v4R0E9ZkdB6DPJwD4aYz9DQVxBBDQYwbYkJ8Ee4Q3BvOclQU8woED3pwtBJcxmQfkmUEFSum5BR4eSwE7RHMGl9gDB5OGGQLBcnEDtVjHBM+WvQOqDsT/L1V3A29dLQIjVsUAL1VVB+H9bQf9dEr9es4PAeICfQFnsPkHqbJi+uFYewRM7BMGKNrtAYOhEQIS2SEGR+WVBRBRrQMc6ZkAovm5B3olwQfvndUGU9LLAY7+nQLdQjz8uqSQ+DYvvwIHS28AZwTHBJI++wLjJCsFGJE1BNIazQIILLsFiH9TA1i4Ov5meQ8GKIRrBH7jOQKY+DMHq4yHBeMhaQVCZP0HIwrHAfeMQQJi108ArSl9BKkOkP73EHUGoewtBh4g3wPPAXEFyXa5AX7w0P7UED0HldHhBxv1gQTT4wMCd3l1BBZomwR6aTUF7XaVANEExQbAVTz84XGJBOeINQSoUyMDWNvlArcZQQblLZEEUETxBlaSWQFAbmsAZnNnADZJpQXJJL8Fd3XVBWOBVQdDjYEEkNalA9EBnQbgxG8HwnknBvWJaQXMKUEBNe2RBBqJYQVwWDcFSdcvAvJ0dwfaGZUFrJBVBXt+gQLHFL8Fq4GlB5WFhQTPNtEC+rOa/HMWQwDbBlEAg/C7BXHMMweikXEEVhhrBus4MQW7dTED+aWTAgxoUQN5AOUHgAnBB9bY0QY5joUCXZyHBh7wnwcDGD8Ew+0JBiuQOwXlMWkDH8Ig/GUBjQYqUUUGy4vlA15EeQdl1E0A2KihBmUolv0wIR0EgO25B6lpqQeFHHMHUZaDAmL27QMffKMHKBHRBL5M3PjNb98Als3FBgggwQD5O0j9WVqZAWapKQY2gE8Fpn5RA9H4fwSitij8=", + "encoding": "base64", + "path": [ + "z", + 42, + "data" + ] + }, + { + "data": "CEpSQfMxwr8dWjFBIucdweQeKMCmCmJBTT5CQe+gh0AMTrU/UzsrQcAM60DZHMlA1NMLwSbx08Cns1pA9bRfQdBuWkHtlJfA8op0QfFCL8FpPh3B5qlsQTAkqz/n5ChB5y5jQZOueUEa0Pi+W9qzwBjtb0FsuKDA76/dPzBjhsA45lLAFBR4wMfBO0H8Q1lBrWt8wI/jVcDV7GlB9Nckwbg0IMHE0r/A44LbQBx1s77ilDpBDId5QWNcRkGS9F9BODjePn3SMsH7vqDAWY7vv570MkCYoj/BdtOUPbNemECaxADBROanQBzXlD5jW0RB8BFGQbBPSkAnowPBtZDEQAqHFEHS+LLAWUkBwZ1fv8DqCKlAQTAkwEUZaUEZTWRBaBS9QMzGn0CVrnVBZtNaQdooe0G8Uf+/FZGHQKxTkMCxqm3AVWSswJZkZMAQPj3BkAoPwJvWwsDAFGhB1ysLQZytB8GnQ3XAKZaQwEUfLsF0dPTAd/S0P9ZC38AQYSjBAJs1QZ3xEUGJkuK/pmKzQN7VacBSDXhByKOVwCRH1UDzrDRBo8L7wLxEUEEW+JFABeOGQCH1OEGSKYFBtj9cQcJGY8ACh0ZB0WEPwfJOOkGpvTNA3S38QIKPlMC9WE1Blho1QcnHSsC4hClB7J5JQXXlfEHRrlxBklEdQJQxCcGgjmTAa9BdQQxnEsGvCH5BopA9QUFoR0HdrAVBGt9aQdUOAMEZ7UfB/W1kQWLAwr4tWmtBTgROQYxvz8BLZRXBT1ssweoFYUG/faxAOO4cv22BO8Ex/2BB6qdcQauDwkBtPd7ArQ3Yv9wlqT8jSyfBCRfCwLaObUFrgDTB6D02Qaspm0CJPCc/+tHGQPj+XkEt52tBKJ8NQXMkfkA9LxfBdfwFwaZ0K8E57ilBKvMwwTudvkCBITbAsT1uQYtKQUGfnidBMtpFQSpRqEB81E9BPXPAwHucXkEqJWVBpM96Qe2O/cC7Ele+N0JEP3kMDcEY7nZBOqZrQEEbksAQsWxBpMSOvzyqmEATLmdAhlUvQVrcysA2VABBOXQUwT/8OcA=", + "encoding": "base64", + "path": [ + "z", + 43, + "data" + ] + }, + { + "data": "+841QUdJj8BYPwNB/B4qwawB8cBjJ1lB9ZQWQT16wz9Y63zAIRTuQDiNCUA8TL0/1Pm3wJ6ON8BUFeA86SBIQe3kaUEeQFG/7tN7QfS/LcELDyzBXUpxQRtSScB5wklBDbFuQW87eEHzR7TA3wASwesqWkHxdw7BCXgKwBgCnr9UKsbAoc4Bwf2lG0Hlt1tBGRRsv9R4ycCs6GhBiBkfwX2TB8GtsO+/BOfEP9bvscCaRWBBGR9/QezDKUGPTD9B3EaZQERANMGmgUK/taDlwPDUeL/WFjvBIYOswNn9uUBf9TLBynqUQKHhosBnGiBBW6IcQc9OkEA6US7Bmy2jQJsOqkC0pBfBECalwITSKcAFNUVAS57qwCSdfUHKslNB5D+6QMVEYkCJdG5Box4zQZnpckFaIg9Ayvl0PxYVDMEOc87AX0kfwJqyUD/WYzTBd0ANQAJoFcD0G3hBOY0zQR8am8De+D6+01zowGJrBcFdfJLAINqGwCSqhcA7kxzB+HT5QAvuoEDi7ypA0zbVQCV6Rz6bY4JBzIwTwXh7BUBeHFNB+2g2wUX0MkF9uPc/jnemQOU6WUEROn5BYLFGQWxExr7MgRtBeErNwJ5iFEEc2yu/JFU6QMHxDcFJrCZB9B9TQbCMQj/z601BYhkwQZK2hEGyJXFBcqq1vwljLcFnlC4/OVdBQZchxsDDvnhBF6EQQQ2aHEEiri5BmM47Qei1p8CilzPB20xgQSuqe8A7FGNB8MkxQYk6RsC81C3BpCQowUdsS0FMrKC9tcbAwN2oM8HlXEdBDelHQU0CkEDlVCjBLgrOP3zLPcAMqQ3BFBkNwATLckF/0DnBrx5WQXGJa0AXfoRAki7yQPXZeUG3R1dBEvejQGjfUz+5pfnAPYajwISlMsHNjvdATSJBwbd8vEC4gbnAIGFpQbrNG0GrZEhBbQxkQTIjtEDVlm1BWQkdwfmoZ0HqGUxBC019QV6kn8CRrI9AEr2YwHoQvcAJLWxBehvcQCpGZb6m6FlBMVmTwCW38kDy3fA+9r/+QGXKDsDjui5BQkrywE12vsA=", + "encoding": "base64", + "path": [ + "z", + 44, + "data" + ] + }, + { + "data": "ZRgGQVbszcBbXoFAPgkmwfCfMsFWuUFB4yatQEEgAMAcmALB+XM8QKMygcBjbHzA5gbOv9yT6j+HZV/A/n0eQSJGbkEth1JAKlB1QTl2GsGoiyjB4QlmQevKycBQ9l9Bzs5sQZDbZ0FA9RPBilw0wXxOM0EOXzbB6B2rwI3TA0Dh9P/A2w8xweSGxkA4XExBnRMWQDe8/cDs1ldBgQAJwb6tvMCW8DxAaLySwFgeFcEcVHxB1F52QU6M8UC29ApBKo/JQClyI8F/A25A8/cuwRJjjcDy4STB1ScYwRJNlkBAuVDBjHcCQDYpEsEMz89AkJ+5QM8fQEDMmkXBpIAnQPYSiD0jGUDB+M+cv/5mvj+thsu9N5UswQX2gkHkqTFBUWx5QGkrpT7zIVhBQDrsQCPXW0HrpqlAxs1AwKcSOcG0sPvAwGl+P5pTkkB9UBjBQeqyQNe3DkBcLnxBsW9RQRIDMD6x/VhAYC0NwSr4kcBLCQu/EbQGwRIk7b7GIwDBieY6QIx2qb5DLLFAAuWyQOJvckDHXIJB7vdFwX7fVsDAPmVBFitawYmpAkGgqMC/09ZnQMvTbkH9O2tBwTUeQbtnNUC7GrFAJFwzwAGfs0DuQ3zA5PVYwCByPMF/j9pAwNxmQX5YgUAjHGlBlHQAQaCHhEELM3hBWN6YwEisPcHd5Y5ASXUSQWpNAcC3vmRB68eXQNd/vUDSP05BHkYIQdiCvb/ungzBhatLQZx6z8AauUlBIvMBQc3wkz/0ZzLBlAMTwdfJIUETmrHAIysgwQ6ZGcEDxxtBSCAiQda4zz+XYEzBNmeIQCVpwsCwwcXAjEIbQF91a0FspyzBN0drQVe6Nz9an5lAymXjQFmhhEF1jDBBCEWgPKsUOcB7kqbAaJ8yv4ciJ8Fcw1VADXpBwcijg0CjI/TAKTlTQfNOt0DbFl5Bi4d4QeT4f0C8boBB5NNDwQmfYEHU6yFBAIlwQWINhb+jY9hADKoPwdYW6r/Xt1JBQowaQRDwgkDwAzhByWjjwO7WH0Fp5j3AIhxfQA4kLkAjsVRB0kydwAc2+cA=", + "encoding": "base64", + "path": [ + "z", + 45, + "data" + ] + }, + { + "data": "jb+AQDUa48DAmJ2/eMETwXOzWcF+HRlBZtqpPSecncCfEzHB2XkdwOyhDMEQoADBmStGQPtvrED2wsXALnG/QDEiZkEKZqJAO8RfQU9W7sBywBTBCL9IQZAFAsFOTWpBIwhcQaEZR0FtTjjBzSREwZjz8kCu10rBTXXwwN6WlUCLxwnBz+1NwfC1ij/xkShBq66XQCMJBMFCNjVBkP7HwFdXFcCaUMJALzAVwdI4PMGBIodBZ7VdQfr2TkBoX4NAUY63QNDxAcE2MsBAnNNVwVqR3MDzKPvAPXdEwRKFCEARWVzBJUXBvwf0PMF5E+Y/9hrhPtzDi705GUzB63g0vwjypsBqM1XBgj5GQFvRmkAIeVHAnItQwQbHgEGcifVASQ5IPyUoSsCgozFB9bkDQAseNEHcksVAowXCwB6gUcE3efjALHSCQLhpwkBx1tPA163gQFvtskCT6nJBMV1jQSwTl0AgeqFAYs0SwSK6/T7KVWdAxrMywUKaVkDcdajAYh84wA1RsMC/8L5AsrQ+QGkrrUCb6nZB8r1kwUKe8MCpXWlBbW5rwZXadkDmzI/AxHAIPxuceEF/JUhB5NXBQPwHmEBUKIK+ki3XP7YMLz+EbsrAJ6sHwa/pVsG3JQZAQAhvQfWFmEA9TnpBG/RdQIitekGjW3BBvwLkwBLoPMG74clAAtefQKgAOkBlWUBBGyt7v5SOUz/+AmNBE5h+QPynMEDTpqTArnYjQb6h/MC1CR1BlCJ2QC7RmECwoiXB+47cwMO0wUC0NBrBIRtLwWw23MBL/rpAnHHVQIrn7L+ZV17BwYSuQBPY/MBBmR3ARqGzQAtaVkF8Xw7BLGR0Qf3pK8D44ElAl7mqQH5AhkH1jexAUwijwCEruMCaOdu/vrl4QE9CCsGnxA/A2SUzwd1loz+M3APBVUUqQVye4r3Fe2dBp0GBQXA7lT/YdoRBA9pXwVTeR0HqYctAQOdSQf73TkDaGNhAq94+wWZCOkCCKylBsd0+Qe3uzkC0OQVB4CcJwT5DPkEAGLXAqTUMwMZKuEDJeHFBXW2uv5IsA8E=", + "encoding": "base64", + "path": [ + "z", + 46, + "data" + ] + }, + { + "data": "ZTjIvzX6wMCR+8LAukjpwEhVb8GOPLdAY46owOZF38AtZEzBiF/hwLp6QcGxWizBqC3CQJb60UBSZf3AcOMpP3R0T0F2/IJAwbQ5QSWLisDZR+TA2v4WQQYrC8EwZ2dB63E6QcZKFEHBpErBd75DwV7XLUDNR07B0IQIwafqv0DHI/vAsVRawbxGkcD3dNxAS6WvQJdb58AiUv9A0x9FwDrk+D8ehtlA9NZLwSg1UcH8uYpBniQzQY6n+b/SIcu/JvZ4QPOmocDkDbxASlRqwUUiBcEpoIrA+TFdwSY4mb+4dlfBzyiTwDnUU8G2hFzAxq6jwC9GTsA+h0PBRrtzwF5wFMHK/VjBEDq/QC5MykBIWLXAAypjwb3db0Fujy1Am54qwP4qvMBc6/NAHhaCwBO58kAGWppABCABwVELWMGLsLzARiC9QEloqEBAMynAHnPMQJQI2kB0cFpBu71nQQ9IzkBpkHlAIjYDweKZoED+McdAFd5KwUs3t0CFFc+/anT3wENTE8He/IlADlQVv48zkEBME1pB2/Bxwe1sJMFlel1B6cVrwbbax7+zf9TAhnQ3wDUwdUESixNBbpJzP73Ui0DsQMDAPFGmQAd1kMD1t/LAX1hCwfDJXsEJ3k/AdAFqQX7jNEDaR4BB99AUwOjDXEFE11dBJKkGwQ8HLcHiJ71ArG2cvjs1vECXaQlB9+PLwFKhkcCIdWtBGOvNv9BYs0DcuWe+shzIQJTA/8ArJ7ZAQMy8vwH90EA0XQnBCWhrwM/s+z5DEUfBabljwYTIRsDgw1o/IGEKQJT1mMBESGDBxyqMQCSJB8F5VAJAJm3LQJ3fMUEvk7/AuNZvQZHqrMB5FJk+mO0lQHBPgUGk3iFAd2QNwRkd9MCbqhNAUzfPQEstusCPyuPAgLUWweBB/78Swu7A5dzaQOqhwMCPM2NB53uAQXkGB8CSZ4JBxW1bwYLtG0G4sr8/QX8iQWFywECQZqRA9VFcwfQ5vUBNwdtASXtZQcdS00A6NX5A234OwcTxUkFI/u3AasPkwCRayED8IoJBg1EnQAws3MA=", + "encoding": "base64", + "path": [ + "z", + 47, + "data" + ] + }, + { + "data": "njPUwFuJIsAZWBzB4T+TwP7KdMHIfLo+4dITwcszAMG3kFbBt14lwQ0NY8FwlEXBfavWQOeZsUC86wjBXjCewDxUJ0Ennb4/vJIBQY/5yb6XyYPA/RueQD3XAMHbolVBDMAFQdc8nEB2eU3B6eM0wRwHQMDMgULBOIQDwY/frUAHrqvAmrJXwVELEsFz8fA/DPd9QLeimMCs7ltAEk1SPzETpkCgBbJAgTpwwRdRVsEngIhB4tfoQALk08DwhtfARtOdP2czib8pvYBAr4FuwfxlCcHY+mg+tE9kwSB8hcB9M0PBNAzbwJTmWMHQ7vrAlvYXwfrptcA+Cy3BSsLCwKA0QcG/B03BHMPUQMeytkBhsN/ApAFmwTECUEFkv1PAWvaswFAZ98DTrENAir0PwewyJUBdovY/dioPwdYZTsGUnfu/2Ki5QBX6M0C7HgZAyGGDQMcMv0ArLjBBXr9cQU8bwkBQM0M/aJu0wN9n4UDP8tVAehZSwdLNwUDF2CBAkW4zwXrUN8F6OqU/UeJ9wCWt4z+1lyxBLv5uwVXkPcGvRj9BRjZcwQg3zsDyhvfA2XGywLHNYkEDephAOe+PwJB02D+RJyfBwhLUQI7lCcEPx+zAf5RpwSBTVcHYavbAZqFVQQdcAr9pqHpBrdDswCtQLUF1mCxB4eUIwTBiD8Flnm1AEfqvwHqpy0AWXXdASWgnwce3CcHv1WVBLNTWwPqNxkC4RJNAQTtAP31M0MDAPpU+nQnLwMx7wkC8G77AVG7DPuHcqcC652HBGfJrwUN/xz/vm4zAOuE6wFC42MA5jVPBd4WCP5fB+MBi5KtAz2mfQL0M+EA7FwbAaJFbQXt36cDXRi/A+tRQv7JRakEq/kPAv8M0wb10BsH2BaZA6CzYQMJTA8CQ1CzBtH3YwKjvlsA6YJ/AoQDsP0GCKcGkqU9BK35yQWY+m8CjMHNBFSpQweN9uEBYNXPALSi7QBZs1EAL5htAYsBpwWyMz0CNpf0/AbhoQbnNnUDY6b+/urP9wIPbW0FS5AHBbfEtwSJdoEAjE4ZB0YanQAV7WMA=", + "encoding": "base64", + "path": [ + "z", + 48, + "data" + ] + }, + { + "data": "ycAnwRiqPUDGYETBGOWbv7X7asHS26XA0RM+wZso+sD1T1HBtMRGwQEUdMECCE/BeBGwQLuFQkB5tfvAm88VwcRA00C0EN+/XmhaQOnTZUDsGKy+Q5dKv7E9xcAZHjNB2T5wQIqkIL9Dj0LBVeAYwR0u+MCg6ijB+SrJwJzXMkDILQW/SgxHwfw3SsE4QW/AWNwJP5v1Pb/iU/+/duqIQCLyy0DFgD5AWzGCwesnTcHOs39BkJABQNBiJMGh8ijBaqziv4wGTUCYR4o/eLhjwRfF78D7H5BAWGVbwegQy8AYVSDBHIIBwXjsTcGG5zHBzn1KwXyT68D4aAnB+YznwL9TW8GUgjLBFkSnQP5PWkAxStvA1TpawUL3IEEpmgPBRBblwGC4CMF/dxLA+jNJwRGMU8DCp9q/adYIwSMlNcF6iE5AMydeQPf8Gb9Vpb1A9900PxUXZUC4oeFApVNAQRELjEAdvjfAbK10v3V43EDtR6VAiHtKwfNkjkBmk65AWb5WwcTzSMGBnxDAZyjPwFIv4L9NcdlAm9RcwUPBR8HjbgxB4Vg9wRRQIcHnZe/AFfDtwBY5P0FB6Ui/Zs4NwZCiAMD2zVrBV/zAQN++OMH0BqjAErx/wd6JO8ENuC7BfAgvQQzcb8Ah+mZBF1c0wZLf00AjitlAVs/rwKr3ycC+Qa4+vzoYwfxwo0Dgaf2/3SRVwR5INME0EVBBVjIqwc7DlkCqJOVAw0KjwKYFQcCFc6fAM10hwTwOdEAhhiDASS+EQGjgHcE0s2zBwB9lwQAPq0DhUgnB6NfnwOOt8MAuBTnB3yZGwGwEuMDOYc9A4vIMQPHoS0BzQRtA4P40QSy+A8GN66XAyiN6wC7jQUGRB/rA1XlKwcwi/cBmncJAYPCoQAM0E0DmDFbBCd9NwPeu0MDPcpy+EpFswF0KX8FvIStBlCNVQf1N2cALRFJBJi03wdLRLz9toAHBxFCVPhvKqECDdWu/2VNowfURpUBQbGLAlJ1qQdlaAEB4qcrAzUypwFRrVkE4kO3AtzpXwb0aKkAW9INBZjG0QMlUDUA=", + "encoding": "base64", + "path": [ + "z", + 49, + "data" + ] + } + ], + "model_module": "ipyvolume", + "model_module_version": "^0.5.0-beta.1", + "model_name": "ScatterModel", + "state": { + "geo": "arrow", + "line_material": "IPY_MODEL_e8566485affb45f8bd994182350ee604", + "material": "IPY_MODEL_3e8cee824d0f4b68ad7f23b1717c261e", + "selected": null, + "sequence_index": 17, + "size": 7, + "size_selected": 26, + "texture": null, + "visible": true, + "vx": [ + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + } + ], + "vy": [ + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + } + ], + "vz": [ + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + } + ], + "x": [ + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + } + ], + "y": [ + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + } + ], + "z": [ + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 200 + ] + } + ] + } + }, + "c641231c68b14e8292677203201fa6b0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.1.0", + "model_name": "LayoutModel", + "state": {} + }, + "c70fb21381d94e9f8d203c17d13aa7fc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.4.0", + "model_name": "VBoxModel", + "state": { + "children": [ + "IPY_MODEL_8dbf31d0ae3648cbabe83f95f9b7e3b5" + ], + "layout": "IPY_MODEL_3ddf7e481aec4de694577c019c98cfaf" + } + }, + "ca43709a8b204164a304b73735979e94": { + "model_module": "jupyter-threejs", + "model_module_version": "~1.0.0", + "model_name": "SceneModel", + "state": { + "_model_module_version": "~1.0.0", + "_view_module": null, + "_view_module_version": "", + "background": null + } + }, + "ca841fd5477640649d0cd0bc7e980b61": { + "model_module": "ipyvolume", + "model_module_version": "^0.5.0-beta.1", + "model_name": "FigureModel", + "state": { + "ambient_coefficient": 0.5, + "animation": 200, + "camera": "IPY_MODEL_c0d781a560654bd5bcdddd6a44889c19", + "capture_fps": null, + "diffuse_coefficient": 0.8, + "height": 500, + "layout": "IPY_MODEL_8cd7b3c022054937a9d9fc5778faa430", + "matrix_projection": [ + 2.9448154572796907, + 0, + 0, + 0, + 0, + 2.3558523658237527, + 0, + 0, + 0, + 0, + -1.00010000500025, + -1, + 0, + 0, + -0.200010000500025, + 0 + ], + "matrix_world": [ + 0.05, + 0, + 0, + 0, + 0, + 0.16666666666666666, + 1.020538999289461e-17, + 0, + 0, + -3.061616997868383e-18, + 0.05, + 0, + 0, + 0, + -2, + 1 + ], + "meshes": [], + "scatters": [ + "IPY_MODEL_ff6eb48719bb46c89367ccf844932fed" + ], + "scene": "IPY_MODEL_9909dfc27b8445c9b2c0b0e34b75bbad", + "specular_coefficient": 0.5, + "specular_exponent": 5, + "volumes": [], + "width": 400, + "xlim": [ + -10, + 10 + ], + "ylim": [ + -3, + 3 + ], + "zlim": [ + -10, + 10 + ] + } + }, + "cc7835a92f184cba990381766ff7a5d9": { + "model_module": "ipyvolume", + "model_module_version": "^0.5.0-beta.1", + "model_name": "FigureModel", + "state": { + "ambient_coefficient": 0.5, + "animation": 200, + "camera": "IPY_MODEL_4d7a6daf02e04c048401fe27f6e9411b", + "capture_fps": null, + "diffuse_coefficient": 0.8, + "height": 500, + "layout": "IPY_MODEL_25277f48e0c34a6682c66c20e00a34e7", + "matrix_projection": [ + 2.9448154572796907, + 0, + 0, + 0, + 0, + 2.3558523658237527, + 0, + 0, + 0, + 0, + -1.00010000500025, + -1, + 0, + 0, + -0.200010000500025, + 0 + ], + "matrix_world": [ + 0.5, + 0, + 0, + 0, + 0, + 0.5, + 3.061616997868383e-17, + 0, + 0, + -3.061616997868383e-17, + 0.5, + 0, + 0, + 0, + -2, + 1 + ], + "meshes": [], + "scatters": [ + "IPY_MODEL_6cbccad5b7db418eb20315cbbe3ea8be" + ], + "scene": "IPY_MODEL_197353e08a2a47d896802d935ab84101", + "specular_coefficient": 0.5, + "specular_exponent": 5, + "volumes": [], + "width": 400, + "xlim": [ + -1, + 1 + ], + "ylim": [ + -1, + 1 + ], + "zlim": [ + -1, + 1 + ] + } + }, + "ce132e4bd9694a83834a81a60daea3ee": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.4.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_d3251110850a4dda956417d360076caa", + "IPY_MODEL_ea561674d7254c89aacdac5c4bf4815a" + ], + "layout": "IPY_MODEL_abf85081062f4e82888c09171f55ee72" + } + }, + "cfb2da5a977640d4af4ec44890f9a747": { + "model_module": "jupyter-threejs", + "model_module_version": "~1.0.0", + "model_name": "PerspectiveCameraModel", + "state": { + "_model_module_version": "~1.0.0", + "_view_module": null, + "_view_module_version": "", + "fov": 46, + "position": [ + 0, + 0, + 2 + ], + "projectionMatrix": [ + 2.3558523658237527, + 0, + 0, + 0, + 0, + 2.3558523658237527, + 0, + 0, + 0, + 0, + -1.00010000500025, + -1, + 0, + 0, + -0.200010000500025, + 0 + ] + } + }, + "cfb85996953142479439894fb4c96c1a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.4.0", + "model_name": "FloatSliderModel", + "state": { + "layout": "IPY_MODEL_d081f58788c84a87b245ddc053e78377", + "max": 14, + "style": "IPY_MODEL_0b15901ef7b34307971333d2fde5913e", + "value": 14 + } + }, + "d081f58788c84a87b245ddc053e78377": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.1.0", + "model_name": "LayoutModel", + "state": {} + }, + "d1bb401a114241488e3f386d31f21d8e": { + "model_module": "@jupyter-widgets/output", + "model_module_version": "1.0.0", + "model_name": "OutputModel", + "state": { + "layout": "IPY_MODEL_5a2ace988cc0485f8d31dd37b76a4365", + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": "convert -delay 5.0 -loop 0 /var/folders/4h/rklzvjwj08170p1nlsntfdkw0000gn/T/tmpyxtyf5fp/frame-*.png wave.gif\n" + } + ] + } + }, + "d3251110850a4dda956417d360076caa": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.4.0", + "model_name": "PlayModel", + "state": { + "interval": 200, + "layout": "IPY_MODEL_15ae0e209e304a3b9bb24fe0fea70351", + "max": 14, + "style": "IPY_MODEL_fa7852dab7a74edda19d766352adbb66", + "value": 14 + } + }, + "d4522e05191c44e59e373863e22cab61": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.4.0", + "model_name": "PlayModel", + "state": { + "interval": 200, + "layout": "IPY_MODEL_a10382301480402aa1ddd69c44656e92", + "max": 2, + "style": "IPY_MODEL_4163df1232f24aeb85117381a8944736", + "value": 1 + } + }, + "d79017ea773b4b6f9d66a60a706b6668": { + "model_module": "ipyvolume", + "model_module_version": "^0.5.0-beta.1", + "model_name": "FigureModel", + "state": { + "ambient_coefficient": 0.5, + "animation": 200, + "camera": "IPY_MODEL_245072663ea94bb096b2321d43813961", + "capture_fps": null, + "diffuse_coefficient": 0.8, + "height": 500, + "layout": "IPY_MODEL_ee12cdc16e854395840290d35c74b46f", + "matrix_projection": [ + 2.9448154572796907, + 0, + 0, + 0, + 0, + 2.3558523658237527, + 0, + 0, + 0, + 0, + -1.00010000500025, + -1, + 0, + 0, + -0.200010000500025, + 0 + ], + "matrix_world": [ + 0.05, + 0, + 0, + 0, + 0, + 0.16666666666666666, + 1.020538999289461e-17, + 0, + 0, + -3.061616997868383e-18, + 0.05, + 0, + 0, + 0, + -2, + 1 + ], + "meshes": [], + "scatters": [ + "IPY_MODEL_0b44784ed5904895a8c2cc1e5f71c18c" + ], + "scene": "IPY_MODEL_e8757e3650794e76b697b1f1df0f6fcc", + "specular_coefficient": 0.5, + "specular_exponent": 5, + "volumes": [], + "width": 400, + "xlim": [ + -10, + 10 + ], + "ylim": [ + -3, + 3 + ], + "zlim": [ + -10, + 10 + ] + } + }, + "dab1ee01ae48430abf2f36fdef09580e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.4.0", + "model_name": "SliderStyleModel", + "state": { + "description_width": "" + } + }, + "dc41199297ca477eb7746db122b34869": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.4.0", + "model_name": "VBoxModel", + "state": { + "children": [ + "IPY_MODEL_ca841fd5477640649d0cd0bc7e980b61", + "IPY_MODEL_ce132e4bd9694a83834a81a60daea3ee" + ], + "layout": "IPY_MODEL_42dbcaf6de244359ae06cf249b1762fa" + } + }, + "e13c3dfe59994790b9a7b82c10c980a6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.4.0", + "model_name": "FloatSliderModel", + "state": { + "layout": "IPY_MODEL_b05fab60e7a440729bd5414b8c187821", + "max": 2, + "style": "IPY_MODEL_dab1ee01ae48430abf2f36fdef09580e", + "value": 1 + } + }, + "e492fbd963294c17a8e32f74283216e9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.1.0", + "model_name": "LayoutModel", + "state": {} + }, + "e5a7217eef0b4574bf0bc5c2f102a3ee": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.4.0", + "model_name": "LinkModel", + "state": { + "source": [ + "IPY_MODEL_d3251110850a4dda956417d360076caa", + "value" + ], + "target": [ + "IPY_MODEL_ea561674d7254c89aacdac5c4bf4815a", + "value" + ] + } + }, + "e8566485affb45f8bd994182350ee604": { + "model_module": "jupyter-threejs", + "model_module_version": "~1.0.0", + "model_name": "ShaderMaterialModel", + "state": { + "_model_module_version": "~1.0.0", + "_view_module": null, + "_view_module_version": "" + } + }, + "e8757e3650794e76b697b1f1df0f6fcc": { + "model_module": "jupyter-threejs", + "model_module_version": "~1.0.0", + "model_name": "SceneModel", + "state": { + "_model_module_version": "~1.0.0", + "_view_module": null, + "_view_module_version": "", + "background": null + } + }, + "ea561674d7254c89aacdac5c4bf4815a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.4.0", + "model_name": "FloatSliderModel", + "state": { + "layout": "IPY_MODEL_ed0a30f9ef184d1e8baa5fa562891b1c", + "max": 14, + "style": "IPY_MODEL_3bd5bd6b326b48749588ca49278a6f8a", + "value": 14 + } + }, + "ed0a30f9ef184d1e8baa5fa562891b1c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.1.0", + "model_name": "LayoutModel", + "state": {} + }, + "edbdc0ff545b4bddb8d1bd00dd7ee5a7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.4.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "ee12cdc16e854395840290d35c74b46f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.1.0", + "model_name": "LayoutModel", + "state": {} + }, + "f1e04a722ad847569876e85392fab858": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.1.0", + "model_name": "LayoutModel", + "state": {} + }, + "f864ec653a9b4f7fb057ccc1baba8ac9": { + "buffers": [ + { + "data": "AACAv83MTL8=", + "encoding": "base64", + "path": [ + "x", + 0, + "data" + ] + }, + { + "data": "AACAP83MzL0=", + "encoding": "base64", + "path": [ + "x", + 1, + "data" + ] + }, + { + "data": "AAAAAAAAAD8=", + "encoding": "base64", + "path": [ + "x", + 2, + "data" + ] + }, + { + "data": "AAAAAAAAAAA=", + "encoding": "base64", + "path": [ + "y", + 0, + "data" + ] + }, + { + "data": "AAAAAAAAAAA=", + "encoding": "base64", + "path": [ + "z", + 0, + "data" + ] + } + ], + "model_module": "ipyvolume", + "model_module_version": "^0.5.0-beta.1", + "model_name": "ScatterModel", + "state": { + "line_material": "IPY_MODEL_8f267d3de871489e9d9f86652fb27317", + "material": "IPY_MODEL_75202cde091f4ea7889b666f63fc7bfb", + "selected": null, + "sequence_index": 1, + "size": 2, + "size_selected": 2.6, + "texture": null, + "visible": true, + "vx": null, + "vy": null, + "vz": null, + "x": [ + { + "data": {}, + "dtype": "float32", + "shape": [ + 2 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 2 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 2 + ] + } + ], + "y": [ + { + "data": {}, + "dtype": "float32", + "shape": [ + 2 + ] + } + ], + "z": [ + { + "data": {}, + "dtype": "float32", + "shape": [ + 2 + ] + } + ] + } + }, + "fa7852dab7a74edda19d766352adbb66": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.4.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "fc3eca8b4090422bbff25ef37b9707c6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.4.0", + "model_name": "SliderStyleModel", + "state": { + "description_width": "" + } + }, + "fd44c9c13f624c51a0b923236f832f36": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.4.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_992acf7dd9a44c028b851bd16b142ffc", + "IPY_MODEL_cfb85996953142479439894fb4c96c1a" + ], + "layout": "IPY_MODEL_22f0f8cc309d4401b5cdc4e70e771051" + } + }, + "ff6eb48719bb46c89367ccf844932fed": { + "buffers": [ + { + "data": "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", + "encoding": "base64", + "path": [ + "color", + 0, + "data" + ] + }, + { + "data": "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", + "encoding": "base64", + "path": [ + "color", + 1, + "data" + ] + }, + { + "data": "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", + "encoding": "base64", + "path": [ + "color", + 2, + "data" + ] + }, + { + "data": "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", + "encoding": "base64", + "path": [ + "color", + 3, + "data" + ] + }, + { + "data": "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", + "encoding": "base64", + "path": [ + "color", + 4, + "data" + ] + }, + { + "data": "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", + "encoding": "base64", + "path": [ + "color", + 5, + "data" + ] + }, + { + "data": "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", + "encoding": "base64", + "path": [ + "color", + 6, + "data" + ] + }, + { + "data": "KdCiO8Hsfz/NzMw9AACAPx53Cr/Z0HY/zczMPQAAgD9jb2a/cfFuP83MzD0AAIA/tW9/v1IIaz/NzMw9AACAPwKIWr+fP2w/zczMPQAAgD9smwy/UR5yP83MzD0AAIA/FSA8vjD5ej/NzMw9AACAPyhoJT5HQ3s/zczMPQAAgD/Z1+A+cVhyP83MzD0AAIA/UoUiP3dRaz/NzMw9AACAP8icQT+pgmY/zczMPQAAgD/N2FE/6MtjP83MzD0AAIA/ZM1WP//tYj/NzMw9AACAP83YUT/oy2M/zczMPQAAgD/InEE/qYJmP83MzD0AAIA/UoUiP3dRaz/NzMw9AACAP9nX4D5xWHI/zczMPQAAgD8oaCU+R0N7P83MzD0AAIA/FSA8vjD5ej/NzMw9AACAP2ybDL9RHnI/zczMPQAAgD8CiFq/nz9sP83MzD0AAIA/tW9/v1IIaz/NzMw9AACAP2NvZr9x8W4/zczMPQAAgD8edwq/2dB2P83MzD0AAIA/KdCiO8Hsfz/NzMw9AACAPx53Cr/Z0HY/zczMPQAAgD+DEGy/sFZuP83MzD0AAIA/wPR7v/HZaj/NzMw9AACAPxQLQL+VBm4/zczMPQAAgD9PQaq+ly13P83MzD0AAIA/Z/wEPjM3fD/NzMw9AACAP4+qBj/NUG8/zczMPQAAgD9fqEw/7q5kP83MzD0AAIA/GkJyP1ePXT/NzMw9AACAP2g/fz+J1Vk/zczMPQAAgD9hg34/a4NYP83MzD0AAIA/+c95P2JcWD/NzMw9AACAPwuFdz83bVg/zczMPQAAgD/5z3k/YlxYP83MzD0AAIA/YYN+P2uDWD/NzMw9AACAP2g/fz+J1Vk/zczMPQAAgD8aQnI/V49dP83MzD0AAIA/X6hMP+6uZD/NzMw9AACAP4+qBj/NUG8/zczMPQAAgD9n/AQ+Mzd8P83MzD0AAIA/T0Gqvpctdz/NzMw9AACAPxQLQL+VBm4/zczMPQAAgD/A9Hu/8dlqP83MzD0AAIA/gxBsv7BWbj/NzMw9AACAPx53Cr/Z0HY/zczMPQAAgD9jb2a/cfFuP83MzD0AAIA/wPR7v/HZaj/NzMw9AACAP27ENb9MyW4/zczMPQAAgD9DP1u+lS16P83MzD0AAIA/ANuiPpdddj/NzMw9AACAPxnGOz+Scmc/zczMPQAAgD/3DXU/u+lcP83MzD0AAIA/YYN+P2uDWD/NzMw9AACAP9qRZj+5slk/zczMPQAAgD9nsj8/4lpeP83MzD0AAIA/48cZP8nlYz/NzMw9AACAPxjP/j63Img/zczMPQAAgD/wIuw+JrNpP83MzD0AAIA/GM/+PrciaD/NzMw9AACAP+PHGT/J5WM/zczMPQAAgD9nsj8/4lpeP83MzD0AAIA/2pFmP7myWT/NzMw9AACAP2GDfj9rg1g/zczMPQAAgD/3DXU/u+lcP83MzD0AAIA/GcY7P5JyZz/NzMw9AACAPwDboj6XXXY/zczMPQAAgD9DP1u+lS16P83MzD0AAIA/bsQ1v0zJbj/NzMw9AACAP8D0e7/x2Wo/zczMPQAAgD9jb2a/cfFuP83MzD0AAIA/tW9/v1IIaz/NzMw9AACAPxQLQL+VBm4/zczMPQAAgD9DP1u+lS16P83MzD0AAIA/eivCPrRcdD/NzMw9AACAP83YUT/oy2M/zczMPQAAgD9oP38/idVZP83MzD0AAIA/57BqPzlQWT/NzMw9AACAPxLmKT/9c2E/zczMPQAAgD+nMrE+xNZuP83MzD0AAIA/V7hTPQ1HfT/NzMw9AACAP7FHLr6loHY/zczMPQAAgD9aIZu+FtpuP83MzD0AAIA/L3qxviIzbD/NzMw9AACAP1ohm74W2m4/zczMPQAAgD+xRy6+paB2P83MzD0AAIA/V7hTPQ1HfT/NzMw9AACAP6cysT7E1m4/zczMPQAAgD8S5ik//XNhP83MzD0AAIA/57BqPzlQWT/NzMw9AACAP2g/fz+J1Vk/zczMPQAAgD/N2FE/6MtjP83MzD0AAIA/eivCPrRcdD/NzMw9AACAP0M/W76VLXo/zczMPQAAgD8UC0C/lQZuP83MzD0AAIA/tW9/v1IIaz/NzMw9AACAPwKIWr+fP2w/zczMPQAAgD9PQaq+ly13P83MzD0AAIA/ANuiPpdddj/NzMw9AACAP83YUT/oy2M/zczMPQAAgD+k/38/7ydZP83MzD0AAIA/fAhYP71DWz/NzMw9AACAP/Ai7D4ms2k/zczMPQAAgD8zTvs7rZd/P83MzD0AAIA/v5THvqWGaT/NzMw9AACAP+p5K7+gt1Y/zczMPQAAgD9v6VS/KiJKP83MzD0AAIA/nB5ovw9yQz/NzMw9AACAP/hnbb+ha0E/zczMPQAAgD+cHmi/D3JDP83MzD0AAIA/b+lUvyoiSj/NzMw9AACAP+p5K7+gt1Y/zczMPQAAgD+/lMe+pYZpP83MzD0AAIA/M077O62Xfz/NzMw9AACAP/Ai7D4ms2k/zczMPQAAgD98CFg/vUNbP83MzD0AAIA/pP9/P+8nWT/NzMw9AACAP83YUT/oy2M/zczMPQAAgD8A26I+l112P83MzD0AAIA/T0Gqvpctdz/NzMw9AACAPwKIWr+fP2w/zczMPQAAgD9smwy/UR5yP83MzD0AAIA/Z/wEPjM3fD/NzMw9AACAPxnGOz+Scmc/zczMPQAAgD9oP38/idVZP83MzD0AAIA/fAhYP71DWz/NzMw9AACAP9pNxT5jDW0/zczMPQAAgD+xRy6+paB2P83MzD0AAIA/AAoiv9tdWT/NzMw9AACAP5weaL8PckM/zczMPQAAgD/HfH+/UzM4P83MzD0AAIA/Gwd6vx+xNT/NzMw9AACAPym3bL9tJzc/zczMPQAAgD/sh2a/QTY4P83MzD0AAIA/Kbdsv20nNz/NzMw9AACAPxsHer8fsTU/zczMPQAAgD/HfH+/UzM4P83MzD0AAIA/nB5ovw9yQz/NzMw9AACAPwAKIr/bXVk/zczMPQAAgD+xRy6+paB2P83MzD0AAIA/2k3FPmMNbT/NzMw9AACAP3wIWD+9Q1s/zczMPQAAgD9oP38/idVZP83MzD0AAIA/GcY7P5JyZz/NzMw9AACAP2f8BD4zN3w/zczMPQAAgD9smwy/UR5yP83MzD0AAIA/FSA8vjD5ej/NzMw9AACAP4+qBj/NUG8/zczMPQAAgD/3DXU/u+lcP83MzD0AAIA/57BqPzlQWT/NzMw9AACAP/Ai7D4ms2k/zczMPQAAgD+xRy6+paB2P83MzD0AAIA/rpE0v8MZVD/NzMw9AACAP+WGeb+vHDw/zczMPQAAgD9ydHa/Deg1P83MzD0AAIA/XPJEvyKdPz/NzMw9AACAP82QB78VwVA/zczMPQAAgD93ubK+aZNfP83MzD0AAIA/LDyRvhdJZT/NzMw9AACAP3e5sr5pk18/zczMPQAAgD/NkAe/FcFQP83MzD0AAIA/XPJEvyKdPz/NzMw9AACAP3J0dr8N6DU/zczMPQAAgD/lhnm/rxw8P83MzD0AAIA/rpE0v8MZVD/NzMw9AACAP7FHLr6loHY/zczMPQAAgD/wIuw+JrNpP83MzD0AAIA/57BqPzlQWT/NzMw9AACAP/cNdT+76Vw/zczMPQAAgD+PqgY/zVBvP83MzD0AAIA/FSA8vjD5ej/NzMw9AACAPyhoJT5HQ3s/zczMPQAAgD9fqEw/7q5kP83MzD0AAIA/YYN+P2uDWD/NzMw9AACAPxLmKT/9c2E/zczMPQAAgD8zTvs7rZd/P83MzD0AAIA/AAoiv9tdWT/NzMw9AACAP+WGeb+vHDw/zczMPQAAgD8pt2y/bSc3P83MzD0AAIA/uHsVv+CUTD/NzMw9AACAP324Fb401nE/zczMPQAAgD+HNmQ+GL9oP83MzD0AAIA/acXkPhcaTz/NzMw9AACAP4XfBD/rQEY/zczMPQAAgD9pxeQ+FxpPP83MzD0AAIA/hzZkPhi/aD/NzMw9AACAP324Fb401nE/zczMPQAAgD+4exW/4JRMP83MzD0AAIA/Kbdsv20nNz/NzMw9AACAP+WGeb+vHDw/zczMPQAAgD8ACiK/211ZP83MzD0AAIA/M077O62Xfz/NzMw9AACAPxLmKT/9c2E/zczMPQAAgD9hg34/a4NYP83MzD0AAIA/X6hMP+6uZD/NzMw9AACAPyhoJT5HQ3s/zczMPQAAgD/Z1+A+cVhyP83MzD0AAIA/GkJyP1ePXT/NzMw9AACAP9qRZj+5slk/zczMPQAAgD+nMrE+xNZuP83MzD0AAIA/v5THvqWGaT/NzMw9AACAP5weaL8PckM/zczMPQAAgD9ydHa/Deg1P83MzD0AAIA/uHsVv+CUTD/NzMw9AACAP8AV2bq41X8/zczMPQAAgD+F3wQ/60BGP83MzD0AAIA/YGdVP9i5Gj/NzMw9AACAP8P9dD+SxQQ/zczMPQAAgD/9Tns/ovL9Ps3MzD0AAIA/w/10P5LFBD/NzMw9AACAP2BnVT/YuRo/zczMPQAAgD+F3wQ/60BGP83MzD0AAIA/wBXZurjVfz/NzMw9AACAP7h7Fb/glEw/zczMPQAAgD9ydHa/Deg1P83MzD0AAIA/nB5ovw9yQz/NzMw9AACAP7+Ux76lhmk/zczMPQAAgD+nMrE+xNZuP83MzD0AAIA/2pFmP7myWT/NzMw9AACAPxpCcj9Xj10/zczMPQAAgD/Z1+A+cVhyP83MzD0AAIA/UoUiP3dRaz/NzMw9AACAP2g/fz+J1Vk/zczMPQAAgD9nsj8/4lpeP83MzD0AAIA/V7hTPQ1HfT/NzMw9AACAP+p5K7+gt1Y/zczMPQAAgD/HfH+/UzM4P83MzD0AAIA/XPJEvyKdPz/NzMw9AACAP324Fb401nE/zczMPQAAgD+F3wQ/60BGP83MzD0AAIA/K2RsP19xCz/NzMw9AACAPz2afT++5ek+zczMPQAAgD844F8/6Kv3Ps3MzD0AAIA/vxdNP96aAz/NzMw9AACAPzjgXz/oq/c+zczMPQAAgD89mn0/vuXpPs3MzD0AAIA/K2RsP19xCz/NzMw9AACAP4XfBD/rQEY/zczMPQAAgD99uBW+NNZxP83MzD0AAIA/XPJEvyKdPz/NzMw9AACAP8d8f79TMzg/zczMPQAAgD/qeSu/oLdWP83MzD0AAIA/V7hTPQ1HfT/NzMw9AACAP2eyPz/iWl4/zczMPQAAgD9oP38/idVZP83MzD0AAIA/UoUiP3dRaz/NzMw9AACAP8icQT+pgmY/zczMPQAAgD9hg34/a4NYP83MzD0AAIA/48cZP8nlYz/NzMw9AACAP7FHLr6loHY/zczMPQAAgD9v6VS/KiJKP83MzD0AAIA/Gwd6vx+xNT/NzMw9AACAP82QB78VwVA/zczMPQAAgD+HNmQ+GL9oP83MzD0AAIA/YGdVP9i5Gj/NzMw9AACAPz2afT++5ek+zczMPQAAgD9PKzU/g+0OP83MzD0AAIA/962TPvshTT/NzMw9AACAP7UKxD31cG4/zczMPQAAgD/3rZM++yFNP83MzD0AAIA/Tys1P4PtDj/NzMw9AACAPz2afT++5ek+zczMPQAAgD9gZ1U/2LkaP83MzD0AAIA/hzZkPhi/aD/NzMw9AACAP82QB78VwVA/zczMPQAAgD8bB3q/H7E1P83MzD0AAIA/b+lUvyoiSj/NzMw9AACAP7FHLr6loHY/zczMPQAAgD/jxxk/yeVjP83MzD0AAIA/YYN+P2uDWD/NzMw9AACAP8icQT+pgmY/zczMPQAAgD/N2FE/6MtjP83MzD0AAIA/+c95P2JcWD/NzMw9AACAPxjP/j63Img/zczMPQAAgD9aIZu+FtpuP83MzD0AAIA/nB5ovw9yQz/NzMw9AACAPym3bL9tJzc/zczMPQAAgD93ubK+aZNfP83MzD0AAIA/acXkPhcaTz/NzMw9AACAP8P9dD+SxQQ/zczMPQAAgD844F8/6Kv3Ps3MzD0AAIA/962TPvshTT/NzMw9AACAP/C8w76SrjI/zczMPQAAgD81Iyy/05PcPs3MzD0AAIA/8LzDvpKuMj/NzMw9AACAP/etkz77IU0/zczMPQAAgD844F8/6Kv3Ps3MzD0AAIA/w/10P5LFBD/NzMw9AACAP2nF5D4XGk8/zczMPQAAgD93ubK+aZNfP83MzD0AAIA/Kbdsv20nNz/NzMw9AACAP5weaL8PckM/zczMPQAAgD9aIZu+FtpuP83MzD0AAIA/GM/+PrciaD/NzMw9AACAP/nPeT9iXFg/zczMPQAAgD/N2FE/6MtjP83MzD0AAIA/ZM1WP//tYj/NzMw9AACAPwuFdz83bVg/zczMPQAAgD/wIuw+JrNpP83MzD0AAIA/L3qxviIzbD/NzMw9AACAP/hnbb+ha0E/zczMPQAAgD/sh2a/QTY4P83MzD0AAIA/LDyRvhdJZT/NzMw9AACAP4XfBD/rQEY/zczMPQAAgD/9Tns/ovL9Ps3MzD0AAIA/vxdNP96aAz/NzMw9AACAP7UKxD31cG4/zczMPQAAgD81Iyy/05PcPs3MzD0AAIA/AACAvwAAAADNzMw9AACAPzUjLL/Tk9w+zczMPQAAgD+1CsQ99XBuP83MzD0AAIA/vxdNP96aAz/NzMw9AACAP/1Oez+i8v0+zczMPQAAgD+F3wQ/60BGP83MzD0AAIA/LDyRvhdJZT/NzMw9AACAP+yHZr9BNjg/zczMPQAAgD/4Z22/oWtBP83MzD0AAIA/L3qxviIzbD/NzMw9AACAP/Ai7D4ms2k/zczMPQAAgD8LhXc/N21YP83MzD0AAIA/ZM1WP//tYj/NzMw9AACAP83YUT/oy2M/zczMPQAAgD/5z3k/YlxYP83MzD0AAIA/GM/+PrciaD/NzMw9AACAP1ohm74W2m4/zczMPQAAgD+cHmi/D3JDP83MzD0AAIA/Kbdsv20nNz/NzMw9AACAP3e5sr5pk18/zczMPQAAgD9pxeQ+FxpPP83MzD0AAIA/w/10P5LFBD/NzMw9AACAPzjgXz/oq/c+zczMPQAAgD/3rZM++yFNP83MzD0AAIA/8LzDvpKuMj/NzMw9AACAPzUjLL/Tk9w+zczMPQAAgD/wvMO+kq4yP83MzD0AAIA/962TPvshTT/NzMw9AACAPzjgXz/oq/c+zczMPQAAgD/D/XQ/ksUEP83MzD0AAIA/acXkPhcaTz/NzMw9AACAP3e5sr5pk18/zczMPQAAgD8pt2y/bSc3P83MzD0AAIA/nB5ovw9yQz/NzMw9AACAP1ohm74W2m4/zczMPQAAgD8Yz/4+tyJoP83MzD0AAIA/+c95P2JcWD/NzMw9AACAP83YUT/oy2M/zczMPQAAgD/InEE/qYJmP83MzD0AAIA/YYN+P2uDWD/NzMw9AACAP+PHGT/J5WM/zczMPQAAgD+xRy6+paB2P83MzD0AAIA/b+lUvyoiSj/NzMw9AACAPxsHer8fsTU/zczMPQAAgD/NkAe/FcFQP83MzD0AAIA/hzZkPhi/aD/NzMw9AACAP2BnVT/YuRo/zczMPQAAgD89mn0/vuXpPs3MzD0AAIA/Tys1P4PtDj/NzMw9AACAP/etkz77IU0/zczMPQAAgD+1CsQ99XBuP83MzD0AAIA/962TPvshTT/NzMw9AACAP08rNT+D7Q4/zczMPQAAgD89mn0/vuXpPs3MzD0AAIA/YGdVP9i5Gj/NzMw9AACAP4c2ZD4Yv2g/zczMPQAAgD/NkAe/FcFQP83MzD0AAIA/Gwd6vx+xNT/NzMw9AACAP2/pVL8qIko/zczMPQAAgD+xRy6+paB2P83MzD0AAIA/48cZP8nlYz/NzMw9AACAP2GDfj9rg1g/zczMPQAAgD/InEE/qYJmP83MzD0AAIA/UoUiP3dRaz/NzMw9AACAP2g/fz+J1Vk/zczMPQAAgD9nsj8/4lpeP83MzD0AAIA/V7hTPQ1HfT/NzMw9AACAP+p5K7+gt1Y/zczMPQAAgD/HfH+/UzM4P83MzD0AAIA/XPJEvyKdPz/NzMw9AACAP324Fb401nE/zczMPQAAgD+F3wQ/60BGP83MzD0AAIA/K2RsP19xCz/NzMw9AACAPz2afT++5ek+zczMPQAAgD844F8/6Kv3Ps3MzD0AAIA/vxdNP96aAz/NzMw9AACAPzjgXz/oq/c+zczMPQAAgD89mn0/vuXpPs3MzD0AAIA/K2RsP19xCz/NzMw9AACAP4XfBD/rQEY/zczMPQAAgD99uBW+NNZxP83MzD0AAIA/XPJEvyKdPz/NzMw9AACAP8d8f79TMzg/zczMPQAAgD/qeSu/oLdWP83MzD0AAIA/V7hTPQ1HfT/NzMw9AACAP2eyPz/iWl4/zczMPQAAgD9oP38/idVZP83MzD0AAIA/UoUiP3dRaz/NzMw9AACAP9nX4D5xWHI/zczMPQAAgD8aQnI/V49dP83MzD0AAIA/2pFmP7myWT/NzMw9AACAP6cysT7E1m4/zczMPQAAgD+/lMe+pYZpP83MzD0AAIA/nB5ovw9yQz/NzMw9AACAP3J0dr8N6DU/zczMPQAAgD+4exW/4JRMP83MzD0AAIA/wBXZurjVfz/NzMw9AACAP4XfBD/rQEY/zczMPQAAgD9gZ1U/2LkaP83MzD0AAIA/w/10P5LFBD/NzMw9AACAP/1Oez+i8v0+zczMPQAAgD/D/XQ/ksUEP83MzD0AAIA/YGdVP9i5Gj/NzMw9AACAP4XfBD/rQEY/zczMPQAAgD/AFdm6uNV/P83MzD0AAIA/uHsVv+CUTD/NzMw9AACAP3J0dr8N6DU/zczMPQAAgD+cHmi/D3JDP83MzD0AAIA/v5THvqWGaT/NzMw9AACAP6cysT7E1m4/zczMPQAAgD/akWY/ubJZP83MzD0AAIA/GkJyP1ePXT/NzMw9AACAP9nX4D5xWHI/zczMPQAAgD8oaCU+R0N7P83MzD0AAIA/X6hMP+6uZD/NzMw9AACAP2GDfj9rg1g/zczMPQAAgD8S5ik//XNhP83MzD0AAIA/M077O62Xfz/NzMw9AACAPwAKIr/bXVk/zczMPQAAgD/lhnm/rxw8P83MzD0AAIA/Kbdsv20nNz/NzMw9AACAP7h7Fb/glEw/zczMPQAAgD99uBW+NNZxP83MzD0AAIA/hzZkPhi/aD/NzMw9AACAP2nF5D4XGk8/zczMPQAAgD+F3wQ/60BGP83MzD0AAIA/acXkPhcaTz/NzMw9AACAP4c2ZD4Yv2g/zczMPQAAgD99uBW+NNZxP83MzD0AAIA/uHsVv+CUTD/NzMw9AACAPym3bL9tJzc/zczMPQAAgD/lhnm/rxw8P83MzD0AAIA/AAoiv9tdWT/NzMw9AACAPzNO+zutl38/zczMPQAAgD8S5ik//XNhP83MzD0AAIA/YYN+P2uDWD/NzMw9AACAP1+oTD/urmQ/zczMPQAAgD8oaCU+R0N7P83MzD0AAIA/FSA8vjD5ej/NzMw9AACAP4+qBj/NUG8/zczMPQAAgD/3DXU/u+lcP83MzD0AAIA/57BqPzlQWT/NzMw9AACAP/Ai7D4ms2k/zczMPQAAgD+xRy6+paB2P83MzD0AAIA/rpE0v8MZVD/NzMw9AACAP+WGeb+vHDw/zczMPQAAgD9ydHa/Deg1P83MzD0AAIA/XPJEvyKdPz/NzMw9AACAP82QB78VwVA/zczMPQAAgD93ubK+aZNfP83MzD0AAIA/LDyRvhdJZT/NzMw9AACAP3e5sr5pk18/zczMPQAAgD/NkAe/FcFQP83MzD0AAIA/XPJEvyKdPz/NzMw9AACAP3J0dr8N6DU/zczMPQAAgD/lhnm/rxw8P83MzD0AAIA/rpE0v8MZVD/NzMw9AACAP7FHLr6loHY/zczMPQAAgD/wIuw+JrNpP83MzD0AAIA/57BqPzlQWT/NzMw9AACAP/cNdT+76Vw/zczMPQAAgD+PqgY/zVBvP83MzD0AAIA/FSA8vjD5ej/NzMw9AACAP2ybDL9RHnI/zczMPQAAgD9n/AQ+Mzd8P83MzD0AAIA/GcY7P5JyZz/NzMw9AACAP2g/fz+J1Vk/zczMPQAAgD98CFg/vUNbP83MzD0AAIA/2k3FPmMNbT/NzMw9AACAP7FHLr6loHY/zczMPQAAgD8ACiK/211ZP83MzD0AAIA/nB5ovw9yQz/NzMw9AACAP8d8f79TMzg/zczMPQAAgD8bB3q/H7E1P83MzD0AAIA/Kbdsv20nNz/NzMw9AACAP+yHZr9BNjg/zczMPQAAgD8pt2y/bSc3P83MzD0AAIA/Gwd6vx+xNT/NzMw9AACAP8d8f79TMzg/zczMPQAAgD+cHmi/D3JDP83MzD0AAIA/AAoiv9tdWT/NzMw9AACAP7FHLr6loHY/zczMPQAAgD/aTcU+Yw1tP83MzD0AAIA/fAhYP71DWz/NzMw9AACAP2g/fz+J1Vk/zczMPQAAgD8Zxjs/knJnP83MzD0AAIA/Z/wEPjM3fD/NzMw9AACAP2ybDL9RHnI/zczMPQAAgD8CiFq/nz9sP83MzD0AAIA/T0Gqvpctdz/NzMw9AACAPwDboj6XXXY/zczMPQAAgD/N2FE/6MtjP83MzD0AAIA/pP9/P+8nWT/NzMw9AACAP3wIWD+9Q1s/zczMPQAAgD/wIuw+JrNpP83MzD0AAIA/M077O62Xfz/NzMw9AACAP7+Ux76lhmk/zczMPQAAgD/qeSu/oLdWP83MzD0AAIA/b+lUvyoiSj/NzMw9AACAP5weaL8PckM/zczMPQAAgD/4Z22/oWtBP83MzD0AAIA/nB5ovw9yQz/NzMw9AACAP2/pVL8qIko/zczMPQAAgD/qeSu/oLdWP83MzD0AAIA/v5THvqWGaT/NzMw9AACAPzNO+zutl38/zczMPQAAgD/wIuw+JrNpP83MzD0AAIA/fAhYP71DWz/NzMw9AACAP6T/fz/vJ1k/zczMPQAAgD/N2FE/6MtjP83MzD0AAIA/ANuiPpdddj/NzMw9AACAP09Bqr6XLXc/zczMPQAAgD8CiFq/nz9sP83MzD0AAIA/tW9/v1IIaz/NzMw9AACAPxQLQL+VBm4/zczMPQAAgD9DP1u+lS16P83MzD0AAIA/eivCPrRcdD/NzMw9AACAP83YUT/oy2M/zczMPQAAgD9oP38/idVZP83MzD0AAIA/57BqPzlQWT/NzMw9AACAPxLmKT/9c2E/zczMPQAAgD+nMrE+xNZuP83MzD0AAIA/V7hTPQ1HfT/NzMw9AACAP7FHLr6loHY/zczMPQAAgD9aIZu+FtpuP83MzD0AAIA/L3qxviIzbD/NzMw9AACAP1ohm74W2m4/zczMPQAAgD+xRy6+paB2P83MzD0AAIA/V7hTPQ1HfT/NzMw9AACAP6cysT7E1m4/zczMPQAAgD8S5ik//XNhP83MzD0AAIA/57BqPzlQWT/NzMw9AACAP2g/fz+J1Vk/zczMPQAAgD/N2FE/6MtjP83MzD0AAIA/eivCPrRcdD/NzMw9AACAP0M/W76VLXo/zczMPQAAgD8UC0C/lQZuP83MzD0AAIA/tW9/v1IIaz/NzMw9AACAP2NvZr9x8W4/zczMPQAAgD/A9Hu/8dlqP83MzD0AAIA/bsQ1v0zJbj/NzMw9AACAP0M/W76VLXo/zczMPQAAgD8A26I+l112P83MzD0AAIA/GcY7P5JyZz/NzMw9AACAP/cNdT+76Vw/zczMPQAAgD9hg34/a4NYP83MzD0AAIA/2pFmP7myWT/NzMw9AACAP2eyPz/iWl4/zczMPQAAgD/jxxk/yeVjP83MzD0AAIA/GM/+PrciaD/NzMw9AACAP/Ai7D4ms2k/zczMPQAAgD8Yz/4+tyJoP83MzD0AAIA/48cZP8nlYz/NzMw9AACAP2eyPz/iWl4/zczMPQAAgD/akWY/ubJZP83MzD0AAIA/YYN+P2uDWD/NzMw9AACAP/cNdT+76Vw/zczMPQAAgD8Zxjs/knJnP83MzD0AAIA/ANuiPpdddj/NzMw9AACAP0M/W76VLXo/zczMPQAAgD9uxDW/TMluP83MzD0AAIA/wPR7v/HZaj/NzMw9AACAP2NvZr9x8W4/zczMPQAAgD8edwq/2dB2P83MzD0AAIA/gxBsv7BWbj/NzMw9AACAP8D0e7/x2Wo/zczMPQAAgD8UC0C/lQZuP83MzD0AAIA/T0Gqvpctdz/NzMw9AACAP2f8BD4zN3w/zczMPQAAgD+PqgY/zVBvP83MzD0AAIA/X6hMP+6uZD/NzMw9AACAPxpCcj9Xj10/zczMPQAAgD9oP38/idVZP83MzD0AAIA/YYN+P2uDWD/NzMw9AACAP/nPeT9iXFg/zczMPQAAgD8LhXc/N21YP83MzD0AAIA/+c95P2JcWD/NzMw9AACAP2GDfj9rg1g/zczMPQAAgD9oP38/idVZP83MzD0AAIA/GkJyP1ePXT/NzMw9AACAP1+oTD/urmQ/zczMPQAAgD+PqgY/zVBvP83MzD0AAIA/Z/wEPjM3fD/NzMw9AACAP09Bqr6XLXc/zczMPQAAgD8UC0C/lQZuP83MzD0AAIA/wPR7v/HZaj/NzMw9AACAP4MQbL+wVm4/zczMPQAAgD8edwq/2dB2P83MzD0AAIA/KdCiO8Hsfz/NzMw9AACAPx53Cr/Z0HY/zczMPQAAgD9jb2a/cfFuP83MzD0AAIA/tW9/v1IIaz/NzMw9AACAPwKIWr+fP2w/zczMPQAAgD9smwy/UR5yP83MzD0AAIA/FSA8vjD5ej/NzMw9AACAPyhoJT5HQ3s/zczMPQAAgD/Z1+A+cVhyP83MzD0AAIA/UoUiP3dRaz/NzMw9AACAP8icQT+pgmY/zczMPQAAgD/N2FE/6MtjP83MzD0AAIA/ZM1WP//tYj/NzMw9AACAP83YUT/oy2M/zczMPQAAgD/InEE/qYJmP83MzD0AAIA/UoUiP3dRaz/NzMw9AACAP9nX4D5xWHI/zczMPQAAgD8oaCU+R0N7P83MzD0AAIA/FSA8vjD5ej/NzMw9AACAP2ybDL9RHnI/zczMPQAAgD8CiFq/nz9sP83MzD0AAIA/tW9/v1IIaz/NzMw9AACAP2NvZr9x8W4/zczMPQAAgD8edwq/2dB2P83MzD0AAIA/KdCiO8Hsfz/NzMw9AACAPw==", + "encoding": "base64", + "path": [ + "color", + 7, + "data" + ] + }, + { + "data": "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", + "encoding": "base64", + "path": [ + "color", + 8, + "data" + ] + }, + { + "data": "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", + "encoding": "base64", + "path": [ + "color", + 9, + "data" + ] + }, + { + "data": "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", + "encoding": "base64", + "path": [ + "color", + 10, + "data" + ] + }, + { + "data": "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", + "encoding": "base64", + "path": [ + "color", + 11, + "data" + ] + }, + { + "data": "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", + "encoding": "base64", + "path": [ + "color", + 12, + "data" + ] + }, + { + "data": "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", + "encoding": "base64", + "path": [ + "color", + 13, + "data" + ] + }, + { + "data": "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", + "encoding": "base64", + "path": [ + "color", + 14, + "data" + ] + }, + { + "data": "wuDiPx8W6z/IEPI/R4j1P1B09D8rQO8/lWbnP72+3j8A19Y/NJzQPxdZzD8x8ck/dyzJPzHxyT8XWcw/NJzQPwDX1j+9vt4/lWbnPytA7z9QdPQ/R4j1P8gQ8j8fFus/wuDiPx8W6z/5mfI/ZbH1P/3g8j/ow+o/+pbfP2Un1D9yuso/1WnEP0ccwT+J8L8/782/P9rcvz/vzb8/ifC/P0ccwT/VacQ/crrKP2Un1D/6lt8/6MPqP/3g8j9lsfU/+ZnyPx8W6z/IEPI/ZbH1P1808j8UG+g/WGfaP8UtzT8F18M/ifC/P2v9wD9FHsU/IgjKP+zJzT/oLM8/7MnNPyIIyj9FHsU/a/3AP4nwvz8F18M/xS3NP1hn2j8UG+g/XzTyP2Wx9T/IEPI/R4j1P/3g8j8UG+g/qqDYPzHxyT9HHME/GabAP1zdxz81u9M/+YfgP9tA6z99JfI/Yn/0P30l8j/bQOs/+YfgPzW70z9c3cc/GabAP0ccwT8x8ck/qqDYPxQb6D/94PI/R4j1P1B09D/ow+o/WGfaPzHxyT9igsA/62DCP+gszz9WleI/L972P1vFA0BFWQlAKlAMQPU1DUAqUAxARVkJQFvFA0Av3vY/VpXiP+gszz/rYMI/YoLAPzHxyT9YZ9o/6MPqP1B09D8rQO8/+pbfP8UtzT9HHME/62DCP70l0j/bQOs/upgCQCpQDEAqTBFA02gSQOrCEUDeShFA6sIRQNNoEkAqTBFAKlAMQLqYAkDbQOs/vSXSP+tgwj9HHME/xS3NP/qW3z8rQO8/lWbnP2Un1D8F18M/GabAP+gszz/bQOs/Re4EQFCQD0B6UBJA9gIOQP9pBkBQsP8/iKD6P1Cw/z//aQZA9gIOQHpQEkBQkA9ARe4EQNtA6z/oLM8/GabAPwXXwz9lJ9Q/lWbnP72+3j9yuso/ifC/P1zdxz9WleI/upgCQFCQD0DqwhFAe0MIQBmA7z+OVM4/qpi3P5XArz+qmLc/jlTOPxmA7z97QwhA6sIRQFCQD0C6mAJAVpXiP1zdxz+J8L8/crrKP72+3j8A19Y/1WnEP2v9wD81u9M/L972PypQDEB6UBJAe0MIQE0X4z+VwK8/OCqJP6tnaz8UIGE/q2drPzgqiT+VwK8/TRfjP3tDCEB6UBJAKlAMQC/e9j81u9M/a/3AP9VpxD8A19Y/NJzQP0ccwT9FHsU/+YfgP1vFA0AqTBFA9gIOQBmA7z+VwK8/nDt3P8NZTz+3j1s/EVZpP7ePWz/DWU8/nDt3P5XArz8ZgO8/9gIOQCpMEUBbxQNA+YfgP0UexT9HHME/NJzQPxdZzD+J8L8/IgjKP9tA6z9FWQlA02gSQP9pBkCOVM4/OCqJP8NZTz9gaX0/xdm1P/Rg0z/F2bU/YGl9P8NZTz84Kok/jlTOP/9pBkDTaBJARVkJQNtA6z8iCMo/ifC/PxdZzD8x8ck/782/P+zJzT99JfI/KlAMQOrCEUBQsP8/qpi3P6tnaz+3j1s/xdm1P1++E0AbDzJAX74TQMXZtT+3j1s/q2drP6qYtz9QsP8/6sIRQCpQDEB9JfI/7MnNP+/Nvz8x8ck/dyzJP9rcvz/oLM8/Yn/0P/U1DUDeShFAiKD6P5XArz8UIGE/EVZpP/Rg0z8bDzJA0vFiQBsPMkD0YNM/EVZpPxQgYT+VwK8/iKD6P95KEUD1NQ1AYn/0P+gszz/a3L8/dyzJPzHxyT/vzb8/7MnNP30l8j8qUAxA6sIRQFCw/z+qmLc/q2drP7ePWz/F2bU/X74TQBsPMkBfvhNAxdm1P7ePWz+rZ2s/qpi3P1Cw/z/qwhFAKlAMQH0l8j/syc0/782/PzHxyT8XWcw/ifC/PyIIyj/bQOs/RVkJQNNoEkD/aQZAjlTOPzgqiT/DWU8/YGl9P8XZtT/0YNM/xdm1P2BpfT/DWU8/OCqJP45Uzj//aQZA02gSQEVZCUDbQOs/IgjKP4nwvz8XWcw/NJzQP0ccwT9FHsU/+YfgP1vFA0AqTBFA9gIOQBmA7z+VwK8/nDt3P8NZTz+3j1s/EVZpP7ePWz/DWU8/nDt3P5XArz8ZgO8/9gIOQCpMEUBbxQNA+YfgP0UexT9HHME/NJzQPwDX1j/VacQ/a/3APzW70z8v3vY/KlAMQHpQEkB7QwhATRfjP5XArz84Kok/q2drPxQgYT+rZ2s/OCqJP5XArz9NF+M/e0MIQHpQEkAqUAxAL972PzW70z9r/cA/1WnEPwDX1j+9vt4/crrKP4nwvz9c3cc/VpXiP7qYAkBQkA9A6sIRQHtDCEAZgO8/jlTOP6qYtz+VwK8/qpi3P45Uzj8ZgO8/e0MIQOrCEUBQkA9AupgCQFaV4j9c3cc/ifC/P3K6yj+9vt4/lWbnP2Un1D8F18M/GabAP+gszz/bQOs/Re4EQFCQD0B6UBJA9gIOQP9pBkBQsP8/iKD6P1Cw/z//aQZA9gIOQHpQEkBQkA9ARe4EQNtA6z/oLM8/GabAPwXXwz9lJ9Q/lWbnPytA7z/6lt8/xS3NP0ccwT/rYMI/vSXSP9tA6z+6mAJAKlAMQCpMEUDTaBJA6sIRQN5KEUDqwhFA02gSQCpMEUAqUAxAupgCQNtA6z+9JdI/62DCP0ccwT/FLc0/+pbfPytA7z9QdPQ/6MPqP1hn2j8x8ck/YoLAP+tgwj/oLM8/VpXiPy/e9j9bxQNARVkJQCpQDED1NQ1AKlAMQEVZCUBbxQNAL972P1aV4j/oLM8/62DCP2KCwD8x8ck/WGfaP+jD6j9QdPQ/R4j1P/3g8j8UG+g/qqDYPzHxyT9HHME/GabAP1zdxz81u9M/+YfgP9tA6z99JfI/Yn/0P30l8j/bQOs/+YfgPzW70z9c3cc/GabAP0ccwT8x8ck/qqDYPxQb6D/94PI/R4j1P8gQ8j9lsfU/XzTyPxQb6D9YZ9o/xS3NPwXXwz+J8L8/a/3AP0UexT8iCMo/7MnNP+gszz/syc0/IgjKP0UexT9r/cA/ifC/PwXXwz/FLc0/WGfaPxQb6D9fNPI/ZbH1P8gQ8j8fFus/+ZnyP2Wx9T/94PI/6MPqP/qW3z9lJ9Q/crrKP9VpxD9HHME/ifC/P+/Nvz/a3L8/782/P4nwvz9HHME/1WnEP3K6yj9lJ9Q/+pbfP+jD6j/94PI/ZbH1P/mZ8j8fFus/wuDiPx8W6z/IEPI/R4j1P1B09D8rQO8/lWbnP72+3j8A19Y/NJzQPxdZzD8x8ck/dyzJPzHxyT8XWcw/NJzQPwDX1j+9vt4/lWbnPytA7z9QdPQ/R4j1P8gQ8j8fFus/wuDiPw==", + "encoding": "base64", + "path": [ + "size", + 0, + "data" + ] + }, + { + "data": "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", + "encoding": "base64", + "path": [ + "size", + 1, + "data" + ] + }, + { + "data": "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", + "encoding": "base64", + "path": [ + "size", + 2, + "data" + ] + }, + { + "data": "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", + "encoding": "base64", + "path": [ + "size", + 3, + "data" + ] + }, + { + "data": "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", + "encoding": "base64", + "path": [ + "size", + 4, + "data" + ] + }, + { + "data": "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", + "encoding": "base64", + "path": [ + "size", + 5, + "data" + ] + }, + { + "data": "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", + "encoding": "base64", + "path": [ + "size", + 6, + "data" + ] + }, + { + "data": "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", + "encoding": "base64", + "path": [ + "size", + 7, + "data" + ] + }, + { + "data": "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", + "encoding": "base64", + "path": [ + "size", + 8, + "data" + ] + }, + { + "data": "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", + "encoding": "base64", + "path": [ + "size", + 9, + "data" + ] + }, + { + "data": "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", + "encoding": "base64", + "path": [ + "size", + 10, + "data" + ] + }, + { + "data": "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", + "encoding": "base64", + "path": [ + "size", + 11, + "data" + ] + }, + { + "data": "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", + "encoding": "base64", + "path": [ + "size", + 12, + "data" + ] + }, + { + "data": "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", + "encoding": "base64", + "path": [ + "size", + 13, + "data" + ] + }, + { + "data": "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", + "encoding": "base64", + "path": [ + "size", + 14, + "data" + ] + }, + { + "data": "AAAgwauqEsFVVQXBAADwwFVV1cCrqrrAAACgwFVVhcBVVVXAAAAgwFVV1b9VVVW/AAAAAFVVVT9VVdU/AAAgQFVVVUBVVYVAAACgQKuqukBVVdVAAADwQFVVBUGrqhJBAAAgQQAAIMGrqhLBVVUFwQAA8MBVVdXAq6q6wAAAoMBVVYXAVVVVwAAAIMBVVdW/VVVVvwAAAABVVVU/VVXVPwAAIEBVVVVAVVWFQAAAoECrqrpAVVXVQAAA8EBVVQVBq6oSQQAAIEEAACDBq6oSwVVVBcEAAPDAVVXVwKuqusAAAKDAVVWFwFVVVcAAACDAVVXVv1VVVb8AAAAAVVVVP1VV1T8AACBAVVVVQFVVhUAAAKBAq6q6QFVV1UAAAPBAVVUFQauqEkEAACBBAAAgwauqEsFVVQXBAADwwFVV1cCrqrrAAACgwFVVhcBVVVXAAAAgwFVV1b9VVVW/AAAAAFVVVT9VVdU/AAAgQFVVVUBVVYVAAACgQKuqukBVVdVAAADwQFVVBUGrqhJBAAAgQQAAIMGrqhLBVVUFwQAA8MBVVdXAq6q6wAAAoMBVVYXAVVVVwAAAIMBVVdW/VVVVvwAAAABVVVU/VVXVPwAAIEBVVVVAVVWFQAAAoECrqrpAVVXVQAAA8EBVVQVBq6oSQQAAIEEAACDBq6oSwVVVBcEAAPDAVVXVwKuqusAAAKDAVVWFwFVVVcAAACDAVVXVv1VVVb8AAAAAVVVVP1VV1T8AACBAVVVVQFVVhUAAAKBAq6q6QFVV1UAAAPBAVVUFQauqEkEAACBBAAAgwauqEsFVVQXBAADwwFVV1cCrqrrAAACgwFVVhcBVVVXAAAAgwFVV1b9VVVW/AAAAAFVVVT9VVdU/AAAgQFVVVUBVVYVAAACgQKuqukBVVdVAAADwQFVVBUGrqhJBAAAgQQAAIMGrqhLBVVUFwQAA8MBVVdXAq6q6wAAAoMBVVYXAVVVVwAAAIMBVVdW/VVVVvwAAAABVVVU/VVXVPwAAIEBVVVVAVVWFQAAAoECrqrpAVVXVQAAA8EBVVQVBq6oSQQAAIEEAACDBq6oSwVVVBcEAAPDAVVXVwKuqusAAAKDAVVWFwFVVVcAAACDAVVXVv1VVVb8AAAAAVVVVP1VV1T8AACBAVVVVQFVVhUAAAKBAq6q6QFVV1UAAAPBAVVUFQauqEkEAACBBAAAgwauqEsFVVQXBAADwwFVV1cCrqrrAAACgwFVVhcBVVVXAAAAgwFVV1b9VVVW/AAAAAFVVVT9VVdU/AAAgQFVVVUBVVYVAAACgQKuqukBVVdVAAADwQFVVBUGrqhJBAAAgQQAAIMGrqhLBVVUFwQAA8MBVVdXAq6q6wAAAoMBVVYXAVVVVwAAAIMBVVdW/VVVVvwAAAABVVVU/VVXVPwAAIEBVVVVAVVWFQAAAoECrqrpAVVXVQAAA8EBVVQVBq6oSQQAAIEEAACDBq6oSwVVVBcEAAPDAVVXVwKuqusAAAKDAVVWFwFVVVcAAACDAVVXVv1VVVb8AAAAAVVVVP1VV1T8AACBAVVVVQFVVhUAAAKBAq6q6QFVV1UAAAPBAVVUFQauqEkEAACBBAAAgwauqEsFVVQXBAADwwFVV1cCrqrrAAACgwFVVhcBVVVXAAAAgwFVV1b9VVVW/AAAAAFVVVT9VVdU/AAAgQFVVVUBVVYVAAACgQKuqukBVVdVAAADwQFVVBUGrqhJBAAAgQQAAIMGrqhLBVVUFwQAA8MBVVdXAq6q6wAAAoMBVVYXAVVVVwAAAIMBVVdW/VVVVvwAAAABVVVU/VVXVPwAAIEBVVVVAVVWFQAAAoECrqrpAVVXVQAAA8EBVVQVBq6oSQQAAIEEAACDBq6oSwVVVBcEAAPDAVVXVwKuqusAAAKDAVVWFwFVVVcAAACDAVVXVv1VVVb8AAAAAVVVVP1VV1T8AACBAVVVVQFVVhUAAAKBAq6q6QFVV1UAAAPBAVVUFQauqEkEAACBBAAAgwauqEsFVVQXBAADwwFVV1cCrqrrAAACgwFVVhcBVVVXAAAAgwFVV1b9VVVW/AAAAAFVVVT9VVdU/AAAgQFVVVUBVVYVAAACgQKuqukBVVdVAAADwQFVVBUGrqhJBAAAgQQAAIMGrqhLBVVUFwQAA8MBVVdXAq6q6wAAAoMBVVYXAVVVVwAAAIMBVVdW/VVVVvwAAAABVVVU/VVXVPwAAIEBVVVVAVVWFQAAAoECrqrpAVVXVQAAA8EBVVQVBq6oSQQAAIEEAACDBq6oSwVVVBcEAAPDAVVXVwKuqusAAAKDAVVWFwFVVVcAAACDAVVXVv1VVVb8AAAAAVVVVP1VV1T8AACBAVVVVQFVVhUAAAKBAq6q6QFVV1UAAAPBAVVUFQauqEkEAACBBAAAgwauqEsFVVQXBAADwwFVV1cCrqrrAAACgwFVVhcBVVVXAAAAgwFVV1b9VVVW/AAAAAFVVVT9VVdU/AAAgQFVVVUBVVYVAAACgQKuqukBVVdVAAADwQFVVBUGrqhJBAAAgQQAAIMGrqhLBVVUFwQAA8MBVVdXAq6q6wAAAoMBVVYXAVVVVwAAAIMBVVdW/VVVVvwAAAABVVVU/VVXVPwAAIEBVVVVAVVWFQAAAoECrqrpAVVXVQAAA8EBVVQVBq6oSQQAAIEEAACDBq6oSwVVVBcEAAPDAVVXVwKuqusAAAKDAVVWFwFVVVcAAACDAVVXVv1VVVb8AAAAAVVVVP1VV1T8AACBAVVVVQFVVhUAAAKBAq6q6QFVV1UAAAPBAVVUFQauqEkEAACBBAAAgwauqEsFVVQXBAADwwFVV1cCrqrrAAACgwFVVhcBVVVXAAAAgwFVV1b9VVVW/AAAAAFVVVT9VVdU/AAAgQFVVVUBVVYVAAACgQKuqukBVVdVAAADwQFVVBUGrqhJBAAAgQQAAIMGrqhLBVVUFwQAA8MBVVdXAq6q6wAAAoMBVVYXAVVVVwAAAIMBVVdW/VVVVvwAAAABVVVU/VVXVPwAAIEBVVVVAVVWFQAAAoECrqrpAVVXVQAAA8EBVVQVBq6oSQQAAIEEAACDBq6oSwVVVBcEAAPDAVVXVwKuqusAAAKDAVVWFwFVVVcAAACDAVVXVv1VVVb8AAAAAVVVVP1VV1T8AACBAVVVVQFVVhUAAAKBAq6q6QFVV1UAAAPBAVVUFQauqEkEAACBBAAAgwauqEsFVVQXBAADwwFVV1cCrqrrAAACgwFVVhcBVVVXAAAAgwFVV1b9VVVW/AAAAAFVVVT9VVdU/AAAgQFVVVUBVVYVAAACgQKuqukBVVdVAAADwQFVVBUGrqhJBAAAgQQ==", + "encoding": "base64", + "path": [ + "x", + 0, + "data" + ] + }, + { + "data": "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", + "encoding": "base64", + "path": [ + "y", + 0, + "data" + ] + }, + { + "data": "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", + "encoding": "base64", + "path": [ + "y", + 1, + "data" + ] + }, + { + "data": "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", + "encoding": "base64", + "path": [ + "y", + 2, + "data" + ] + }, + { + "data": "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", + "encoding": "base64", + "path": [ + "y", + 3, + "data" + ] + }, + { + "data": "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", + "encoding": "base64", + "path": [ + "y", + 4, + "data" + ] + }, + { + "data": "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", + "encoding": "base64", + "path": [ + "y", + 5, + "data" + ] + }, + { + "data": "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", + "encoding": "base64", + "path": [ + "y", + 6, + "data" + ] + }, + { + "data": "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", + "encoding": "base64", + "path": [ + "y", + 7, + "data" + ] + }, + { + "data": "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", + "encoding": "base64", + "path": [ + "y", + 8, + "data" + ] + }, + { + "data": "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", + "encoding": "base64", + "path": [ + "y", + 9, + "data" + ] + }, + { + "data": "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", + "encoding": "base64", + "path": [ + "y", + 10, + "data" + ] + }, + { + "data": "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", + "encoding": "base64", + "path": [ + "y", + 11, + "data" + ] + }, + { + "data": "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", + "encoding": "base64", + "path": [ + "y", + 12, + "data" + ] + }, + { + "data": "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", + "encoding": "base64", + "path": [ + "y", + 13, + "data" + ] + }, + { + "data": "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", + "encoding": "base64", + "path": [ + "y", + 14, + "data" + ] + }, + { + "data": "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", + "encoding": "base64", + "path": [ + "z", + 0, + "data" + ] + } + ], + "model_module": "ipyvolume", + "model_module_version": "^0.5.0-beta.1", + "model_name": "ScatterModel", + "state": { + "color": [ + { + "data": {}, + "dtype": "float32", + "shape": [ + 625, + 4 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 625, + 4 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 625, + 4 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 625, + 4 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 625, + 4 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 625, + 4 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 625, + 4 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 625, + 4 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 625, + 4 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 625, + 4 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 625, + 4 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 625, + 4 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 625, + 4 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 625, + 4 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 625, + 4 + ] + } + ], + "geo": "sphere", + "line_material": "IPY_MODEL_0fa46a2814a34bd59ca3e501c5d8118a", + "material": "IPY_MODEL_bf169eb7e0d9407bbd19c23a12ca33fe", + "selected": null, + "sequence_index": 14, + "size": [ + { + "data": {}, + "dtype": "float32", + "shape": [ + 625 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 625 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 625 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 625 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 625 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 625 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 625 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 625 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 625 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 625 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 625 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 625 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 625 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 625 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 625 + ] + } + ], + "size_selected": 2.6, + "texture": null, + "visible": true, + "vx": null, + "vy": null, + "vz": null, + "x": [ + { + "data": {}, + "dtype": "float32", + "shape": [ + 625 + ] + } + ], + "y": [ + { + "data": {}, + "dtype": "float32", + "shape": [ + 625 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 625 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 625 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 625 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 625 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 625 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 625 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 625 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 625 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 625 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 625 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 625 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 625 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 625 + ] + }, + { + "data": {}, + "dtype": "float32", + "shape": [ + 625 + ] + } + ], + "z": [ + { + "data": {}, + "dtype": "float32", + "shape": [ + 625 + ] + } + ] + } + } + }, + "version_major": 2, + "version_minor": 0 + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/docs/source/examples/bars.ipynb b/docs/source/examples/bars.ipynb new file mode 100644 index 00000000..d0656135 --- /dev/null +++ b/docs/source/examples/bars.ipynb @@ -0,0 +1,350 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Bar charts\n", + "This is 'abusing' the scatter object to create a 3d bar chart" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-04-02T11:10:24.290979Z", + "start_time": "2020-04-02T11:10:22.431581Z" + } + }, + "outputs": [], + "source": [ + "import ipyvolume as ipv\n", + "import numpy as np" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-04-02T11:20:11.984273Z", + "start_time": "2020-04-02T11:20:11.976574Z" + } + }, + "outputs": [], + "source": [ + "# set up data similar to animation notebook\n", + "\n", + "u_scale = 10\n", + "Nx, Ny = 30, 15\n", + "u = np.linspace(-u_scale, u_scale, Nx)\n", + "v = np.linspace(-u_scale, u_scale, Ny)\n", + "x, y = np.meshgrid(u, v, indexing='ij')\n", + "r = np.sqrt(x**2+y**2)\n", + "x = x.flatten()\n", + "y = y.flatten()\n", + "r = r.flatten()\n", + "\n", + "time = np.linspace(0, np.pi*2, 15)\n", + "z = np.array([(np.cos(r + t) * np.exp(-r/5)) for t in time])\n", + "zz = z" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-04-02T11:20:12.401084Z", + "start_time": "2020-04-02T11:20:12.344392Z" + } + }, + "outputs": [], + "source": [ + "fig = ipv.figure()\n", + "s = ipv.scatter(x, 0, y, aux=zz, marker=\"sphere\")\n", + "dx = u[1] - u[0]\n", + "dy = v[1] - v[0]\n", + "# make the x and z lim half a 'box' larger\n", + "ipv.xlim(-u_scale-dx/2, u_scale+dx/2)\n", + "ipv.zlim(-u_scale-dx/2, u_scale+dx/2)\n", + "ipv.ylim(-1.2, 1.2)\n", + "ipv.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We now make boxes, that fit exactly in the volume, by giving them a size of 1, in domain coordinates (so 1 unit as read of by the x-axis etc)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-04-02T11:20:12.941581Z", + "start_time": "2020-04-02T11:20:12.934218Z" + } + }, + "outputs": [], + "source": [ + "# make the size 1, in domain coordinates (so 1 unit as read of by the x-axis etc)\n", + "s.geo = 'box'\n", + "s.size = 1\n", + "s.size_x_scale = fig.scales['x']\n", + "s.size_y_scale = fig.scales['y']\n", + "s.size_z_scale = fig.scales['z']" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-04-02T11:20:13.260996Z", + "start_time": "2020-04-02T11:20:13.257282Z" + } + }, + "outputs": [], + "source": [ + "s.shader_snippets = {'size':\n", + " 'size_vector.y = SCALE_SIZE_Y(aux_current); '\n", + "}\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Using a shader snippet (that runs on the GPU), we set the y size equal to the aux value. However, since the box has size 1 around the origin of (0,0,0), we need to translate it up in the y direction by 0.5." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-04-02T11:20:13.831684Z", + "start_time": "2020-04-02T11:20:13.825276Z" + } + }, + "outputs": [], + "source": [ + "s.shader_snippets = {'size':\n", + " 'size_vector.y = SCALE_SIZE_Y(aux_current) - SCALE_SIZE_Y(0.0) ; '\n", + "}\n", + "\n", + "s.geo_matrix = [dx, 0, 0, 0, 0, 1, 0, 0, 0, 0, dy, 0, 0.0, 0.5, 0, 1]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Since we see the boxes with negative sizes inside out, we made the material double sided" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-04-02T11:20:14.386124Z", + "start_time": "2020-04-02T11:20:14.383093Z" + } + }, + "outputs": [], + "source": [ + "# since we see the boxes with negative sizes inside out, we made the material double sided\n", + "s.material.side = \"DoubleSide\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-04-02T11:20:14.758048Z", + "start_time": "2020-04-02T11:20:14.751625Z" + } + }, + "outputs": [], + "source": [ + "# Now also include, color, which containts rgb values\n", + "color = np.array([[np.cos(r + t), 1-np.abs(z[i]), 0.1+z[i]*0] for i, t in enumerate(time)])\n", + "color = np.transpose(color, (0, 2, 1)) # flip the last axes\n", + "s.color = color" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-04-02T11:20:15.323857Z", + "start_time": "2020-04-02T11:20:15.295520Z" + } + }, + "outputs": [], + "source": [ + "ipv.animation_control(s, interval=200)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "# Spherical bar charts" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-04-02T11:20:34.913567Z", + "start_time": "2020-04-02T11:20:34.907298Z" + } + }, + "outputs": [], + "source": [ + "# Create spherical coordinates\n", + "u = np.linspace(0, 1, Nx)\n", + "v = np.linspace(0, 1, Ny)\n", + "u, v = np.meshgrid(u, v, indexing='ij')\n", + "phi = u * 2 * np.pi\n", + "theta = v * np.pi\n", + "radius = 1\n", + "xs = radius * np.cos(phi) * np.sin(theta)\n", + "ys = radius * np.sin(phi) * np.sin(theta)\n", + "zs = radius * np.cos(theta)\n", + "xs = xs.flatten()\n", + "ys = ys.flatten()\n", + "zs = zs.flatten()\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-04-02T11:20:35.405470Z", + "start_time": "2020-04-02T11:20:35.313505Z" + } + }, + "outputs": [], + "source": [ + "fig = ipv.figure()\n", + "# we use the coordinates as the normals, and thus direction\n", + "s = ipv.scatter(xs, ys, zs, vx=xs, vy=ys, vz=zs, aux=zz, color=color, marker=\"cylinder_hr\")\n", + "ipv.xyzlim(2)\n", + "ipv.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-04-02T11:20:36.122432Z", + "start_time": "2020-04-02T11:20:36.098701Z" + } + }, + "outputs": [], + "source": [ + "ipv.animation_control(s, interval=200)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-04-02T11:20:36.676871Z", + "start_time": "2020-04-02T11:20:36.671562Z" + } + }, + "outputs": [], + "source": [ + "import bqplot\n", + "# the aux range is from -1 to 1, but if we put 0 as min, negative values will go inside\n", + "# the max determines the 'height' of the bars\n", + "aux_scale = bqplot.LinearScale(min=0, max=5)\n", + "s.aux_scale = aux_scale" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-04-02T11:20:37.470078Z", + "start_time": "2020-04-02T11:20:37.464541Z" + } + }, + "outputs": [], + "source": [ + "s.shader_snippets = {'size':\n", + " '''float sc = (SCALE_AUX(aux_current) - SCALE_AUX(0.0)); size_vector.y = sc;\n", + " '''}\n", + "s.material.side = \"DoubleSide\"\n", + "s.size = 2\n", + "s.geo_matrix = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0.0, 0.5, 0, 1]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-04-02T11:20:19.953260Z", + "start_time": "2020-04-02T11:20:19.949808Z" + } + }, + "outputs": [], + "source": [ + "ipv.style.box_off()\n", + "ipv.style.axes_off()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "[screenshot](screenshot/bars.gif)" + ] + } + ], + "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.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/docs/source/examples/bokeh.ipynb b/docs/source/examples/bokeh.ipynb new file mode 100644 index 00000000..22fa4801 --- /dev/null +++ b/docs/source/examples/bokeh.ipynb @@ -0,0 +1,257 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# ipyvolume & bokeh\n", + "This example shows how the selection from a ipyvolume quiver plot can be controlled with a bokeh scatter plot and it's selection tools." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ipyvolume quiver plot\n", + "The 3d quiver plot is done using ipyvolume" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-03-30T11:27:28.420204Z", + "start_time": "2020-03-30T11:27:26.054278Z" + } + }, + "outputs": [], + "source": [ + "import ipyvolume\n", + "import ipyvolume as ipv\n", + "import vaex" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We load some data from vaex, but only use the first 10 000 samples for performance reasons of Bokeh." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-03-30T11:27:28.442856Z", + "start_time": "2020-03-30T11:27:28.422421Z" + } + }, + "outputs": [], + "source": [ + "ds = vaex.example()\n", + "N = 10000" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We make a quiver plot using ipyvolume's matplotlib's style api." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-03-30T11:27:28.505281Z", + "start_time": "2020-03-30T11:27:28.456845Z" + } + }, + "outputs": [], + "source": [ + "ipv.figure()\n", + "quiver = ipv.quiver(ds.data.x[:N], ds.data.y[:N], ds.data.z[:N],\n", + " ds.data.vx[:N], ds.data.vy[:N], ds.data.vz[:N],\n", + " size=1, size_selected=5, color_selected=\"grey\")\n", + "ipv.xyzlim(-30, 30)\n", + "ipv.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Bokeh scatter part\n", + "The 2d scatter plot is done using Bokeh." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-03-30T11:27:31.015118Z", + "start_time": "2020-03-30T11:27:30.238615Z" + } + }, + "outputs": [], + "source": [ + "# currently broken\n", + "# from bokeh.io import output_notebook, show\n", + "# from bokeh.plotting import figure\n", + "# from bokeh.models import CustomJS, ColumnDataSource\n", + "\n", + "# import ipyvolume.bokeh\n", + "# output_notebook()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-03-30T11:27:33.950845Z", + "start_time": "2020-03-30T11:27:33.934619Z" + } + }, + "outputs": [], + "source": [ + "# data_source = ColumnDataSource(data=dict(x=ds.data.Lz[:N], y=ds.data.E[:N]))\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-03-30T11:27:35.151433Z", + "start_time": "2020-03-30T11:27:35.117128Z" + } + }, + "outputs": [], + "source": [ + "# p = figure(title=\"E Lz space\", tools='lasso_select', width=500, height=500)\n", + "# r = p.circle('x', 'y', source=data_source, color=\"navy\", alpha=0.2)\n", + "# ipyvolume.bokeh.link_data_source_selection_to_widget(data_source, quiver, 'selected')\n", + "# show(p)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now try doing a selection and see how the above 3d quiver plot reflects this selection." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-03-30T11:28:19.937280Z", + "start_time": "2020-03-30T11:28:19.887671Z" + } + }, + "outputs": [], + "source": [ + "# # but them next to eachother\n", + "# import ipywidgets\n", + "# out = ipywidgets.Output()\n", + "# with out:\n", + "# show(p)\n", + "# ipywidgets.HBox([out, ipv.gcc()])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Embedding in html" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "A bit of a hack, but it is possible to embed the widget and the bokeh part into a single html file (use at own risk)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-03-30T11:29:22.923631Z", + "start_time": "2020-03-30T11:29:22.884487Z" + }, + "run_control": { + "marked": false + } + }, + "outputs": [], + "source": [ + "# from bokeh.resources import CDN\n", + "# from bokeh.embed import components\n", + "\n", + "# script, div = components((p))\n", + "# template_options = dict(extra_script_head=script + CDN.render_js() + CDN.render_css(),\n", + "# body_pre=\"

Do selections in 2d (bokeh)

\" + div + \"

And see the selection in ipyvolume

\")\n", + "# ipyvolume.embed.embed_html(\"tmp/bokeh.html\",\n", + "# [ipv.gcc(), ipyvolume.bokeh.wmh], all_states=True,\n", + "# template_options=template_options)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-03-30T11:31:52.470776Z", + "start_time": "2020-03-30T11:31:52.463462Z" + } + }, + "outputs": [], + "source": [ + "# uncomment the next line to open the html file\n", + "# !open tmp/bokeh.html" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2020-03-30T11:32:05.782676Z", + "start_time": "2020-03-30T11:32:05.622311Z" + } + }, + "source": [ + "[screenshot](screenshot/bokeh.png)" + ] + } + ], + "metadata": { + "anaconda-cloud": {}, + "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.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/docs/source/examples/bqplot.html b/docs/source/examples/bqplot.html new file mode 100644 index 00000000..37552e55 --- /dev/null +++ b/docs/source/examples/bqplot.html @@ -0,0 +1,1372 @@ + + + + + IPyVolume Widget + + + + + + + + + + + + + + + + + diff --git a/docs/source/bqplot.ipynb b/docs/source/examples/bqplot.ipynb similarity index 98% rename from docs/source/bqplot.ipynb rename to docs/source/examples/bqplot.ipynb index bfdda689..1599603f 100644 --- a/docs/source/bqplot.ipynb +++ b/docs/source/examples/bqplot.ipynb @@ -4,15 +4,18 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Mixing ipyvolume with bqplot\n", + "# ipyvolume & bqplot\n", "This example shows how the selection from a ipyvolume quiver plot can be controlled with a bqplot scatter plot and it's selection tools. We first get a small dataset from [vaex](http://vaex.astro.rug.nl)" ] }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": { - "collapsed": true + "ExecuteTime": { + "end_time": "2020-03-30T09:35:58.831629Z", + "start_time": "2020-03-30T09:35:57.091842Z" + } }, "outputs": [], "source": [ @@ -22,9 +25,12 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": { - "collapsed": true + "ExecuteTime": { + "end_time": "2020-03-30T09:35:58.869088Z", + "start_time": "2020-03-30T09:35:58.834939Z" + } }, "outputs": [], "source": [ @@ -43,9 +49,12 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": { - "collapsed": true + "ExecuteTime": { + "end_time": "2020-03-30T09:35:59.432634Z", + "start_time": "2020-03-30T09:35:58.962130Z" + } }, "outputs": [], "source": [ @@ -54,24 +63,14 @@ }, { "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "6f4236b7dbcf408baccf01ebadd87cf6", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "A Jupyter Widget" - ] - }, - "metadata": {}, - "output_type": "display_data" + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-03-30T09:35:59.725401Z", + "start_time": "2020-03-30T09:35:59.667736Z" } - ], + }, + "outputs": [], "source": [ "plt.figure(1, title=\"E Lz space\")\n", "scatter = plt.scatter(Lz, E,\n", @@ -93,39 +92,32 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": { - "collapsed": true + "ExecuteTime": { + "end_time": "2020-03-30T09:36:20.462125Z", + "start_time": "2020-03-30T09:36:20.458907Z" + } }, "outputs": [], "source": [ - "import ipyvolume.pylab as p3" + "import ipyvolume.pylab as ipv" ] }, { "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "95af93aa37304d32a1e7377c01588c4d", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "A Jupyter Widget" - ] - }, - "metadata": {}, - "output_type": "display_data" + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-03-30T09:36:20.916054Z", + "start_time": "2020-03-30T09:36:20.878387Z" } - ], + }, + "outputs": [], "source": [ - "p3.clear()\n", - "quiver = p3.quiver(x, y, z, vx, vy, vz, size=2, size_selected=5, color_selected=\"blue\")\n", - "p3.show()" + "ipv.clear()\n", + "quiver = ipv.quiver(x, y, z, vx, vy, vz, size=2, size_selected=5, color_selected=\"blue\")\n", + "ipv.show()" ] }, { @@ -138,9 +130,12 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": { - "collapsed": true + "ExecuteTime": { + "end_time": "2020-03-30T09:36:22.992336Z", + "start_time": "2020-03-30T09:36:22.989485Z" + } }, "outputs": [], "source": [ @@ -149,9 +144,12 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": { - "collapsed": true + "ExecuteTime": { + "end_time": "2020-03-30T09:36:23.775866Z", + "start_time": "2020-03-30T09:36:23.764508Z" + } }, "outputs": [], "source": [ @@ -160,27 +158,18 @@ }, { "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "8ff91eab8612446ea033a3c851fc89d0", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "A Jupyter Widget" - ] - }, - "metadata": {}, - "output_type": "display_data" + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-03-30T09:36:24.421375Z", + "start_time": "2020-03-30T09:36:24.395806Z" } - ], + }, + "outputs": [], "source": [ - "hbox = VBox([p3.current.container, plt.figure(1)])\n", - "hbox" + "hbox = VBox([ipv.current.container, plt.figure(1)])\n", + "# TODO: cannot display the figure twice currently\n", + "# hbox" ] }, { @@ -193,9 +182,12 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": { - "collapsed": true + "ExecuteTime": { + "end_time": "2020-03-30T09:38:03.987677Z", + "start_time": "2020-03-30T09:38:03.984690Z" + } }, "outputs": [], "source": [ @@ -207,18 +199,35 @@ }, { "cell_type": "code", - "execution_count": 14, - "metadata": {}, + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-03-30T09:38:08.473063Z", + "start_time": "2020-03-30T09:38:05.098925Z" + } + }, "outputs": [], "source": [ "ipyvolume.embed.embed_html(\"bqplot.html\", hbox, offline=True, devmode=True)" ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "%debug" + ] + }, { "cell_type": "code", "execution_count": null, "metadata": { - "collapsed": true + "ExecuteTime": { + "end_time": "2020-03-30T09:38:12.646162Z", + "start_time": "2020-03-30T09:38:12.396730Z" + } }, "outputs": [], "source": [ @@ -226,19 +235,19 @@ ] }, { - "cell_type": "code", - "execution_count": null, + "cell_type": "markdown", "metadata": { "collapsed": true }, - "outputs": [], - "source": [] + "source": [ + "[screenshot](screenshot/bqplot.png)" + ] } ], "metadata": { "anaconda-cloud": {}, "kernelspec": { - "display_name": "Python [default]", + "display_name": "Python 3", "language": "python", "name": "python3" }, @@ -252,7 +261,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.5.2" + "version": "3.7.3" }, "widgets": { "application/vnd.jupyter.widget-state+json": { @@ -358,6 +367,7 @@ "layout": "IPY_MODEL_55a0da91a25d4349b406f5385c486abf", "selected": [ { + "buffer": {}, "dtype": "int32", "shape": [ 74 @@ -368,6 +378,7 @@ "size_selected": 5, "vx": [ { + "buffer": {}, "dtype": "float32", "shape": [ 2000 @@ -376,6 +387,7 @@ ], "vy": [ { + "buffer": {}, "dtype": "float32", "shape": [ 2000 @@ -384,6 +396,7 @@ ], "vz": [ { + "buffer": {}, "dtype": "float32", "shape": [ 2000 @@ -392,6 +405,7 @@ ], "x": [ { + "buffer": {}, "dtype": "float32", "shape": [ 2000 @@ -400,6 +414,7 @@ ], "y": [ { + "buffer": {}, "dtype": "float32", "shape": [ 2000 @@ -408,6 +423,7 @@ ], "z": [ { + "buffer": {}, "dtype": "float32", "shape": [ 2000 diff --git a/docs/source/examples/js/embed-amd_v0.18.0.js b/docs/source/examples/js/embed-amd_v0.18.0.js new file mode 100644 index 00000000..7536eeb6 --- /dev/null +++ b/docs/source/examples/js/embed-amd_v0.18.0.js @@ -0,0 +1,210 @@ +define("@jupyter-widgets/base",[],function(){return function(e){var t={};function n(r){if(t[r])return t[r].exports;var i=t[r]={i:r,l:!1,exports:{}};return e[r].call(i.exports,i,i.exports,n),i.l=!0,i.exports}return n.m=e,n.c=t,n.d=function(e,t,r){n.o(e,t)||Object.defineProperty(e,t,{enumerable:!0,get:r})},n.r=function(e){"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0})},n.t=function(e,t){if(1&t&&(e=n(e)),8&t)return e;if(4&t&&"object"==typeof e&&e&&e.__esModule)return e;var r=Object.create(null);if(n.r(r),Object.defineProperty(r,"default",{enumerable:!0,value:e}),2&t&&"string"!=typeof e)for(var i in e)n.d(r,i,function(t){return e[t]}.bind(null,i));return r},n.n=function(e){var t=e&&e.__esModule?function(){return e.default}:function(){return e};return n.d(t,"a",t),t},n.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},n.p="https://unpkg.com/@jupyter-widgets/html-manager@0.18.4/dist/",n(n.s=318)}([function(e,t){"function"==typeof Object.create?e.exports=function(e,t){t&&(e.super_=t,e.prototype=Object.create(t.prototype,{constructor:{value:e,enumerable:!1,writable:!0,configurable:!0}}))}:e.exports=function(e,t){if(t){e.super_=t;var n=function(){};n.prototype=t.prototype,e.prototype=new n,e.prototype.constructor=e}}},function(e,t,n){var r=n(6),i=r.Buffer;function o(e,t){for(var n in e)t[n]=e[n]}function s(e,t,n){return i(e,t,n)}i.from&&i.alloc&&i.allocUnsafe&&i.allocUnsafeSlow?e.exports=r:(o(r,t),t.Buffer=s),o(i,s),s.from=function(e,t,n){if("number"==typeof e)throw new TypeError("Argument must not be a number");return i(e,t,n)},s.alloc=function(e,t,n){if("number"!=typeof e)throw new TypeError("Argument must be a number");var r=i(e);return void 0!==t?"string"==typeof n?r.fill(t,n):r.fill(t):r.fill(0),r},s.allocUnsafe=function(e){if("number"!=typeof e)throw new TypeError("Argument must be a number");return i(e)},s.allocUnsafeSlow=function(e){if("number"!=typeof e)throw new TypeError("Argument must be a number");return r.SlowBuffer(e)}},function(e,t,n){"use strict";function r(e){for(var n in e)t.hasOwnProperty(n)||(t[n]=e[n])}Object.defineProperty(t,"__esModule",{value:!0}),r(n(284)),r(n(285)),r(n(286)),r(n(287)),r(n(288)),r(n(289)),r(n(12)),r(n(290)),r(n(291)),r(n(292)),r(n(293)),r(n(294)),r(n(295)),r(n(296)),r(n(297)),r(n(298)),r(n(299))},function(e,t,n){(function(e){!function(e,t){"use strict";function r(e,t){if(!e)throw new Error(t||"Assertion failed")}function i(e,t){e.super_=t;var n=function(){};n.prototype=t.prototype,e.prototype=new n,e.prototype.constructor=e}function o(e,t,n){if(o.isBN(e))return e;this.negative=0,this.words=null,this.length=0,this.red=null,null!==e&&("le"!==t&&"be"!==t||(n=t,t=10),this._init(e||0,t||10,n||"be"))}var s;"object"==typeof e?e.exports=o:t.BN=o,o.BN=o,o.wordSize=26;try{s=n(168).Buffer}catch(e){}function a(e,t,n){for(var r=0,i=Math.min(e.length,n),o=t;o=49&&s<=54?s-49+10:s>=17&&s<=22?s-17+10:15&s}return r}function c(e,t,n,r){for(var i=0,o=Math.min(e.length,n),s=t;s=49?a-49+10:a>=17?a-17+10:a}return i}o.isBN=function(e){return e instanceof o||null!==e&&"object"==typeof e&&e.constructor.wordSize===o.wordSize&&Array.isArray(e.words)},o.max=function(e,t){return e.cmp(t)>0?e:t},o.min=function(e,t){return e.cmp(t)<0?e:t},o.prototype._init=function(e,t,n){if("number"==typeof e)return this._initNumber(e,t,n);if("object"==typeof e)return this._initArray(e,t,n);"hex"===t&&(t=16),r(t===(0|t)&&t>=2&&t<=36);var i=0;"-"===(e=e.toString().replace(/\s+/g,""))[0]&&i++,16===t?this._parseHex(e,i):this._parseBase(e,t,i),"-"===e[0]&&(this.negative=1),this.strip(),"le"===n&&this._initArray(this.toArray(),t,n)},o.prototype._initNumber=function(e,t,n){e<0&&(this.negative=1,e=-e),e<67108864?(this.words=[67108863&e],this.length=1):e<4503599627370496?(this.words=[67108863&e,e/67108864&67108863],this.length=2):(r(e<9007199254740992),this.words=[67108863&e,e/67108864&67108863,1],this.length=3),"le"===n&&this._initArray(this.toArray(),t,n)},o.prototype._initArray=function(e,t,n){if(r("number"==typeof e.length),e.length<=0)return this.words=[0],this.length=1,this;this.length=Math.ceil(e.length/3),this.words=new Array(this.length);for(var i=0;i=0;i-=3)s=e[i]|e[i-1]<<8|e[i-2]<<16,this.words[o]|=s<>>26-a&67108863,(a+=24)>=26&&(a-=26,o++);else if("le"===n)for(i=0,o=0;i>>26-a&67108863,(a+=24)>=26&&(a-=26,o++);return this.strip()},o.prototype._parseHex=function(e,t){this.length=Math.ceil((e.length-t)/6),this.words=new Array(this.length);for(var n=0;n=t;n-=6)i=a(e,n,n+6),this.words[r]|=i<>>26-o&4194303,(o+=24)>=26&&(o-=26,r++);n+6!==t&&(i=a(e,t,n+6),this.words[r]|=i<>>26-o&4194303),this.strip()},o.prototype._parseBase=function(e,t,n){this.words=[0],this.length=1;for(var r=0,i=1;i<=67108863;i*=t)r++;r--,i=i/t|0;for(var o=e.length-n,s=o%r,a=Math.min(o,o-s)+n,u=0,f=n;f1&&0===this.words[this.length-1];)this.length--;return this._normSign()},o.prototype._normSign=function(){return 1===this.length&&0===this.words[0]&&(this.negative=0),this},o.prototype.inspect=function(){return(this.red?""};var u=["","0","00","000","0000","00000","000000","0000000","00000000","000000000","0000000000","00000000000","000000000000","0000000000000","00000000000000","000000000000000","0000000000000000","00000000000000000","000000000000000000","0000000000000000000","00000000000000000000","000000000000000000000","0000000000000000000000","00000000000000000000000","000000000000000000000000","0000000000000000000000000"],f=[0,0,25,16,12,11,10,9,8,8,7,7,7,7,6,6,6,6,6,6,6,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],h=[0,0,33554432,43046721,16777216,48828125,60466176,40353607,16777216,43046721,1e7,19487171,35831808,62748517,7529536,11390625,16777216,24137569,34012224,47045881,64e6,4084101,5153632,6436343,7962624,9765625,11881376,14348907,17210368,20511149,243e5,28629151,33554432,39135393,45435424,52521875,60466176];function d(e,t,n){n.negative=t.negative^e.negative;var r=e.length+t.length|0;n.length=r,r=r-1|0;var i=0|e.words[0],o=0|t.words[0],s=i*o,a=67108863&s,c=s/67108864|0;n.words[0]=a;for(var u=1;u>>26,h=67108863&c,d=Math.min(u,t.length-1),l=Math.max(0,u-e.length+1);l<=d;l++){var p=u-l|0;f+=(s=(i=0|e.words[p])*(o=0|t.words[l])+h)/67108864|0,h=67108863&s}n.words[u]=0|h,c=0|f}return 0!==c?n.words[u]=0|c:n.length--,n.strip()}o.prototype.toString=function(e,t){var n;if(t=0|t||1,16===(e=e||10)||"hex"===e){n="";for(var i=0,o=0,s=0;s>>24-i&16777215)||s!==this.length-1?u[6-c.length]+c+n:c+n,(i+=2)>=26&&(i-=26,s--)}for(0!==o&&(n=o.toString(16)+n);n.length%t!=0;)n="0"+n;return 0!==this.negative&&(n="-"+n),n}if(e===(0|e)&&e>=2&&e<=36){var d=f[e],l=h[e];n="";var p=this.clone();for(p.negative=0;!p.isZero();){var m=p.modn(l).toString(e);n=(p=p.idivn(l)).isZero()?m+n:u[d-m.length]+m+n}for(this.isZero()&&(n="0"+n);n.length%t!=0;)n="0"+n;return 0!==this.negative&&(n="-"+n),n}r(!1,"Base should be between 2 and 36")},o.prototype.toNumber=function(){var e=this.words[0];return 2===this.length?e+=67108864*this.words[1]:3===this.length&&1===this.words[2]?e+=4503599627370496+67108864*this.words[1]:this.length>2&&r(!1,"Number can only safely store up to 53 bits"),0!==this.negative?-e:e},o.prototype.toJSON=function(){return this.toString(16)},o.prototype.toBuffer=function(e,t){return r(void 0!==s),this.toArrayLike(s,e,t)},o.prototype.toArray=function(e,t){return this.toArrayLike(Array,e,t)},o.prototype.toArrayLike=function(e,t,n){var i=this.byteLength(),o=n||Math.max(1,i);r(i<=o,"byte array longer than desired length"),r(o>0,"Requested array length <= 0"),this.strip();var s,a,c="le"===t,u=new e(o),f=this.clone();if(c){for(a=0;!f.isZero();a++)s=f.andln(255),f.iushrn(8),u[a]=s;for(;a=4096&&(n+=13,t>>>=13),t>=64&&(n+=7,t>>>=7),t>=8&&(n+=4,t>>>=4),t>=2&&(n+=2,t>>>=2),n+t},o.prototype._zeroBits=function(e){if(0===e)return 26;var t=e,n=0;return 0==(8191&t)&&(n+=13,t>>>=13),0==(127&t)&&(n+=7,t>>>=7),0==(15&t)&&(n+=4,t>>>=4),0==(3&t)&&(n+=2,t>>>=2),0==(1&t)&&n++,n},o.prototype.bitLength=function(){var e=this.words[this.length-1],t=this._countBits(e);return 26*(this.length-1)+t},o.prototype.zeroBits=function(){if(this.isZero())return 0;for(var e=0,t=0;te.length?this.clone().ior(e):e.clone().ior(this)},o.prototype.uor=function(e){return this.length>e.length?this.clone().iuor(e):e.clone().iuor(this)},o.prototype.iuand=function(e){var t;t=this.length>e.length?e:this;for(var n=0;ne.length?this.clone().iand(e):e.clone().iand(this)},o.prototype.uand=function(e){return this.length>e.length?this.clone().iuand(e):e.clone().iuand(this)},o.prototype.iuxor=function(e){var t,n;this.length>e.length?(t=this,n=e):(t=e,n=this);for(var r=0;re.length?this.clone().ixor(e):e.clone().ixor(this)},o.prototype.uxor=function(e){return this.length>e.length?this.clone().iuxor(e):e.clone().iuxor(this)},o.prototype.inotn=function(e){r("number"==typeof e&&e>=0);var t=0|Math.ceil(e/26),n=e%26;this._expand(t),n>0&&t--;for(var i=0;i0&&(this.words[i]=~this.words[i]&67108863>>26-n),this.strip()},o.prototype.notn=function(e){return this.clone().inotn(e)},o.prototype.setn=function(e,t){r("number"==typeof e&&e>=0);var n=e/26|0,i=e%26;return this._expand(n+1),this.words[n]=t?this.words[n]|1<e.length?(n=this,r=e):(n=e,r=this);for(var i=0,o=0;o>>26;for(;0!==i&&o>>26;if(this.length=n.length,0!==i)this.words[this.length]=i,this.length++;else if(n!==this)for(;oe.length?this.clone().iadd(e):e.clone().iadd(this)},o.prototype.isub=function(e){if(0!==e.negative){e.negative=0;var t=this.iadd(e);return e.negative=1,t._normSign()}if(0!==this.negative)return this.negative=0,this.iadd(e),this.negative=1,this._normSign();var n,r,i=this.cmp(e);if(0===i)return this.negative=0,this.length=1,this.words[0]=0,this;i>0?(n=this,r=e):(n=e,r=this);for(var o=0,s=0;s>26,this.words[s]=67108863&t;for(;0!==o&&s>26,this.words[s]=67108863&t;if(0===o&&s>>13,l=0|s[1],p=8191&l,m=l>>>13,b=0|s[2],v=8191&b,g=b>>>13,y=0|s[3],_=8191&y,w=y>>>13,x=0|s[4],M=8191&x,S=x>>>13,E=0|s[5],A=8191&E,k=E>>>13,C=0|s[6],P=8191&C,I=C>>>13,T=0|s[7],O=8191&T,j=T>>>13,L=0|s[8],B=8191&L,D=L>>>13,z=0|s[9],R=8191&z,N=z>>>13,q=0|a[0],H=8191&q,W=q>>>13,F=0|a[1],U=8191&F,K=F>>>13,V=0|a[2],Y=8191&V,X=V>>>13,$=0|a[3],G=8191&$,J=$>>>13,Z=0|a[4],Q=8191&Z,ee=Z>>>13,te=0|a[5],ne=8191&te,re=te>>>13,ie=0|a[6],oe=8191&ie,se=ie>>>13,ae=0|a[7],ce=8191&ae,ue=ae>>>13,fe=0|a[8],he=8191&fe,de=fe>>>13,le=0|a[9],pe=8191&le,me=le>>>13;n.negative=e.negative^t.negative,n.length=19;var be=(u+(r=Math.imul(h,H))|0)+((8191&(i=(i=Math.imul(h,W))+Math.imul(d,H)|0))<<13)|0;u=((o=Math.imul(d,W))+(i>>>13)|0)+(be>>>26)|0,be&=67108863,r=Math.imul(p,H),i=(i=Math.imul(p,W))+Math.imul(m,H)|0,o=Math.imul(m,W);var ve=(u+(r=r+Math.imul(h,U)|0)|0)+((8191&(i=(i=i+Math.imul(h,K)|0)+Math.imul(d,U)|0))<<13)|0;u=((o=o+Math.imul(d,K)|0)+(i>>>13)|0)+(ve>>>26)|0,ve&=67108863,r=Math.imul(v,H),i=(i=Math.imul(v,W))+Math.imul(g,H)|0,o=Math.imul(g,W),r=r+Math.imul(p,U)|0,i=(i=i+Math.imul(p,K)|0)+Math.imul(m,U)|0,o=o+Math.imul(m,K)|0;var ge=(u+(r=r+Math.imul(h,Y)|0)|0)+((8191&(i=(i=i+Math.imul(h,X)|0)+Math.imul(d,Y)|0))<<13)|0;u=((o=o+Math.imul(d,X)|0)+(i>>>13)|0)+(ge>>>26)|0,ge&=67108863,r=Math.imul(_,H),i=(i=Math.imul(_,W))+Math.imul(w,H)|0,o=Math.imul(w,W),r=r+Math.imul(v,U)|0,i=(i=i+Math.imul(v,K)|0)+Math.imul(g,U)|0,o=o+Math.imul(g,K)|0,r=r+Math.imul(p,Y)|0,i=(i=i+Math.imul(p,X)|0)+Math.imul(m,Y)|0,o=o+Math.imul(m,X)|0;var ye=(u+(r=r+Math.imul(h,G)|0)|0)+((8191&(i=(i=i+Math.imul(h,J)|0)+Math.imul(d,G)|0))<<13)|0;u=((o=o+Math.imul(d,J)|0)+(i>>>13)|0)+(ye>>>26)|0,ye&=67108863,r=Math.imul(M,H),i=(i=Math.imul(M,W))+Math.imul(S,H)|0,o=Math.imul(S,W),r=r+Math.imul(_,U)|0,i=(i=i+Math.imul(_,K)|0)+Math.imul(w,U)|0,o=o+Math.imul(w,K)|0,r=r+Math.imul(v,Y)|0,i=(i=i+Math.imul(v,X)|0)+Math.imul(g,Y)|0,o=o+Math.imul(g,X)|0,r=r+Math.imul(p,G)|0,i=(i=i+Math.imul(p,J)|0)+Math.imul(m,G)|0,o=o+Math.imul(m,J)|0;var _e=(u+(r=r+Math.imul(h,Q)|0)|0)+((8191&(i=(i=i+Math.imul(h,ee)|0)+Math.imul(d,Q)|0))<<13)|0;u=((o=o+Math.imul(d,ee)|0)+(i>>>13)|0)+(_e>>>26)|0,_e&=67108863,r=Math.imul(A,H),i=(i=Math.imul(A,W))+Math.imul(k,H)|0,o=Math.imul(k,W),r=r+Math.imul(M,U)|0,i=(i=i+Math.imul(M,K)|0)+Math.imul(S,U)|0,o=o+Math.imul(S,K)|0,r=r+Math.imul(_,Y)|0,i=(i=i+Math.imul(_,X)|0)+Math.imul(w,Y)|0,o=o+Math.imul(w,X)|0,r=r+Math.imul(v,G)|0,i=(i=i+Math.imul(v,J)|0)+Math.imul(g,G)|0,o=o+Math.imul(g,J)|0,r=r+Math.imul(p,Q)|0,i=(i=i+Math.imul(p,ee)|0)+Math.imul(m,Q)|0,o=o+Math.imul(m,ee)|0;var we=(u+(r=r+Math.imul(h,ne)|0)|0)+((8191&(i=(i=i+Math.imul(h,re)|0)+Math.imul(d,ne)|0))<<13)|0;u=((o=o+Math.imul(d,re)|0)+(i>>>13)|0)+(we>>>26)|0,we&=67108863,r=Math.imul(P,H),i=(i=Math.imul(P,W))+Math.imul(I,H)|0,o=Math.imul(I,W),r=r+Math.imul(A,U)|0,i=(i=i+Math.imul(A,K)|0)+Math.imul(k,U)|0,o=o+Math.imul(k,K)|0,r=r+Math.imul(M,Y)|0,i=(i=i+Math.imul(M,X)|0)+Math.imul(S,Y)|0,o=o+Math.imul(S,X)|0,r=r+Math.imul(_,G)|0,i=(i=i+Math.imul(_,J)|0)+Math.imul(w,G)|0,o=o+Math.imul(w,J)|0,r=r+Math.imul(v,Q)|0,i=(i=i+Math.imul(v,ee)|0)+Math.imul(g,Q)|0,o=o+Math.imul(g,ee)|0,r=r+Math.imul(p,ne)|0,i=(i=i+Math.imul(p,re)|0)+Math.imul(m,ne)|0,o=o+Math.imul(m,re)|0;var xe=(u+(r=r+Math.imul(h,oe)|0)|0)+((8191&(i=(i=i+Math.imul(h,se)|0)+Math.imul(d,oe)|0))<<13)|0;u=((o=o+Math.imul(d,se)|0)+(i>>>13)|0)+(xe>>>26)|0,xe&=67108863,r=Math.imul(O,H),i=(i=Math.imul(O,W))+Math.imul(j,H)|0,o=Math.imul(j,W),r=r+Math.imul(P,U)|0,i=(i=i+Math.imul(P,K)|0)+Math.imul(I,U)|0,o=o+Math.imul(I,K)|0,r=r+Math.imul(A,Y)|0,i=(i=i+Math.imul(A,X)|0)+Math.imul(k,Y)|0,o=o+Math.imul(k,X)|0,r=r+Math.imul(M,G)|0,i=(i=i+Math.imul(M,J)|0)+Math.imul(S,G)|0,o=o+Math.imul(S,J)|0,r=r+Math.imul(_,Q)|0,i=(i=i+Math.imul(_,ee)|0)+Math.imul(w,Q)|0,o=o+Math.imul(w,ee)|0,r=r+Math.imul(v,ne)|0,i=(i=i+Math.imul(v,re)|0)+Math.imul(g,ne)|0,o=o+Math.imul(g,re)|0,r=r+Math.imul(p,oe)|0,i=(i=i+Math.imul(p,se)|0)+Math.imul(m,oe)|0,o=o+Math.imul(m,se)|0;var Me=(u+(r=r+Math.imul(h,ce)|0)|0)+((8191&(i=(i=i+Math.imul(h,ue)|0)+Math.imul(d,ce)|0))<<13)|0;u=((o=o+Math.imul(d,ue)|0)+(i>>>13)|0)+(Me>>>26)|0,Me&=67108863,r=Math.imul(B,H),i=(i=Math.imul(B,W))+Math.imul(D,H)|0,o=Math.imul(D,W),r=r+Math.imul(O,U)|0,i=(i=i+Math.imul(O,K)|0)+Math.imul(j,U)|0,o=o+Math.imul(j,K)|0,r=r+Math.imul(P,Y)|0,i=(i=i+Math.imul(P,X)|0)+Math.imul(I,Y)|0,o=o+Math.imul(I,X)|0,r=r+Math.imul(A,G)|0,i=(i=i+Math.imul(A,J)|0)+Math.imul(k,G)|0,o=o+Math.imul(k,J)|0,r=r+Math.imul(M,Q)|0,i=(i=i+Math.imul(M,ee)|0)+Math.imul(S,Q)|0,o=o+Math.imul(S,ee)|0,r=r+Math.imul(_,ne)|0,i=(i=i+Math.imul(_,re)|0)+Math.imul(w,ne)|0,o=o+Math.imul(w,re)|0,r=r+Math.imul(v,oe)|0,i=(i=i+Math.imul(v,se)|0)+Math.imul(g,oe)|0,o=o+Math.imul(g,se)|0,r=r+Math.imul(p,ce)|0,i=(i=i+Math.imul(p,ue)|0)+Math.imul(m,ce)|0,o=o+Math.imul(m,ue)|0;var Se=(u+(r=r+Math.imul(h,he)|0)|0)+((8191&(i=(i=i+Math.imul(h,de)|0)+Math.imul(d,he)|0))<<13)|0;u=((o=o+Math.imul(d,de)|0)+(i>>>13)|0)+(Se>>>26)|0,Se&=67108863,r=Math.imul(R,H),i=(i=Math.imul(R,W))+Math.imul(N,H)|0,o=Math.imul(N,W),r=r+Math.imul(B,U)|0,i=(i=i+Math.imul(B,K)|0)+Math.imul(D,U)|0,o=o+Math.imul(D,K)|0,r=r+Math.imul(O,Y)|0,i=(i=i+Math.imul(O,X)|0)+Math.imul(j,Y)|0,o=o+Math.imul(j,X)|0,r=r+Math.imul(P,G)|0,i=(i=i+Math.imul(P,J)|0)+Math.imul(I,G)|0,o=o+Math.imul(I,J)|0,r=r+Math.imul(A,Q)|0,i=(i=i+Math.imul(A,ee)|0)+Math.imul(k,Q)|0,o=o+Math.imul(k,ee)|0,r=r+Math.imul(M,ne)|0,i=(i=i+Math.imul(M,re)|0)+Math.imul(S,ne)|0,o=o+Math.imul(S,re)|0,r=r+Math.imul(_,oe)|0,i=(i=i+Math.imul(_,se)|0)+Math.imul(w,oe)|0,o=o+Math.imul(w,se)|0,r=r+Math.imul(v,ce)|0,i=(i=i+Math.imul(v,ue)|0)+Math.imul(g,ce)|0,o=o+Math.imul(g,ue)|0,r=r+Math.imul(p,he)|0,i=(i=i+Math.imul(p,de)|0)+Math.imul(m,he)|0,o=o+Math.imul(m,de)|0;var Ee=(u+(r=r+Math.imul(h,pe)|0)|0)+((8191&(i=(i=i+Math.imul(h,me)|0)+Math.imul(d,pe)|0))<<13)|0;u=((o=o+Math.imul(d,me)|0)+(i>>>13)|0)+(Ee>>>26)|0,Ee&=67108863,r=Math.imul(R,U),i=(i=Math.imul(R,K))+Math.imul(N,U)|0,o=Math.imul(N,K),r=r+Math.imul(B,Y)|0,i=(i=i+Math.imul(B,X)|0)+Math.imul(D,Y)|0,o=o+Math.imul(D,X)|0,r=r+Math.imul(O,G)|0,i=(i=i+Math.imul(O,J)|0)+Math.imul(j,G)|0,o=o+Math.imul(j,J)|0,r=r+Math.imul(P,Q)|0,i=(i=i+Math.imul(P,ee)|0)+Math.imul(I,Q)|0,o=o+Math.imul(I,ee)|0,r=r+Math.imul(A,ne)|0,i=(i=i+Math.imul(A,re)|0)+Math.imul(k,ne)|0,o=o+Math.imul(k,re)|0,r=r+Math.imul(M,oe)|0,i=(i=i+Math.imul(M,se)|0)+Math.imul(S,oe)|0,o=o+Math.imul(S,se)|0,r=r+Math.imul(_,ce)|0,i=(i=i+Math.imul(_,ue)|0)+Math.imul(w,ce)|0,o=o+Math.imul(w,ue)|0,r=r+Math.imul(v,he)|0,i=(i=i+Math.imul(v,de)|0)+Math.imul(g,he)|0,o=o+Math.imul(g,de)|0;var Ae=(u+(r=r+Math.imul(p,pe)|0)|0)+((8191&(i=(i=i+Math.imul(p,me)|0)+Math.imul(m,pe)|0))<<13)|0;u=((o=o+Math.imul(m,me)|0)+(i>>>13)|0)+(Ae>>>26)|0,Ae&=67108863,r=Math.imul(R,Y),i=(i=Math.imul(R,X))+Math.imul(N,Y)|0,o=Math.imul(N,X),r=r+Math.imul(B,G)|0,i=(i=i+Math.imul(B,J)|0)+Math.imul(D,G)|0,o=o+Math.imul(D,J)|0,r=r+Math.imul(O,Q)|0,i=(i=i+Math.imul(O,ee)|0)+Math.imul(j,Q)|0,o=o+Math.imul(j,ee)|0,r=r+Math.imul(P,ne)|0,i=(i=i+Math.imul(P,re)|0)+Math.imul(I,ne)|0,o=o+Math.imul(I,re)|0,r=r+Math.imul(A,oe)|0,i=(i=i+Math.imul(A,se)|0)+Math.imul(k,oe)|0,o=o+Math.imul(k,se)|0,r=r+Math.imul(M,ce)|0,i=(i=i+Math.imul(M,ue)|0)+Math.imul(S,ce)|0,o=o+Math.imul(S,ue)|0,r=r+Math.imul(_,he)|0,i=(i=i+Math.imul(_,de)|0)+Math.imul(w,he)|0,o=o+Math.imul(w,de)|0;var ke=(u+(r=r+Math.imul(v,pe)|0)|0)+((8191&(i=(i=i+Math.imul(v,me)|0)+Math.imul(g,pe)|0))<<13)|0;u=((o=o+Math.imul(g,me)|0)+(i>>>13)|0)+(ke>>>26)|0,ke&=67108863,r=Math.imul(R,G),i=(i=Math.imul(R,J))+Math.imul(N,G)|0,o=Math.imul(N,J),r=r+Math.imul(B,Q)|0,i=(i=i+Math.imul(B,ee)|0)+Math.imul(D,Q)|0,o=o+Math.imul(D,ee)|0,r=r+Math.imul(O,ne)|0,i=(i=i+Math.imul(O,re)|0)+Math.imul(j,ne)|0,o=o+Math.imul(j,re)|0,r=r+Math.imul(P,oe)|0,i=(i=i+Math.imul(P,se)|0)+Math.imul(I,oe)|0,o=o+Math.imul(I,se)|0,r=r+Math.imul(A,ce)|0,i=(i=i+Math.imul(A,ue)|0)+Math.imul(k,ce)|0,o=o+Math.imul(k,ue)|0,r=r+Math.imul(M,he)|0,i=(i=i+Math.imul(M,de)|0)+Math.imul(S,he)|0,o=o+Math.imul(S,de)|0;var Ce=(u+(r=r+Math.imul(_,pe)|0)|0)+((8191&(i=(i=i+Math.imul(_,me)|0)+Math.imul(w,pe)|0))<<13)|0;u=((o=o+Math.imul(w,me)|0)+(i>>>13)|0)+(Ce>>>26)|0,Ce&=67108863,r=Math.imul(R,Q),i=(i=Math.imul(R,ee))+Math.imul(N,Q)|0,o=Math.imul(N,ee),r=r+Math.imul(B,ne)|0,i=(i=i+Math.imul(B,re)|0)+Math.imul(D,ne)|0,o=o+Math.imul(D,re)|0,r=r+Math.imul(O,oe)|0,i=(i=i+Math.imul(O,se)|0)+Math.imul(j,oe)|0,o=o+Math.imul(j,se)|0,r=r+Math.imul(P,ce)|0,i=(i=i+Math.imul(P,ue)|0)+Math.imul(I,ce)|0,o=o+Math.imul(I,ue)|0,r=r+Math.imul(A,he)|0,i=(i=i+Math.imul(A,de)|0)+Math.imul(k,he)|0,o=o+Math.imul(k,de)|0;var Pe=(u+(r=r+Math.imul(M,pe)|0)|0)+((8191&(i=(i=i+Math.imul(M,me)|0)+Math.imul(S,pe)|0))<<13)|0;u=((o=o+Math.imul(S,me)|0)+(i>>>13)|0)+(Pe>>>26)|0,Pe&=67108863,r=Math.imul(R,ne),i=(i=Math.imul(R,re))+Math.imul(N,ne)|0,o=Math.imul(N,re),r=r+Math.imul(B,oe)|0,i=(i=i+Math.imul(B,se)|0)+Math.imul(D,oe)|0,o=o+Math.imul(D,se)|0,r=r+Math.imul(O,ce)|0,i=(i=i+Math.imul(O,ue)|0)+Math.imul(j,ce)|0,o=o+Math.imul(j,ue)|0,r=r+Math.imul(P,he)|0,i=(i=i+Math.imul(P,de)|0)+Math.imul(I,he)|0,o=o+Math.imul(I,de)|0;var Ie=(u+(r=r+Math.imul(A,pe)|0)|0)+((8191&(i=(i=i+Math.imul(A,me)|0)+Math.imul(k,pe)|0))<<13)|0;u=((o=o+Math.imul(k,me)|0)+(i>>>13)|0)+(Ie>>>26)|0,Ie&=67108863,r=Math.imul(R,oe),i=(i=Math.imul(R,se))+Math.imul(N,oe)|0,o=Math.imul(N,se),r=r+Math.imul(B,ce)|0,i=(i=i+Math.imul(B,ue)|0)+Math.imul(D,ce)|0,o=o+Math.imul(D,ue)|0,r=r+Math.imul(O,he)|0,i=(i=i+Math.imul(O,de)|0)+Math.imul(j,he)|0,o=o+Math.imul(j,de)|0;var Te=(u+(r=r+Math.imul(P,pe)|0)|0)+((8191&(i=(i=i+Math.imul(P,me)|0)+Math.imul(I,pe)|0))<<13)|0;u=((o=o+Math.imul(I,me)|0)+(i>>>13)|0)+(Te>>>26)|0,Te&=67108863,r=Math.imul(R,ce),i=(i=Math.imul(R,ue))+Math.imul(N,ce)|0,o=Math.imul(N,ue),r=r+Math.imul(B,he)|0,i=(i=i+Math.imul(B,de)|0)+Math.imul(D,he)|0,o=o+Math.imul(D,de)|0;var Oe=(u+(r=r+Math.imul(O,pe)|0)|0)+((8191&(i=(i=i+Math.imul(O,me)|0)+Math.imul(j,pe)|0))<<13)|0;u=((o=o+Math.imul(j,me)|0)+(i>>>13)|0)+(Oe>>>26)|0,Oe&=67108863,r=Math.imul(R,he),i=(i=Math.imul(R,de))+Math.imul(N,he)|0,o=Math.imul(N,de);var je=(u+(r=r+Math.imul(B,pe)|0)|0)+((8191&(i=(i=i+Math.imul(B,me)|0)+Math.imul(D,pe)|0))<<13)|0;u=((o=o+Math.imul(D,me)|0)+(i>>>13)|0)+(je>>>26)|0,je&=67108863;var Le=(u+(r=Math.imul(R,pe))|0)+((8191&(i=(i=Math.imul(R,me))+Math.imul(N,pe)|0))<<13)|0;return u=((o=Math.imul(N,me))+(i>>>13)|0)+(Le>>>26)|0,Le&=67108863,c[0]=be,c[1]=ve,c[2]=ge,c[3]=ye,c[4]=_e,c[5]=we,c[6]=xe,c[7]=Me,c[8]=Se,c[9]=Ee,c[10]=Ae,c[11]=ke,c[12]=Ce,c[13]=Pe,c[14]=Ie,c[15]=Te,c[16]=Oe,c[17]=je,c[18]=Le,0!==u&&(c[19]=u,n.length++),n};function p(e,t,n){return(new m).mulp(e,t,n)}function m(e,t){this.x=e,this.y=t}Math.imul||(l=d),o.prototype.mulTo=function(e,t){var n=this.length+e.length;return 10===this.length&&10===e.length?l(this,e,t):n<63?d(this,e,t):n<1024?function(e,t,n){n.negative=t.negative^e.negative,n.length=e.length+t.length;for(var r=0,i=0,o=0;o>>26)|0)>>>26,s&=67108863}n.words[o]=a,r=s,s=i}return 0!==r?n.words[o]=r:n.length--,n.strip()}(this,e,t):p(this,e,t)},m.prototype.makeRBT=function(e){for(var t=new Array(e),n=o.prototype._countBits(e)-1,r=0;r>=1;return r},m.prototype.permute=function(e,t,n,r,i,o){for(var s=0;s>>=1)i++;return 1<>>=13,n[2*s+1]=8191&o,o>>>=13;for(s=2*t;s>=26,t+=i/67108864|0,t+=o>>>26,this.words[n]=67108863&o}return 0!==t&&(this.words[n]=t,this.length++),this},o.prototype.muln=function(e){return this.clone().imuln(e)},o.prototype.sqr=function(){return this.mul(this)},o.prototype.isqr=function(){return this.imul(this.clone())},o.prototype.pow=function(e){var t=function(e){for(var t=new Array(e.bitLength()),n=0;n>>i}return t}(e);if(0===t.length)return new o(1);for(var n=this,r=0;r=0);var t,n=e%26,i=(e-n)/26,o=67108863>>>26-n<<26-n;if(0!==n){var s=0;for(t=0;t>>26-n}s&&(this.words[t]=s,this.length++)}if(0!==i){for(t=this.length-1;t>=0;t--)this.words[t+i]=this.words[t];for(t=0;t=0),i=t?(t-t%26)/26:0;var o=e%26,s=Math.min((e-o)/26,this.length),a=67108863^67108863>>>o<s)for(this.length-=s,u=0;u=0&&(0!==f||u>=i);u--){var h=0|this.words[u];this.words[u]=f<<26-o|h>>>o,f=h&a}return c&&0!==f&&(c.words[c.length++]=f),0===this.length&&(this.words[0]=0,this.length=1),this.strip()},o.prototype.ishrn=function(e,t,n){return r(0===this.negative),this.iushrn(e,t,n)},o.prototype.shln=function(e){return this.clone().ishln(e)},o.prototype.ushln=function(e){return this.clone().iushln(e)},o.prototype.shrn=function(e){return this.clone().ishrn(e)},o.prototype.ushrn=function(e){return this.clone().iushrn(e)},o.prototype.testn=function(e){r("number"==typeof e&&e>=0);var t=e%26,n=(e-t)/26,i=1<=0);var t=e%26,n=(e-t)/26;if(r(0===this.negative,"imaskn works only with positive numbers"),this.length<=n)return this;if(0!==t&&n++,this.length=Math.min(n,this.length),0!==t){var i=67108863^67108863>>>t<=67108864;t++)this.words[t]-=67108864,t===this.length-1?this.words[t+1]=1:this.words[t+1]++;return this.length=Math.max(this.length,t+1),this},o.prototype.isubn=function(e){if(r("number"==typeof e),r(e<67108864),e<0)return this.iaddn(-e);if(0!==this.negative)return this.negative=0,this.iaddn(e),this.negative=1,this;if(this.words[0]-=e,1===this.length&&this.words[0]<0)this.words[0]=-this.words[0],this.negative=1;else for(var t=0;t>26)-(c/67108864|0),this.words[i+n]=67108863&o}for(;i>26,this.words[i+n]=67108863&o;if(0===a)return this.strip();for(r(-1===a),a=0,i=0;i>26,this.words[i]=67108863&o;return this.negative=1,this.strip()},o.prototype._wordDiv=function(e,t){var n=(this.length,e.length),r=this.clone(),i=e,s=0|i.words[i.length-1];0!==(n=26-this._countBits(s))&&(i=i.ushln(n),r.iushln(n),s=0|i.words[i.length-1]);var a,c=r.length-i.length;if("mod"!==t){(a=new o(null)).length=c+1,a.words=new Array(a.length);for(var u=0;u=0;h--){var d=67108864*(0|r.words[i.length+h])+(0|r.words[i.length+h-1]);for(d=Math.min(d/s|0,67108863),r._ishlnsubmul(i,d,h);0!==r.negative;)d--,r.negative=0,r._ishlnsubmul(i,1,h),r.isZero()||(r.negative^=1);a&&(a.words[h]=d)}return a&&a.strip(),r.strip(),"div"!==t&&0!==n&&r.iushrn(n),{div:a||null,mod:r}},o.prototype.divmod=function(e,t,n){return r(!e.isZero()),this.isZero()?{div:new o(0),mod:new o(0)}:0!==this.negative&&0===e.negative?(a=this.neg().divmod(e,t),"mod"!==t&&(i=a.div.neg()),"div"!==t&&(s=a.mod.neg(),n&&0!==s.negative&&s.iadd(e)),{div:i,mod:s}):0===this.negative&&0!==e.negative?(a=this.divmod(e.neg(),t),"mod"!==t&&(i=a.div.neg()),{div:i,mod:a.mod}):0!=(this.negative&e.negative)?(a=this.neg().divmod(e.neg(),t),"div"!==t&&(s=a.mod.neg(),n&&0!==s.negative&&s.isub(e)),{div:a.div,mod:s}):e.length>this.length||this.cmp(e)<0?{div:new o(0),mod:this}:1===e.length?"div"===t?{div:this.divn(e.words[0]),mod:null}:"mod"===t?{div:null,mod:new o(this.modn(e.words[0]))}:{div:this.divn(e.words[0]),mod:new o(this.modn(e.words[0]))}:this._wordDiv(e,t);var i,s,a},o.prototype.div=function(e){return this.divmod(e,"div",!1).div},o.prototype.mod=function(e){return this.divmod(e,"mod",!1).mod},o.prototype.umod=function(e){return this.divmod(e,"mod",!0).mod},o.prototype.divRound=function(e){var t=this.divmod(e);if(t.mod.isZero())return t.div;var n=0!==t.div.negative?t.mod.isub(e):t.mod,r=e.ushrn(1),i=e.andln(1),o=n.cmp(r);return o<0||1===i&&0===o?t.div:0!==t.div.negative?t.div.isubn(1):t.div.iaddn(1)},o.prototype.modn=function(e){r(e<=67108863);for(var t=(1<<26)%e,n=0,i=this.length-1;i>=0;i--)n=(t*n+(0|this.words[i]))%e;return n},o.prototype.idivn=function(e){r(e<=67108863);for(var t=0,n=this.length-1;n>=0;n--){var i=(0|this.words[n])+67108864*t;this.words[n]=i/e|0,t=i%e}return this.strip()},o.prototype.divn=function(e){return this.clone().idivn(e)},o.prototype.egcd=function(e){r(0===e.negative),r(!e.isZero());var t=this,n=e.clone();t=0!==t.negative?t.umod(e):t.clone();for(var i=new o(1),s=new o(0),a=new o(0),c=new o(1),u=0;t.isEven()&&n.isEven();)t.iushrn(1),n.iushrn(1),++u;for(var f=n.clone(),h=t.clone();!t.isZero();){for(var d=0,l=1;0==(t.words[0]&l)&&d<26;++d,l<<=1);if(d>0)for(t.iushrn(d);d-- >0;)(i.isOdd()||s.isOdd())&&(i.iadd(f),s.isub(h)),i.iushrn(1),s.iushrn(1);for(var p=0,m=1;0==(n.words[0]&m)&&p<26;++p,m<<=1);if(p>0)for(n.iushrn(p);p-- >0;)(a.isOdd()||c.isOdd())&&(a.iadd(f),c.isub(h)),a.iushrn(1),c.iushrn(1);t.cmp(n)>=0?(t.isub(n),i.isub(a),s.isub(c)):(n.isub(t),a.isub(i),c.isub(s))}return{a:a,b:c,gcd:n.iushln(u)}},o.prototype._invmp=function(e){r(0===e.negative),r(!e.isZero());var t=this,n=e.clone();t=0!==t.negative?t.umod(e):t.clone();for(var i,s=new o(1),a=new o(0),c=n.clone();t.cmpn(1)>0&&n.cmpn(1)>0;){for(var u=0,f=1;0==(t.words[0]&f)&&u<26;++u,f<<=1);if(u>0)for(t.iushrn(u);u-- >0;)s.isOdd()&&s.iadd(c),s.iushrn(1);for(var h=0,d=1;0==(n.words[0]&d)&&h<26;++h,d<<=1);if(h>0)for(n.iushrn(h);h-- >0;)a.isOdd()&&a.iadd(c),a.iushrn(1);t.cmp(n)>=0?(t.isub(n),s.isub(a)):(n.isub(t),a.isub(s))}return(i=0===t.cmpn(1)?s:a).cmpn(0)<0&&i.iadd(e),i},o.prototype.gcd=function(e){if(this.isZero())return e.abs();if(e.isZero())return this.abs();var t=this.clone(),n=e.clone();t.negative=0,n.negative=0;for(var r=0;t.isEven()&&n.isEven();r++)t.iushrn(1),n.iushrn(1);for(;;){for(;t.isEven();)t.iushrn(1);for(;n.isEven();)n.iushrn(1);var i=t.cmp(n);if(i<0){var o=t;t=n,n=o}else if(0===i||0===n.cmpn(1))break;t.isub(n)}return n.iushln(r)},o.prototype.invm=function(e){return this.egcd(e).a.umod(e)},o.prototype.isEven=function(){return 0==(1&this.words[0])},o.prototype.isOdd=function(){return 1==(1&this.words[0])},o.prototype.andln=function(e){return this.words[0]&e},o.prototype.bincn=function(e){r("number"==typeof e);var t=e%26,n=(e-t)/26,i=1<>>26,a&=67108863,this.words[s]=a}return 0!==o&&(this.words[s]=o,this.length++),this},o.prototype.isZero=function(){return 1===this.length&&0===this.words[0]},o.prototype.cmpn=function(e){var t,n=e<0;if(0!==this.negative&&!n)return-1;if(0===this.negative&&n)return 1;if(this.strip(),this.length>1)t=1;else{n&&(e=-e),r(e<=67108863,"Number is too big");var i=0|this.words[0];t=i===e?0:ie.length)return 1;if(this.length=0;n--){var r=0|this.words[n],i=0|e.words[n];if(r!==i){ri&&(t=1);break}}return t},o.prototype.gtn=function(e){return 1===this.cmpn(e)},o.prototype.gt=function(e){return 1===this.cmp(e)},o.prototype.gten=function(e){return this.cmpn(e)>=0},o.prototype.gte=function(e){return this.cmp(e)>=0},o.prototype.ltn=function(e){return-1===this.cmpn(e)},o.prototype.lt=function(e){return-1===this.cmp(e)},o.prototype.lten=function(e){return this.cmpn(e)<=0},o.prototype.lte=function(e){return this.cmp(e)<=0},o.prototype.eqn=function(e){return 0===this.cmpn(e)},o.prototype.eq=function(e){return 0===this.cmp(e)},o.red=function(e){return new x(e)},o.prototype.toRed=function(e){return r(!this.red,"Already a number in reduction context"),r(0===this.negative,"red works only with positives"),e.convertTo(this)._forceRed(e)},o.prototype.fromRed=function(){return r(this.red,"fromRed works only with numbers in reduction context"),this.red.convertFrom(this)},o.prototype._forceRed=function(e){return this.red=e,this},o.prototype.forceRed=function(e){return r(!this.red,"Already a number in reduction context"),this._forceRed(e)},o.prototype.redAdd=function(e){return r(this.red,"redAdd works only with red numbers"),this.red.add(this,e)},o.prototype.redIAdd=function(e){return r(this.red,"redIAdd works only with red numbers"),this.red.iadd(this,e)},o.prototype.redSub=function(e){return r(this.red,"redSub works only with red numbers"),this.red.sub(this,e)},o.prototype.redISub=function(e){return r(this.red,"redISub works only with red numbers"),this.red.isub(this,e)},o.prototype.redShl=function(e){return r(this.red,"redShl works only with red numbers"),this.red.shl(this,e)},o.prototype.redMul=function(e){return r(this.red,"redMul works only with red numbers"),this.red._verify2(this,e),this.red.mul(this,e)},o.prototype.redIMul=function(e){return r(this.red,"redMul works only with red numbers"),this.red._verify2(this,e),this.red.imul(this,e)},o.prototype.redSqr=function(){return r(this.red,"redSqr works only with red numbers"),this.red._verify1(this),this.red.sqr(this)},o.prototype.redISqr=function(){return r(this.red,"redISqr works only with red numbers"),this.red._verify1(this),this.red.isqr(this)},o.prototype.redSqrt=function(){return r(this.red,"redSqrt works only with red numbers"),this.red._verify1(this),this.red.sqrt(this)},o.prototype.redInvm=function(){return r(this.red,"redInvm works only with red numbers"),this.red._verify1(this),this.red.invm(this)},o.prototype.redNeg=function(){return r(this.red,"redNeg works only with red numbers"),this.red._verify1(this),this.red.neg(this)},o.prototype.redPow=function(e){return r(this.red&&!e.red,"redPow(normalNum)"),this.red._verify1(this),this.red.pow(this,e)};var b={k256:null,p224:null,p192:null,p25519:null};function v(e,t){this.name=e,this.p=new o(t,16),this.n=this.p.bitLength(),this.k=new o(1).iushln(this.n).isub(this.p),this.tmp=this._tmp()}function g(){v.call(this,"k256","ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe fffffc2f")}function y(){v.call(this,"p224","ffffffff ffffffff ffffffff ffffffff 00000000 00000000 00000001")}function _(){v.call(this,"p192","ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff")}function w(){v.call(this,"25519","7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed")}function x(e){if("string"==typeof e){var t=o._prime(e);this.m=t.p,this.prime=t}else r(e.gtn(1),"modulus must be greater than 1"),this.m=e,this.prime=null}function M(e){x.call(this,e),this.shift=this.m.bitLength(),this.shift%26!=0&&(this.shift+=26-this.shift%26),this.r=new o(1).iushln(this.shift),this.r2=this.imod(this.r.sqr()),this.rinv=this.r._invmp(this.m),this.minv=this.rinv.mul(this.r).isubn(1).div(this.m),this.minv=this.minv.umod(this.r),this.minv=this.r.sub(this.minv)}v.prototype._tmp=function(){var e=new o(null);return e.words=new Array(Math.ceil(this.n/13)),e},v.prototype.ireduce=function(e){var t,n=e;do{this.split(n,this.tmp),t=(n=(n=this.imulK(n)).iadd(this.tmp)).bitLength()}while(t>this.n);var r=t0?n.isub(this.p):n.strip(),n},v.prototype.split=function(e,t){e.iushrn(this.n,0,t)},v.prototype.imulK=function(e){return e.imul(this.k)},i(g,v),g.prototype.split=function(e,t){for(var n=Math.min(e.length,9),r=0;r>>22,i=o}i>>>=22,e.words[r-10]=i,0===i&&e.length>10?e.length-=10:e.length-=9},g.prototype.imulK=function(e){e.words[e.length]=0,e.words[e.length+1]=0,e.length+=2;for(var t=0,n=0;n>>=26,e.words[n]=i,t=r}return 0!==t&&(e.words[e.length++]=t),e},o._prime=function(e){if(b[e])return b[e];var t;if("k256"===e)t=new g;else if("p224"===e)t=new y;else if("p192"===e)t=new _;else{if("p25519"!==e)throw new Error("Unknown prime "+e);t=new w}return b[e]=t,t},x.prototype._verify1=function(e){r(0===e.negative,"red works only with positives"),r(e.red,"red works only with red numbers")},x.prototype._verify2=function(e,t){r(0==(e.negative|t.negative),"red works only with positives"),r(e.red&&e.red===t.red,"red works only with red numbers")},x.prototype.imod=function(e){return this.prime?this.prime.ireduce(e)._forceRed(this):e.umod(this.m)._forceRed(this)},x.prototype.neg=function(e){return e.isZero()?e.clone():this.m.sub(e)._forceRed(this)},x.prototype.add=function(e,t){this._verify2(e,t);var n=e.add(t);return n.cmp(this.m)>=0&&n.isub(this.m),n._forceRed(this)},x.prototype.iadd=function(e,t){this._verify2(e,t);var n=e.iadd(t);return n.cmp(this.m)>=0&&n.isub(this.m),n},x.prototype.sub=function(e,t){this._verify2(e,t);var n=e.sub(t);return n.cmpn(0)<0&&n.iadd(this.m),n._forceRed(this)},x.prototype.isub=function(e,t){this._verify2(e,t);var n=e.isub(t);return n.cmpn(0)<0&&n.iadd(this.m),n},x.prototype.shl=function(e,t){return this._verify1(e),this.imod(e.ushln(t))},x.prototype.imul=function(e,t){return this._verify2(e,t),this.imod(e.imul(t))},x.prototype.mul=function(e,t){return this._verify2(e,t),this.imod(e.mul(t))},x.prototype.isqr=function(e){return this.imul(e,e.clone())},x.prototype.sqr=function(e){return this.mul(e,e)},x.prototype.sqrt=function(e){if(e.isZero())return e.clone();var t=this.m.andln(3);if(r(t%2==1),3===t){var n=this.m.add(new o(1)).iushrn(2);return this.pow(e,n)}for(var i=this.m.subn(1),s=0;!i.isZero()&&0===i.andln(1);)s++,i.iushrn(1);r(!i.isZero());var a=new o(1).toRed(this),c=a.redNeg(),u=this.m.subn(1).iushrn(1),f=this.m.bitLength();for(f=new o(2*f*f).toRed(this);0!==this.pow(f,u).cmp(c);)f.redIAdd(c);for(var h=this.pow(f,i),d=this.pow(e,i.addn(1).iushrn(1)),l=this.pow(e,i),p=s;0!==l.cmp(a);){for(var m=l,b=0;0!==m.cmp(a);b++)m=m.redSqr();r(b=0;r--){for(var u=t.words[r],f=c-1;f>=0;f--){var h=u>>f&1;i!==n[0]&&(i=this.sqr(i)),0!==h||0!==s?(s<<=1,s|=h,(4===++a||0===r&&0===f)&&(i=this.mul(i,n[s]),a=0,s=0)):a=0}c=26}return i},x.prototype.convertTo=function(e){var t=e.umod(this.m);return t===e?t.clone():t},x.prototype.convertFrom=function(e){var t=e.clone();return t.red=null,t},o.mont=function(e){return new M(e)},i(M,x),M.prototype.convertTo=function(e){return this.imod(e.ushln(this.shift))},M.prototype.convertFrom=function(e){var t=this.imod(e.mul(this.rinv));return t.red=null,t},M.prototype.imul=function(e,t){if(e.isZero()||t.isZero())return e.words[0]=0,e.length=1,e;var n=e.imul(t),r=n.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m),i=n.isub(r).iushrn(this.shift),o=i;return i.cmp(this.m)>=0?o=i.isub(this.m):i.cmpn(0)<0&&(o=i.iadd(this.m)),o._forceRed(this)},M.prototype.mul=function(e,t){if(e.isZero()||t.isZero())return new o(0)._forceRed(this);var n=e.mul(t),r=n.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m),i=n.isub(r).iushrn(this.shift),s=i;return i.cmp(this.m)>=0?s=i.isub(this.m):i.cmpn(0)<0&&(s=i.iadd(this.m)),s._forceRed(this)},M.prototype.invm=function(e){return this.imod(e._invmp(this.m).mul(this.r2))._forceRed(this)}}(e,this)}).call(this,n(39)(e))},function(e,t,n){"use strict";var r,i=this&&this.__extends||(r=function(e,t){return(r=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(e,t){e.__proto__=t}||function(e,t){for(var n in t)t.hasOwnProperty(n)&&(e[n]=t[n])})(e,t)},function(e,t){function n(){this.constructor=e}r(e,t),e.prototype=null===t?Object.create(t):(n.prototype=t.prototype,new n)});Object.defineProperty(t,"__esModule",{value:!0});var o,s=n(2),a=n(5),c=n(23),u=n(11),f=n(69),h=function(){function e(e){void 0===e&&(e={}),this._flags=0,this._layout=null,this._parent=null,this._disposed=new u.Signal(this),this.node=o.createNode(e),this.addClass("p-Widget")}return e.prototype.dispose=function(){this.isDisposed||(this.setFlag(e.Flag.IsDisposed),this._disposed.emit(void 0),this.parent?this.parent=null:this.isAttached&&e.detach(this),this._layout&&(this._layout.dispose(),this._layout=null),u.Signal.clearData(this),a.MessageLoop.clearData(this),c.AttachedProperty.clearData(this))},Object.defineProperty(e.prototype,"disposed",{get:function(){return this._disposed},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"isDisposed",{get:function(){return this.testFlag(e.Flag.IsDisposed)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"isAttached",{get:function(){return this.testFlag(e.Flag.IsAttached)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"isHidden",{get:function(){return this.testFlag(e.Flag.IsHidden)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"isVisible",{get:function(){return this.testFlag(e.Flag.IsVisible)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"title",{get:function(){return o.titleProperty.get(this)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"id",{get:function(){return this.node.id},set:function(e){this.node.id=e},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"dataset",{get:function(){return this.node.dataset},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"parent",{get:function(){return this._parent},set:function(t){if(this._parent!==t){if(t&&this.contains(t))throw new Error("Invalid parent widget.");if(this._parent&&!this._parent.isDisposed){var n=new e.ChildMessage("child-removed",this);a.MessageLoop.sendMessage(this._parent,n)}if(this._parent=t,this._parent&&!this._parent.isDisposed){n=new e.ChildMessage("child-added",this);a.MessageLoop.sendMessage(this._parent,n)}this.isDisposed||a.MessageLoop.sendMessage(this,e.Msg.ParentChanged)}},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"layout",{get:function(){return this._layout},set:function(t){if(this._layout!==t){if(this.testFlag(e.Flag.DisallowLayout))throw new Error("Cannot set widget layout.");if(this._layout)throw new Error("Cannot change widget layout.");if(t.parent)throw new Error("Cannot change layout parent.");this._layout=t,t.parent=this}},enumerable:!0,configurable:!0}),e.prototype.children=function(){return this._layout?this._layout.iter():s.empty()},e.prototype.contains=function(e){for(var t=e;t;t=t._parent)if(t===this)return!0;return!1},e.prototype.hasClass=function(e){return this.node.classList.contains(e)},e.prototype.addClass=function(e){this.node.classList.add(e)},e.prototype.removeClass=function(e){this.node.classList.remove(e)},e.prototype.toggleClass=function(e,t){return!0===t?(this.node.classList.add(e),!0):!1===t?(this.node.classList.remove(e),!1):this.node.classList.toggle(e)},e.prototype.update=function(){a.MessageLoop.postMessage(this,e.Msg.UpdateRequest)},e.prototype.fit=function(){a.MessageLoop.postMessage(this,e.Msg.FitRequest)},e.prototype.activate=function(){a.MessageLoop.postMessage(this,e.Msg.ActivateRequest)},e.prototype.close=function(){a.MessageLoop.sendMessage(this,e.Msg.CloseRequest)},e.prototype.show=function(){if(this.testFlag(e.Flag.IsHidden)&&(!this.isAttached||this.parent&&!this.parent.isVisible||a.MessageLoop.sendMessage(this,e.Msg.BeforeShow),this.clearFlag(e.Flag.IsHidden),this.removeClass("p-mod-hidden"),!this.isAttached||this.parent&&!this.parent.isVisible||a.MessageLoop.sendMessage(this,e.Msg.AfterShow),this.parent)){var t=new e.ChildMessage("child-shown",this);a.MessageLoop.sendMessage(this.parent,t)}},e.prototype.hide=function(){if(!this.testFlag(e.Flag.IsHidden)&&(!this.isAttached||this.parent&&!this.parent.isVisible||a.MessageLoop.sendMessage(this,e.Msg.BeforeHide),this.setFlag(e.Flag.IsHidden),this.addClass("p-mod-hidden"),!this.isAttached||this.parent&&!this.parent.isVisible||a.MessageLoop.sendMessage(this,e.Msg.AfterHide),this.parent)){var t=new e.ChildMessage("child-hidden",this);a.MessageLoop.sendMessage(this.parent,t)}},e.prototype.setHidden=function(e){e?this.hide():this.show()},e.prototype.testFlag=function(e){return 0!=(this._flags&e)},e.prototype.setFlag=function(e){this._flags|=e},e.prototype.clearFlag=function(e){this._flags&=~e},e.prototype.processMessage=function(t){switch(t.type){case"resize":this.notifyLayout(t),this.onResize(t);break;case"update-request":this.notifyLayout(t),this.onUpdateRequest(t);break;case"fit-request":this.notifyLayout(t),this.onFitRequest(t);break;case"before-show":this.notifyLayout(t),this.onBeforeShow(t);break;case"after-show":this.setFlag(e.Flag.IsVisible),this.notifyLayout(t),this.onAfterShow(t);break;case"before-hide":this.notifyLayout(t),this.onBeforeHide(t);break;case"after-hide":this.clearFlag(e.Flag.IsVisible),this.notifyLayout(t),this.onAfterHide(t);break;case"before-attach":this.notifyLayout(t),this.onBeforeAttach(t);break;case"after-attach":this.isHidden||this.parent&&!this.parent.isVisible||this.setFlag(e.Flag.IsVisible),this.setFlag(e.Flag.IsAttached),this.notifyLayout(t),this.onAfterAttach(t);break;case"before-detach":this.notifyLayout(t),this.onBeforeDetach(t);break;case"after-detach":this.clearFlag(e.Flag.IsVisible),this.clearFlag(e.Flag.IsAttached),this.notifyLayout(t),this.onAfterDetach(t);break;case"activate-request":this.notifyLayout(t),this.onActivateRequest(t);break;case"close-request":this.notifyLayout(t),this.onCloseRequest(t);break;case"child-added":this.notifyLayout(t),this.onChildAdded(t);break;case"child-removed":this.notifyLayout(t),this.onChildRemoved(t);break;default:this.notifyLayout(t)}},e.prototype.notifyLayout=function(e){this._layout&&this._layout.processParentMessage(e)},e.prototype.onCloseRequest=function(t){this.parent?this.parent=null:this.isAttached&&e.detach(this)},e.prototype.onResize=function(e){},e.prototype.onUpdateRequest=function(e){},e.prototype.onFitRequest=function(e){},e.prototype.onActivateRequest=function(e){},e.prototype.onBeforeShow=function(e){},e.prototype.onAfterShow=function(e){},e.prototype.onBeforeHide=function(e){},e.prototype.onAfterHide=function(e){},e.prototype.onBeforeAttach=function(e){},e.prototype.onAfterAttach=function(e){},e.prototype.onBeforeDetach=function(e){},e.prototype.onAfterDetach=function(e){},e.prototype.onChildAdded=function(e){},e.prototype.onChildRemoved=function(e){},e}();t.Widget=h,function(e){!function(e){e[e.IsDisposed=1]="IsDisposed",e[e.IsAttached=2]="IsAttached",e[e.IsHidden=4]="IsHidden",e[e.IsVisible=8]="IsVisible",e[e.DisallowLayout=16]="DisallowLayout"}(e.Flag||(e.Flag={})),function(e){e.BeforeShow=new a.Message("before-show"),e.AfterShow=new a.Message("after-show"),e.BeforeHide=new a.Message("before-hide"),e.AfterHide=new a.Message("after-hide"),e.BeforeAttach=new a.Message("before-attach"),e.AfterAttach=new a.Message("after-attach"),e.BeforeDetach=new a.Message("before-detach"),e.AfterDetach=new a.Message("after-detach"),e.ParentChanged=new a.Message("parent-changed"),e.UpdateRequest=new a.ConflatableMessage("update-request"),e.FitRequest=new a.ConflatableMessage("fit-request"),e.ActivateRequest=new a.ConflatableMessage("activate-request"),e.CloseRequest=new a.ConflatableMessage("close-request")}(e.Msg||(e.Msg={}));var t=function(e){function t(t,n){var r=e.call(this,t)||this;return r.child=n,r}return i(t,e),t}(a.Message);e.ChildMessage=t;var n=function(e){function t(t,n){var r=e.call(this,"resize")||this;return r.width=t,r.height=n,r}return i(t,e),t}(a.Message);e.ResizeMessage=n,function(e){e.UnknownSize=new e(-1,-1)}(n=e.ResizeMessage||(e.ResizeMessage={})),e.attach=function(t,n,r){if(void 0===r&&(r=null),t.parent)throw new Error("Cannot attach a child widget.");if(t.isAttached||document.body.contains(t.node))throw new Error("Widget is already attached.");if(!document.body.contains(n))throw new Error("Host is not attached.");a.MessageLoop.sendMessage(t,e.Msg.BeforeAttach),n.insertBefore(t.node,r),a.MessageLoop.sendMessage(t,e.Msg.AfterAttach)},e.detach=function(t){if(t.parent)throw new Error("Cannot detach a child widget.");if(!t.isAttached||!document.body.contains(t.node))throw new Error("Widget is not attached.");a.MessageLoop.sendMessage(t,e.Msg.BeforeDetach),t.node.parentNode.removeChild(t.node),a.MessageLoop.sendMessage(t,e.Msg.AfterDetach)}}(h=t.Widget||(t.Widget={})),t.Widget=h,function(e){e.titleProperty=new c.AttachedProperty({name:"title",create:function(e){return new f.Title({owner:e})}}),e.createNode=function(e){return e.node||document.createElement("div")}}(o||(o={}))},function(e,t,n){"use strict";(function(e,r){var i,o=this&&this.__extends||(i=function(e,t){return(i=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(e,t){e.__proto__=t}||function(e,t){for(var n in t)t.hasOwnProperty(n)&&(e[n]=t[n])})(e,t)},function(e,t){function n(){this.constructor=e}i(e,t),e.prototype=null===t?Object.create(t):(n.prototype=t.prototype,new n)});Object.defineProperty(t,"__esModule",{value:!0});var s=n(2),a=n(304),c=function(){function e(e){this.type=e}return Object.defineProperty(e.prototype,"isConflatable",{get:function(){return!1},enumerable:!0,configurable:!0}),e.prototype.conflate=function(e){return!1},e}();t.Message=c;var u=function(e){function t(){return null!==e&&e.apply(this,arguments)||this}return o(t,e),Object.defineProperty(t.prototype,"isConflatable",{get:function(){return!0},enumerable:!0,configurable:!0}),t.prototype.conflate=function(e){return!0},t}(c);t.ConflatableMessage=u,function(t){function n(e,t){var n=o.get(e);n&&0!==n.length?s.every(s.retro(n),function(n){return!n||function(e,t,n){var r=!0;try{r="function"==typeof e?e(t,n):e.messageHook(t,n)}catch(e){u(e)}return r}(n,e,t)})&&p(e,t):p(e,t)}t.sendMessage=n,t.postMessage=function(e,t){t.isConflatable&&s.some(i,function(n){return n.handler===e&&!!n.msg&&n.msg.type===t.type&&!!n.msg.isConflatable&&n.msg.conflate(t)})||m(e,t)},t.installMessageHook=function(e,t){var n=o.get(e);n&&-1!==n.indexOf(t)||(n?n.push(t):o.set(e,[t]))},t.removeMessageHook=function(e,t){var n=o.get(e);if(n){var r=n.indexOf(t);-1!==r&&(n[r]=null,v(n))}},t.clearData=function(e){var t=o.get(e);t&&t.length>0&&(s.ArrayExt.fill(t,null),v(t)),s.each(i,function(t){t.handler===e&&(t.handler=null,t.msg=null)})},t.flush=function(){h||0===f||(l(f),h=!0,b(),h=!1)},t.getExceptionHandler=function(){return u},t.setExceptionHandler=function(e){var t=u;return u=e,t};var i=new a.LinkedList,o=new WeakMap,c=new Set,u=function(e){console.error(e)},f=0,h=!1,d="function"==typeof requestAnimationFrame?requestAnimationFrame:e,l="function"==typeof cancelAnimationFrame?cancelAnimationFrame:r;function p(e,t){try{e.processMessage(t)}catch(e){u(e)}}function m(e,t){i.addLast({handler:e,msg:t}),0===f&&(f=d(b))}function b(){if(f=0,!i.isEmpty){var e={handler:null,msg:null};for(i.addLast(e);;){var t=i.removeFirst();if(t===e)return;t.handler&&t.msg&&n(t.handler,t.msg)}}}function v(e){0===c.size&&d(g),c.add(e)}function g(){c.forEach(y),c.clear()}function y(e){s.ArrayExt.removeAllWhere(e,_)}function _(e){return null===e}}(t.MessageLoop||(t.MessageLoop={}))}).call(this,n(36).setImmediate,n(36).clearImmediate)},function(e,t,n){"use strict";(function(e){ +/*! + * The buffer module from node.js, for the browser. + * + * @author Feross Aboukhadijeh + * @license MIT + */ +var r=n(49),i=n(132),o=n(74);function s(){return c.TYPED_ARRAY_SUPPORT?2147483647:1073741823}function a(e,t){if(s()=s())throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x"+s().toString(16)+" bytes");return 0|e}function p(e,t){if(c.isBuffer(e))return e.length;if("undefined"!=typeof ArrayBuffer&&"function"==typeof ArrayBuffer.isView&&(ArrayBuffer.isView(e)||e instanceof ArrayBuffer))return e.byteLength;"string"!=typeof e&&(e=""+e);var n=e.length;if(0===n)return 0;for(var r=!1;;)switch(t){case"ascii":case"latin1":case"binary":return n;case"utf8":case"utf-8":case void 0:return q(e).length;case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return 2*n;case"hex":return n>>>1;case"base64":return H(e).length;default:if(r)return q(e).length;t=(""+t).toLowerCase(),r=!0}}function m(e,t,n){var r=e[t];e[t]=e[n],e[n]=r}function b(e,t,n,r,i){if(0===e.length)return-1;if("string"==typeof n?(r=n,n=0):n>2147483647?n=2147483647:n<-2147483648&&(n=-2147483648),n=+n,isNaN(n)&&(n=i?0:e.length-1),n<0&&(n=e.length+n),n>=e.length){if(i)return-1;n=e.length-1}else if(n<0){if(!i)return-1;n=0}if("string"==typeof t&&(t=c.from(t,r)),c.isBuffer(t))return 0===t.length?-1:v(e,t,n,r,i);if("number"==typeof t)return t&=255,c.TYPED_ARRAY_SUPPORT&&"function"==typeof Uint8Array.prototype.indexOf?i?Uint8Array.prototype.indexOf.call(e,t,n):Uint8Array.prototype.lastIndexOf.call(e,t,n):v(e,[t],n,r,i);throw new TypeError("val must be string, number or Buffer")}function v(e,t,n,r,i){var o,s=1,a=e.length,c=t.length;if(void 0!==r&&("ucs2"===(r=String(r).toLowerCase())||"ucs-2"===r||"utf16le"===r||"utf-16le"===r)){if(e.length<2||t.length<2)return-1;s=2,a/=2,c/=2,n/=2}function u(e,t){return 1===s?e[t]:e.readUInt16BE(t*s)}if(i){var f=-1;for(o=n;oa&&(n=a-c),o=n;o>=0;o--){for(var h=!0,d=0;di&&(r=i):r=i;var o=t.length;if(o%2!=0)throw new TypeError("Invalid hex string");r>o/2&&(r=o/2);for(var s=0;s>8,i=n%256,o.push(i),o.push(r);return o}(t,e.length-n),e,n,r)}function S(e,t,n){return 0===t&&n===e.length?r.fromByteArray(e):r.fromByteArray(e.slice(t,n))}function E(e,t,n){n=Math.min(e.length,n);for(var r=[],i=t;i239?4:u>223?3:u>191?2:1;if(i+h<=n)switch(h){case 1:u<128&&(f=u);break;case 2:128==(192&(o=e[i+1]))&&(c=(31&u)<<6|63&o)>127&&(f=c);break;case 3:o=e[i+1],s=e[i+2],128==(192&o)&&128==(192&s)&&(c=(15&u)<<12|(63&o)<<6|63&s)>2047&&(c<55296||c>57343)&&(f=c);break;case 4:o=e[i+1],s=e[i+2],a=e[i+3],128==(192&o)&&128==(192&s)&&128==(192&a)&&(c=(15&u)<<18|(63&o)<<12|(63&s)<<6|63&a)>65535&&c<1114112&&(f=c)}null===f?(f=65533,h=1):f>65535&&(f-=65536,r.push(f>>>10&1023|55296),f=56320|1023&f),r.push(f),i+=h}return function(e){var t=e.length;if(t<=A)return String.fromCharCode.apply(String,e);var n="",r=0;for(;rthis.length)return"";if((void 0===n||n>this.length)&&(n=this.length),n<=0)return"";if((n>>>=0)<=(t>>>=0))return"";for(e||(e="utf8");;)switch(e){case"hex":return P(this,t,n);case"utf8":case"utf-8":return E(this,t,n);case"ascii":return k(this,t,n);case"latin1":case"binary":return C(this,t,n);case"base64":return S(this,t,n);case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return I(this,t,n);default:if(r)throw new TypeError("Unknown encoding: "+e);e=(e+"").toLowerCase(),r=!0}}.apply(this,arguments)},c.prototype.equals=function(e){if(!c.isBuffer(e))throw new TypeError("Argument must be a Buffer");return this===e||0===c.compare(this,e)},c.prototype.inspect=function(){var e="",n=t.INSPECT_MAX_BYTES;return this.length>0&&(e=this.toString("hex",0,n).match(/.{2}/g).join(" "),this.length>n&&(e+=" ... ")),""},c.prototype.compare=function(e,t,n,r,i){if(!c.isBuffer(e))throw new TypeError("Argument must be a Buffer");if(void 0===t&&(t=0),void 0===n&&(n=e?e.length:0),void 0===r&&(r=0),void 0===i&&(i=this.length),t<0||n>e.length||r<0||i>this.length)throw new RangeError("out of range index");if(r>=i&&t>=n)return 0;if(r>=i)return-1;if(t>=n)return 1;if(this===e)return 0;for(var o=(i>>>=0)-(r>>>=0),s=(n>>>=0)-(t>>>=0),a=Math.min(o,s),u=this.slice(r,i),f=e.slice(t,n),h=0;hi)&&(n=i),e.length>0&&(n<0||t<0)||t>this.length)throw new RangeError("Attempt to write outside buffer bounds");r||(r="utf8");for(var o=!1;;)switch(r){case"hex":return g(this,e,t,n);case"utf8":case"utf-8":return y(this,e,t,n);case"ascii":return _(this,e,t,n);case"latin1":case"binary":return w(this,e,t,n);case"base64":return x(this,e,t,n);case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return M(this,e,t,n);default:if(o)throw new TypeError("Unknown encoding: "+r);r=(""+r).toLowerCase(),o=!0}},c.prototype.toJSON=function(){return{type:"Buffer",data:Array.prototype.slice.call(this._arr||this,0)}};var A=4096;function k(e,t,n){var r="";n=Math.min(e.length,n);for(var i=t;ir)&&(n=r);for(var i="",o=t;on)throw new RangeError("Trying to access beyond buffer length")}function O(e,t,n,r,i,o){if(!c.isBuffer(e))throw new TypeError('"buffer" argument must be a Buffer instance');if(t>i||te.length)throw new RangeError("Index out of range")}function j(e,t,n,r){t<0&&(t=65535+t+1);for(var i=0,o=Math.min(e.length-n,2);i>>8*(r?i:1-i)}function L(e,t,n,r){t<0&&(t=4294967295+t+1);for(var i=0,o=Math.min(e.length-n,4);i>>8*(r?i:3-i)&255}function B(e,t,n,r,i,o){if(n+r>e.length)throw new RangeError("Index out of range");if(n<0)throw new RangeError("Index out of range")}function D(e,t,n,r,o){return o||B(e,0,n,4),i.write(e,t,n,r,23,4),n+4}function z(e,t,n,r,o){return o||B(e,0,n,8),i.write(e,t,n,r,52,8),n+8}c.prototype.slice=function(e,t){var n,r=this.length;if((e=~~e)<0?(e+=r)<0&&(e=0):e>r&&(e=r),(t=void 0===t?r:~~t)<0?(t+=r)<0&&(t=0):t>r&&(t=r),t0&&(i*=256);)r+=this[e+--t]*i;return r},c.prototype.readUInt8=function(e,t){return t||T(e,1,this.length),this[e]},c.prototype.readUInt16LE=function(e,t){return t||T(e,2,this.length),this[e]|this[e+1]<<8},c.prototype.readUInt16BE=function(e,t){return t||T(e,2,this.length),this[e]<<8|this[e+1]},c.prototype.readUInt32LE=function(e,t){return t||T(e,4,this.length),(this[e]|this[e+1]<<8|this[e+2]<<16)+16777216*this[e+3]},c.prototype.readUInt32BE=function(e,t){return t||T(e,4,this.length),16777216*this[e]+(this[e+1]<<16|this[e+2]<<8|this[e+3])},c.prototype.readIntLE=function(e,t,n){e|=0,t|=0,n||T(e,t,this.length);for(var r=this[e],i=1,o=0;++o=(i*=128)&&(r-=Math.pow(2,8*t)),r},c.prototype.readIntBE=function(e,t,n){e|=0,t|=0,n||T(e,t,this.length);for(var r=t,i=1,o=this[e+--r];r>0&&(i*=256);)o+=this[e+--r]*i;return o>=(i*=128)&&(o-=Math.pow(2,8*t)),o},c.prototype.readInt8=function(e,t){return t||T(e,1,this.length),128&this[e]?-1*(255-this[e]+1):this[e]},c.prototype.readInt16LE=function(e,t){t||T(e,2,this.length);var n=this[e]|this[e+1]<<8;return 32768&n?4294901760|n:n},c.prototype.readInt16BE=function(e,t){t||T(e,2,this.length);var n=this[e+1]|this[e]<<8;return 32768&n?4294901760|n:n},c.prototype.readInt32LE=function(e,t){return t||T(e,4,this.length),this[e]|this[e+1]<<8|this[e+2]<<16|this[e+3]<<24},c.prototype.readInt32BE=function(e,t){return t||T(e,4,this.length),this[e]<<24|this[e+1]<<16|this[e+2]<<8|this[e+3]},c.prototype.readFloatLE=function(e,t){return t||T(e,4,this.length),i.read(this,e,!0,23,4)},c.prototype.readFloatBE=function(e,t){return t||T(e,4,this.length),i.read(this,e,!1,23,4)},c.prototype.readDoubleLE=function(e,t){return t||T(e,8,this.length),i.read(this,e,!0,52,8)},c.prototype.readDoubleBE=function(e,t){return t||T(e,8,this.length),i.read(this,e,!1,52,8)},c.prototype.writeUIntLE=function(e,t,n,r){(e=+e,t|=0,n|=0,r)||O(this,e,t,n,Math.pow(2,8*n)-1,0);var i=1,o=0;for(this[t]=255&e;++o=0&&(o*=256);)this[t+i]=e/o&255;return t+n},c.prototype.writeUInt8=function(e,t,n){return e=+e,t|=0,n||O(this,e,t,1,255,0),c.TYPED_ARRAY_SUPPORT||(e=Math.floor(e)),this[t]=255&e,t+1},c.prototype.writeUInt16LE=function(e,t,n){return e=+e,t|=0,n||O(this,e,t,2,65535,0),c.TYPED_ARRAY_SUPPORT?(this[t]=255&e,this[t+1]=e>>>8):j(this,e,t,!0),t+2},c.prototype.writeUInt16BE=function(e,t,n){return e=+e,t|=0,n||O(this,e,t,2,65535,0),c.TYPED_ARRAY_SUPPORT?(this[t]=e>>>8,this[t+1]=255&e):j(this,e,t,!1),t+2},c.prototype.writeUInt32LE=function(e,t,n){return e=+e,t|=0,n||O(this,e,t,4,4294967295,0),c.TYPED_ARRAY_SUPPORT?(this[t+3]=e>>>24,this[t+2]=e>>>16,this[t+1]=e>>>8,this[t]=255&e):L(this,e,t,!0),t+4},c.prototype.writeUInt32BE=function(e,t,n){return e=+e,t|=0,n||O(this,e,t,4,4294967295,0),c.TYPED_ARRAY_SUPPORT?(this[t]=e>>>24,this[t+1]=e>>>16,this[t+2]=e>>>8,this[t+3]=255&e):L(this,e,t,!1),t+4},c.prototype.writeIntLE=function(e,t,n,r){if(e=+e,t|=0,!r){var i=Math.pow(2,8*n-1);O(this,e,t,n,i-1,-i)}var o=0,s=1,a=0;for(this[t]=255&e;++o>0)-a&255;return t+n},c.prototype.writeIntBE=function(e,t,n,r){if(e=+e,t|=0,!r){var i=Math.pow(2,8*n-1);O(this,e,t,n,i-1,-i)}var o=n-1,s=1,a=0;for(this[t+o]=255&e;--o>=0&&(s*=256);)e<0&&0===a&&0!==this[t+o+1]&&(a=1),this[t+o]=(e/s>>0)-a&255;return t+n},c.prototype.writeInt8=function(e,t,n){return e=+e,t|=0,n||O(this,e,t,1,127,-128),c.TYPED_ARRAY_SUPPORT||(e=Math.floor(e)),e<0&&(e=255+e+1),this[t]=255&e,t+1},c.prototype.writeInt16LE=function(e,t,n){return e=+e,t|=0,n||O(this,e,t,2,32767,-32768),c.TYPED_ARRAY_SUPPORT?(this[t]=255&e,this[t+1]=e>>>8):j(this,e,t,!0),t+2},c.prototype.writeInt16BE=function(e,t,n){return e=+e,t|=0,n||O(this,e,t,2,32767,-32768),c.TYPED_ARRAY_SUPPORT?(this[t]=e>>>8,this[t+1]=255&e):j(this,e,t,!1),t+2},c.prototype.writeInt32LE=function(e,t,n){return e=+e,t|=0,n||O(this,e,t,4,2147483647,-2147483648),c.TYPED_ARRAY_SUPPORT?(this[t]=255&e,this[t+1]=e>>>8,this[t+2]=e>>>16,this[t+3]=e>>>24):L(this,e,t,!0),t+4},c.prototype.writeInt32BE=function(e,t,n){return e=+e,t|=0,n||O(this,e,t,4,2147483647,-2147483648),e<0&&(e=4294967295+e+1),c.TYPED_ARRAY_SUPPORT?(this[t]=e>>>24,this[t+1]=e>>>16,this[t+2]=e>>>8,this[t+3]=255&e):L(this,e,t,!1),t+4},c.prototype.writeFloatLE=function(e,t,n){return D(this,e,t,!0,n)},c.prototype.writeFloatBE=function(e,t,n){return D(this,e,t,!1,n)},c.prototype.writeDoubleLE=function(e,t,n){return z(this,e,t,!0,n)},c.prototype.writeDoubleBE=function(e,t,n){return z(this,e,t,!1,n)},c.prototype.copy=function(e,t,n,r){if(n||(n=0),r||0===r||(r=this.length),t>=e.length&&(t=e.length),t||(t=0),r>0&&r=this.length)throw new RangeError("sourceStart out of bounds");if(r<0)throw new RangeError("sourceEnd out of bounds");r>this.length&&(r=this.length),e.length-t=0;--i)e[i+t]=this[i+n];else if(o<1e3||!c.TYPED_ARRAY_SUPPORT)for(i=0;i>>=0,n=void 0===n?this.length:n>>>0,e||(e=0),"number"==typeof e)for(o=t;o55295&&n<57344){if(!i){if(n>56319){(t-=3)>-1&&o.push(239,191,189);continue}if(s+1===r){(t-=3)>-1&&o.push(239,191,189);continue}i=n;continue}if(n<56320){(t-=3)>-1&&o.push(239,191,189),i=n;continue}n=65536+(i-55296<<10|n-56320)}else i&&(t-=3)>-1&&o.push(239,191,189);if(i=null,n<128){if((t-=1)<0)break;o.push(n)}else if(n<2048){if((t-=2)<0)break;o.push(n>>6|192,63&n|128)}else if(n<65536){if((t-=3)<0)break;o.push(n>>12|224,n>>6&63|128,63&n|128)}else{if(!(n<1114112))throw new Error("Invalid code point");if((t-=4)<0)break;o.push(n>>18|240,n>>12&63|128,n>>6&63|128,63&n|128)}}return o}function H(e){return r.toByteArray(function(e){if((e=function(e){return e.trim?e.trim():e.replace(/^\s+|\s+$/g,"")}(e).replace(R,"")).length<2)return"";for(;e.length%4!=0;)e+="=";return e}(e))}function W(e,t,n,r){for(var i=0;i=t.length||i>=e.length);++i)t[i+n]=e[i];return i}}).call(this,n(9))},function(e,t,n){"use strict";function r(e){for(var n in e)t.hasOwnProperty(n)||(t[n]=e[n])}Object.defineProperty(t,"__esModule",{value:!0}),r(n(300)),r(n(301)),r(n(302)),r(n(303))},function(e,t,n){"use strict";var r=t;r.version=n(174).version,r.utils=n(175),r.rand=n(96),r.curve=n(40),r.curves=n(180),r.ec=n(188),r.eddsa=n(192)},function(e,t){var n;n=function(){return this}();try{n=n||new Function("return this")()}catch(e){"object"==typeof window&&(n=window)}e.exports=n},function(e,t){function n(e,t){if(!e)throw new Error(t||"Assertion failed")}e.exports=n,n.equal=function(e,t,n){if(e!=t)throw new Error(n||"Assertion failed: "+e+" != "+t)}},function(e,t,n){"use strict";(function(e){Object.defineProperty(t,"__esModule",{value:!0});var r,i=n(2),o=function(){function e(e){this.sender=e}return e.prototype.connect=function(e,t){return r.connect(this,e,t)},e.prototype.disconnect=function(e,t){return r.disconnect(this,e,t)},e.prototype.emit=function(e){r.emit(this,e)},e}();t.Signal=o,function(e){e.disconnectBetween=function(e,t){r.disconnectBetween(e,t)},e.disconnectSender=function(e){r.disconnectSender(e)},e.disconnectReceiver=function(e){r.disconnectReceiver(e)},e.disconnectAll=function(e){r.disconnectAll(e)},e.clearData=function(e){r.disconnectAll(e)},e.getExceptionHandler=function(){return r.exceptionHandler},e.setExceptionHandler=function(e){var t=r.exceptionHandler;return r.exceptionHandler=e,t}}(o=t.Signal||(t.Signal={})),t.Signal=o,function(t){t.exceptionHandler=function(e){console.error(e)},t.connect=function(e,t,i){i=i||void 0;var o=n.get(e.sender);if(o||(o=[],n.set(e.sender,o)),a(o,e,t,i))return!1;var s=i||t,c=r.get(s);c||(c=[],r.set(s,c));var u={signal:e,slot:t,thisArg:i};return o.push(u),c.push(u),!0},t.disconnect=function(e,t,i){i=i||void 0;var o=n.get(e.sender);if(!o||0===o.length)return!1;var s=a(o,e,t,i);if(!s)return!1;var c=i||t,f=r.get(c);return s.signal=null,u(o),u(f),!0},t.disconnectBetween=function(e,t){var o=n.get(e);if(o&&0!==o.length){var s=r.get(t);s&&0!==s.length&&(i.each(s,function(t){t.signal&&t.signal.sender===e&&(t.signal=null)}),u(o),u(s))}},t.disconnectSender=function(e){var t=n.get(e);t&&0!==t.length&&(i.each(t,function(e){if(e.signal){var t=e.thisArg||e.slot;e.signal=null,u(r.get(t))}}),u(t))},t.disconnectReceiver=function(e){var t=r.get(e);t&&0!==t.length&&(i.each(t,function(e){if(e.signal){var t=e.signal.sender;e.signal=null,u(n.get(t))}}),u(t))},t.disconnectAll=function(e){var t=n.get(e);t&&t.length>0&&(i.each(t,function(e){e.signal=null}),u(t));var o=r.get(e);o&&o.length>0&&(i.each(o,function(e){e.signal=null}),u(o))},t.emit=function(e,t){var r=n.get(e.sender);if(r&&0!==r.length)for(var i=0,o=r.length;i=this._source.length))return this._source[this._index++]},e}();t.ArrayIterator=i;var o=function(){function e(e,t){void 0===t&&(t=Object.keys(e)),this._index=0,this._source=e,this._keys=t}return e.prototype.iter=function(){return this},e.prototype.clone=function(){var t=new e(this._source,this._keys);return t._index=this._index,t},e.prototype.next=function(){if(!(this._index>=this._keys.length)){var e=this._keys[this._index++];return e in this._source?e:this.next()}},e}();t.KeyIterator=o;var s=function(){function e(e,t){void 0===t&&(t=Object.keys(e)),this._index=0,this._source=e,this._keys=t}return e.prototype.iter=function(){return this},e.prototype.clone=function(){var t=new e(this._source,this._keys);return t._index=this._index,t},e.prototype.next=function(){if(!(this._index>=this._keys.length)){var e=this._keys[this._index++];return e in this._source?this._source[e]:this.next()}},e}();t.ValueIterator=s;var a=function(){function e(e,t){void 0===t&&(t=Object.keys(e)),this._index=0,this._source=e,this._keys=t}return e.prototype.iter=function(){return this},e.prototype.clone=function(){var t=new e(this._source,this._keys);return t._index=this._index,t},e.prototype.next=function(){if(!(this._index>=this._keys.length)){var e=this._keys[this._index++];return e in this._source?[e,this._source[e]]:this.next()}},e}();t.ItemIterator=a;var c=function(){function e(e){this._fn=e}return e.prototype.iter=function(){return this},e.prototype.clone=function(){throw new Error("An `FnIterator` cannot be cloned.")},e.prototype.next=function(){return this._fn.call(void 0)},e}();t.FnIterator=c},function(e,t,n){"use strict";var r=n(10),i=n(0);function o(e,t){return 55296==(64512&e.charCodeAt(t))&&(!(t<0||t+1>=e.length)&&56320==(64512&e.charCodeAt(t+1)))}function s(e){return(e>>>24|e>>>8&65280|e<<8&16711680|(255&e)<<24)>>>0}function a(e){return 1===e.length?"0"+e:e}function c(e){return 7===e.length?"0"+e:6===e.length?"00"+e:5===e.length?"000"+e:4===e.length?"0000"+e:3===e.length?"00000"+e:2===e.length?"000000"+e:1===e.length?"0000000"+e:e}t.inherits=i,t.toArray=function(e,t){if(Array.isArray(e))return e.slice();if(!e)return[];var n=[];if("string"==typeof e)if(t){if("hex"===t)for((e=e.replace(/[^a-z0-9]+/gi,"")).length%2!=0&&(e="0"+e),i=0;i>6|192,n[r++]=63&s|128):o(e,i)?(s=65536+((1023&s)<<10)+(1023&e.charCodeAt(++i)),n[r++]=s>>18|240,n[r++]=s>>12&63|128,n[r++]=s>>6&63|128,n[r++]=63&s|128):(n[r++]=s>>12|224,n[r++]=s>>6&63|128,n[r++]=63&s|128)}else for(i=0;i>>0}return s},t.split32=function(e,t){for(var n=new Array(4*e.length),r=0,i=0;r>>24,n[i+1]=o>>>16&255,n[i+2]=o>>>8&255,n[i+3]=255&o):(n[i+3]=o>>>24,n[i+2]=o>>>16&255,n[i+1]=o>>>8&255,n[i]=255&o)}return n},t.rotr32=function(e,t){return e>>>t|e<<32-t},t.rotl32=function(e,t){return e<>>32-t},t.sum32=function(e,t){return e+t>>>0},t.sum32_3=function(e,t,n){return e+t+n>>>0},t.sum32_4=function(e,t,n,r){return e+t+n+r>>>0},t.sum32_5=function(e,t,n,r,i){return e+t+n+r+i>>>0},t.sum64=function(e,t,n,r){var i=e[t],o=r+e[t+1]>>>0,s=(o>>0,e[t+1]=o},t.sum64_hi=function(e,t,n,r){return(t+r>>>0>>0},t.sum64_lo=function(e,t,n,r){return t+r>>>0},t.sum64_4_hi=function(e,t,n,r,i,o,s,a){var c=0,u=t;return c+=(u=u+r>>>0)>>0)>>0)>>0},t.sum64_4_lo=function(e,t,n,r,i,o,s,a){return t+r+o+a>>>0},t.sum64_5_hi=function(e,t,n,r,i,o,s,a,c,u){var f=0,h=t;return f+=(h=h+r>>>0)>>0)>>0)>>0)>>0},t.sum64_5_lo=function(e,t,n,r,i,o,s,a,c,u){return t+r+o+a+u>>>0},t.rotr64_hi=function(e,t,n){return(t<<32-n|e>>>n)>>>0},t.rotr64_lo=function(e,t,n){return(e<<32-n|t>>>n)>>>0},t.shr64_hi=function(e,t,n){return e>>>n},t.shr64_lo=function(e,t,n){return(e<<32-n|t>>>n)>>>0}},function(e,t,n){var r=n(111),i="object"==typeof self&&self&&self.Object===Object&&self,o=r||i||Function("return this")();e.exports=o},function(e,t){var n,r,i=e.exports={};function o(){throw new Error("setTimeout has not been defined")}function s(){throw new Error("clearTimeout has not been defined")}function a(e){if(n===setTimeout)return setTimeout(e,0);if((n===o||!n)&&setTimeout)return n=setTimeout,setTimeout(e,0);try{return n(e,0)}catch(t){try{return n.call(null,e,0)}catch(t){return n.call(this,e,0)}}}!function(){try{n="function"==typeof setTimeout?setTimeout:o}catch(e){n=o}try{r="function"==typeof clearTimeout?clearTimeout:s}catch(e){r=s}}();var c,u=[],f=!1,h=-1;function d(){f&&c&&(f=!1,c.length?u=c.concat(u):h=-1,u.length&&l())}function l(){if(!f){var e=a(d);f=!0;for(var t=u.length;t;){for(c=u,u=[];++h1)for(var n=1;no)throw new RangeError("requested too many random bytes");var n=s.allocUnsafe(e);if(e>0)if(e>i)for(var c=0;c=this._finalSize&&(this._update(this._block),this._block.fill(0));var n=8*this._len;if(n<=4294967295)this._block.writeUInt32BE(n,this._blockSize-4);else{var r=(4294967295&n)>>>0,i=(n-r)/4294967296;this._block.writeUInt32BE(i,this._blockSize-8),this._block.writeUInt32BE(r,this._blockSize-4)}this._update(this._block);var o=this._hash();return e?o.toString(e):o},i.prototype._update=function(){throw new Error("_update must be implemented by subclass")},e.exports=i},function(e,t,n){var r=n(229),i=n(234);e.exports=function(e,t){var n=i(e,t);return r(n)?n:void 0}},function(e,t,n){"use strict";Object.defineProperty(t,"__esModule",{value:!0});var r,i=function(){function e(e){this._pid=r.nextPID(),this.name=e.name,this._create=e.create,this._coerce=e.coerce||null,this._compare=e.compare||null,this._changed=e.changed||null}return e.prototype.get=function(e){var t=r.ensureMap(e);return this._pid in t?t[this._pid]:t[this._pid]=this._createValue(e)},e.prototype.set=function(e,t){var n,i=r.ensureMap(e);n=this._pid in i?i[this._pid]:i[this._pid]=this._createValue(e);var o=this._coerceValue(e,t);this._maybeNotify(e,n,i[this._pid]=o)},e.prototype.coerce=function(e){var t,n=r.ensureMap(e);t=this._pid in n?n[this._pid]:n[this._pid]=this._createValue(e);var i=this._coerceValue(e,t);this._maybeNotify(e,t,n[this._pid]=i)},e.prototype._createValue=function(e){return(0,this._create)(e)},e.prototype._coerceValue=function(e,t){var n=this._coerce;return n?n(e,t):t},e.prototype._compareValue=function(e,t){var n=this._compare;return n?n(e,t):e===t},e.prototype._maybeNotify=function(e,t,n){var r=this._changed;r&&!this._compareValue(t,n)&&r(e,t,n)},e}();t.AttachedProperty=i,function(e){e.clearData=function(e){r.ownerData.delete(e)}}(i=t.AttachedProperty||(t.AttachedProperty={})),t.AttachedProperty=i,function(e){var t;e.ownerData=new WeakMap,e.nextPID=(t=0,function(){return"pid-"+(""+Math.random()).slice(2)+"-"+t++}),e.ensureMap=function(t){var n=e.ownerData.get(t);return n||(n=Object.create(null),e.ownerData.set(t,n),n)}}(r||(r={}))},function(e,t,n){"use strict";var r=n(0),i=n(52),o=n(58),s=n(59),a=n(16);function c(e){a.call(this,"digest"),this._hash=e}r(c,a),c.prototype._update=function(e){this._hash.update(e)},c.prototype._final=function(){return this._hash.digest()},e.exports=function(e){return"md5"===(e=e.toLowerCase())?new i:"rmd160"===e||"ripemd160"===e?new o:new c(s(e))}},function(e,t,n){(function(e){function n(e){return Object.prototype.toString.call(e)}t.isArray=function(e){return Array.isArray?Array.isArray(e):"[object Array]"===n(e)},t.isBoolean=function(e){return"boolean"==typeof e},t.isNull=function(e){return null===e},t.isNullOrUndefined=function(e){return null==e},t.isNumber=function(e){return"number"==typeof e},t.isString=function(e){return"string"==typeof e},t.isSymbol=function(e){return"symbol"==typeof e},t.isUndefined=function(e){return void 0===e},t.isRegExp=function(e){return"[object RegExp]"===n(e)},t.isObject=function(e){return"object"==typeof e&&null!==e},t.isDate=function(e){return"[object Date]"===n(e)},t.isError=function(e){return"[object Error]"===n(e)||e instanceof Error},t.isFunction=function(e){return"function"==typeof e},t.isPrimitive=function(e){return null===e||"boolean"==typeof e||"number"==typeof e||"string"==typeof e||"symbol"==typeof e||void 0===e},t.isBuffer=e.isBuffer}).call(this,n(6).Buffer)},function(e,t,n){(function(t){e.exports=function(e,n){for(var r=Math.min(e.length,n.length),i=new t(r),o=0;o=this._delta8){var n=(e=this.pending).length%this._delta8;this.pending=e.slice(e.length-n,e.length),0===this.pending.length&&(this.pending=null),e=r.join32(e,0,e.length-n,this.endian);for(var i=0;i>>24&255,r[i++]=e>>>16&255,r[i++]=e>>>8&255,r[i++]=255&e}else for(r[i++]=255&e,r[i++]=e>>>8&255,r[i++]=e>>>16&255,r[i++]=e>>>24&255,r[i++]=0,r[i++]=0,r[i++]=0,r[i++]=0,o=8;o0&&(s+=v.stretch,a++)}if(t===o)return 0;if(t<=r){for(c=0;c=i){for(c=0;c0&&l>.01;){var p=l,m=s;for(c=0;c0&&l>.01;)for(b=l/d,c=0;c0&&l>.01;)for(p=l,m=s,c=0;c=v.maxSize?(l-=v.maxSize-v.size,s-=v.stretch,v.size=v.maxSize,v.done=!0,d--,a--):(l-=b,v.size+=b));for(;d>0&&l>.01;)for(b=l/d,c=0;c=v.maxSize?(l-=v.maxSize-v.size,v.size=v.maxSize,v.done=!0,d--):(l-=b,v.size+=b))}}return 0},e.adjust=function(e,t,n){0!==e.length&&0!==n&&(n>0?function(e,t,n){for(var r=0,i=0;i<=t;++i){var o=e[i];r+=o.maxSize-o.size}for(var s=0,i=t+1,a=e.length;i=0&&c>0;--i){var o=e[i],u=o.maxSize-o.size;u>=c?(o.sizeHint=o.size+c,c=0):(o.sizeHint=o.size+u,c-=u)}for(var f=n,i=t+1,a=e.length;i0;++i){var o=e[i],u=o.size-o.minSize;u>=f?(o.sizeHint=o.size-f,f=0):(o.sizeHint=o.size-u,f-=u)}}(e,t,n):function(e,t,n){for(var r=0,i=t+1,o=e.length;i0;++i){var s=e[i],u=s.maxSize-s.size;u>=c?(s.sizeHint=s.size+c,c=0):(s.sizeHint=s.size+u,c-=u)}for(var f=n,i=t;i>=0&&f>0;--i){var s=e[i],u=s.size-s.minSize;u>=f?(s.sizeHint=s.size-f,f=0):(s.sizeHint=s.size-u,f-=u)}}(e,t,-n))}}(t.BoxEngine||(t.BoxEngine={}))},function(e,t,n){"use strict";var r,i=this&&this.__extends||(r=function(e,t){return(r=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(e,t){e.__proto__=t}||function(e,t){for(var n in t)t.hasOwnProperty(n)&&(e[n]=t[n])})(e,t)},function(e,t){function n(){this.constructor=e}r(e,t),e.prototype=null===t?Object.create(t):(n.prototype=t.prototype,new n)});Object.defineProperty(t,"__esModule",{value:!0});var o=n(2),s=n(5),a=n(17),c=n(4),u=function(e){function t(){var t=null!==e&&e.apply(this,arguments)||this;return t._widgets=[],t}return i(t,e),t.prototype.dispose=function(){for(;this._widgets.length>0;)this._widgets.pop().dispose();e.prototype.dispose.call(this)},Object.defineProperty(t.prototype,"widgets",{get:function(){return this._widgets},enumerable:!0,configurable:!0}),t.prototype.iter=function(){return o.iter(this._widgets)},t.prototype.addWidget=function(e){this.insertWidget(this._widgets.length,e)},t.prototype.insertWidget=function(e,t){t.parent=this.parent;var n=this._widgets.indexOf(t),r=Math.max(0,Math.min(e,this._widgets.length));if(-1===n)return o.ArrayExt.insert(this._widgets,r,t),void(this.parent&&this.attachWidget(r,t));r===this._widgets.length&&r--,n!==r&&(o.ArrayExt.move(this._widgets,n,r),this.parent&&this.moveWidget(n,r,t))},t.prototype.removeWidget=function(e){this.removeWidgetAt(this._widgets.indexOf(e))},t.prototype.removeWidgetAt=function(e){var t=o.ArrayExt.removeAt(this._widgets,e);t&&this.parent&&this.detachWidget(e,t)},t.prototype.init=function(){var t=this;e.prototype.init.call(this),o.each(this,function(e,n){t.attachWidget(n,e)})},t.prototype.attachWidget=function(e,t){var n=this.parent.node.children[e];this.parent.isAttached&&s.MessageLoop.sendMessage(t,c.Widget.Msg.BeforeAttach),this.parent.node.insertBefore(t.node,n),this.parent.isAttached&&s.MessageLoop.sendMessage(t,c.Widget.Msg.AfterAttach)},t.prototype.moveWidget=function(e,t,n){this.parent.isAttached&&s.MessageLoop.sendMessage(n,c.Widget.Msg.BeforeDetach),this.parent.node.removeChild(n.node),this.parent.isAttached&&s.MessageLoop.sendMessage(n,c.Widget.Msg.AfterDetach);var r=this.parent.node.children[t];this.parent.isAttached&&s.MessageLoop.sendMessage(n,c.Widget.Msg.BeforeAttach),this.parent.node.insertBefore(n.node,r),this.parent.isAttached&&s.MessageLoop.sendMessage(n,c.Widget.Msg.AfterAttach)},t.prototype.detachWidget=function(e,t){this.parent.isAttached&&s.MessageLoop.sendMessage(t,c.Widget.Msg.BeforeDetach),this.parent.node.removeChild(t.node),this.parent.isAttached&&s.MessageLoop.sendMessage(t,c.Widget.Msg.AfterDetach)},t}(a.Layout);t.PanelLayout=u},function(e,t,n){"use strict";function r(e){for(var n in e)t.hasOwnProperty(n)||(t[n]=e[n])}Object.defineProperty(t,"__esModule",{value:!0}),r(n(32)),r(n(68)),r(n(307)),r(n(308)),r(n(309)),r(n(122)),r(n(310)),r(n(311)),r(n(312)),r(n(17)),r(n(121)),r(n(313)),r(n(46)),r(n(33)),r(n(314)),r(n(315)),r(n(123)),r(n(316)),r(n(124)),r(n(125)),r(n(72)),r(n(317)),r(n(69)),r(n(4))},function(e,t,n){"use strict";(function(t){void 0===t||!t.version||0===t.version.indexOf("v0.")||0===t.version.indexOf("v1.")&&0!==t.version.indexOf("v1.8.")?e.exports={nextTick:function(e,n,r,i){if("function"!=typeof e)throw new TypeError('"callback" argument must be a function');var o,s,a=arguments.length;switch(a){case 0:case 1:return t.nextTick(e);case 2:return t.nextTick(function(){e.call(null,n)});case 3:return t.nextTick(function(){e.call(null,n,r)});case 4:return t.nextTick(function(){e.call(null,n,r,i)});default:for(o=new Array(a-1),s=0;s=0&&(e._idleTimeoutId=setTimeout(function(){e._onTimeout&&e._onTimeout()},t))},n(136),t.setImmediate="undefined"!=typeof self&&self.setImmediate||void 0!==e&&e.setImmediate||this&&this.setImmediate,t.clearImmediate="undefined"!=typeof self&&self.clearImmediate||void 0!==e&&e.clearImmediate||this&&this.clearImmediate}).call(this,n(9))},function(e,t,n){var r=n(1).Buffer;function i(e){r.isBuffer(e)||(e=r.from(e));for(var t=e.length/4|0,n=new Array(t),i=0;i>>24]^f[p>>>16&255]^h[m>>>8&255]^d[255&b]^t[v++],s=u[p>>>24]^f[m>>>16&255]^h[b>>>8&255]^d[255&l]^t[v++],a=u[m>>>24]^f[b>>>16&255]^h[l>>>8&255]^d[255&p]^t[v++],c=u[b>>>24]^f[l>>>16&255]^h[p>>>8&255]^d[255&m]^t[v++],l=o,p=s,m=a,b=c;return o=(r[l>>>24]<<24|r[p>>>16&255]<<16|r[m>>>8&255]<<8|r[255&b])^t[v++],s=(r[p>>>24]<<24|r[m>>>16&255]<<16|r[b>>>8&255]<<8|r[255&l])^t[v++],a=(r[m>>>24]<<24|r[b>>>16&255]<<16|r[l>>>8&255]<<8|r[255&p])^t[v++],c=(r[b>>>24]<<24|r[l>>>16&255]<<16|r[p>>>8&255]<<8|r[255&m])^t[v++],[o>>>=0,s>>>=0,a>>>=0,c>>>=0]}var a=[0,1,2,4,8,16,32,64,128,27,54],c=function(){for(var e=new Array(256),t=0;t<256;t++)e[t]=t<128?t<<1:t<<1^283;for(var n=[],r=[],i=[[],[],[],[]],o=[[],[],[],[]],s=0,a=0,c=0;c<256;++c){var u=a^a<<1^a<<2^a<<3^a<<4;u=u>>>8^255&u^99,n[s]=u,r[u]=s;var f=e[s],h=e[f],d=e[h],l=257*e[u]^16843008*u;i[0][s]=l<<24|l>>>8,i[1][s]=l<<16|l>>>16,i[2][s]=l<<8|l>>>24,i[3][s]=l,l=16843009*d^65537*h^257*f^16843008*s,o[0][u]=l<<24|l>>>8,o[1][u]=l<<16|l>>>16,o[2][u]=l<<8|l>>>24,o[3][u]=l,0===s?s=a=1:(s=f^e[e[e[d^f]]],a^=e[e[a]])}return{SBOX:n,INV_SBOX:r,SUB_MIX:i,INV_SUB_MIX:o}}();function u(e){this._key=i(e),this._reset()}u.blockSize=16,u.keySize=32,u.prototype.blockSize=u.blockSize,u.prototype.keySize=u.keySize,u.prototype._reset=function(){for(var e=this._key,t=e.length,n=t+6,r=4*(n+1),i=[],o=0;o>>24,s=c.SBOX[s>>>24]<<24|c.SBOX[s>>>16&255]<<16|c.SBOX[s>>>8&255]<<8|c.SBOX[255&s],s^=a[o/t|0]<<24):t>6&&o%t==4&&(s=c.SBOX[s>>>24]<<24|c.SBOX[s>>>16&255]<<16|c.SBOX[s>>>8&255]<<8|c.SBOX[255&s]),i[o]=i[o-t]^s}for(var u=[],f=0;f>>24]]^c.INV_SUB_MIX[1][c.SBOX[d>>>16&255]]^c.INV_SUB_MIX[2][c.SBOX[d>>>8&255]]^c.INV_SUB_MIX[3][c.SBOX[255&d]]}this._nRounds=n,this._keySchedule=i,this._invKeySchedule=u},u.prototype.encryptBlockRaw=function(e){return s(e=i(e),this._keySchedule,c.SUB_MIX,c.SBOX,this._nRounds)},u.prototype.encryptBlock=function(e){var t=this.encryptBlockRaw(e),n=r.allocUnsafe(16);return n.writeUInt32BE(t[0],0),n.writeUInt32BE(t[1],4),n.writeUInt32BE(t[2],8),n.writeUInt32BE(t[3],12),n},u.prototype.decryptBlock=function(e){var t=(e=i(e))[1];e[1]=e[3],e[3]=t;var n=s(e,this._invKeySchedule,c.INV_SUB_MIX,c.INV_SBOX,this._nRounds),o=r.allocUnsafe(16);return o.writeUInt32BE(n[0],0),o.writeUInt32BE(n[3],4),o.writeUInt32BE(n[2],8),o.writeUInt32BE(n[1],12),o},u.prototype.scrub=function(){o(this._keySchedule),o(this._invKeySchedule),o(this._key)},e.exports.AES=u},function(e,t,n){var r=n(1).Buffer,i=n(52);e.exports=function(e,t,n,o){if(r.isBuffer(e)||(e=r.from(e,"binary")),t&&(r.isBuffer(t)||(t=r.from(t,"binary")),8!==t.length))throw new RangeError("salt should be Buffer with 8 byte length");for(var s=n/8,a=r.alloc(s),c=r.alloc(o||0),u=r.alloc(0);s>0||o>0;){var f=new i;f.update(u),f.update(e),t&&f.update(t),u=f.digest();var h=0;if(s>0){var d=a.length-s;h=Math.min(s,u.length),u.copy(a,d,0,h),s-=h}if(h0){var l=c.length-o,p=Math.min(o,u.length-h);u.copy(c,l,h,h+p),o-=p}}return u.fill(0),{key:a,iv:c}}},function(e,t){e.exports=function(e){return e.webpackPolyfill||(e.deprecate=function(){},e.paths=[],e.children||(e.children=[]),Object.defineProperty(e,"loaded",{enumerable:!0,get:function(){return e.l}}),Object.defineProperty(e,"id",{enumerable:!0,get:function(){return e.i}}),e.webpackPolyfill=1),e}},function(e,t,n){"use strict";var r=t;r.base=n(176),r.short=n(177),r.mont=n(178),r.edwards=n(179)},function(e,t,n){var r=n(195),i=n(206),o=n(207),s=n(61),a=n(85),c=n(1).Buffer;function u(e){var t;"object"!=typeof e||c.isBuffer(e)||(t=e.passphrase,e=e.key),"string"==typeof e&&(e=c.from(e));var n,u,f=o(e,t),h=f.tag,d=f.data;switch(h){case"CERTIFICATE":u=r.certificate.decode(d,"der").tbsCertificate.subjectPublicKeyInfo;case"PUBLIC KEY":switch(u||(u=r.PublicKey.decode(d,"der")),n=u.algorithm.algorithm.join(".")){case"1.2.840.113549.1.1.1":return r.RSAPublicKey.decode(u.subjectPublicKey.data,"der");case"1.2.840.10045.2.1":return u.subjectPrivateKey=u.subjectPublicKey,{type:"ec",data:u};case"1.2.840.10040.4.1":return u.algorithm.params.pub_key=r.DSAparam.decode(u.subjectPublicKey.data,"der"),{type:"dsa",data:u.algorithm.params};default:throw new Error("unknown key id "+n)}throw new Error("unknown key type "+h);case"ENCRYPTED PRIVATE KEY":d=function(e,t){var n=e.algorithm.decrypt.kde.kdeparams.salt,r=parseInt(e.algorithm.decrypt.kde.kdeparams.iters.toString(),10),o=i[e.algorithm.decrypt.cipher.algo.join(".")],u=e.algorithm.decrypt.cipher.iv,f=e.subjectPrivateKey,h=parseInt(o.split("-")[1],10)/8,d=a.pbkdf2Sync(t,n,r,h,"sha1"),l=s.createDecipheriv(o,d,u),p=[];return p.push(l.update(f)),p.push(l.final()),c.concat(p)}(d=r.EncryptedPrivateKey.decode(d,"der"),t);case"PRIVATE KEY":switch(n=(u=r.PrivateKey.decode(d,"der")).algorithm.algorithm.join(".")){case"1.2.840.113549.1.1.1":return r.RSAPrivateKey.decode(u.subjectPrivateKey,"der");case"1.2.840.10045.2.1":return{curve:u.algorithm.curve,privateKey:r.ECPrivateKey.decode(u.subjectPrivateKey,"der").privateKey};case"1.2.840.10040.4.1":return u.algorithm.params.priv_key=r.DSAparam.decode(u.subjectPrivateKey,"der"),{type:"dsa",params:u.algorithm.params};default:throw new Error("unknown key id "+n)}throw new Error("unknown key type "+h);case"RSA PUBLIC KEY":return r.RSAPublicKey.decode(d,"der");case"RSA PRIVATE KEY":return r.RSAPrivateKey.decode(d,"der");case"DSA PRIVATE KEY":return{type:"dsa",params:r.DSAPrivateKey.decode(d,"der")};case"EC PRIVATE KEY":return{curve:(d=r.ECPrivateKey.decode(d,"der")).parameters.value,privateKey:d.privateKey};default:throw new Error("unknown key type "+h)}}e.exports=u,u.signature=r.signature},function(e,t,n){var r=n(219),i=n(220),o=n(221),s=n(222),a=n(223);function c(e){var t=-1,n=null==e?0:e.length;for(this.clear();++t=c.length)n.appendChild(t(s[h]));else{var d=c[h],l=s[h];if(d!==l)if("text"!==d.type||"text"!==l.type)if("text"!==d.type&&"text"!==l.type){var p=l.attrs.key;if(p&&p in a){var m=a[p];m.vNode!==d&&(r.ArrayExt.move(c,c.indexOf(m.vNode,h+1),h),n.insertBefore(m.element,u),d=m.vNode,u=m.element)}if(d!==l){var b=d.attrs.key;b&&b!==p?(r.ArrayExt.insert(c,h,l),n.insertBefore(t(l),u)):d.tag===l.tag?(i(u,d.attrs,l.attrs),e(u,d.children,l.children),u=u.nextSibling):(r.ArrayExt.insert(c,h,l),n.insertBefore(t(l),u))}else u=u.nextSibling}else r.ArrayExt.insert(c,h,l),n.insertBefore(t(l),u);else u.textContent=l.content,u=u.nextSibling;else u=u.nextSibling}for(h=c.length-f;h>0;--h)n.removeChild(n.lastChild)}};var n={key:!0,className:!0,htmlFor:!0,dataset:!0,style:!0};function i(e,t,r){if(t!==r){var i;for(i in t)i in n||i in r||("on"===i.substr(0,2)?e[i]=null:e.removeAttribute(i));for(i in r)i in n||t[i]===r[i]||("on"===i.substr(0,2)?e[i]=r[i]:e.setAttribute(i,r[i]));t.className!==r.className&&(void 0!==r.className?e.setAttribute("class",r.className):e.removeAttribute("class")),t.htmlFor!==r.htmlFor&&(void 0!==r.htmlFor?e.setAttribute("for",r.htmlFor):e.removeAttribute("for")),t.dataset!==r.dataset&&function(e,t,n){for(var r in t)r in n||e.removeAttribute("data-"+r);for(var i in n)t[i]!==n[i]&&e.setAttribute("data-"+i,n[i])}(e,t.dataset||{},r.dataset||{}),t.style!==r.style&&function(e,t,n){var r,i=e.style;for(r in t)r in n||(i[r]="");for(r in n)t[r]!==n[r]&&(i[r]=n[r])}(e,t.style||{},r.style||{})}}}(o||(o={}))},function(e,t,n){"use strict";Object.defineProperty(t,"__esModule",{value:!0});var r,i=n(70),o=function(){function e(e){var t=this;this._onScrollFrame=function(){if(t._scrollTarget){var e=t._scrollTarget,n=e.element,i=e.edge,o=e.distance,s=r.SCROLL_EDGE_SIZE-o,a=Math.pow(s/r.SCROLL_EDGE_SIZE,2),c=Math.max(1,Math.round(a*r.SCROLL_EDGE_SIZE));switch(i){case"top":n.scrollTop-=c;break;case"left":n.scrollLeft-=c;break;case"right":n.scrollLeft+=c;break;case"bottom":n.scrollTop+=c}requestAnimationFrame(t._onScrollFrame)}},this._disposed=!1,this._dropAction="none",this._override=null,this._currentTarget=null,this._currentElement=null,this._promise=null,this._scrollTarget=null,this._resolve=null,this.mimeData=e.mimeData,this.dragImage=e.dragImage||null,this.proposedAction=e.proposedAction||"copy",this.supportedActions=e.supportedActions||"all",this.source=e.source||null}return e.prototype.dispose=function(){if(!this._disposed){if(this._disposed=!0,this._currentTarget){var e=r.createMouseEvent("mouseup",-1,-1);r.dispatchDragLeave(this,this._currentTarget,null,e)}this._finalize("none")}},Object.defineProperty(e.prototype,"isDisposed",{get:function(){return this._disposed},enumerable:!0,configurable:!0}),e.prototype.start=function(e,t){var n=this;if(this._disposed)return Promise.resolve("none");if(this._promise)return this._promise;this._addListeners(),this._attachDragImage(e,t),this._promise=new Promise(function(e,t){n._resolve=e});var i=r.createMouseEvent("mousemove",e,t);return document.dispatchEvent(i),this._promise},e.prototype.handleEvent=function(e){switch(e.type){case"mousemove":this._evtMouseMove(e);break;case"mouseup":this._evtMouseUp(e);break;case"keydown":this._evtKeyDown(e);break;default:e.preventDefault(),e.stopPropagation()}},e.prototype._evtMouseMove=function(e){e.preventDefault(),e.stopPropagation(),this._updateCurrentTarget(e),this._updateDragScroll(e),this._moveDragImage(e.clientX,e.clientY)},e.prototype._evtMouseUp=function(e){if(e.preventDefault(),e.stopPropagation(),0===e.button)if(this._updateCurrentTarget(e),this._currentTarget){if("none"===this._dropAction)return r.dispatchDragLeave(this,this._currentTarget,null,e),void this._finalize("none");var t=r.dispatchDrop(this,this._currentTarget,e);this._finalize(t)}else this._finalize("none")},e.prototype._evtKeyDown=function(e){e.preventDefault(),e.stopPropagation(),27===e.keyCode&&this.dispose()},e.prototype._addListeners=function(){document.addEventListener("mousedown",this,!0),document.addEventListener("mousemove",this,!0),document.addEventListener("mouseup",this,!0),document.addEventListener("mouseenter",this,!0),document.addEventListener("mouseleave",this,!0),document.addEventListener("mouseover",this,!0),document.addEventListener("mouseout",this,!0),document.addEventListener("keydown",this,!0),document.addEventListener("keyup",this,!0),document.addEventListener("keypress",this,!0),document.addEventListener("contextmenu",this,!0)},e.prototype._removeListeners=function(){document.removeEventListener("mousedown",this,!0),document.removeEventListener("mousemove",this,!0),document.removeEventListener("mouseup",this,!0),document.removeEventListener("mouseenter",this,!0),document.removeEventListener("mouseleave",this,!0),document.removeEventListener("mouseover",this,!0),document.removeEventListener("mouseout",this,!0),document.removeEventListener("keydown",this,!0),document.removeEventListener("keyup",this,!0),document.removeEventListener("keypress",this,!0),document.removeEventListener("contextmenu",this,!0)},e.prototype._updateDragScroll=function(e){var t=r.findScrollTarget(e);(this._scrollTarget||t)&&(this._scrollTarget||setTimeout(this._onScrollFrame,500),this._scrollTarget=t)},e.prototype._updateCurrentTarget=function(e){var t=this._currentTarget,n=this._currentTarget,i=this._currentElement,o=document.elementFromPoint(e.clientX,e.clientY);this._currentElement=o,o!==i&&o!==n&&r.dispatchDragExit(this,n,o,e),o!==i&&o!==n&&(n=r.dispatchDragEnter(this,o,n,e)),n!==t&&(this._currentTarget=n,r.dispatchDragLeave(this,t,n,e));var s=r.dispatchDragOver(this,n,e);this._setDropAction(s)},e.prototype._attachDragImage=function(e,t){if(this.dragImage){this.dragImage.classList.add("p-mod-drag-image");var n=this.dragImage.style;n.pointerEvents="none",n.position="fixed",n.top=t+"px",n.left=e+"px",document.body.appendChild(this.dragImage)}},e.prototype._moveDragImage=function(e,t){if(this.dragImage){var n=this.dragImage.style;n.top=t+"px",n.left=e+"px"}},e.prototype._detachDragImage=function(){if(this.dragImage){var e=this.dragImage.parentNode;e&&e.removeChild(this.dragImage)}},e.prototype._setDropAction=function(t){if(t=r.validateAction(t,this.supportedActions),!this._override||this._dropAction!==t)switch(t){case"none":this._dropAction=t,this._override=e.overrideCursor("no-drop");break;case"copy":this._dropAction=t,this._override=e.overrideCursor("copy");break;case"link":this._dropAction=t,this._override=e.overrideCursor("alias");break;case"move":this._dropAction=t,this._override=e.overrideCursor("move")}},e.prototype._finalize=function(e){var t=this._resolve;this._removeListeners(),this._detachDragImage(),this._override&&(this._override.dispose(),this._override=null),this.mimeData.clear(),this._disposed=!0,this._dropAction="none",this._currentTarget=null,this._currentElement=null,this._scrollTarget=null,this._promise=null,this._resolve=null,t&&t(e)},e}();t.Drag=o,function(e){e.overrideCursor=function(e){var n=++t;return document.body.style.cursor=e,document.body.classList.add("p-mod-override-cursor"),new i.DisposableDelegate(function(){n===t&&(document.body.style.cursor="",document.body.classList.remove("p-mod-override-cursor"))})};var t=0}(o=t.Drag||(t.Drag={})),t.Drag=o,function(e){e.SCROLL_EDGE_SIZE=20,e.validateAction=function(e,r){return t[e]&n[r]?e:"none"},e.createMouseEvent=function(e,t,n){var r=document.createEvent("MouseEvent");return r.initMouseEvent(e,!0,!0,window,0,0,0,t,n,!1,!1,!1,!1,0,null),r},e.findScrollTarget=function(t){for(var n=t.clientX,r=t.clientY,i=document.elementFromPoint(n,r);i;i=i.parentElement)if(i.hasAttribute("data-p-dragscroll")){var o=0,s=0;i===document.body&&(o=window.pageXOffset,s=window.pageYOffset);var a=i.getBoundingClientRect(),c=a.top+s,u=a.left+o,f=u+a.width,h=c+a.height;if(!(n=f||r=h)){var d=n-u+1,l=r-c+1,p=f-n,m=h-r,b=Math.min(d,l,p,m);if(!(b>e.SCROLL_EDGE_SIZE)){var v=void 0;switch(b){case m:v="bottom";break;case l:v="top";break;case p:v="right";break;case d:v="left";break;default:throw"unreachable"}var g=i.scrollWidth-i.clientWidth,y=i.scrollHeight-i.clientHeight,_=void 0;switch(v){case"top":_=y>0&&i.scrollTop>0;break;case"left":_=g>0&&i.scrollLeft>0;break;case"right":_=g>0&&i.scrollLeft0&&i.scrollTop0?r-4:r,h=0;h>16&255,a[c++]=t>>8&255,a[c++]=255&t;2===s&&(t=i[e.charCodeAt(h)]<<2|i[e.charCodeAt(h+1)]>>4,a[c++]=255&t);1===s&&(t=i[e.charCodeAt(h)]<<10|i[e.charCodeAt(h+1)]<<4|i[e.charCodeAt(h+2)]>>2,a[c++]=t>>8&255,a[c++]=255&t);return a},t.fromByteArray=function(e){for(var t,n=e.length,i=n%3,o=[],s=0,a=n-i;sa?a:s+16383));1===i?(t=e[n-1],o.push(r[t>>2]+r[t<<4&63]+"==")):2===i&&(t=(e[n-2]<<8)+e[n-1],o.push(r[t>>10]+r[t>>4&63]+r[t<<2&63]+"="));return o.join("")};for(var r=[],i=[],o="undefined"!=typeof Uint8Array?Uint8Array:Array,s="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",a=0,c=s.length;a0)throw new Error("Invalid string. Length must be a multiple of 4");var n=e.indexOf("=");return-1===n&&(n=t),[n,n===t?0:4-n%4]}function f(e,t,n){for(var i,o,s=[],a=t;a>18&63]+r[o>>12&63]+r[o>>6&63]+r[63&o]);return s.join("")}i["-".charCodeAt(0)]=62,i["_".charCodeAt(0)]=63},function(e,t,n){(function(r){var i,o,s;s="object"==typeof self&&self.self==self&&self||"object"==typeof r&&r.global==r&&r,i=[n(283),n(51),t],void 0===(o=function(e,t,n){s.Backbone=function(e,t,n,r){var i=e.Backbone,o=Array.prototype.slice;t.VERSION="1.2.3",t.$=r,t.noConflict=function(){return e.Backbone=i,this},t.emulateHTTP=!1,t.emulateJSON=!1;var s=function(e,t,r){n.each(t,function(t,i){n[i]&&(e.prototype[i]=function(e,t,r){switch(e){case 1:return function(){return n[t](this[r])};case 2:return function(e){return n[t](this[r],e)};case 3:return function(e,i){return n[t](this[r],a(e,this),i)};case 4:return function(e,i,o){return n[t](this[r],a(e,this),i,o)};default:return function(){var e=o.call(arguments);return e.unshift(this[r]),n[t].apply(n,e)}}}(t,i,r))})},a=function(e,t){return n.isFunction(e)?e:n.isObject(e)&&!t._isModel(e)?c(e):n.isString(e)?function(t){return t.get(e)}:e},c=function(e){var t=n.matches(e);return function(e){return t(e.attributes)}},u=t.Events={},f=/\s+/,h=function(e,t,r,i,o){var s,a=0;if(r&&"object"==typeof r){void 0!==i&&"context"in o&&void 0===o.context&&(o.context=i);for(s=n.keys(r);a7),this._useHashChange=this._wantsHashChange&&this._hasHashChange,this._wantsPushState=!!this.options.pushState,this._hasPushState=!(!this.history||!this.history.pushState),this._usePushState=this._wantsPushState&&this._hasPushState,this.fragment=this.getFragment(),this.root=("/"+this.root+"/").replace(L,"/"),this._wantsHashChange&&this._wantsPushState){if(!this._hasPushState&&!this.atRoot()){var t=this.root.slice(0,-1)||"/";return this.location.replace(t+"#"+this.getPath()),!0}this._hasPushState&&this.atRoot()&&this.navigate(this.getHash(),{replace:!0})}if(!this._hasHashChange&&this._wantsHashChange&&!this._usePushState){this.iframe=document.createElement("iframe"),this.iframe.src="javascript:0",this.iframe.style.display="none",this.iframe.tabIndex=-1;var r=document.body,i=r.insertBefore(this.iframe,r.firstChild).contentWindow;i.document.open(),i.document.close(),i.location.hash="#"+this.fragment}var o=window.addEventListener||function(e,t){return attachEvent("on"+e,t)};if(this._usePushState?o("popstate",this.checkUrl,!1):this._useHashChange&&!this.iframe?o("hashchange",this.checkUrl,!1):this._wantsHashChange&&(this._checkUrlInterval=setInterval(this.checkUrl,this.interval)),!this.options.silent)return this.loadUrl()},stop:function(){var e=window.removeEventListener||function(e,t){return detachEvent("on"+e,t)};this._usePushState?e("popstate",this.checkUrl,!1):this._useHashChange&&!this.iframe&&e("hashchange",this.checkUrl,!1),this.iframe&&(document.body.removeChild(this.iframe),this.iframe=null),this._checkUrlInterval&&clearInterval(this._checkUrlInterval),O.started=!1},route:function(e,t){this.handlers.unshift({route:e,callback:t})},checkUrl:function(e){var t=this.getFragment();if(t===this.fragment&&this.iframe&&(t=this.getHash(this.iframe.contentWindow)),t===this.fragment)return!1;this.iframe&&this.navigate(t),this.loadUrl()},loadUrl:function(e){return!!this.matchRoot()&&(e=this.fragment=this.getFragment(e),n.some(this.handlers,function(t){if(t.route.test(e))return t.callback(e),!0}))},navigate:function(e,t){if(!O.started)return!1;t&&!0!==t||(t={trigger:!!t}),e=this.getFragment(e||"");var n=this.root;""!==e&&"?"!==e.charAt(0)||(n=n.slice(0,-1)||"/");var r=n+e;if(e=this.decodeFragment(e.replace(B,"")),this.fragment!==e){if(this.fragment=e,this._usePushState)this.history[t.replace?"replaceState":"pushState"]({},document.title,r);else{if(!this._wantsHashChange)return this.location.assign(r);if(this._updateHash(this.location,e,t.replace),this.iframe&&e!==this.getHash(this.iframe.contentWindow)){var i=this.iframe.contentWindow;t.replace||(i.document.open(),i.document.close()),this._updateHash(i.location,e,t.replace)}}return t.trigger?this.loadUrl(e):void 0}},_updateHash:function(e,t,n){if(n){var r=e.href.replace(/(javascript:|#).*$/,"");e.replace(r+"#"+t)}else e.hash="#"+t}}),t.history=new O,g.extend=y.extend=k.extend=M.extend=O.extend=function(e,t){var r,i=this;r=e&&n.has(e,"constructor")?e.constructor:function(){return i.apply(this,arguments)},n.extend(r,i,t);var o=function(){this.constructor=r};return o.prototype=i.prototype,r.prototype=new o,e&&n.extend(r.prototype,e),r.__super__=i.prototype,r};var D=function(){throw new Error('A "url" property or function must be specified')},z=function(e,t){var n=t.error;t.error=function(r){n&&n.call(t.context,e,r,t),e.trigger("error",e,r,t)}};return t}(s,n,e,t)}.apply(t,i))||(e.exports=o)}).call(this,n(9))},function(e,t,n){var r; +/*! + * jQuery JavaScript Library v3.4.1 + * https://jquery.com/ + * + * Includes Sizzle.js + * https://sizzlejs.com/ + * + * Copyright JS Foundation and other contributors + * Released under the MIT license + * https://jquery.org/license + * + * Date: 2019-05-01T21:04Z + */ +/*! + * jQuery JavaScript Library v3.4.1 + * https://jquery.com/ + * + * Includes Sizzle.js + * https://sizzlejs.com/ + * + * Copyright JS Foundation and other contributors + * Released under the MIT license + * https://jquery.org/license + * + * Date: 2019-05-01T21:04Z + */ +!function(t,n){"use strict";"object"==typeof e.exports?e.exports=t.document?n(t,!0):function(e){if(!e.document)throw new Error("jQuery requires a window with a document");return n(e)}:n(t)}("undefined"!=typeof window?window:this,function(n,i){"use strict";var o=[],s=n.document,a=Object.getPrototypeOf,c=o.slice,u=o.concat,f=o.push,h=o.indexOf,d={},l=d.toString,p=d.hasOwnProperty,m=p.toString,b=m.call(Object),v={},g=function(e){return"function"==typeof e&&"number"!=typeof e.nodeType},y=function(e){return null!=e&&e===e.window},_={type:!0,src:!0,nonce:!0,noModule:!0};function w(e,t,n){var r,i,o=(n=n||s).createElement("script");if(o.text=e,t)for(r in _)(i=t[r]||t.getAttribute&&t.getAttribute(r))&&o.setAttribute(r,i);n.head.appendChild(o).parentNode.removeChild(o)}function x(e){return null==e?e+"":"object"==typeof e||"function"==typeof e?d[l.call(e)]||"object":typeof e}var M=function(e,t){return new M.fn.init(e,t)},S=/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g;function E(e){var t=!!e&&"length"in e&&e.length,n=x(e);return!g(e)&&!y(e)&&("array"===n||0===t||"number"==typeof t&&t>0&&t-1 in e)}M.fn=M.prototype={jquery:"3.4.1",constructor:M,length:0,toArray:function(){return c.call(this)},get:function(e){return null==e?c.call(this):e<0?this[e+this.length]:this[e]},pushStack:function(e){var t=M.merge(this.constructor(),e);return t.prevObject=this,t},each:function(e){return M.each(this,e)},map:function(e){return this.pushStack(M.map(this,function(t,n){return e.call(t,n,t)}))},slice:function(){return this.pushStack(c.apply(this,arguments))},first:function(){return this.eq(0)},last:function(){return this.eq(-1)},eq:function(e){var t=this.length,n=+e+(e<0?t:0);return this.pushStack(n>=0&&n+~]|"+z+")"+z+"*"),K=new RegExp(z+"|>"),V=new RegExp(q),Y=new RegExp("^"+R+"$"),X={ID:new RegExp("^#("+R+")"),CLASS:new RegExp("^\\.("+R+")"),TAG:new RegExp("^("+R+"|[*])"),ATTR:new RegExp("^"+N),PSEUDO:new RegExp("^"+q),CHILD:new RegExp("^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\("+z+"*(even|odd|(([+-]|)(\\d*)n|)"+z+"*(?:([+-]|)"+z+"*(\\d+)|))"+z+"*\\)|)","i"),bool:new RegExp("^(?:"+D+")$","i"),needsContext:new RegExp("^"+z+"*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\("+z+"*((?:-\\d)?\\d*)"+z+"*\\)|)(?=[^-]|$)","i")},$=/HTML$/i,G=/^(?:input|select|textarea|button)$/i,J=/^h\d$/i,Z=/^[^{]+\{\s*\[native \w/,Q=/^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,ee=/[+~]/,te=new RegExp("\\\\([\\da-f]{1,6}"+z+"?|("+z+")|.)","ig"),ne=function(e,t,n){var r="0x"+t-65536;return r!=r||n?t:r<0?String.fromCharCode(r+65536):String.fromCharCode(r>>10|55296,1023&r|56320)},re=/([\0-\x1f\x7f]|^-?\d)|^-$|[^\0-\x1f\x7f-\uFFFF\w-]/g,ie=function(e,t){return t?"\0"===e?"�":e.slice(0,-1)+"\\"+e.charCodeAt(e.length-1).toString(16)+" ":"\\"+e},oe=function(){d()},se=_e(function(e){return!0===e.disabled&&"fieldset"===e.nodeName.toLowerCase()},{dir:"parentNode",next:"legend"});try{j.apply(I=L.call(w.childNodes),w.childNodes),I[w.childNodes.length].nodeType}catch(e){j={apply:I.length?function(e,t){O.apply(e,L.call(t))}:function(e,t){for(var n=e.length,r=0;e[n++]=t[r++];);e.length=n-1}}}function ae(e,t,r,i){var o,a,u,f,h,p,v,g=t&&t.ownerDocument,x=t?t.nodeType:9;if(r=r||[],"string"!=typeof e||!e||1!==x&&9!==x&&11!==x)return r;if(!i&&((t?t.ownerDocument||t:w)!==l&&d(t),t=t||l,m)){if(11!==x&&(h=Q.exec(e)))if(o=h[1]){if(9===x){if(!(u=t.getElementById(o)))return r;if(u.id===o)return r.push(u),r}else if(g&&(u=g.getElementById(o))&&y(t,u)&&u.id===o)return r.push(u),r}else{if(h[2])return j.apply(r,t.getElementsByTagName(e)),r;if((o=h[3])&&n.getElementsByClassName&&t.getElementsByClassName)return j.apply(r,t.getElementsByClassName(o)),r}if(n.qsa&&!k[e+" "]&&(!b||!b.test(e))&&(1!==x||"object"!==t.nodeName.toLowerCase())){if(v=e,g=t,1===x&&K.test(e)){for((f=t.getAttribute("id"))?f=f.replace(re,ie):t.setAttribute("id",f=_),a=(p=s(e)).length;a--;)p[a]="#"+f+" "+ye(p[a]);v=p.join(","),g=ee.test(e)&&ve(t.parentNode)||t}try{return j.apply(r,g.querySelectorAll(v)),r}catch(t){k(e,!0)}finally{f===_&&t.removeAttribute("id")}}}return c(e.replace(W,"$1"),t,r,i)}function ce(){var e=[];return function t(n,i){return e.push(n+" ")>r.cacheLength&&delete t[e.shift()],t[n+" "]=i}}function ue(e){return e[_]=!0,e}function fe(e){var t=l.createElement("fieldset");try{return!!e(t)}catch(e){return!1}finally{t.parentNode&&t.parentNode.removeChild(t),t=null}}function he(e,t){for(var n=e.split("|"),i=n.length;i--;)r.attrHandle[n[i]]=t}function de(e,t){var n=t&&e,r=n&&1===e.nodeType&&1===t.nodeType&&e.sourceIndex-t.sourceIndex;if(r)return r;if(n)for(;n=n.nextSibling;)if(n===t)return-1;return e?1:-1}function le(e){return function(t){return"input"===t.nodeName.toLowerCase()&&t.type===e}}function pe(e){return function(t){var n=t.nodeName.toLowerCase();return("input"===n||"button"===n)&&t.type===e}}function me(e){return function(t){return"form"in t?t.parentNode&&!1===t.disabled?"label"in t?"label"in t.parentNode?t.parentNode.disabled===e:t.disabled===e:t.isDisabled===e||t.isDisabled!==!e&&se(t)===e:t.disabled===e:"label"in t&&t.disabled===e}}function be(e){return ue(function(t){return t=+t,ue(function(n,r){for(var i,o=e([],n.length,t),s=o.length;s--;)n[i=o[s]]&&(n[i]=!(r[i]=n[i]))})})}function ve(e){return e&&void 0!==e.getElementsByTagName&&e}for(t in n=ae.support={},o=ae.isXML=function(e){var t=e.namespaceURI,n=(e.ownerDocument||e).documentElement;return!$.test(t||n&&n.nodeName||"HTML")},d=ae.setDocument=function(e){var t,i,s=e?e.ownerDocument||e:w;return s!==l&&9===s.nodeType&&s.documentElement?(p=(l=s).documentElement,m=!o(l),w!==l&&(i=l.defaultView)&&i.top!==i&&(i.addEventListener?i.addEventListener("unload",oe,!1):i.attachEvent&&i.attachEvent("onunload",oe)),n.attributes=fe(function(e){return e.className="i",!e.getAttribute("className")}),n.getElementsByTagName=fe(function(e){return e.appendChild(l.createComment("")),!e.getElementsByTagName("*").length}),n.getElementsByClassName=Z.test(l.getElementsByClassName),n.getById=fe(function(e){return p.appendChild(e).id=_,!l.getElementsByName||!l.getElementsByName(_).length}),n.getById?(r.filter.ID=function(e){var t=e.replace(te,ne);return function(e){return e.getAttribute("id")===t}},r.find.ID=function(e,t){if(void 0!==t.getElementById&&m){var n=t.getElementById(e);return n?[n]:[]}}):(r.filter.ID=function(e){var t=e.replace(te,ne);return function(e){var n=void 0!==e.getAttributeNode&&e.getAttributeNode("id");return n&&n.value===t}},r.find.ID=function(e,t){if(void 0!==t.getElementById&&m){var n,r,i,o=t.getElementById(e);if(o){if((n=o.getAttributeNode("id"))&&n.value===e)return[o];for(i=t.getElementsByName(e),r=0;o=i[r++];)if((n=o.getAttributeNode("id"))&&n.value===e)return[o]}return[]}}),r.find.TAG=n.getElementsByTagName?function(e,t){return void 0!==t.getElementsByTagName?t.getElementsByTagName(e):n.qsa?t.querySelectorAll(e):void 0}:function(e,t){var n,r=[],i=0,o=t.getElementsByTagName(e);if("*"===e){for(;n=o[i++];)1===n.nodeType&&r.push(n);return r}return o},r.find.CLASS=n.getElementsByClassName&&function(e,t){if(void 0!==t.getElementsByClassName&&m)return t.getElementsByClassName(e)},v=[],b=[],(n.qsa=Z.test(l.querySelectorAll))&&(fe(function(e){p.appendChild(e).innerHTML="",e.querySelectorAll("[msallowcapture^='']").length&&b.push("[*^$]="+z+"*(?:''|\"\")"),e.querySelectorAll("[selected]").length||b.push("\\["+z+"*(?:value|"+D+")"),e.querySelectorAll("[id~="+_+"-]").length||b.push("~="),e.querySelectorAll(":checked").length||b.push(":checked"),e.querySelectorAll("a#"+_+"+*").length||b.push(".#.+[+~]")}),fe(function(e){e.innerHTML="";var t=l.createElement("input");t.setAttribute("type","hidden"),e.appendChild(t).setAttribute("name","D"),e.querySelectorAll("[name=d]").length&&b.push("name"+z+"*[*^$|!~]?="),2!==e.querySelectorAll(":enabled").length&&b.push(":enabled",":disabled"),p.appendChild(e).disabled=!0,2!==e.querySelectorAll(":disabled").length&&b.push(":enabled",":disabled"),e.querySelectorAll("*,:x"),b.push(",.*:")})),(n.matchesSelector=Z.test(g=p.matches||p.webkitMatchesSelector||p.mozMatchesSelector||p.oMatchesSelector||p.msMatchesSelector))&&fe(function(e){n.disconnectedMatch=g.call(e,"*"),g.call(e,"[s!='']:x"),v.push("!=",q)}),b=b.length&&new RegExp(b.join("|")),v=v.length&&new RegExp(v.join("|")),t=Z.test(p.compareDocumentPosition),y=t||Z.test(p.contains)?function(e,t){var n=9===e.nodeType?e.documentElement:e,r=t&&t.parentNode;return e===r||!(!r||1!==r.nodeType||!(n.contains?n.contains(r):e.compareDocumentPosition&&16&e.compareDocumentPosition(r)))}:function(e,t){if(t)for(;t=t.parentNode;)if(t===e)return!0;return!1},C=t?function(e,t){if(e===t)return h=!0,0;var r=!e.compareDocumentPosition-!t.compareDocumentPosition;return r||(1&(r=(e.ownerDocument||e)===(t.ownerDocument||t)?e.compareDocumentPosition(t):1)||!n.sortDetached&&t.compareDocumentPosition(e)===r?e===l||e.ownerDocument===w&&y(w,e)?-1:t===l||t.ownerDocument===w&&y(w,t)?1:f?B(f,e)-B(f,t):0:4&r?-1:1)}:function(e,t){if(e===t)return h=!0,0;var n,r=0,i=e.parentNode,o=t.parentNode,s=[e],a=[t];if(!i||!o)return e===l?-1:t===l?1:i?-1:o?1:f?B(f,e)-B(f,t):0;if(i===o)return de(e,t);for(n=e;n=n.parentNode;)s.unshift(n);for(n=t;n=n.parentNode;)a.unshift(n);for(;s[r]===a[r];)r++;return r?de(s[r],a[r]):s[r]===w?-1:a[r]===w?1:0},l):l},ae.matches=function(e,t){return ae(e,null,null,t)},ae.matchesSelector=function(e,t){if((e.ownerDocument||e)!==l&&d(e),n.matchesSelector&&m&&!k[t+" "]&&(!v||!v.test(t))&&(!b||!b.test(t)))try{var r=g.call(e,t);if(r||n.disconnectedMatch||e.document&&11!==e.document.nodeType)return r}catch(e){k(t,!0)}return ae(t,l,null,[e]).length>0},ae.contains=function(e,t){return(e.ownerDocument||e)!==l&&d(e),y(e,t)},ae.attr=function(e,t){(e.ownerDocument||e)!==l&&d(e);var i=r.attrHandle[t.toLowerCase()],o=i&&P.call(r.attrHandle,t.toLowerCase())?i(e,t,!m):void 0;return void 0!==o?o:n.attributes||!m?e.getAttribute(t):(o=e.getAttributeNode(t))&&o.specified?o.value:null},ae.escape=function(e){return(e+"").replace(re,ie)},ae.error=function(e){throw new Error("Syntax error, unrecognized expression: "+e)},ae.uniqueSort=function(e){var t,r=[],i=0,o=0;if(h=!n.detectDuplicates,f=!n.sortStable&&e.slice(0),e.sort(C),h){for(;t=e[o++];)t===e[o]&&(i=r.push(o));for(;i--;)e.splice(r[i],1)}return f=null,e},i=ae.getText=function(e){var t,n="",r=0,o=e.nodeType;if(o){if(1===o||9===o||11===o){if("string"==typeof e.textContent)return e.textContent;for(e=e.firstChild;e;e=e.nextSibling)n+=i(e)}else if(3===o||4===o)return e.nodeValue}else for(;t=e[r++];)n+=i(t);return n},(r=ae.selectors={cacheLength:50,createPseudo:ue,match:X,attrHandle:{},find:{},relative:{">":{dir:"parentNode",first:!0}," ":{dir:"parentNode"},"+":{dir:"previousSibling",first:!0},"~":{dir:"previousSibling"}},preFilter:{ATTR:function(e){return e[1]=e[1].replace(te,ne),e[3]=(e[3]||e[4]||e[5]||"").replace(te,ne),"~="===e[2]&&(e[3]=" "+e[3]+" "),e.slice(0,4)},CHILD:function(e){return e[1]=e[1].toLowerCase(),"nth"===e[1].slice(0,3)?(e[3]||ae.error(e[0]),e[4]=+(e[4]?e[5]+(e[6]||1):2*("even"===e[3]||"odd"===e[3])),e[5]=+(e[7]+e[8]||"odd"===e[3])):e[3]&&ae.error(e[0]),e},PSEUDO:function(e){var t,n=!e[6]&&e[2];return X.CHILD.test(e[0])?null:(e[3]?e[2]=e[4]||e[5]||"":n&&V.test(n)&&(t=s(n,!0))&&(t=n.indexOf(")",n.length-t)-n.length)&&(e[0]=e[0].slice(0,t),e[2]=n.slice(0,t)),e.slice(0,3))}},filter:{TAG:function(e){var t=e.replace(te,ne).toLowerCase();return"*"===e?function(){return!0}:function(e){return e.nodeName&&e.nodeName.toLowerCase()===t}},CLASS:function(e){var t=S[e+" "];return t||(t=new RegExp("(^|"+z+")"+e+"("+z+"|$)"))&&S(e,function(e){return t.test("string"==typeof e.className&&e.className||void 0!==e.getAttribute&&e.getAttribute("class")||"")})},ATTR:function(e,t,n){return function(r){var i=ae.attr(r,e);return null==i?"!="===t:!t||(i+="","="===t?i===n:"!="===t?i!==n:"^="===t?n&&0===i.indexOf(n):"*="===t?n&&i.indexOf(n)>-1:"$="===t?n&&i.slice(-n.length)===n:"~="===t?(" "+i.replace(H," ")+" ").indexOf(n)>-1:"|="===t&&(i===n||i.slice(0,n.length+1)===n+"-"))}},CHILD:function(e,t,n,r,i){var o="nth"!==e.slice(0,3),s="last"!==e.slice(-4),a="of-type"===t;return 1===r&&0===i?function(e){return!!e.parentNode}:function(t,n,c){var u,f,h,d,l,p,m=o!==s?"nextSibling":"previousSibling",b=t.parentNode,v=a&&t.nodeName.toLowerCase(),g=!c&&!a,y=!1;if(b){if(o){for(;m;){for(d=t;d=d[m];)if(a?d.nodeName.toLowerCase()===v:1===d.nodeType)return!1;p=m="only"===e&&!p&&"nextSibling"}return!0}if(p=[s?b.firstChild:b.lastChild],s&&g){for(y=(l=(u=(f=(h=(d=b)[_]||(d[_]={}))[d.uniqueID]||(h[d.uniqueID]={}))[e]||[])[0]===x&&u[1])&&u[2],d=l&&b.childNodes[l];d=++l&&d&&d[m]||(y=l=0)||p.pop();)if(1===d.nodeType&&++y&&d===t){f[e]=[x,l,y];break}}else if(g&&(y=l=(u=(f=(h=(d=t)[_]||(d[_]={}))[d.uniqueID]||(h[d.uniqueID]={}))[e]||[])[0]===x&&u[1]),!1===y)for(;(d=++l&&d&&d[m]||(y=l=0)||p.pop())&&((a?d.nodeName.toLowerCase()!==v:1!==d.nodeType)||!++y||(g&&((f=(h=d[_]||(d[_]={}))[d.uniqueID]||(h[d.uniqueID]={}))[e]=[x,y]),d!==t)););return(y-=i)===r||y%r==0&&y/r>=0}}},PSEUDO:function(e,t){var n,i=r.pseudos[e]||r.setFilters[e.toLowerCase()]||ae.error("unsupported pseudo: "+e);return i[_]?i(t):i.length>1?(n=[e,e,"",t],r.setFilters.hasOwnProperty(e.toLowerCase())?ue(function(e,n){for(var r,o=i(e,t),s=o.length;s--;)e[r=B(e,o[s])]=!(n[r]=o[s])}):function(e){return i(e,0,n)}):i}},pseudos:{not:ue(function(e){var t=[],n=[],r=a(e.replace(W,"$1"));return r[_]?ue(function(e,t,n,i){for(var o,s=r(e,null,i,[]),a=e.length;a--;)(o=s[a])&&(e[a]=!(t[a]=o))}):function(e,i,o){return t[0]=e,r(t,null,o,n),t[0]=null,!n.pop()}}),has:ue(function(e){return function(t){return ae(e,t).length>0}}),contains:ue(function(e){return e=e.replace(te,ne),function(t){return(t.textContent||i(t)).indexOf(e)>-1}}),lang:ue(function(e){return Y.test(e||"")||ae.error("unsupported lang: "+e),e=e.replace(te,ne).toLowerCase(),function(t){var n;do{if(n=m?t.lang:t.getAttribute("xml:lang")||t.getAttribute("lang"))return(n=n.toLowerCase())===e||0===n.indexOf(e+"-")}while((t=t.parentNode)&&1===t.nodeType);return!1}}),target:function(t){var n=e.location&&e.location.hash;return n&&n.slice(1)===t.id},root:function(e){return e===p},focus:function(e){return e===l.activeElement&&(!l.hasFocus||l.hasFocus())&&!!(e.type||e.href||~e.tabIndex)},enabled:me(!1),disabled:me(!0),checked:function(e){var t=e.nodeName.toLowerCase();return"input"===t&&!!e.checked||"option"===t&&!!e.selected},selected:function(e){return e.parentNode&&e.parentNode.selectedIndex,!0===e.selected},empty:function(e){for(e=e.firstChild;e;e=e.nextSibling)if(e.nodeType<6)return!1;return!0},parent:function(e){return!r.pseudos.empty(e)},header:function(e){return J.test(e.nodeName)},input:function(e){return G.test(e.nodeName)},button:function(e){var t=e.nodeName.toLowerCase();return"input"===t&&"button"===e.type||"button"===t},text:function(e){var t;return"input"===e.nodeName.toLowerCase()&&"text"===e.type&&(null==(t=e.getAttribute("type"))||"text"===t.toLowerCase())},first:be(function(){return[0]}),last:be(function(e,t){return[t-1]}),eq:be(function(e,t,n){return[n<0?n+t:n]}),even:be(function(e,t){for(var n=0;nt?t:n;--r>=0;)e.push(r);return e}),gt:be(function(e,t,n){for(var r=n<0?n+t:n;++r1?function(t,n,r){for(var i=e.length;i--;)if(!e[i](t,n,r))return!1;return!0}:e[0]}function xe(e,t,n,r,i){for(var o,s=[],a=0,c=e.length,u=null!=t;a-1&&(o[u]=!(s[u]=h))}}else v=xe(v===s?v.splice(p,v.length):v),i?i(null,s,v,c):j.apply(s,v)})}function Se(e){for(var t,n,i,o=e.length,s=r.relative[e[0].type],a=s||r.relative[" "],c=s?1:0,f=_e(function(e){return e===t},a,!0),h=_e(function(e){return B(t,e)>-1},a,!0),d=[function(e,n,r){var i=!s&&(r||n!==u)||((t=n).nodeType?f(e,n,r):h(e,n,r));return t=null,i}];c1&&we(d),c>1&&ye(e.slice(0,c-1).concat({value:" "===e[c-2].type?"*":""})).replace(W,"$1"),n,c0,i=e.length>0,o=function(o,s,a,c,f){var h,p,b,v=0,g="0",y=o&&[],_=[],w=u,M=o||i&&r.find.TAG("*",f),S=x+=null==w?1:Math.random()||.1,E=M.length;for(f&&(u=s===l||s||f);g!==E&&null!=(h=M[g]);g++){if(i&&h){for(p=0,s||h.ownerDocument===l||(d(h),a=!m);b=e[p++];)if(b(h,s||l,a)){c.push(h);break}f&&(x=S)}n&&((h=!b&&h)&&v--,o&&y.push(h))}if(v+=g,n&&g!==v){for(p=0;b=t[p++];)b(y,_,s,a);if(o){if(v>0)for(;g--;)y[g]||_[g]||(_[g]=T.call(c));_=xe(_)}j.apply(c,_),f&&!o&&_.length>0&&v+t.length>1&&ae.uniqueSort(c)}return f&&(x=S,u=w),y};return n?ue(o):o}(o,i))).selector=e}return a},c=ae.select=function(e,t,n,i){var o,c,u,f,h,d="function"==typeof e&&e,l=!i&&s(e=d.selector||e);if(n=n||[],1===l.length){if((c=l[0]=l[0].slice(0)).length>2&&"ID"===(u=c[0]).type&&9===t.nodeType&&m&&r.relative[c[1].type]){if(!(t=(r.find.ID(u.matches[0].replace(te,ne),t)||[])[0]))return n;d&&(t=t.parentNode),e=e.slice(c.shift().value.length)}for(o=X.needsContext.test(e)?0:c.length;o--&&(u=c[o],!r.relative[f=u.type]);)if((h=r.find[f])&&(i=h(u.matches[0].replace(te,ne),ee.test(c[0].type)&&ve(t.parentNode)||t))){if(c.splice(o,1),!(e=i.length&&ye(c)))return j.apply(n,i),n;break}}return(d||a(e,l))(i,t,!m,n,!t||ee.test(e)&&ve(t.parentNode)||t),n},n.sortStable=_.split("").sort(C).join("")===_,n.detectDuplicates=!!h,d(),n.sortDetached=fe(function(e){return 1&e.compareDocumentPosition(l.createElement("fieldset"))}),fe(function(e){return e.innerHTML="","#"===e.firstChild.getAttribute("href")})||he("type|href|height|width",function(e,t,n){if(!n)return e.getAttribute(t,"type"===t.toLowerCase()?1:2)}),n.attributes&&fe(function(e){return e.innerHTML="",e.firstChild.setAttribute("value",""),""===e.firstChild.getAttribute("value")})||he("value",function(e,t,n){if(!n&&"input"===e.nodeName.toLowerCase())return e.defaultValue}),fe(function(e){return null==e.getAttribute("disabled")})||he(D,function(e,t,n){var r;if(!n)return!0===e[t]?t.toLowerCase():(r=e.getAttributeNode(t))&&r.specified?r.value:null}),ae}(n);M.find=A,M.expr=A.selectors,M.expr[":"]=M.expr.pseudos,M.uniqueSort=M.unique=A.uniqueSort,M.text=A.getText,M.isXMLDoc=A.isXML,M.contains=A.contains,M.escapeSelector=A.escape;var k=function(e,t,n){for(var r=[],i=void 0!==n;(e=e[t])&&9!==e.nodeType;)if(1===e.nodeType){if(i&&M(e).is(n))break;r.push(e)}return r},C=function(e,t){for(var n=[];e;e=e.nextSibling)1===e.nodeType&&e!==t&&n.push(e);return n},P=M.expr.match.needsContext;function I(e,t){return e.nodeName&&e.nodeName.toLowerCase()===t.toLowerCase()}var T=/^<([a-z][^\/\0>:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i;function O(e,t,n){return g(t)?M.grep(e,function(e,r){return!!t.call(e,r,e)!==n}):t.nodeType?M.grep(e,function(e){return e===t!==n}):"string"!=typeof t?M.grep(e,function(e){return h.call(t,e)>-1!==n}):M.filter(t,e,n)}M.filter=function(e,t,n){var r=t[0];return n&&(e=":not("+e+")"),1===t.length&&1===r.nodeType?M.find.matchesSelector(r,e)?[r]:[]:M.find.matches(e,M.grep(t,function(e){return 1===e.nodeType}))},M.fn.extend({find:function(e){var t,n,r=this.length,i=this;if("string"!=typeof e)return this.pushStack(M(e).filter(function(){for(t=0;t1?M.uniqueSort(n):n},filter:function(e){return this.pushStack(O(this,e||[],!1))},not:function(e){return this.pushStack(O(this,e||[],!0))},is:function(e){return!!O(this,"string"==typeof e&&P.test(e)?M(e):e||[],!1).length}});var j,L=/^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]+))$/;(M.fn.init=function(e,t,n){var r,i;if(!e)return this;if(n=n||j,"string"==typeof e){if(!(r="<"===e[0]&&">"===e[e.length-1]&&e.length>=3?[null,e,null]:L.exec(e))||!r[1]&&t)return!t||t.jquery?(t||n).find(e):this.constructor(t).find(e);if(r[1]){if(t=t instanceof M?t[0]:t,M.merge(this,M.parseHTML(r[1],t&&t.nodeType?t.ownerDocument||t:s,!0)),T.test(r[1])&&M.isPlainObject(t))for(r in t)g(this[r])?this[r](t[r]):this.attr(r,t[r]);return this}return(i=s.getElementById(r[2]))&&(this[0]=i,this.length=1),this}return e.nodeType?(this[0]=e,this.length=1,this):g(e)?void 0!==n.ready?n.ready(e):e(M):M.makeArray(e,this)}).prototype=M.fn,j=M(s);var B=/^(?:parents|prev(?:Until|All))/,D={children:!0,contents:!0,next:!0,prev:!0};function z(e,t){for(;(e=e[t])&&1!==e.nodeType;);return e}M.fn.extend({has:function(e){var t=M(e,this),n=t.length;return this.filter(function(){for(var e=0;e-1:1===n.nodeType&&M.find.matchesSelector(n,e))){o.push(n);break}return this.pushStack(o.length>1?M.uniqueSort(o):o)},index:function(e){return e?"string"==typeof e?h.call(M(e),this[0]):h.call(this,e.jquery?e[0]:e):this[0]&&this[0].parentNode?this.first().prevAll().length:-1},add:function(e,t){return this.pushStack(M.uniqueSort(M.merge(this.get(),M(e,t))))},addBack:function(e){return this.add(null==e?this.prevObject:this.prevObject.filter(e))}}),M.each({parent:function(e){var t=e.parentNode;return t&&11!==t.nodeType?t:null},parents:function(e){return k(e,"parentNode")},parentsUntil:function(e,t,n){return k(e,"parentNode",n)},next:function(e){return z(e,"nextSibling")},prev:function(e){return z(e,"previousSibling")},nextAll:function(e){return k(e,"nextSibling")},prevAll:function(e){return k(e,"previousSibling")},nextUntil:function(e,t,n){return k(e,"nextSibling",n)},prevUntil:function(e,t,n){return k(e,"previousSibling",n)},siblings:function(e){return C((e.parentNode||{}).firstChild,e)},children:function(e){return C(e.firstChild)},contents:function(e){return void 0!==e.contentDocument?e.contentDocument:(I(e,"template")&&(e=e.content||e),M.merge([],e.childNodes))}},function(e,t){M.fn[e]=function(n,r){var i=M.map(this,t,n);return"Until"!==e.slice(-5)&&(r=n),r&&"string"==typeof r&&(i=M.filter(r,i)),this.length>1&&(D[e]||M.uniqueSort(i),B.test(e)&&i.reverse()),this.pushStack(i)}});var R=/[^\x20\t\r\n\f]+/g;function N(e){return e}function q(e){throw e}function H(e,t,n,r){var i;try{e&&g(i=e.promise)?i.call(e).done(t).fail(n):e&&g(i=e.then)?i.call(e,t,n):t.apply(void 0,[e].slice(r))}catch(e){n.apply(void 0,[e])}}M.Callbacks=function(e){e="string"==typeof e?function(e){var t={};return M.each(e.match(R)||[],function(e,n){t[n]=!0}),t}(e):M.extend({},e);var t,n,r,i,o=[],s=[],a=-1,c=function(){for(i=i||e.once,r=t=!0;s.length;a=-1)for(n=s.shift();++a-1;)o.splice(n,1),n<=a&&a--}),this},has:function(e){return e?M.inArray(e,o)>-1:o.length>0},empty:function(){return o&&(o=[]),this},disable:function(){return i=s=[],o=n="",this},disabled:function(){return!o},lock:function(){return i=s=[],n||t||(o=n=""),this},locked:function(){return!!i},fireWith:function(e,n){return i||(n=[e,(n=n||[]).slice?n.slice():n],s.push(n),t||c()),this},fire:function(){return u.fireWith(this,arguments),this},fired:function(){return!!r}};return u},M.extend({Deferred:function(e){var t=[["notify","progress",M.Callbacks("memory"),M.Callbacks("memory"),2],["resolve","done",M.Callbacks("once memory"),M.Callbacks("once memory"),0,"resolved"],["reject","fail",M.Callbacks("once memory"),M.Callbacks("once memory"),1,"rejected"]],r="pending",i={state:function(){return r},always:function(){return o.done(arguments).fail(arguments),this},catch:function(e){return i.then(null,e)},pipe:function(){var e=arguments;return M.Deferred(function(n){M.each(t,function(t,r){var i=g(e[r[4]])&&e[r[4]];o[r[1]](function(){var e=i&&i.apply(this,arguments);e&&g(e.promise)?e.promise().progress(n.notify).done(n.resolve).fail(n.reject):n[r[0]+"With"](this,i?[e]:arguments)})}),e=null}).promise()},then:function(e,r,i){var o=0;function s(e,t,r,i){return function(){var a=this,c=arguments,u=function(){var n,u;if(!(e=o&&(r!==q&&(a=void 0,c=[n]),t.rejectWith(a,c))}};e?f():(M.Deferred.getStackHook&&(f.stackTrace=M.Deferred.getStackHook()),n.setTimeout(f))}}return M.Deferred(function(n){t[0][3].add(s(0,n,g(i)?i:N,n.notifyWith)),t[1][3].add(s(0,n,g(e)?e:N)),t[2][3].add(s(0,n,g(r)?r:q))}).promise()},promise:function(e){return null!=e?M.extend(e,i):i}},o={};return M.each(t,function(e,n){var s=n[2],a=n[5];i[n[1]]=s.add,a&&s.add(function(){r=a},t[3-e][2].disable,t[3-e][3].disable,t[0][2].lock,t[0][3].lock),s.add(n[3].fire),o[n[0]]=function(){return o[n[0]+"With"](this===o?void 0:this,arguments),this},o[n[0]+"With"]=s.fireWith}),i.promise(o),e&&e.call(o,o),o},when:function(e){var t=arguments.length,n=t,r=Array(n),i=c.call(arguments),o=M.Deferred(),s=function(e){return function(n){r[e]=this,i[e]=arguments.length>1?c.call(arguments):n,--t||o.resolveWith(r,i)}};if(t<=1&&(H(e,o.done(s(n)).resolve,o.reject,!t),"pending"===o.state()||g(i[n]&&i[n].then)))return o.then();for(;n--;)H(i[n],s(n),o.reject);return o.promise()}});var W=/^(Eval|Internal|Range|Reference|Syntax|Type|URI)Error$/;M.Deferred.exceptionHook=function(e,t){n.console&&n.console.warn&&e&&W.test(e.name)&&n.console.warn("jQuery.Deferred exception: "+e.message,e.stack,t)},M.readyException=function(e){n.setTimeout(function(){throw e})};var F=M.Deferred();function U(){s.removeEventListener("DOMContentLoaded",U),n.removeEventListener("load",U),M.ready()}M.fn.ready=function(e){return F.then(e).catch(function(e){M.readyException(e)}),this},M.extend({isReady:!1,readyWait:1,ready:function(e){(!0===e?--M.readyWait:M.isReady)||(M.isReady=!0,!0!==e&&--M.readyWait>0||F.resolveWith(s,[M]))}}),M.ready.then=F.then,"complete"===s.readyState||"loading"!==s.readyState&&!s.documentElement.doScroll?n.setTimeout(M.ready):(s.addEventListener("DOMContentLoaded",U),n.addEventListener("load",U));var K=function(e,t,n,r,i,o,s){var a=0,c=e.length,u=null==n;if("object"===x(n))for(a in i=!0,n)K(e,t,a,n[a],!0,o,s);else if(void 0!==r&&(i=!0,g(r)||(s=!0),u&&(s?(t.call(e,r),t=null):(u=t,t=function(e,t,n){return u.call(M(e),n)})),t))for(;a1,null,!0)},removeData:function(e){return this.each(function(){Q.remove(this,e)})}}),M.extend({queue:function(e,t,n){var r;if(e)return t=(t||"fx")+"queue",r=Z.get(e,t),n&&(!r||Array.isArray(n)?r=Z.access(e,t,M.makeArray(n)):r.push(n)),r||[]},dequeue:function(e,t){t=t||"fx";var n=M.queue(e,t),r=n.length,i=n.shift(),o=M._queueHooks(e,t);"inprogress"===i&&(i=n.shift(),r--),i&&("fx"===t&&n.unshift("inprogress"),delete o.stop,i.call(e,function(){M.dequeue(e,t)},o)),!r&&o&&o.empty.fire()},_queueHooks:function(e,t){var n=t+"queueHooks";return Z.get(e,n)||Z.access(e,n,{empty:M.Callbacks("once memory").add(function(){Z.remove(e,[t+"queue",n])})})}}),M.fn.extend({queue:function(e,t){var n=2;return"string"!=typeof e&&(t=e,e="fx",n--),arguments.length\x20\t\r\n\f]*)/i,ve=/^$|^module$|\/(?:java|ecma)script/i,ge={option:[1,""],thead:[1,"","
"],col:[2,"","
"],tr:[2,"","
"],td:[3,"","
"],_default:[0,"",""]};function ye(e,t){var n;return n=void 0!==e.getElementsByTagName?e.getElementsByTagName(t||"*"):void 0!==e.querySelectorAll?e.querySelectorAll(t||"*"):[],void 0===t||t&&I(e,t)?M.merge([e],n):n}function _e(e,t){for(var n=0,r=e.length;n-1)i&&i.push(o);else if(u=ae(o),s=ye(h.appendChild(o),"script"),u&&_e(s),n)for(f=0;o=s[f++];)ve.test(o.type||"")&&n.push(o);return h}we=s.createDocumentFragment().appendChild(s.createElement("div")),(xe=s.createElement("input")).setAttribute("type","radio"),xe.setAttribute("checked","checked"),xe.setAttribute("name","t"),we.appendChild(xe),v.checkClone=we.cloneNode(!0).cloneNode(!0).lastChild.checked,we.innerHTML="",v.noCloneChecked=!!we.cloneNode(!0).lastChild.defaultValue;var Ee=/^key/,Ae=/^(?:mouse|pointer|contextmenu|drag|drop)|click/,ke=/^([^.]*)(?:\.(.+)|)/;function Ce(){return!0}function Pe(){return!1}function Ie(e,t){return e===function(){try{return s.activeElement}catch(e){}}()==("focus"===t)}function Te(e,t,n,r,i,o){var s,a;if("object"==typeof t){for(a in"string"!=typeof n&&(r=r||n,n=void 0),t)Te(e,a,n,r,t[a],o);return e}if(null==r&&null==i?(i=n,r=n=void 0):null==i&&("string"==typeof n?(i=r,r=void 0):(i=r,r=n,n=void 0)),!1===i)i=Pe;else if(!i)return e;return 1===o&&(s=i,(i=function(e){return M().off(e),s.apply(this,arguments)}).guid=s.guid||(s.guid=M.guid++)),e.each(function(){M.event.add(this,t,i,r,n)})}function Oe(e,t,n){n?(Z.set(e,t,!1),M.event.add(e,t,{namespace:!1,handler:function(e){var r,i,o=Z.get(this,t);if(1&e.isTrigger&&this[t]){if(o.length)(M.event.special[t]||{}).delegateType&&e.stopPropagation();else if(o=c.call(arguments),Z.set(this,t,o),r=n(this,t),this[t](),o!==(i=Z.get(this,t))||r?Z.set(this,t,!1):i={},o!==i)return e.stopImmediatePropagation(),e.preventDefault(),i.value}else o.length&&(Z.set(this,t,{value:M.event.trigger(M.extend(o[0],M.Event.prototype),o.slice(1),this)}),e.stopImmediatePropagation())}})):void 0===Z.get(e,t)&&M.event.add(e,t,Ce)}M.event={global:{},add:function(e,t,n,r,i){var o,s,a,c,u,f,h,d,l,p,m,b=Z.get(e);if(b)for(n.handler&&(n=(o=n).handler,i=o.selector),i&&M.find.matchesSelector(se,i),n.guid||(n.guid=M.guid++),(c=b.events)||(c=b.events={}),(s=b.handle)||(s=b.handle=function(t){return void 0!==M&&M.event.triggered!==t.type?M.event.dispatch.apply(e,arguments):void 0}),u=(t=(t||"").match(R)||[""]).length;u--;)l=m=(a=ke.exec(t[u])||[])[1],p=(a[2]||"").split(".").sort(),l&&(h=M.event.special[l]||{},l=(i?h.delegateType:h.bindType)||l,h=M.event.special[l]||{},f=M.extend({type:l,origType:m,data:r,handler:n,guid:n.guid,selector:i,needsContext:i&&M.expr.match.needsContext.test(i),namespace:p.join(".")},o),(d=c[l])||((d=c[l]=[]).delegateCount=0,h.setup&&!1!==h.setup.call(e,r,p,s)||e.addEventListener&&e.addEventListener(l,s)),h.add&&(h.add.call(e,f),f.handler.guid||(f.handler.guid=n.guid)),i?d.splice(d.delegateCount++,0,f):d.push(f),M.event.global[l]=!0)},remove:function(e,t,n,r,i){var o,s,a,c,u,f,h,d,l,p,m,b=Z.hasData(e)&&Z.get(e);if(b&&(c=b.events)){for(u=(t=(t||"").match(R)||[""]).length;u--;)if(l=m=(a=ke.exec(t[u])||[])[1],p=(a[2]||"").split(".").sort(),l){for(h=M.event.special[l]||{},d=c[l=(r?h.delegateType:h.bindType)||l]||[],a=a[2]&&new RegExp("(^|\\.)"+p.join("\\.(?:.*\\.|)")+"(\\.|$)"),s=o=d.length;o--;)f=d[o],!i&&m!==f.origType||n&&n.guid!==f.guid||a&&!a.test(f.namespace)||r&&r!==f.selector&&("**"!==r||!f.selector)||(d.splice(o,1),f.selector&&d.delegateCount--,h.remove&&h.remove.call(e,f));s&&!d.length&&(h.teardown&&!1!==h.teardown.call(e,p,b.handle)||M.removeEvent(e,l,b.handle),delete c[l])}else for(l in c)M.event.remove(e,l+t[u],n,r,!0);M.isEmptyObject(c)&&Z.remove(e,"handle events")}},dispatch:function(e){var t,n,r,i,o,s,a=M.event.fix(e),c=new Array(arguments.length),u=(Z.get(this,"events")||{})[a.type]||[],f=M.event.special[a.type]||{};for(c[0]=a,t=1;t=1))for(;u!==this;u=u.parentNode||this)if(1===u.nodeType&&("click"!==e.type||!0!==u.disabled)){for(o=[],s={},n=0;n-1:M.find(i,this,null,[u]).length),s[i]&&o.push(r);o.length&&a.push({elem:u,handlers:o})}return u=this,c\x20\t\r\n\f]*)[^>]*)\/>/gi,Le=/\s*$/g;function ze(e,t){return I(e,"table")&&I(11!==t.nodeType?t:t.firstChild,"tr")&&M(e).children("tbody")[0]||e}function Re(e){return e.type=(null!==e.getAttribute("type"))+"/"+e.type,e}function Ne(e){return"true/"===(e.type||"").slice(0,5)?e.type=e.type.slice(5):e.removeAttribute("type"),e}function qe(e,t){var n,r,i,o,s,a,c,u;if(1===t.nodeType){if(Z.hasData(e)&&(o=Z.access(e),s=Z.set(t,o),u=o.events))for(i in delete s.handle,s.events={},u)for(n=0,r=u[i].length;n1&&"string"==typeof p&&!v.checkClone&&Be.test(p))return e.each(function(i){var o=e.eq(i);m&&(t[0]=p.call(this,i,o.html())),We(o,t,n,r)});if(d&&(o=(i=Se(t,e[0].ownerDocument,!1,e,r)).firstChild,1===i.childNodes.length&&(i=o),o||r)){for(a=(s=M.map(ye(i,"script"),Re)).length;h")},clone:function(e,t,n){var r,i,o,s,a=e.cloneNode(!0),c=ae(e);if(!(v.noCloneChecked||1!==e.nodeType&&11!==e.nodeType||M.isXMLDoc(e)))for(s=ye(a),r=0,i=(o=ye(e)).length;r0&&_e(s,!c&&ye(e,"script")),a},cleanData:function(e){for(var t,n,r,i=M.event.special,o=0;void 0!==(n=e[o]);o++)if(G(n)){if(t=n[Z.expando]){if(t.events)for(r in t.events)i[r]?M.event.remove(n,r):M.removeEvent(n,r,t.handle);n[Z.expando]=void 0}n[Q.expando]&&(n[Q.expando]=void 0)}}}),M.fn.extend({detach:function(e){return Fe(this,e,!0)},remove:function(e){return Fe(this,e)},text:function(e){return K(this,function(e){return void 0===e?M.text(this):this.empty().each(function(){1!==this.nodeType&&11!==this.nodeType&&9!==this.nodeType||(this.textContent=e)})},null,e,arguments.length)},append:function(){return We(this,arguments,function(e){1!==this.nodeType&&11!==this.nodeType&&9!==this.nodeType||ze(this,e).appendChild(e)})},prepend:function(){return We(this,arguments,function(e){if(1===this.nodeType||11===this.nodeType||9===this.nodeType){var t=ze(this,e);t.insertBefore(e,t.firstChild)}})},before:function(){return We(this,arguments,function(e){this.parentNode&&this.parentNode.insertBefore(e,this)})},after:function(){return We(this,arguments,function(e){this.parentNode&&this.parentNode.insertBefore(e,this.nextSibling)})},empty:function(){for(var e,t=0;null!=(e=this[t]);t++)1===e.nodeType&&(M.cleanData(ye(e,!1)),e.textContent="");return this},clone:function(e,t){return e=null!=e&&e,t=null==t?e:t,this.map(function(){return M.clone(this,e,t)})},html:function(e){return K(this,function(e){var t=this[0]||{},n=0,r=this.length;if(void 0===e&&1===t.nodeType)return t.innerHTML;if("string"==typeof e&&!Le.test(e)&&!ge[(be.exec(e)||["",""])[1].toLowerCase()]){e=M.htmlPrefilter(e);try{for(;n=0&&(c+=Math.max(0,Math.ceil(e["offset"+t[0].toUpperCase()+t.slice(1)]-o-c-a-.5))||0),c}function ot(e,t,n){var r=Ke(e),i=(!v.boxSizingReliable()||n)&&"border-box"===M.css(e,"boxSizing",!1,r),o=i,s=Ye(e,t,r),a="offset"+t[0].toUpperCase()+t.slice(1);if(Ue.test(s)){if(!n)return s;s="auto"}return(!v.boxSizingReliable()&&i||"auto"===s||!parseFloat(s)&&"inline"===M.css(e,"display",!1,r))&&e.getClientRects().length&&(i="border-box"===M.css(e,"boxSizing",!1,r),(o=a in e)&&(s=e[a])),(s=parseFloat(s)||0)+it(e,t,n||(i?"border":"content"),o,r,s)+"px"}function st(e,t,n,r,i){return new st.prototype.init(e,t,n,r,i)}M.extend({cssHooks:{opacity:{get:function(e,t){if(t){var n=Ye(e,"opacity");return""===n?"1":n}}}},cssNumber:{animationIterationCount:!0,columnCount:!0,fillOpacity:!0,flexGrow:!0,flexShrink:!0,fontWeight:!0,gridArea:!0,gridColumn:!0,gridColumnEnd:!0,gridColumnStart:!0,gridRow:!0,gridRowEnd:!0,gridRowStart:!0,lineHeight:!0,opacity:!0,order:!0,orphans:!0,widows:!0,zIndex:!0,zoom:!0},cssProps:{},style:function(e,t,n,r){if(e&&3!==e.nodeType&&8!==e.nodeType&&e.style){var i,o,s,a=$(t),c=et.test(t),u=e.style;if(c||(t=Ze(a)),s=M.cssHooks[t]||M.cssHooks[a],void 0===n)return s&&"get"in s&&void 0!==(i=s.get(e,!1,r))?i:u[t];"string"===(o=typeof n)&&(i=ie.exec(n))&&i[1]&&(n=he(e,t,i),o="number"),null!=n&&n==n&&("number"!==o||c||(n+=i&&i[3]||(M.cssNumber[a]?"":"px")),v.clearCloneStyle||""!==n||0!==t.indexOf("background")||(u[t]="inherit"),s&&"set"in s&&void 0===(n=s.set(e,n,r))||(c?u.setProperty(t,n):u[t]=n))}},css:function(e,t,n,r){var i,o,s,a=$(t);return et.test(t)||(t=Ze(a)),(s=M.cssHooks[t]||M.cssHooks[a])&&"get"in s&&(i=s.get(e,!0,n)),void 0===i&&(i=Ye(e,t,r)),"normal"===i&&t in nt&&(i=nt[t]),""===n||n?(o=parseFloat(i),!0===n||isFinite(o)?o||0:i):i}}),M.each(["height","width"],function(e,t){M.cssHooks[t]={get:function(e,n,r){if(n)return!Qe.test(M.css(e,"display"))||e.getClientRects().length&&e.getBoundingClientRect().width?ot(e,t,r):fe(e,tt,function(){return ot(e,t,r)})},set:function(e,n,r){var i,o=Ke(e),s=!v.scrollboxSize()&&"absolute"===o.position,a=(s||r)&&"border-box"===M.css(e,"boxSizing",!1,o),c=r?it(e,t,r,a,o):0;return a&&s&&(c-=Math.ceil(e["offset"+t[0].toUpperCase()+t.slice(1)]-parseFloat(o[t])-it(e,t,"border",!1,o)-.5)),c&&(i=ie.exec(n))&&"px"!==(i[3]||"px")&&(e.style[t]=n,n=M.css(e,t)),rt(0,n,c)}}}),M.cssHooks.marginLeft=Xe(v.reliableMarginLeft,function(e,t){if(t)return(parseFloat(Ye(e,"marginLeft"))||e.getBoundingClientRect().left-fe(e,{marginLeft:0},function(){return e.getBoundingClientRect().left}))+"px"}),M.each({margin:"",padding:"",border:"Width"},function(e,t){M.cssHooks[e+t]={expand:function(n){for(var r=0,i={},o="string"==typeof n?n.split(" "):[n];r<4;r++)i[e+oe[r]+t]=o[r]||o[r-2]||o[0];return i}},"margin"!==e&&(M.cssHooks[e+t].set=rt)}),M.fn.extend({css:function(e,t){return K(this,function(e,t,n){var r,i,o={},s=0;if(Array.isArray(t)){for(r=Ke(e),i=t.length;s1)}}),M.Tween=st,st.prototype={constructor:st,init:function(e,t,n,r,i,o){this.elem=e,this.prop=n,this.easing=i||M.easing._default,this.options=t,this.start=this.now=this.cur(),this.end=r,this.unit=o||(M.cssNumber[n]?"":"px")},cur:function(){var e=st.propHooks[this.prop];return e&&e.get?e.get(this):st.propHooks._default.get(this)},run:function(e){var t,n=st.propHooks[this.prop];return this.options.duration?this.pos=t=M.easing[this.easing](e,this.options.duration*e,0,1,this.options.duration):this.pos=t=e,this.now=(this.end-this.start)*t+this.start,this.options.step&&this.options.step.call(this.elem,this.now,this),n&&n.set?n.set(this):st.propHooks._default.set(this),this}},st.prototype.init.prototype=st.prototype,st.propHooks={_default:{get:function(e){var t;return 1!==e.elem.nodeType||null!=e.elem[e.prop]&&null==e.elem.style[e.prop]?e.elem[e.prop]:(t=M.css(e.elem,e.prop,""))&&"auto"!==t?t:0},set:function(e){M.fx.step[e.prop]?M.fx.step[e.prop](e):1!==e.elem.nodeType||!M.cssHooks[e.prop]&&null==e.elem.style[Ze(e.prop)]?e.elem[e.prop]=e.now:M.style(e.elem,e.prop,e.now+e.unit)}}},st.propHooks.scrollTop=st.propHooks.scrollLeft={set:function(e){e.elem.nodeType&&e.elem.parentNode&&(e.elem[e.prop]=e.now)}},M.easing={linear:function(e){return e},swing:function(e){return.5-Math.cos(e*Math.PI)/2},_default:"swing"},M.fx=st.prototype.init,M.fx.step={};var at,ct,ut=/^(?:toggle|show|hide)$/,ft=/queueHooks$/;function ht(){ct&&(!1===s.hidden&&n.requestAnimationFrame?n.requestAnimationFrame(ht):n.setTimeout(ht,M.fx.interval),M.fx.tick())}function dt(){return n.setTimeout(function(){at=void 0}),at=Date.now()}function lt(e,t){var n,r=0,i={height:e};for(t=t?1:0;r<4;r+=2-t)i["margin"+(n=oe[r])]=i["padding"+n]=e;return t&&(i.opacity=i.width=e),i}function pt(e,t,n){for(var r,i=(mt.tweeners[t]||[]).concat(mt.tweeners["*"]),o=0,s=i.length;o1)},removeAttr:function(e){return this.each(function(){M.removeAttr(this,e)})}}),M.extend({attr:function(e,t,n){var r,i,o=e.nodeType;if(3!==o&&8!==o&&2!==o)return void 0===e.getAttribute?M.prop(e,t,n):(1===o&&M.isXMLDoc(e)||(i=M.attrHooks[t.toLowerCase()]||(M.expr.match.bool.test(t)?bt:void 0)),void 0!==n?null===n?void M.removeAttr(e,t):i&&"set"in i&&void 0!==(r=i.set(e,n,t))?r:(e.setAttribute(t,n+""),n):i&&"get"in i&&null!==(r=i.get(e,t))?r:null==(r=M.find.attr(e,t))?void 0:r)},attrHooks:{type:{set:function(e,t){if(!v.radioValue&&"radio"===t&&I(e,"input")){var n=e.value;return e.setAttribute("type",t),n&&(e.value=n),t}}}},removeAttr:function(e,t){var n,r=0,i=t&&t.match(R);if(i&&1===e.nodeType)for(;n=i[r++];)e.removeAttribute(n)}}),bt={set:function(e,t,n){return!1===t?M.removeAttr(e,n):e.setAttribute(n,n),n}},M.each(M.expr.match.bool.source.match(/\w+/g),function(e,t){var n=vt[t]||M.find.attr;vt[t]=function(e,t,r){var i,o,s=t.toLowerCase();return r||(o=vt[s],vt[s]=i,i=null!=n(e,t,r)?s:null,vt[s]=o),i}});var gt=/^(?:input|select|textarea|button)$/i,yt=/^(?:a|area)$/i;function _t(e){return(e.match(R)||[]).join(" ")}function wt(e){return e.getAttribute&&e.getAttribute("class")||""}function xt(e){return Array.isArray(e)?e:"string"==typeof e&&e.match(R)||[]}M.fn.extend({prop:function(e,t){return K(this,M.prop,e,t,arguments.length>1)},removeProp:function(e){return this.each(function(){delete this[M.propFix[e]||e]})}}),M.extend({prop:function(e,t,n){var r,i,o=e.nodeType;if(3!==o&&8!==o&&2!==o)return 1===o&&M.isXMLDoc(e)||(t=M.propFix[t]||t,i=M.propHooks[t]),void 0!==n?i&&"set"in i&&void 0!==(r=i.set(e,n,t))?r:e[t]=n:i&&"get"in i&&null!==(r=i.get(e,t))?r:e[t]},propHooks:{tabIndex:{get:function(e){var t=M.find.attr(e,"tabindex");return t?parseInt(t,10):gt.test(e.nodeName)||yt.test(e.nodeName)&&e.href?0:-1}}},propFix:{for:"htmlFor",class:"className"}}),v.optSelected||(M.propHooks.selected={get:function(e){var t=e.parentNode;return t&&t.parentNode&&t.parentNode.selectedIndex,null},set:function(e){var t=e.parentNode;t&&(t.selectedIndex,t.parentNode&&t.parentNode.selectedIndex)}}),M.each(["tabIndex","readOnly","maxLength","cellSpacing","cellPadding","rowSpan","colSpan","useMap","frameBorder","contentEditable"],function(){M.propFix[this.toLowerCase()]=this}),M.fn.extend({addClass:function(e){var t,n,r,i,o,s,a,c=0;if(g(e))return this.each(function(t){M(this).addClass(e.call(this,t,wt(this)))});if((t=xt(e)).length)for(;n=this[c++];)if(i=wt(n),r=1===n.nodeType&&" "+_t(i)+" "){for(s=0;o=t[s++];)r.indexOf(" "+o+" ")<0&&(r+=o+" ");i!==(a=_t(r))&&n.setAttribute("class",a)}return this},removeClass:function(e){var t,n,r,i,o,s,a,c=0;if(g(e))return this.each(function(t){M(this).removeClass(e.call(this,t,wt(this)))});if(!arguments.length)return this.attr("class","");if((t=xt(e)).length)for(;n=this[c++];)if(i=wt(n),r=1===n.nodeType&&" "+_t(i)+" "){for(s=0;o=t[s++];)for(;r.indexOf(" "+o+" ")>-1;)r=r.replace(" "+o+" "," ");i!==(a=_t(r))&&n.setAttribute("class",a)}return this},toggleClass:function(e,t){var n=typeof e,r="string"===n||Array.isArray(e);return"boolean"==typeof t&&r?t?this.addClass(e):this.removeClass(e):g(e)?this.each(function(n){M(this).toggleClass(e.call(this,n,wt(this),t),t)}):this.each(function(){var t,i,o,s;if(r)for(i=0,o=M(this),s=xt(e);t=s[i++];)o.hasClass(t)?o.removeClass(t):o.addClass(t);else void 0!==e&&"boolean"!==n||((t=wt(this))&&Z.set(this,"__className__",t),this.setAttribute&&this.setAttribute("class",t||!1===e?"":Z.get(this,"__className__")||""))})},hasClass:function(e){var t,n,r=0;for(t=" "+e+" ";n=this[r++];)if(1===n.nodeType&&(" "+_t(wt(n))+" ").indexOf(t)>-1)return!0;return!1}});var Mt=/\r/g;M.fn.extend({val:function(e){var t,n,r,i=this[0];return arguments.length?(r=g(e),this.each(function(n){var i;1===this.nodeType&&(null==(i=r?e.call(this,n,M(this).val()):e)?i="":"number"==typeof i?i+="":Array.isArray(i)&&(i=M.map(i,function(e){return null==e?"":e+""})),(t=M.valHooks[this.type]||M.valHooks[this.nodeName.toLowerCase()])&&"set"in t&&void 0!==t.set(this,i,"value")||(this.value=i))})):i?(t=M.valHooks[i.type]||M.valHooks[i.nodeName.toLowerCase()])&&"get"in t&&void 0!==(n=t.get(i,"value"))?n:"string"==typeof(n=i.value)?n.replace(Mt,""):null==n?"":n:void 0}}),M.extend({valHooks:{option:{get:function(e){var t=M.find.attr(e,"value");return null!=t?t:_t(M.text(e))}},select:{get:function(e){var t,n,r,i=e.options,o=e.selectedIndex,s="select-one"===e.type,a=s?null:[],c=s?o+1:i.length;for(r=o<0?c:s?o:0;r-1)&&(n=!0);return n||(e.selectedIndex=-1),o}}}}),M.each(["radio","checkbox"],function(){M.valHooks[this]={set:function(e,t){if(Array.isArray(t))return e.checked=M.inArray(M(e).val(),t)>-1}},v.checkOn||(M.valHooks[this].get=function(e){return null===e.getAttribute("value")?"on":e.value})}),v.focusin="onfocusin"in n;var St=/^(?:focusinfocus|focusoutblur)$/,Et=function(e){e.stopPropagation()};M.extend(M.event,{trigger:function(e,t,r,i){var o,a,c,u,f,h,d,l,m=[r||s],b=p.call(e,"type")?e.type:e,v=p.call(e,"namespace")?e.namespace.split("."):[];if(a=l=c=r=r||s,3!==r.nodeType&&8!==r.nodeType&&!St.test(b+M.event.triggered)&&(b.indexOf(".")>-1&&(v=b.split("."),b=v.shift(),v.sort()),f=b.indexOf(":")<0&&"on"+b,(e=e[M.expando]?e:new M.Event(b,"object"==typeof e&&e)).isTrigger=i?2:3,e.namespace=v.join("."),e.rnamespace=e.namespace?new RegExp("(^|\\.)"+v.join("\\.(?:.*\\.|)")+"(\\.|$)"):null,e.result=void 0,e.target||(e.target=r),t=null==t?[e]:M.makeArray(t,[e]),d=M.event.special[b]||{},i||!d.trigger||!1!==d.trigger.apply(r,t))){if(!i&&!d.noBubble&&!y(r)){for(u=d.delegateType||b,St.test(u+b)||(a=a.parentNode);a;a=a.parentNode)m.push(a),c=a;c===(r.ownerDocument||s)&&m.push(c.defaultView||c.parentWindow||n)}for(o=0;(a=m[o++])&&!e.isPropagationStopped();)l=a,e.type=o>1?u:d.bindType||b,(h=(Z.get(a,"events")||{})[e.type]&&Z.get(a,"handle"))&&h.apply(a,t),(h=f&&a[f])&&h.apply&&G(a)&&(e.result=h.apply(a,t),!1===e.result&&e.preventDefault());return e.type=b,i||e.isDefaultPrevented()||d._default&&!1!==d._default.apply(m.pop(),t)||!G(r)||f&&g(r[b])&&!y(r)&&((c=r[f])&&(r[f]=null),M.event.triggered=b,e.isPropagationStopped()&&l.addEventListener(b,Et),r[b](),e.isPropagationStopped()&&l.removeEventListener(b,Et),M.event.triggered=void 0,c&&(r[f]=c)),e.result}},simulate:function(e,t,n){var r=M.extend(new M.Event,n,{type:e,isSimulated:!0});M.event.trigger(r,null,t)}}),M.fn.extend({trigger:function(e,t){return this.each(function(){M.event.trigger(e,t,this)})},triggerHandler:function(e,t){var n=this[0];if(n)return M.event.trigger(e,t,n,!0)}}),v.focusin||M.each({focus:"focusin",blur:"focusout"},function(e,t){var n=function(e){M.event.simulate(t,e.target,M.event.fix(e))};M.event.special[t]={setup:function(){var r=this.ownerDocument||this,i=Z.access(r,t);i||r.addEventListener(e,n,!0),Z.access(r,t,(i||0)+1)},teardown:function(){var r=this.ownerDocument||this,i=Z.access(r,t)-1;i?Z.access(r,t,i):(r.removeEventListener(e,n,!0),Z.remove(r,t))}}});var At=n.location,kt=Date.now(),Ct=/\?/;M.parseXML=function(e){var t;if(!e||"string"!=typeof e)return null;try{t=(new n.DOMParser).parseFromString(e,"text/xml")}catch(e){t=void 0}return t&&!t.getElementsByTagName("parsererror").length||M.error("Invalid XML: "+e),t};var Pt=/\[\]$/,It=/\r?\n/g,Tt=/^(?:submit|button|image|reset|file)$/i,Ot=/^(?:input|select|textarea|keygen)/i;function jt(e,t,n,r){var i;if(Array.isArray(t))M.each(t,function(t,i){n||Pt.test(e)?r(e,i):jt(e+"["+("object"==typeof i&&null!=i?t:"")+"]",i,n,r)});else if(n||"object"!==x(t))r(e,t);else for(i in t)jt(e+"["+i+"]",t[i],n,r)}M.param=function(e,t){var n,r=[],i=function(e,t){var n=g(t)?t():t;r[r.length]=encodeURIComponent(e)+"="+encodeURIComponent(null==n?"":n)};if(null==e)return"";if(Array.isArray(e)||e.jquery&&!M.isPlainObject(e))M.each(e,function(){i(this.name,this.value)});else for(n in e)jt(n,e[n],t,i);return r.join("&")},M.fn.extend({serialize:function(){return M.param(this.serializeArray())},serializeArray:function(){return this.map(function(){var e=M.prop(this,"elements");return e?M.makeArray(e):this}).filter(function(){var e=this.type;return this.name&&!M(this).is(":disabled")&&Ot.test(this.nodeName)&&!Tt.test(e)&&(this.checked||!me.test(e))}).map(function(e,t){var n=M(this).val();return null==n?null:Array.isArray(n)?M.map(n,function(e){return{name:t.name,value:e.replace(It,"\r\n")}}):{name:t.name,value:n.replace(It,"\r\n")}}).get()}});var Lt=/%20/g,Bt=/#.*$/,Dt=/([?&])_=[^&]*/,zt=/^(.*?):[ \t]*([^\r\n]*)$/gm,Rt=/^(?:GET|HEAD)$/,Nt=/^\/\//,qt={},Ht={},Wt="*/".concat("*"),Ft=s.createElement("a");function Ut(e){return function(t,n){"string"!=typeof t&&(n=t,t="*");var r,i=0,o=t.toLowerCase().match(R)||[];if(g(n))for(;r=o[i++];)"+"===r[0]?(r=r.slice(1)||"*",(e[r]=e[r]||[]).unshift(n)):(e[r]=e[r]||[]).push(n)}}function Kt(e,t,n,r){var i={},o=e===Ht;function s(a){var c;return i[a]=!0,M.each(e[a]||[],function(e,a){var u=a(t,n,r);return"string"!=typeof u||o||i[u]?o?!(c=u):void 0:(t.dataTypes.unshift(u),s(u),!1)}),c}return s(t.dataTypes[0])||!i["*"]&&s("*")}function Vt(e,t){var n,r,i=M.ajaxSettings.flatOptions||{};for(n in t)void 0!==t[n]&&((i[n]?e:r||(r={}))[n]=t[n]);return r&&M.extend(!0,e,r),e}Ft.href=At.href,M.extend({active:0,lastModified:{},etag:{},ajaxSettings:{url:At.href,type:"GET",isLocal:/^(?:about|app|app-storage|.+-extension|file|res|widget):$/.test(At.protocol),global:!0,processData:!0,async:!0,contentType:"application/x-www-form-urlencoded; charset=UTF-8",accepts:{"*":Wt,text:"text/plain",html:"text/html",xml:"application/xml, text/xml",json:"application/json, text/javascript"},contents:{xml:/\bxml\b/,html:/\bhtml/,json:/\bjson\b/},responseFields:{xml:"responseXML",text:"responseText",json:"responseJSON"},converters:{"* text":String,"text html":!0,"text json":JSON.parse,"text xml":M.parseXML},flatOptions:{url:!0,context:!0}},ajaxSetup:function(e,t){return t?Vt(Vt(e,M.ajaxSettings),t):Vt(M.ajaxSettings,e)},ajaxPrefilter:Ut(qt),ajaxTransport:Ut(Ht),ajax:function(e,t){"object"==typeof e&&(t=e,e=void 0),t=t||{};var r,i,o,a,c,u,f,h,d,l,p=M.ajaxSetup({},t),m=p.context||p,b=p.context&&(m.nodeType||m.jquery)?M(m):M.event,v=M.Deferred(),g=M.Callbacks("once memory"),y=p.statusCode||{},_={},w={},x="canceled",S={readyState:0,getResponseHeader:function(e){var t;if(f){if(!a)for(a={};t=zt.exec(o);)a[t[1].toLowerCase()+" "]=(a[t[1].toLowerCase()+" "]||[]).concat(t[2]);t=a[e.toLowerCase()+" "]}return null==t?null:t.join(", ")},getAllResponseHeaders:function(){return f?o:null},setRequestHeader:function(e,t){return null==f&&(e=w[e.toLowerCase()]=w[e.toLowerCase()]||e,_[e]=t),this},overrideMimeType:function(e){return null==f&&(p.mimeType=e),this},statusCode:function(e){var t;if(e)if(f)S.always(e[S.status]);else for(t in e)y[t]=[y[t],e[t]];return this},abort:function(e){var t=e||x;return r&&r.abort(t),E(0,t),this}};if(v.promise(S),p.url=((e||p.url||At.href)+"").replace(Nt,At.protocol+"//"),p.type=t.method||t.type||p.method||p.type,p.dataTypes=(p.dataType||"*").toLowerCase().match(R)||[""],null==p.crossDomain){u=s.createElement("a");try{u.href=p.url,u.href=u.href,p.crossDomain=Ft.protocol+"//"+Ft.host!=u.protocol+"//"+u.host}catch(e){p.crossDomain=!0}}if(p.data&&p.processData&&"string"!=typeof p.data&&(p.data=M.param(p.data,p.traditional)),Kt(qt,p,t,S),f)return S;for(d in(h=M.event&&p.global)&&0==M.active++&&M.event.trigger("ajaxStart"),p.type=p.type.toUpperCase(),p.hasContent=!Rt.test(p.type),i=p.url.replace(Bt,""),p.hasContent?p.data&&p.processData&&0===(p.contentType||"").indexOf("application/x-www-form-urlencoded")&&(p.data=p.data.replace(Lt,"+")):(l=p.url.slice(i.length),p.data&&(p.processData||"string"==typeof p.data)&&(i+=(Ct.test(i)?"&":"?")+p.data,delete p.data),!1===p.cache&&(i=i.replace(Dt,"$1"),l=(Ct.test(i)?"&":"?")+"_="+kt+++l),p.url=i+l),p.ifModified&&(M.lastModified[i]&&S.setRequestHeader("If-Modified-Since",M.lastModified[i]),M.etag[i]&&S.setRequestHeader("If-None-Match",M.etag[i])),(p.data&&p.hasContent&&!1!==p.contentType||t.contentType)&&S.setRequestHeader("Content-Type",p.contentType),S.setRequestHeader("Accept",p.dataTypes[0]&&p.accepts[p.dataTypes[0]]?p.accepts[p.dataTypes[0]]+("*"!==p.dataTypes[0]?", "+Wt+"; q=0.01":""):p.accepts["*"]),p.headers)S.setRequestHeader(d,p.headers[d]);if(p.beforeSend&&(!1===p.beforeSend.call(m,S,p)||f))return S.abort();if(x="abort",g.add(p.complete),S.done(p.success),S.fail(p.error),r=Kt(Ht,p,t,S)){if(S.readyState=1,h&&b.trigger("ajaxSend",[S,p]),f)return S;p.async&&p.timeout>0&&(c=n.setTimeout(function(){S.abort("timeout")},p.timeout));try{f=!1,r.send(_,E)}catch(e){if(f)throw e;E(-1,e)}}else E(-1,"No Transport");function E(e,t,s,a){var u,d,l,_,w,x=t;f||(f=!0,c&&n.clearTimeout(c),r=void 0,o=a||"",S.readyState=e>0?4:0,u=e>=200&&e<300||304===e,s&&(_=function(e,t,n){for(var r,i,o,s,a=e.contents,c=e.dataTypes;"*"===c[0];)c.shift(),void 0===r&&(r=e.mimeType||t.getResponseHeader("Content-Type"));if(r)for(i in a)if(a[i]&&a[i].test(r)){c.unshift(i);break}if(c[0]in n)o=c[0];else{for(i in n){if(!c[0]||e.converters[i+" "+c[0]]){o=i;break}s||(s=i)}o=o||s}if(o)return o!==c[0]&&c.unshift(o),n[o]}(p,S,s)),_=function(e,t,n,r){var i,o,s,a,c,u={},f=e.dataTypes.slice();if(f[1])for(s in e.converters)u[s.toLowerCase()]=e.converters[s];for(o=f.shift();o;)if(e.responseFields[o]&&(n[e.responseFields[o]]=t),!c&&r&&e.dataFilter&&(t=e.dataFilter(t,e.dataType)),c=o,o=f.shift())if("*"===o)o=c;else if("*"!==c&&c!==o){if(!(s=u[c+" "+o]||u["* "+o]))for(i in u)if((a=i.split(" "))[1]===o&&(s=u[c+" "+a[0]]||u["* "+a[0]])){!0===s?s=u[i]:!0!==u[i]&&(o=a[0],f.unshift(a[1]));break}if(!0!==s)if(s&&e.throws)t=s(t);else try{t=s(t)}catch(e){return{state:"parsererror",error:s?e:"No conversion from "+c+" to "+o}}}return{state:"success",data:t}}(p,_,S,u),u?(p.ifModified&&((w=S.getResponseHeader("Last-Modified"))&&(M.lastModified[i]=w),(w=S.getResponseHeader("etag"))&&(M.etag[i]=w)),204===e||"HEAD"===p.type?x="nocontent":304===e?x="notmodified":(x=_.state,d=_.data,u=!(l=_.error))):(l=x,!e&&x||(x="error",e<0&&(e=0))),S.status=e,S.statusText=(t||x)+"",u?v.resolveWith(m,[d,x,S]):v.rejectWith(m,[S,x,l]),S.statusCode(y),y=void 0,h&&b.trigger(u?"ajaxSuccess":"ajaxError",[S,p,u?d:l]),g.fireWith(m,[S,x]),h&&(b.trigger("ajaxComplete",[S,p]),--M.active||M.event.trigger("ajaxStop")))}return S},getJSON:function(e,t,n){return M.get(e,t,n,"json")},getScript:function(e,t){return M.get(e,void 0,t,"script")}}),M.each(["get","post"],function(e,t){M[t]=function(e,n,r,i){return g(n)&&(i=i||r,r=n,n=void 0),M.ajax(M.extend({url:e,type:t,dataType:i,data:n,success:r},M.isPlainObject(e)&&e))}}),M._evalUrl=function(e,t){return M.ajax({url:e,type:"GET",dataType:"script",cache:!0,async:!1,global:!1,converters:{"text script":function(){}},dataFilter:function(e){M.globalEval(e,t)}})},M.fn.extend({wrapAll:function(e){var t;return this[0]&&(g(e)&&(e=e.call(this[0])),t=M(e,this[0].ownerDocument).eq(0).clone(!0),this[0].parentNode&&t.insertBefore(this[0]),t.map(function(){for(var e=this;e.firstElementChild;)e=e.firstElementChild;return e}).append(this)),this},wrapInner:function(e){return g(e)?this.each(function(t){M(this).wrapInner(e.call(this,t))}):this.each(function(){var t=M(this),n=t.contents();n.length?n.wrapAll(e):t.append(e)})},wrap:function(e){var t=g(e);return this.each(function(n){M(this).wrapAll(t?e.call(this,n):e)})},unwrap:function(e){return this.parent(e).not("body").each(function(){M(this).replaceWith(this.childNodes)}),this}}),M.expr.pseudos.hidden=function(e){return!M.expr.pseudos.visible(e)},M.expr.pseudos.visible=function(e){return!!(e.offsetWidth||e.offsetHeight||e.getClientRects().length)},M.ajaxSettings.xhr=function(){try{return new n.XMLHttpRequest}catch(e){}};var Yt={0:200,1223:204},Xt=M.ajaxSettings.xhr();v.cors=!!Xt&&"withCredentials"in Xt,v.ajax=Xt=!!Xt,M.ajaxTransport(function(e){var t,r;if(v.cors||Xt&&!e.crossDomain)return{send:function(i,o){var s,a=e.xhr();if(a.open(e.type,e.url,e.async,e.username,e.password),e.xhrFields)for(s in e.xhrFields)a[s]=e.xhrFields[s];for(s in e.mimeType&&a.overrideMimeType&&a.overrideMimeType(e.mimeType),e.crossDomain||i["X-Requested-With"]||(i["X-Requested-With"]="XMLHttpRequest"),i)a.setRequestHeader(s,i[s]);t=function(e){return function(){t&&(t=r=a.onload=a.onerror=a.onabort=a.ontimeout=a.onreadystatechange=null,"abort"===e?a.abort():"error"===e?"number"!=typeof a.status?o(0,"error"):o(a.status,a.statusText):o(Yt[a.status]||a.status,a.statusText,"text"!==(a.responseType||"text")||"string"!=typeof a.responseText?{binary:a.response}:{text:a.responseText},a.getAllResponseHeaders()))}},a.onload=t(),r=a.onerror=a.ontimeout=t("error"),void 0!==a.onabort?a.onabort=r:a.onreadystatechange=function(){4===a.readyState&&n.setTimeout(function(){t&&r()})},t=t("abort");try{a.send(e.hasContent&&e.data||null)}catch(e){if(t)throw e}},abort:function(){t&&t()}}}),M.ajaxPrefilter(function(e){e.crossDomain&&(e.contents.script=!1)}),M.ajaxSetup({accepts:{script:"text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"},contents:{script:/\b(?:java|ecma)script\b/},converters:{"text script":function(e){return M.globalEval(e),e}}}),M.ajaxPrefilter("script",function(e){void 0===e.cache&&(e.cache=!1),e.crossDomain&&(e.type="GET")}),M.ajaxTransport("script",function(e){var t,n;if(e.crossDomain||e.scriptAttrs)return{send:function(r,i){t=M(" diff --git a/ipyvolume/vue/legend.vue b/ipyvolume/vue/legend.vue new file mode 100644 index 00000000..fc2e06ce --- /dev/null +++ b/ipyvolume/vue/legend.vue @@ -0,0 +1,118 @@ + + + diff --git a/ipyvolume/vue/popup.vue b/ipyvolume/vue/popup.vue new file mode 100644 index 00000000..59080a72 --- /dev/null +++ b/ipyvolume/vue/popup.vue @@ -0,0 +1,19 @@ + + + + + diff --git a/ipyvolume/widgets.py b/ipyvolume/widgets.py index 39f2e267..b6b512bb 100644 --- a/ipyvolume/widgets.py +++ b/ipyvolume/widgets.py @@ -14,6 +14,7 @@ import traitlets from traitlets import Unicode, Integer from traittypes import Array +from bqplot import scales import ipyvolume import ipyvolume as ipv # we should not have ipyvolume under two names either @@ -35,54 +36,36 @@ semver_range_frontend = "~" + ipyvolume._version.__version_js__ -@widgets.register -class Mesh(widgets.Widget): - _view_name = Unicode('MeshView').tag(sync=True) - _view_module = Unicode('ipyvolume').tag(sync=True) - _model_name = Unicode('MeshModel').tag(sync=True) - _model_module = Unicode('ipyvolume').tag(sync=True) - _view_module_version = Unicode(semver_range_frontend).tag(sync=True) - _model_module_version = Unicode(semver_range_frontend).tag(sync=True) - x = Array(default_value=None).tag(sync=True, **array_sequence_serialization) - y = Array(default_value=None).tag(sync=True, **array_sequence_serialization) - z = Array(default_value=None).tag(sync=True, **array_sequence_serialization) - u = Array(default_value=None, allow_none=True).tag(sync=True, **array_sequence_serialization) - v = Array(default_value=None, allow_none=True).tag(sync=True, **array_sequence_serialization) - triangles = Array(default_value=None, allow_none=True).tag(sync=True, **array_serialization) - lines = Array(default_value=None, allow_none=True).tag(sync=True, **array_serialization) - texture = traitlets.Union( - [ - traitlets.Instance(ipywebrtc.MediaStream), - Unicode(), - traitlets.List(Unicode, [], allow_none=True), - Image(default_value=None, allow_none=True), - traitlets.List(Image(default_value=None, allow_none=True)), - ] - ).tag(sync=True, **texture_serialization) +def _typefix(value): + if isinstance(value, (list, tuple)): + return [_typefix(k) for k in value] + else: + try: + value = value.item() + except: + pass + return value - sequence_index = Integer(default_value=0).tag(sync=True) - color = Array(default_value="red", allow_none=True).tag(sync=True, **color_serialization) - visible = traitlets.CBool(default_value=True).tag(sync=True) - material = traitlets.Instance( - pythreejs.ShaderMaterial, help='A :any:`pythreejs.ShaderMaterial` that is used for the mesh' - ).tag(sync=True, **widgets.widget_serialization) +class LegendData(traitlets.HasTraits): + # legend_name = Unicode('MeshModel').tag(sync=True) + description = Unicode('Label').tag(sync=True) + icon = Unicode('mdi-chart-bubble').tag(sync=True) + description_color = Unicode().tag(sync=True) - @traitlets.default('material') - def _default_material(self): - return pythreejs.ShaderMaterial(side=pythreejs.enums.Side.DoubleSide) - - line_material = traitlets.Instance( - pythreejs.ShaderMaterial, help='A :any:`pythreejs.ShaderMaterial` that is used for the lines/wireframe' - ).tag(sync=True, **widgets.widget_serialization) - - @traitlets.default('line_material') - def _default_line_material(self): - return pythreejs.ShaderMaterial() + @traitlets.default('description_color') + def _description_color(self): + value = self.color + while value.ndim >= 1 and not isinstance(value, str): + value = value[0] + value = value.item() + if not isinstance(value, str): + value = 'red' + return value @widgets.register -class Scatter(widgets.Widget): +class Scatter(widgets.Widget, LegendData): _view_name = Unicode('ScatterView').tag(sync=True) _view_module = Unicode('ipyvolume').tag(sync=True) _model_name = Unicode('ScatterModel').tag(sync=True) @@ -92,10 +75,19 @@ class Scatter(widgets.Widget): x = Array(default_value=None).tag(sync=True, **array_sequence_serialization) y = Array(default_value=None).tag(sync=True, **array_sequence_serialization) z = Array(default_value=None).tag(sync=True, **array_sequence_serialization) + aux = Array(default_value=None, allow_none=True).tag(sync=True, **array_sequence_serialization) + aux_scale = traitlets.Instance(scales.Scale, default_value=None, + allow_none=True).tag(sync=True, **widgets.widget_serialization) vx = Array(default_value=None, allow_none=True).tag(sync=True, **array_sequence_serialization) vy = Array(default_value=None, allow_none=True).tag(sync=True, **array_sequence_serialization) vz = Array(default_value=None, allow_none=True).tag(sync=True, **array_sequence_serialization) + color_scale = traitlets.Instance(scales.ColorScale, default_value=None, allow_none=True)\ + .tag(sync=True, **widgets.widget_serialization) selected = Array(default_value=None, allow_none=True).tag(sync=True, **array_sequence_serialization) + hovered = traitlets.Bool(default_value=None, allow_none=True).tag(sync=True) + clicked = traitlets.Bool(default_value=None, allow_none=True).tag(sync=True) + hovered_index = Integer(default_value=None, allow_none=True).tag(sync=True) + clicked_index = Integer(default_value=None, allow_none=True).tag(sync=True) sequence_index = Integer(default_value=0).tag(sync=True) size = traitlets.Union( [ @@ -111,36 +103,54 @@ class Scatter(widgets.Widget): ], default_value=7, ).tag(sync=True) + size_x_scale = traitlets.Instance(scales.Scale, default_value=None, + allow_none=True).tag(sync=True, **widgets.widget_serialization) + size_y_scale = traitlets.Instance(scales.Scale, default_value=None, + allow_none=True).tag(sync=True, **widgets.widget_serialization) + size_z_scale = traitlets.Instance(scales.Scale, default_value=None, + allow_none=True).tag(sync=True, **widgets.widget_serialization) color = Array(default_value="red", allow_none=True).tag(sync=True, **color_serialization) color_selected = traitlets.Union( [Array(default_value=None, allow_none=True).tag(sync=True, **color_serialization), Unicode().tag(sync=True)], default_value="green", ).tag(sync=True) geo = traitlets.Unicode('diamond').tag(sync=True) + geo_matrix = pythreejs.Matrix4().tag(sync=True) connected = traitlets.CBool(default_value=False).tag(sync=True) visible = traitlets.CBool(default_value=True).tag(sync=True) + shader_snippets = traitlets.Dict({'size': '\n'}).tag(sync=True) + + cast_shadow = traitlets.CBool(default_value=True).tag(sync=True) + receive_shadow = traitlets.CBool(default_value=True).tag(sync=True) + popup = traitlets.Instance(widgets.DOMWidget, default_value=None, allow_none=True).tag(sync=True, **widgets.widget_serialization) texture = traitlets.Union( [ traitlets.Instance(ipywebrtc.MediaStream), Unicode(), - traitlets.List(Unicode, [], allow_none=True), + traitlets.List(Unicode(), [], allow_none=True), Image(default_value=None, allow_none=True), traitlets.List(Image(default_value=None, allow_none=True)), ] ).tag(sync=True, **texture_serialization) - material = traitlets.Instance( - pythreejs.ShaderMaterial, help='A :any:`pythreejs.ShaderMaterial` that is used for the mesh' - ).tag(sync=True, **widgets.widget_serialization) + material = traitlets.Union([ + traitlets.Instance(pythreejs.ShaderMaterial), + traitlets.Instance(pythreejs.MeshPhysicalMaterial), + traitlets.Instance(pythreejs.MeshPhongMaterial), + traitlets.Instance(pythreejs.MeshLambertMaterial), + ], help='A :any:`pythreejs.Material` that is used for the mesh').tag(sync=True, **widgets.widget_serialization) @traitlets.default('material') def _default_material(self): return pythreejs.ShaderMaterial() - line_material = traitlets.Instance( - pythreejs.ShaderMaterial, help='A :any:`pythreejs.ShaderMaterial` that is used for the lines/wireframe' - ).tag(sync=True, **widgets.widget_serialization) + line_material = traitlets.Union([ + traitlets.Instance(pythreejs.ShaderMaterial), + traitlets.Instance(pythreejs.MeshPhysicalMaterial), + traitlets.Instance(pythreejs.MeshPhongMaterial), + traitlets.Instance(pythreejs.MeshLambertMaterial), + ], help='A :any:`pythreejs.Material` that is used for the lines/wireframe').tag(sync=True, **widgets.widget_serialization) @traitlets.default('line_material') def _default_line_material(self): @@ -148,7 +158,7 @@ def _default_line_material(self): @widgets.register -class Volume(widgets.Widget): +class Volume(widgets.Widget, LegendData): """Widget class representing a volume (rendering) using three.js.""" _view_name = Unicode('VolumeView').tag(sync=True) @@ -167,6 +177,7 @@ class Volume(widgets.Widget): show_max = traitlets.CFloat(1).tag(sync=True) clamp_min = traitlets.CBool(False).tag(sync=True) clamp_max = traitlets.CBool(False).tag(sync=True) + visible = traitlets.CBool(default_value=True).tag(sync=True) opacity_scale = traitlets.CFloat(1.0).tag(sync=True) brightness = traitlets.CFloat(1.0).tag(sync=True) tf = traitlets.Instance(TransferFunction, allow_none=True).tag(sync=True, **widgets.widget_serialization) @@ -182,6 +193,13 @@ class Volume(widgets.Widget): extent = traitlets.Any().tag(sync=True) extent_original = traitlets.Any() + clip_x_min = traitlets.CFloat(None, allow_none=True).tag(sync=True) + clip_x_max = traitlets.CFloat(None, allow_none=True).tag(sync=True) + clip_y_min = traitlets.CFloat(None, allow_none=True).tag(sync=True) + clip_y_max = traitlets.CFloat(None, allow_none=True).tag(sync=True) + clip_z_min = traitlets.CFloat(None, allow_none=True).tag(sync=True) + clip_z_max = traitlets.CFloat(None, allow_none=True).tag(sync=True) + def __init__(self, **kwargs): super(Volume, self).__init__(**kwargs) self._update_data() @@ -190,6 +208,14 @@ def __init__(self, **kwargs): def _listen_to(self, fig): fig.observe(self.update_data, ['xlim', 'ylim', 'zlim']) + material = traitlets.Union([ + traitlets.Instance(pythreejs.MeshPhongMaterial), + ], help='A :any:`pythreejs.MeshPhongMaterial` that is used for the shading of the volume').tag(sync=True, **widgets.widget_serialization) + + @traitlets.default('material') + def _default_material(self): + return pythreejs.MeshPhongMaterial() + @debounced(method=True) def update_data(self, change=None): self._update_data() @@ -210,13 +236,87 @@ def _update_data(self): viewx, xt = grid_slice(ex[0][0], ex[0][1], shape[2], *xlim) viewy, yt = grid_slice(ex[1][0], ex[1][1], shape[1], *ylim) viewz, zt = grid_slice(ex[2][0], ex[2][1], shape[0], *zlim) - view = [slice(*viewz), slice(*viewy), slice(*viewx)] + view = (slice(*viewz), slice(*viewy), slice(*viewx)) data_view = self.data_original[view] extent = [xt, yt, zt] data_view, extent = reduce_size(data_view, self.data_max_shape, extent) self.data = np.array(data_view) self.extent = extent + icon = Unicode('mdi-cube-outline').tag(sync=True) + + @traitlets.default('description_color') + def _description_color(self): + return 'blue' # maybe sth smarter? + + +@widgets.register +class Mesh(widgets.Widget, LegendData): + _view_name = Unicode('MeshView').tag(sync=True) + _view_module = Unicode('ipyvolume').tag(sync=True) + _model_name = Unicode('MeshModel').tag(sync=True) + _model_module = Unicode('ipyvolume').tag(sync=True) + _view_module_version = Unicode(semver_range_frontend).tag(sync=True) + _model_module_version = Unicode(semver_range_frontend).tag(sync=True) + x = Array(default_value=None).tag(sync=True, **array_sequence_serialization) + y = Array(default_value=None).tag(sync=True, **array_sequence_serialization) + z = Array(default_value=None).tag(sync=True, **array_sequence_serialization) + u = Array(default_value=None, allow_none=True).tag(sync=True, **array_sequence_serialization) + v = Array(default_value=None, allow_none=True).tag(sync=True, **array_sequence_serialization) + triangles = Array(default_value=None, allow_none=True).tag(sync=True, **array_serialization) + lines = Array(default_value=None, allow_none=True).tag(sync=True, **array_serialization) + color_scale = traitlets.Instance(scales.ColorScale, default_value=None, allow_none=True)\ + .tag(sync=True, **widgets.widget_serialization) + texture = traitlets.Union( + [ + traitlets.Instance(ipywebrtc.MediaStream), + Unicode(), + traitlets.List(Unicode(), [], allow_none=True), + Image(default_value=None, allow_none=True), + traitlets.List(Image(default_value=None, allow_none=True)), + ] + ).tag(sync=True, **texture_serialization) + volume = traitlets.Instance(Volume, allow_none=True, default_value=None).tag(sync=True, **widgets.widget_serialization) + + # these are useful for use-driven changes, and will be not animated + x_offset = traitlets.Float(0).tag(sync=True) + y_offset = traitlets.Float(0).tag(sync=True) + z_offset = traitlets.Float(0).tag(sync=True) + + hovered = traitlets.Bool(default_value=None, allow_none=True).tag(sync=True) + clicked = traitlets.Bool(default_value=None, allow_none=True).tag(sync=True) + sequence_index = Integer(default_value=0).tag(sync=True) + color = Array(default_value="red", allow_none=True).tag(sync=True, **color_serialization) + visible = traitlets.CBool(default_value=True).tag(sync=True) + + material = traitlets.Union([ + traitlets.Instance(pythreejs.ShaderMaterial), + traitlets.Instance(pythreejs.MeshPhysicalMaterial), + traitlets.Instance(pythreejs.MeshPhongMaterial), + traitlets.Instance(pythreejs.MeshLambertMaterial), + ], help='A :any:`pythreejs.Material` that is used for the mesh').tag(sync=True, **widgets.widget_serialization) + + @traitlets.default('material') + def _default_material(self): + return pythreejs.ShaderMaterial(side=pythreejs.enums.Side.DoubleSide) + + line_material = traitlets.Union([ + traitlets.Instance(pythreejs.ShaderMaterial), + traitlets.Instance(pythreejs.MeshPhysicalMaterial), + traitlets.Instance(pythreejs.MeshPhongMaterial), + traitlets.Instance(pythreejs.MeshLambertMaterial), + ], help='A :any:`pythreejs.Material` that is used for the lines/wireframe').tag(sync=True, **widgets.widget_serialization) + + @traitlets.default('line_material') + def _default_line_material(self): + return pythreejs.ShaderMaterial() + + cast_shadow = traitlets.CBool(default_value=True).tag(sync=True) + receive_shadow = traitlets.CBool(default_value=True).tag(sync=True) + + icon = Unicode('mdi-triforce').tag(sync=True) + popup = traitlets.Instance(widgets.DOMWidget, default_value=None, allow_none=True).tag(sync=True, **widgets.widget_serialization) + @widgets.register class Figure(ipywebrtc.MediaStream): @@ -240,6 +340,9 @@ class Figure(ipywebrtc.MediaStream): volumes = traitlets.List(traitlets.Instance(Volume), [], allow_none=False).tag( sync=True, **widgets.widget_serialization ) + lights = traitlets.List(traitlets.Instance(pythreejs.Light), [], allow_none=False).tag( + sync=True, **widgets.widget_serialization + ) animation = traitlets.Float(1000.0).tag(sync=True) animation_exponent = traitlets.Float(1.0).tag(sync=True) @@ -255,6 +358,8 @@ class Figure(ipywebrtc.MediaStream): camera_fov = traitlets.CFloat(45, min=0.1, max=179.9).tag(sync=True) camera_center = traitlets.List(traitlets.CFloat(), default_value=[0, 0, 0]).tag(sync=True) # Tuple(traitlets.CFloat(0), traitlets.CFloat(0), traitlets.CFloat(0)).tag(sync=True) + box_center = traitlets.List(traitlets.CFloat(), default_value=[0.5, 0.5, 0.5]).tag(sync=True) + box_size = traitlets.List(traitlets.CFloat(), default_value=[1, 1, 1]).tag(sync=True) camera = traitlets.Instance( pythreejs.Camera, allow_none=True, help='A :any:`pythreejs.Camera` instance to control the camera' @@ -264,8 +369,13 @@ class Figure(ipywebrtc.MediaStream): def _default_camera(self): # see https://github.com/maartenbreddels/ipyvolume/pull/40 for an explanation z = 2 * np.tan(45.0 / 2.0 * np.pi / 180) / np.tan(self.camera_fov / 2.0 * np.pi / 180) - return pythreejs.PerspectiveCamera(fov=self.camera_fov, position=(0, 0, z), width=400, height=500) + return pythreejs.PerspectiveCamera(fov=self.camera_fov, position=(0, 0, z), aspect=1) + controls = traitlets.Instance( + pythreejs.Controls, allow_none=True, help='A :any:`pythreejs.Controls` instance to control the camera' + ).tag(sync=True, **widgets.widget_serialization) + + orientation_control = traitlets.Bool(False).tag(sync=True) scene = traitlets.Instance(pythreejs.Scene, allow_none=True).tag(sync=True, **widgets.widget_serialization) @traitlets.default('scene') @@ -286,11 +396,38 @@ def _default_scene(self): capture_fps = traitlets.CFloat(None, allow_none=True).tag(sync=True) cube_resolution = traitlets.CInt(512).tag(sync=True) - show = traitlets.Unicode("Volume").tag(sync=True) # for debugging + show = traitlets.Unicode("render").tag(sync=True) # for debugging + popup_debouce = traitlets.CInt(100, help="Debouce popup in miliseconds").tag(sync=True) + + @property + def xlim(self): + return self.scales['x'].min, self.scales['x'].max + + @xlim.setter + def xlim(self, value): + self.scales['x'].min, self.scales['x'].max = _typefix(value) + + @property + def ylim(self): + return self.scales['y'].min, self.scales['y'].max + + @ylim.setter + def ylim(self, value): + self.scales['y'].min, self.scales['y'].max = _typefix(value) - xlim = traitlets.List(traitlets.CFloat(), default_value=[0, 1], minlen=2, maxlen=2).tag(sync=True) - ylim = traitlets.List(traitlets.CFloat(), default_value=[0, 1], minlen=2, maxlen=2).tag(sync=True) - zlim = traitlets.List(traitlets.CFloat(), default_value=[0, 1], minlen=2, maxlen=2).tag(sync=True) + @property + def zlim(self): + return self.scales['z'].min, self.scales['z'].max + + @zlim.setter + def zlim(self, value): + self.scales['z'].min, self.scales['z'].max = _typefix(value) + + scales = traitlets.Dict(value_trait=traitlets.Instance(scales.Scale)).tag(sync=True, **widgets.widget_serialization) + + @traitlets.default('scales') + def _default_scale(self): + return dict(x=scales.LinearScale(min=0, max=1), y=scales.LinearScale(min=0, max=1), z=scales.LinearScale(min=0, max=1)) matrix_projection = traitlets.List( traitlets.CFloat(), default_value=[0] * 16, allow_none=True, minlen=16, maxlen=16 @@ -311,6 +448,16 @@ def _default_scene(self): mouse_mode = traitlets.Unicode(default_value='normal').tag(sync=True) panorama_mode = traitlets.Enum(values=['no', '360', '180'], default_value='no').tag(sync=True) + slice_x = traitlets.Float(0).tag(sync=True) + slice_y = traitlets.Float(0).tag(sync=True) + slice_z = traitlets.Float(0).tag(sync=True) + + _shaders = traitlets.Dict(default_value={}).tag(sync=True) + + def _hot_reload(self): + from .hotreload import watch + watch(self) + # xlim = traitlets.Tuple(traitlets.CFloat(0), traitlets.CFloat(1)).tag(sync=True) # y#lim = traitlets.Tuple(traitlets.CFloat(0), traitlets.CFloat(1)).tag(sync=True) # zlim = traitlets.Tuple(traitlets.CFloat(0), traitlets.CFloat(1)).tag(sync=True) diff --git a/js/css/style.css b/js/css/style.css index 9e7a934a..3cea18e3 100644 --- a/js/css/style.css +++ b/js/css/style.css @@ -1,7 +1,7 @@ -.ipyvolume-toolicon { +a.ipyvolume-toolicon { text-align: center; padding: 2px 2px; /* Some top and bottom padding */ - color: #337ab7; + color: #1867c0; position: relative; display: inline-block; } @@ -31,9 +31,26 @@ box-shadow: 0px 8px 16px 0px rgba(0,0,0,0.2); background-color: #f9f9f9; padding-left: 2px; + font-family: Verdana, Geneva, Tahoma, sans-serif; } .ipyvolume-toolicon-dropdown { text-align: left; display: block; } + +.ipyvolume-popup-container { + position: absolute; + z-index: 3; + white-space: nowrap; +} + +.ipyvolume-canvas-container { + position: relative; + margin: 5px; /* otherwise we get scrollbars */ +} + +/* the default is white */ +.ipyvolume-popup-container > .p-Widget > .vuetify-styles > .v-application { + background-color: unset; +} diff --git a/js/glsl/ipyvolume.glsl b/js/glsl/ipyvolume.glsl new file mode 100644 index 00000000..8c22ea8f --- /dev/null +++ b/js/glsl/ipyvolume.glsl @@ -0,0 +1,48 @@ +struct Volume +{ + float opacity_scale; + float brightness; + vec2 data_range; + vec2 show_range; + float rows; + float columns; + float slices; + vec2 size; + vec2 slice_size; + bool clamp_min; + bool clamp_max; + vec3 scale; + vec3 offset; + bool lighting; + + // phong lighting models parameters + vec3 diffuseColor; + vec3 specular; + vec3 emissive; + float shininess; +}; + +vec2 compute_slice_offset(float slice, float columns, vec2 uv_slice_spacing) { + float column = floor((slice+0.5) / (columns)); + float row = slice - column * columns; + return uv_slice_spacing * vec2(row, column); +} + +vec4 sample_as_3d_texture(sampler2D tex, vec2 tex_size, vec3 texCoord, vec2 slice_size, float slices, float rows, float columns) { + float slice = texCoord.z*slices*(slices-1.)/slices ; + float slice_z = floor(slice); + float slice_z_offset = fract(slice); + + vec2 pixel = 1./tex_size; + vec2 uv_slice_spacing = slice_size/tex_size; + + vec2 coord = vec2(texCoord.x, texCoord.y); + vec2 uv = pixel * 0.5 + coord * (uv_slice_spacing - pixel); + + vec2 slice0_offset = compute_slice_offset(slice_z, columns, uv_slice_spacing); + vec2 slice1_offset = compute_slice_offset(slice_z + 1.0, columns, uv_slice_spacing); + + vec4 slice0_color = texture2D(tex, slice0_offset + uv); + vec4 slice1_color = texture2D(tex, slice1_offset + uv); + return mix(slice0_color, slice1_color, slice_z_offset); +} \ No newline at end of file diff --git a/js/glsl/mesh-fragment.glsl b/js/glsl/mesh-fragment.glsl index 55a663de..b1291455 100644 --- a/js/glsl/mesh-fragment.glsl +++ b/js/glsl/mesh-fragment.glsl @@ -1,6 +1,18 @@ +#include + +#ifdef USE_VOLUME +uniform sampler2D volume_texture; +uniform sampler2D transfer_function; +uniform Volume volume; +#endif //USE_VOLUME + + +// mesh-fragment shader +#if defined( AS_DEFAULT ) || defined( AS_COORDINATE ) || defined( AS_ID ) varying vec4 vertex_color; varying vec3 vertex_position; varying vec2 vertex_uv; +varying vec3 vPositionEye; #ifdef USE_TEXTURE uniform sampler2D texture; @@ -8,25 +20,397 @@ varying vec2 vertex_uv; uniform float animation_time_texture; #endif + // taken similar to phong shading + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + // #include + #include + #include // extra compared to phong -void main(void) { -#ifdef USE_RGB - gl_FragColor = vec4(vertex_color.rgb, 1.0); -#else -#ifdef AS_LINE - gl_FragColor = vec4(vertex_color.rgb, vertex_color.a); -#else - vec3 fdx = dFdx( vertex_position ); - vec3 fdy = dFdy( vertex_position ); - vec3 normal = normalize( cross( fdx, fdy ) ); - float diffuse = dot( normal, vec3( 0.0, 0.0, 1.0 ) ); + #include + #include + #include + #include + #include + void main(void) + { + #if defined( AS_COORDINATE ) || defined( AS_ID ) + // should we ignore shading for RGB pass? + gl_FragColor = vec4(vertex_color.rgb, 1.0); + #else + // 0 when in shadow, 1 if visible + float shadow_visibility = getShadowMask(); + #ifdef IS_LINE + gl_FragColor = vec4(vertex_color.rgb * shadow_visibility, vertex_color.a); + #else + vec3 fdx = dFdx( vPositionEye ); + vec3 fdy = dFdy( vPositionEye ); + vec3 normal = normalize( cross( fdx, fdy ) ); + float diffuse = dot( normal, vec3( 0.0, 0.0, 1.0 ) ); + + #if defined(USE_TEXTURE) + vec4 sample = mix(texture2D(texture_previous, vertex_uv), texture2D(texture, vertex_uv), animation_time_texture); + gl_FragColor = vec4(clamp(diffuse, 0.2, 1.) * sample.rgb * shadow_visibility, 1.0); + #elif defined(USE_VOLUME) + vec3 sample_position = vertex_position*volume.scale + vec3(0.5, 0.5, 0.5); + vec4 sample = sample_as_3d_texture(volume_texture, volume.size, sample_position, volume.slice_size, volume.slices, volume.rows, volume.columns); + + // quite similar to volr-fragment.glsl + float raw_data_value = sample.a; + float scaled_data_value = (raw_data_value*(volume.data_range[1] - volume.data_range[0])) + volume.data_range[0]; + float data_value = (scaled_data_value - volume.show_range[0])/(volume.show_range[1] - volume.show_range[0]); + vec4 color_sample = texture2D(transfer_function, vec2(data_value, 0.5)); + + // TODO: 30 should be configurable + gl_FragColor.rgb = color_sample.rgb * volume.brightness * color_sample.a * 30.; + gl_FragColor.a = 1.; + #else + gl_FragColor = vec4(clamp(diffuse, 0.2, 1.) * vertex_color.rgb * shadow_visibility, vertex_color.a); + #endif // USE_TEXTURE / USE_VOLUME + #endif // IS_LINE + #endif // defined( AS_COORDINATE ) || defined( AS_ID ) + } +#endif //defined( AS_DEFAULT ) || defined( AS_COORDINATE ) || defined( AS_ID ) + + + +#ifdef AS_LAMBERT +uniform vec3 diffuse; +uniform vec3 emissive; +uniform float opacity; + +varying vec3 vLightFront; + +#ifdef DOUBLE_SIDED + + varying vec3 vLightBack; + +#endif + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +void main() { + + #include + + vec4 diffuseColor = vec4( diffuse, opacity ); + ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) ); + vec3 totalEmissiveRadiance = emissive; + + #include + #include + #include + #include + #include + #include + #include + + // accumulation + reflectedLight.indirectDiffuse = getAmbientLightIrradiance( ambientLightColor ); + + #include + + reflectedLight.indirectDiffuse *= BRDF_Diffuse_Lambert( diffuseColor.rgb ); + + #ifdef DOUBLE_SIDED + + reflectedLight.directDiffuse = ( gl_FrontFacing ) ? vLightFront : vLightBack; + + #else + + reflectedLight.directDiffuse = vLightFront; + + #endif + + reflectedLight.directDiffuse *= BRDF_Diffuse_Lambert( diffuseColor.rgb ) * getShadowMask(); + + // modulation + #include + + vec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + totalEmissiveRadiance; + + #include + + gl_FragColor = vec4( outgoingLight, diffuseColor.a ); + + #include + #include + #include + #include + #include + +} +#endif //AS_LAMBERT +#ifdef AS_PHONG +#define PHONG + +uniform vec3 diffuse; +uniform vec3 emissive; +uniform vec3 specular; +uniform float shininess; +uniform float opacity; + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +void main() { + + #include + + vec4 diffuseColor = vec4( diffuse, opacity ); + ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) ); + vec3 totalEmissiveRadiance = emissive; + + #include + #include + #include + #include + #include + #include + #include + #include + #include + + // accumulation + #include + #include + #include + #include + + // modulation + #include + + vec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + reflectedLight.directSpecular + reflectedLight.indirectSpecular + totalEmissiveRadiance; + + #include + + gl_FragColor = vec4( outgoingLight, diffuseColor.a ); + + #include + #include + #include + #include + #include + +} +#endif //AS_PHONG +#ifdef AS_PHYSICAL + #define PHYSICAL + uniform vec3 diffuse; + uniform vec3 emissive; + uniform float roughness; + uniform float metalness; + uniform float opacity; + uniform float emissiveIntensity; + + #ifndef STANDARD + uniform float clearCoat; + uniform float clearCoatRoughness; + #endif + + varying vec3 vViewPosition; + + #ifndef FLAT_SHADED + varying vec3 vNormal; + #endif + + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + +void main(void) +{ + #include + + vec4 diffuseColor = vec4( 1.0, 1.0, 1.0, opacity ); + ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) ); + vec3 totalEmissiveRadiance = emissive * emissiveIntensity; + + #include + #include + #include + + #include + #include + #include + #include + #include + + #include + #include + + // accumulation + #include + #include + #include + #include + + // modulation + #include + + vec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + reflectedLight.directSpecular + reflectedLight.indirectSpecular + totalEmissiveRadiance; + gl_FragColor = vec4( outgoingLight, diffuseColor.a ); + + #include + #include + #include + #include + #include + +} +#endif //AS_PHYSICAL +#ifdef AS_DISTANCE +#define DISTANCE + +uniform vec3 referencePosition; +uniform float nearDistance; +uniform float farDistance; +varying vec3 vWorldPosition; + +#include +#include +#include +#include +#include +#include + +void main () { + + #include + + vec4 diffuseColor = vec4( 1.0 ); + + #include + #include + #include + + float dist = length( vWorldPosition - referencePosition ); + dist = ( dist - nearDistance ) / ( farDistance - nearDistance ); + dist = saturate( dist ); // clamp to [ 0, 1 ] + + gl_FragColor = packDepthToRGBA( dist ); + +} +#endif//AS_DISTANCE + +#ifdef AS_DEPTH +#if DEPTH_PACKING == 3200 + + uniform float opacity; + +#endif + +#include +#include +#include +#include +#include +#include +#include + +void main() { + + #include + + vec4 diffuseColor = vec4( 1.0 ); + + #if DEPTH_PACKING == 3200 + + diffuseColor.a = opacity; + + #endif + + #include + #include + #include + + #include + + #if DEPTH_PACKING == 3200 + + gl_FragColor = vec4( vec3( gl_FragCoord.z ), opacity ); + + #elif DEPTH_PACKING == 3201 + + gl_FragColor = packDepthToRGBA( gl_FragCoord.z ); + + #endif -#ifdef USE_TEXTURE - vec4 sample = mix(texture2D(texture_previous, vertex_uv), texture2D(texture, vertex_uv), animation_time_texture); - gl_FragColor = vec4(clamp(diffuse, 0.2, 1.) * sample.rgb, 1.0); -#else - gl_FragColor = vec4(clamp(diffuse, 0.2, 1.) * vertex_color.rgb, vertex_color.a); -#endif // USE_TEXTURE -#endif // AS_LINE -#endif // USE_RGB } +#endif //AS_DEPTH diff --git a/js/glsl/mesh-vertex.glsl b/js/glsl/mesh-vertex.glsl index e2e674c5..00221560 100644 --- a/js/glsl/mesh-vertex.glsl +++ b/js/glsl/mesh-vertex.glsl @@ -1,3 +1,11 @@ +// mesh-vertex shader +#define USE_SCALE_X +#define USE_SCALE_Y +#define USE_SCALE_Z +#include +#include + + // for animation, all between 0 and 1 uniform float animation_time_x; uniform float animation_time_y; @@ -6,14 +14,16 @@ uniform float animation_time_u; uniform float animation_time_v; uniform float animation_time_color; -uniform vec2 xlim; -uniform vec2 ylim; -uniform vec2 zlim; +uniform vec2 domain_x; +uniform vec2 domain_y; +uniform vec2 domain_z; varying vec4 vertex_color; varying vec3 vertex_position; +varying vec3 vPositionEye; attribute vec3 position_previous; +uniform vec3 position_offset; #ifdef USE_TEXTURE attribute float u; @@ -23,29 +33,344 @@ attribute vec3 position_previous; varying vec2 vertex_uv; #endif -attribute vec4 color; -attribute vec4 color_previous; +#ifdef USE_COLORMAP + attribute float color_current; + attribute float color_previous; + uniform vec2 domain_color; +#else + attribute vec4 color_current; + attribute vec4 color_previous; +#endif +uniform sampler2D colormap; + +uniform float id_offset; + +vec4 encodeId(float v) { + vec4 color; + // matches Figure.readId + color.b = floor(v / 256.0 / 256.0); + color.g = floor((v - color.b * 256.0 * 256.0) / 256.0); + color.r = floor(v - color.b * 256.0 * 256.0 - color.g * 256.0); + color.a = 255.0; + // normalize + return color / 255.0; +} + +#if defined( AS_DEFAULT ) || defined( AS_COORDINATE ) || defined( AS_ID ) + // similar to phong + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include +#endif //defined( AS_DEFAULT ) || defined( AS_COORDINATE ) || defined( AS_ID ) + +#ifdef AS_LAMBERT + #define LAMBERT + varying vec3 vLightFront; + + #ifdef DOUBLE_SIDED + varying vec3 vLightBack; + #endif + + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include +#endif //AS_LAMBERT + +#ifdef AS_PHONG + #define PHONG + varying vec3 vViewPosition; + + #ifndef FLAT_SHADED + varying vec3 vNormal; + #endif + + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include +#endif //AS_PHONG +#ifdef AS_PHYSICAL + #define PHYSICAL + varying vec3 vViewPosition; + #ifndef FLAT_SHADED + varying vec3 vNormal; + #endif + + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include +#endif //AS_PHYSICAL +#ifdef AS_DEPTH + #include + #include + #include + #include + #include + #include + #include +#endif //AS_DEPTH +#ifdef AS_DISTANCE + #define DISTANCE + + varying vec3 vWorldPosition; + + #include + #include + #include + #include + #include + #include +#endif //AS_DISTANCE void main(void) { - vec3 origin = vec3(xlim.x, ylim.x, zlim.x); - vec3 size_viewport = vec3(xlim.y, ylim.y, zlim.y) - origin; - - vec3 pos = (mix(position_previous, position, vec3(animation_time_x, animation_time_y, animation_time_z)) - - origin) / size_viewport - 0.5; - gl_Position = projectionMatrix * - modelViewMatrix * - vec4(pos,1.0); - vec3 positionEye = ( modelViewMatrix * vec4( pos, 1.0 ) ).xyz; - vertex_position = positionEye; +#if defined( AS_DEFAULT ) || defined( AS_COORDINATE ) || defined( AS_ID ) + #include + #include + #include + + #include + #include + #include + #include + #include + + #include +#endif //defined( AS_DEFAULT ) || defined( AS_COORDINATE ) || defined( AS_ID ) +#ifdef AS_LAMBERT + #include + #include + #include + + #include + #include + #include + #include + #include + + #include +#endif //AS_LAMBERT +#ifdef AS_PHONG + #include + #include + #include + + #include + #include + #include + #include + #include + + #ifndef FLAT_SHADED // Normal computed with derivatives when FLAT_SHADED + vNormal = normalize( transformedNormal ); + #endif + + #include +#endif //AS_PHONG +#ifdef AS_PHYSICAL + #include + #include + #include + + #include + #include + #include + #include + #include + + #ifndef FLAT_SHADED // Normal computed with derivatives when FLAT_SHADED + vNormal = normalize( transformedNormal ); + #endif + + #include +#endif //AS_PHYSICAL +#ifdef AS_DEPTH + #include + + #include + + #ifdef USE_DISPLACEMENTMAP + + #include + #include + #include + + #endif + + #include +#endif //AS_DEPTH +#ifdef AS_DISTANCE + #include + + #include + + #ifdef USE_DISPLACEMENTMAP + + #include + #include + #include + + #endif + + #include +#endif //AS_DISTANCE + + vec3 animation_time = vec3(animation_time_x, animation_time_y, animation_time_z); + vec3 animated_position = mix(position_previous, position, animation_time) + position_offset; + + transformed = vec3(SCALE_X(animated_position.x), SCALE_Y(animated_position.y), SCALE_Z(animated_position.z)); + vertex_position = transformed; + // gl_Position = projectionMatrix * + // modelViewMatrix * + // vec4(model_pos, 1.0); + // vec3 positionEye = ( modelViewMatrix * vec4(model_pos, 1.0 ) ).xyz; + // vertex_position = positionEye; + + #if defined( AS_COORDINATE ) + // vertex_color = vec4(model_pos + vec3(0.5, 0.5, 0.5), 1.0); + vertex_color = vec4(transformed + vec3(0.5, 0.5, 0.5), 1.0); + #elif defined( AS_ID ) + vertex_color = encodeId(id_offset); + #else + #ifdef USE_COLORMAP + float color_animated = mix(color_previous, color_current, animation_time_color); + float color_index = scale_transform_linear(color_animated, vec2(0.0, 1.0), domain_color); + vertex_color = texture2D(colormap, vec2(color_index, 0)); + #else + vertex_color = mix(color_previous, color_current, animation_time_color); + #endif + #endif + + +#if defined( AS_DEFAULT ) || defined( AS_COORDINATE ) || defined( AS_ID ) + gl_Position = projectionMatrix * modelViewMatrix * vec4( transformed, 1.0 );; + // vec3 model_pos = vec3(SCALE_X(animated_position.x), SCALE_Y(animated_position.y), SCALE_Z(animated_position.z)); + // gl_Position = projectionMatrix * + // modelViewMatrix * + // vec4(model_pos, 1.0); + // vec3 positionEye = ( modelViewMatrix * vec4(model_pos, 1.0 ) ).xyz; + // vertex_position = positionEye; +#endif //defined( AS_DEFAULT ) || defined( AS_COORDINATE ) || defined( AS_ID ) + #ifdef USE_TEXTURE vertex_uv = vec2(mix(u_previous, u, animation_time_u), mix(v_previous, v, animation_time_v)); #endif -#ifdef USE_RGB - vertex_color = vec4(pos + vec3(0.5, 0.5, 0.5), 1.0); -#else - vertex_color = mix(color_previous, color, animation_time_color); -#endif + #if defined(USE_COLOR) && !(defined(AS_DEPTH) || defined(AS_DISTANCE)) + vColor = vertex_color.rgb; + #endif + + +#if defined( AS_DEFAULT ) || defined( AS_COORDINATE ) || defined( AS_ID ) + #include + #include + #include + #include + #include + + #include + #include + vec3 positionEye = ( modelViewMatrix * vec4(transformed, 1.0 ) ).xyz; + vPositionEye = positionEye; + // #include + #include + #include +#endif //defined( AS_DEFAULT ) || defined( AS_COORDINATE ) || defined( AS_ID ) +#ifdef AS_LAMBERT + #include + #include + #include + #include + #include + + #include + #include + #include + #include + #include +#endif //AS_LAMBERT +#ifdef AS_PHONG + #include + #include + #include + #include + #include + #include + + vViewPosition = - mvPosition.xyz; + + #include + #include + #include + #include +#endif //AS_PHONG +#ifdef AS_PHYSICAL + #include + #include + #include + #include + #include + #include + + vViewPosition = - mvPosition.xyz; + + #include + #include + #include +#endif //AS_PHYSICAL +#ifdef AS_DISTANCE + #include + #include + #include + #include + #include + #include + + vWorldPosition = worldPosition.xyz; +#endif //AS_DISTANCE +#ifdef AS_DEPTH + #include + #include + #include + #include + #include + #include +#endif //AS_DEPTH } diff --git a/js/glsl/scales.glsl b/js/glsl/scales.glsl new file mode 100644 index 00000000..ff5bf6f5 --- /dev/null +++ b/js/glsl/scales.glsl @@ -0,0 +1,83 @@ +#define SCALE_TYPE_LINEAR 1 +#define SCALE_TYPE_LOG 2 + + +#ifdef USE_SCALE_X + #if SCALE_TYPE_x == SCALE_TYPE_LINEAR + #define SCALE_X(x) scale_transform_linear(x, vec2(-0.5, 0.5), domain_x) + #elif SCALE_TYPE_x == SCALE_TYPE_LOG + #define SCALE_X(x) scale_transform_log(x, vec2(-0.5, 0.5), domain_x) + #endif +#endif + +#ifdef USE_SCALE_Y + #if SCALE_TYPE_y == SCALE_TYPE_LINEAR + #define SCALE_Y(x) scale_transform_linear(x, vec2(-0.5, 0.5), domain_y) + #elif SCALE_TYPE_y == SCALE_TYPE_LOG + #define SCALE_Y(x) scale_transform_log(x, vec2(-0.5, 0.5), domain_y) + #endif +#endif + +#ifdef USE_SCALE_Z + #if SCALE_TYPE_z == SCALE_TYPE_LINEAR + #define SCALE_Z(x) scale_transform_linear(x, vec2(-0.5, 0.5), domain_z) + #elif SCALE_TYPE_z == SCALE_TYPE_LOG + #define SCALE_Z(x) scale_transform_log(x, vec2(-0.5, 0.5), domain_z) + #endif +#endif + +#ifdef USE_SCALE_SIZE_X + #if SCALE_TYPE_size_x == SCALE_TYPE_LINEAR + #define SCALE_SIZE_X(x) scale_transform_linear(x, vec2(0.0, 1.0), domain_size_x) + #elif SCALE_TYPE_size_x == SCALE_TYPE_LOG + #define SCALE_SIZE_X(x) scale_transform_log(x, vec2(0.0, 1.0), domain_size_x) + #endif +#endif + +#ifdef USE_SCALE_SIZE_Y + #if SCALE_TYPE_size_y == SCALE_TYPE_LINEAR + #define SCALE_SIZE_Y(x) scale_transform_linear(x, vec2(0.0, 1.0), domain_size_y) + #elif SCALE_TYPE_size_y == SCALE_TYPE_LOG + #define SCALE_SIZE_Y(x) scale_transform_log(x, vec2(0.0, 1.0), domain_size_y) + #endif +#endif + +#ifdef USE_SCALE_SIZE_Z + #if SCALE_TYPE_size_z == SCALE_TYPE_LINEAR + #define SCALE_SIZE_Z(x) scale_transform_linear(x, vec2(0.0, 1.0), domain_size_z) + #elif SCALE_TYPE_size_z == SCALE_TYPE_LOG + #define SCALE_SIZE_Z(x) scale_transform_log(x, vec2(0.0, 1.0), domain_size_z) + #endif +#endif + +#ifdef USE_SCALE_AUX + #if SCALE_TYPE_aux == SCALE_TYPE_LINEAR + #define SCALE_AUX(x) scale_transform_linear(x, vec2(0.0, 1.0), domain_aux) + #elif SCALE_TYPE_aux == SCALE_TYPE_LOG + #define SCALE_AUX(x) scale_transform_log(x, vec2(0.0, 1.0), domain_aux) + #endif +#endif + +float scale_transform_linear(float domain_value, vec2 range, vec2 domain) { + float normalized = (domain_value - domain[0]) / (domain[1] - domain[0]); + float range_value = normalized * (range[1] - range[0]) + range[0]; + return range_value; +} + +float scale_transform_linear_inverse(float range_value, vec2 range, vec2 domain) { + float normalized = (range_value - range[0]) / (range[1] - range[0]); + float domain_value = normalized * (domain[1] - domain[0]) + domain[0]; + return domain_value; +} + +float scale_transform_log(float domain_value, vec2 range, vec2 domain) { + float normalized = (log(domain_value) - log(domain[0])) / (log(domain[1]) - log(domain[0])); + float range_value = normalized * (range[1] - range[0]) + range[0]; + return range_value; +} + +float scale_transform_log_inverse(float range_value, vec2 range, vec2 domain) { + float normalized = (range_value - range[0]) / (range[1] - range[0]); + float domain_value = exp(normalized * (log(domain[1]) - log(domain[0])) + log(domain[0])); + return domain_value; +} diff --git a/js/glsl/scatter-fragment.glsl b/js/glsl/scatter-fragment.glsl index 6b9ddf14..79981258 100644 --- a/js/glsl/scatter-fragment.glsl +++ b/js/glsl/scatter-fragment.glsl @@ -1,38 +1,401 @@ -#include - +// scatter-fragment shader varying vec4 vertex_color; varying vec3 vertex_position; varying vec2 vertex_uv; -#ifdef USE_TEXTURE -uniform sampler2D texture; -uniform sampler2D texture_previous; -uniform float animation_time_texture; -#endif +#if defined( AS_DEFAULT ) || defined( AS_COORDINATE ) || defined( AS_ID ) + // extra only used for the default shading + + #ifdef USE_TEXTURE + uniform sampler2D texture; + uniform sampler2D texture_previous; + uniform float animation_time_texture; + #endif + // end of extra only used for the default shading + // taken similar to phong shading + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + // #include + #include + #include // extra compared to phong + + #include + #include + #include + #include + #include + + +void main(void) +{ + #if defined(AS_COORDINATE) + gl_FragColor = vertex_color; + #elif defined(AS_ID) + gl_FragColor = vertex_color; + #else //AS_COORDINATE + // 0 when in shadow, 1 if visible + #ifdef IS_LINE + gl_FragColor = vertex_color; + #else //IS_LINE + #ifdef USE_SPRITE + #ifdef USE_TEXTURE + gl_FragColor = mix(texture2D(texture_previous, vertex_uv), texture2D(texture, vertex_uv), animation_time_texture); + #else + gl_FragColor = vertex_color; + #endif //USE_TEXTURE + #else //USE_SPRITE + vec3 fdxmy = dFdx( vertex_position ); + vec3 fdymy = dFdy( vertex_position ); + vec3 normalmy = normalize( cross( fdxmy, fdymy ) ); + float diffuse = dot( normalmy, vec3( 0.0, 0.0, 1.0 ) ); + + gl_FragColor = vec4(clamp(diffuse, 0.2, 1.) * vertex_color.rgb, vertex_color.a); + #endif//USE_SPRITE + float shadow_visibility = getShadowMask(); + gl_FragColor.rgb *= shadow_visibility; + #endif //IS_LINE + #endif //AS_COORDINATE + #include +} +#endif //defined( AS_DEFAULT ) || defined( AS_COORDINATE ) + +#ifdef AS_LAMBERT +uniform vec3 diffuse; +uniform vec3 emissive; +uniform float opacity; + +varying vec3 vLightFront; + +#ifdef DOUBLE_SIDED + varying vec3 vLightBack; -void main(void) { -#ifdef USE_RGB - gl_FragColor = vertex_color; -#else - #ifdef AS_LINE - gl_FragColor = vertex_color; - #else - #ifdef USE_SPRITE - #ifdef USE_TEXTURE - gl_FragColor = mix(texture2D(texture_previous, vertex_uv), texture2D(texture, vertex_uv), animation_time_texture); - #else - gl_FragColor = vertex_color; - #endif - #else - vec3 fdx = dFdx( vertex_position ); - vec3 fdy = dFdy( vertex_position ); - vec3 normal = normalize( cross( fdx, fdy ) ); - float diffuse = dot( normal, vec3( 0.0, 0.0, 1.0 ) ); - - gl_FragColor = vec4(clamp(diffuse, 0.2, 1.) * vertex_color.rgb, vertex_color.a); - #endif - #endif #endif + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +void main() { + + #include + + vec4 diffuseColor = vec4( diffuse, opacity ); + ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) ); + vec3 totalEmissiveRadiance = emissive; + + #include + #include + #include + #include + #include + #include + #include + + // accumulation + reflectedLight.indirectDiffuse = getAmbientLightIrradiance( ambientLightColor ); + + #include + + reflectedLight.indirectDiffuse *= BRDF_Diffuse_Lambert( diffuseColor.rgb ); + + #ifdef DOUBLE_SIDED + + reflectedLight.directDiffuse = ( gl_FrontFacing ) ? vLightFront : vLightBack; + + #else + + reflectedLight.directDiffuse = vLightFront; + + #endif + + reflectedLight.directDiffuse *= BRDF_Diffuse_Lambert( diffuseColor.rgb ) * getShadowMask(); + + // modulation + #include + + vec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + totalEmissiveRadiance; + + #include + + gl_FragColor = vec4( outgoingLight, diffuseColor.a ); + + #include + #include + #include + #include + #include + +} +#endif //AS_LAMBERT +#ifdef AS_PHONG +#define PHONG + +uniform vec3 diffuse; +uniform vec3 emissive; +uniform vec3 specular; +uniform float shininess; +uniform float opacity; + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +void main() { + + #include + + vec4 diffuseColor = vec4( diffuse, opacity ); + ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) ); + vec3 totalEmissiveRadiance = emissive; + + #include + #include + #include + #include + #include + #include + #include + #include + #include + + // accumulation + #include + #include + #include + #include + + // modulation + #include + + vec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + reflectedLight.directSpecular + reflectedLight.indirectSpecular + totalEmissiveRadiance; + + #include + + gl_FragColor = vec4( outgoingLight, diffuseColor.a ); + + #include + #include #include + #include + #include + +} +#endif //AS_PHONG +#ifdef AS_PHYSICAL + #define PHYSICAL + uniform vec3 diffuse; + uniform vec3 emissive; + uniform float roughness; + uniform float metalness; + uniform float opacity; + uniform float emissiveIntensity; + + #ifndef STANDARD + uniform float clearCoat; + uniform float clearCoatRoughness; + #endif + + varying vec3 vViewPosition; + + #ifndef FLAT_SHADED + varying vec3 vNormal; + #endif + + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + +void main(void) +{ + #include + + vec4 diffuseColor = vec4( 1.0, 1.0, 1.0, opacity ); + ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) ); + vec3 totalEmissiveRadiance = emissive * emissiveIntensity; + + #include + #include + #include + + #include + #include + #include + #include + #include + + #include + #include + + // accumulation + #include + #include + #include + #include + + // modulation + #include + + vec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + reflectedLight.directSpecular + reflectedLight.indirectSpecular + totalEmissiveRadiance; + gl_FragColor = vec4( outgoingLight, diffuseColor.a ); + + #include + #include + #include + #include + #include + +} +#endif //AS_PHYSICAL +#ifdef AS_DISTANCE +#define DISTANCE + +uniform vec3 referencePosition; +uniform float nearDistance; +uniform float farDistance; +varying vec3 vWorldPosition; + +#include +#include +#include +#include +#include +#include + +void main () { + + #include + + vec4 diffuseColor = vec4( 1.0 ); + + #include + #include + #include + + float dist = length( vWorldPosition - referencePosition ); + dist = ( dist - nearDistance ) / ( farDistance - nearDistance ); + dist = saturate( dist ); // clamp to [ 0, 1 ] + + gl_FragColor = packDepthToRGBA( dist ); + +} +#endif//AS_DISTANCE + +#ifdef AS_DEPTH +#if DEPTH_PACKING == 3200 + + uniform float opacity; + +#endif + +#include +#include +#include +#include +#include +#include +#include + +void main() { + + #include + + vec4 diffuseColor = vec4( 1.0 ); + + #if DEPTH_PACKING == 3200 + + diffuseColor.a = opacity; + + #endif + + #include + #include + #include + + #include + + #if DEPTH_PACKING == 3200 + + gl_FragColor = vec4( vec3( gl_FragCoord.z ), opacity ); + + #elif DEPTH_PACKING == 3201 + + gl_FragColor = packDepthToRGBA( gl_FragCoord.z ); + + #endif + } +#endif //AS_DEPTH diff --git a/js/glsl/scatter-vertex.glsl b/js/glsl/scatter-vertex.glsl index 4dc262a7..752c3a50 100644 --- a/js/glsl/scatter-vertex.glsl +++ b/js/glsl/scatter-vertex.glsl @@ -1,64 +1,206 @@ -#include +// scatter-vertex shader +#define USE_SCALE_X +#define USE_SCALE_Y +#define USE_SCALE_Z +#define USE_SCALE_SIZE_X +#define USE_SCALE_SIZE_Y +#define USE_SCALE_SIZE_Z +#define USE_SCALE_AUX +#include - // for animation, all between 0 and 1 +// for animation, all between 0 and 1 uniform float animation_time_x; uniform float animation_time_y; uniform float animation_time_z; +uniform float animation_time_aux; uniform float animation_time_vx; uniform float animation_time_vy; uniform float animation_time_vz; uniform float animation_time_size; uniform float animation_time_color; -uniform vec2 xlim; -uniform vec2 ylim; -uniform vec2 zlim; +uniform vec2 domain_x; +uniform vec2 domain_y; +uniform vec2 domain_z; +uniform vec2 domain_aux; + +uniform vec2 domain_size_x; +uniform vec2 domain_size_y; +uniform vec2 domain_size_z; + +uniform mat4 geo_matrix; +uniform vec3 aspect; varying vec4 vertex_color; varying vec3 vertex_position; varying vec2 vertex_uv; -#ifdef AS_LINE -attribute vec3 position_previous; +#ifdef IS_LINE + attribute vec3 position_previous; #else -attribute float x; -attribute float x_previous; -attribute float y; -attribute float y_previous; -attribute float z; -attribute float z_previous; - -attribute vec3 v; -attribute vec3 v_previous; + attribute float x_next; + attribute float x_previous; + attribute float y_next; + attribute float y_previous; + attribute float z_next; + attribute float z_previous; +#ifdef USE_AUX + attribute float aux_next; + attribute float aux_previous; +#endif + attribute vec3 v_next; + attribute vec3 v_previous; + attribute float size_next; + attribute float size_previous; +#endif -attribute float size; -attribute float size_previous; +#ifdef USE_COLORMAP + attribute float color_next; + attribute float color_previous; + uniform vec2 domain_color; +#else + attribute vec4 color_next; + attribute vec4 color_previous; #endif -attribute vec4 color; -attribute vec4 color_previous; +uniform sampler2D colormap; + +attribute float instance_id; +uniform float id_offset; + +vec4 encodeId(float v) { + vec4 color; + // matches Figure.readId + color.b = floor(v / 256.0 / 256.0); + color.g = floor((v - color.b * 256.0 * 256.0) / 256.0); + color.r = floor(v - color.b * 256.0 * 256.0 - color.g * 256.0); + color.a = 255.0; + // normalize + return color / 255.0; +} +#if defined( AS_DEFAULT ) || defined( AS_COORDINATE ) || defined( AS_ID ) + // similar to phong + // varying vec3 vColor; + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include +#endif //defined( AS_DEFAULT ) || defined( AS_COORDINATE ) || defined( AS_ID ) + +#ifdef AS_LAMBERT + #define LAMBERT + varying vec3 vLightFront; + + #ifdef DOUBLE_SIDED + varying vec3 vLightBack; + #endif + + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include +#endif //AS_LAMBERT +#ifdef AS_PHONG + #define PHONG + varying vec3 vViewPosition; + + #ifndef FLAT_SHADED + varying vec3 vNormal; + #endif + + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include +#endif //AS_PHONG +#ifdef AS_PHYSICAL + #define PHYSICAL + varying vec3 vViewPosition; + + #ifndef FLAT_SHADED + varying vec3 vNormal; + #endif + + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include +#endif //AS_PHYSICAL +#ifdef AS_DEPTH + #include + #include + #include + #include + #include + #include + #include +#endif //AS_DEPTH +#ifdef AS_DISTANCE + #define DISTANCE + + varying vec3 vWorldPosition; + + #include + #include + #include + #include + #include + #include +#endif //AS_DISTANCE void main(void) { - vec3 origin = vec3(xlim.x, ylim.x, zlim.x); - vec3 size_viewport = vec3(xlim.y, ylim.y, zlim.y) - origin; vec3 animation_time = vec3(animation_time_x, animation_time_y, animation_time_z); vec3 animation_time_v = vec3(animation_time_vx, animation_time_vy, animation_time_vz); -#ifdef AS_LINE - vec3 model_pos = (mix(position_previous, position, animation_time) - origin) / size_viewport - 0.5; +#ifdef IS_LINE + vec3 position_current = mix(position_previous, position, animation_time); + vec3 model_pos = vec3(SCALE_X(position_current.x), SCALE_Y(position_current.y), SCALE_Z(position_current.z)); vec4 view_pos = modelViewMatrix * vec4(model_pos, 1.0); #else - vec3 vector = v; + vec3 vector_next = v_next; vec3 vector_previous = v_previous; - vec3 position_offset = vec3(x, y, z); + vec3 position_offset_next = vec3(x_next, y_next, z_next); vec3 position_offset_previous = vec3(x_previous, y_previous, z_previous); // assume the vector points to the y axis - vec3 vector_current = mix(normalize(vector_previous), normalize(vector), animation_time_v) - * mix(length(vector_previous), length(vector), (animation_time_vx+ animation_time_vy+ animation_time_vz)/3.); + vec3 vector_current = mix(normalize(vector_previous), normalize(vector_next), animation_time_v) + * mix(length(vector_previous), length(vector_next), (animation_time_vx+ animation_time_vy+ animation_time_vz)/3.); vec3 y_axis = normalize(vector_current); // we may have bad luck, and alight with 1 vector, so take two vectors, and we'll always find a non-zero vector vec3 some_z_vector_a = vec3(0., 1., 1.); @@ -69,28 +211,229 @@ void main(void) { // the following matrix should point it to the direction of 'vector' mat3 move_to_vector = mat3(x_axis, y_axis, z_axis); - float s = mix(size_previous/100., size/100., animation_time_size); - vec3 model_pos = (mix(position_offset_previous, position_offset, animation_time) - origin) / size_viewport - 0.5; + float size_current = mix(size_previous, size_next, animation_time_size); + // TODO: replace the 0. in SCALE_SIZE_X(0.) by a uniform, so we can make it work with log? + vec3 size_vector = vec3(SCALE_SIZE_X(size_current) - SCALE_SIZE_X(0.), SCALE_SIZE_Y(size_current) - SCALE_SIZE_Y(0.), SCALE_SIZE_Z(size_current) - SCALE_SIZE_Z(0.)); +#ifdef USE_AUX + float aux_current = mix(aux_previous, aux_next, animation_time_aux); +#endif + vec3 position_current_offset = mix(position_offset_previous, position_offset_next, animation_time); + vec3 model_pos = vec3(SCALE_X(position_current_offset.x), SCALE_Y(position_current_offset.y), SCALE_Z(position_current_offset.z)); + // vec3 model_pos = vec3((position_current_offset.x), (position_current_offset.y), (position_current_offset.z)); + SHADER_SNIPPET_SIZE; //vec3 pos = (pos_object ) / size;// - 0.5; #ifdef USE_SPRITE - // if we are a sprite, we add the position in view coordinates, and need to + // if we are a sprite, we add the position in view coordinates, and need to vec4 view_pos = modelViewMatrix * vec4(model_pos, 1.0); view_pos += vec4((position.xy)*(s*0.5),0,0); #else - model_pos += move_to_vector * (position)*s; - vec4 view_pos = modelViewMatrix * vec4(model_pos, 1.0); + // the position is the orignal mesh position, so we scale and add that to the central location + // and we also rotate it into the direction of the vector v + vec4 position_transformed = geo_matrix * vec4(position, 1.0); + position_transformed.xyz = position_transformed.xyz / position_transformed.w; + // correct the aspect of the bounding box, so that glyphs are not transformed + position_transformed.xyz = position_transformed.xyz / aspect; + model_pos += move_to_vector * (position_transformed.xyz*size_vector); + vec4 view_pos = viewMatrix * vec4(model_pos, 1.0); #endif #endif - vec4 mvPosition = view_pos; + + // we repeat threejs's shader, up to begin_vertex +#if defined( AS_DEFAULT ) || defined( AS_COORDINATE ) || defined( AS_ID ) + #include + #include + #include + + #include + #include + #include + #include + #include + + #include +#endif //defined( AS_DEFAULT ) || defined( AS_COORDINATE ) +#ifdef AS_LAMBERT + #include + #include + #include + + #include + objectNormal = move_to_vector * objectNormal; + #include + #include + #include + #include + + #include +#endif //AS_LAMBERT +#ifdef AS_PHONG + #include + #include + #include + + #include + objectNormal = move_to_vector * objectNormal; + #include + #include + #include + #include + + #ifndef FLAT_SHADED // Normal computed with derivatives when FLAT_SHADED + vNormal = normalize( transformedNormal ); + #endif + + #include +#endif //AS_PHONG +#ifdef AS_PHYSICAL + #include + #include + #include + + #include + objectNormal = move_to_vector * objectNormal; + #include + #include + #include + #include + + #ifndef FLAT_SHADED // Normal computed with derivatives when FLAT_SHADED + vNormal = normalize( transformedNormal ); + #endif + + #include +#endif //AS_PHYSICAL +#ifdef AS_DEPTH + #include + + #include + + #ifdef USE_DISPLACEMENTMAP + + #include + #include + #include + + #endif + + #include +#endif //AS_DEPTH +#ifdef AS_DISTANCE + #include + + #include + + #ifdef USE_DISPLACEMENTMAP + + #include + #include + #include + + #endif + + #include +#endif //AS_DISTANCE + + // after begin_vertex, we modify transformed + transformed = model_pos; + + // mvPosition = view_pos; gl_Position = projectionMatrix * view_pos; - vec3 positionEye = ( modelViewMatrix * vec4( model_pos, 1.0 ) ).xyz; - vertex_position = positionEye; + // vec3 positionEye = ( modelViewMatrix * vec4( model_pos, 1.0 ) ).xyz; + // vertex_position = positionEye; vertex_uv = position.xy / 2. - 0.5; -#ifdef USE_RGB +#if defined( AS_COORDINATE ) vertex_color = vec4(model_pos + vec3(0.5, 0.5, 0.5), 1.0); +#elif defined( AS_ID ) + vertex_color = encodeId(instance_id + id_offset); #else - vertex_color = mix(color_previous, color, animation_time_color); + #ifdef USE_COLORMAP + float color_current = mix(color_previous, color_next, animation_time_color); + float color_index = scale_transform_linear(color_current, vec2(0.0, 1.0), domain_color); + vertex_color = texture2D(colormap, vec2(color_index, 0)); + #else + vertex_color = mix(color_previous, color_next, animation_time_color); + #endif #endif + #if defined(USE_COLOR) && !(defined(AS_DEPTH) || defined(AS_DISTANCE)) + vColor = vertex_color.rgb; + #endif + + +#if defined( AS_DEFAULT ) || defined( AS_COORDINATE ) || defined( AS_ID ) + #include + #include + #include + #include + #include + #include + + + #include + vec3 positionEye = ( modelViewMatrix * vec4(transformed, 1.0 ) ).xyz; + vertex_position = positionEye; + // vViewPosition = - mvPosition.xyz; + // #include + #include + #include +#endif // defined( AS_DEFAULT ) || defined( AS_COORDINATE ) || defined( AS_ID ) +#ifdef AS_LAMBERT + #include + #include + #include + #include + #include + + #include + #include + #include + #include + #include +#endif //AS_LAMBERT +#ifdef AS_PHONG + #include + #include + #include + #include + #include + #include + + vViewPosition = - mvPosition.xyz; + #include + #include + #include #include +#endif //AS_PHONG +#ifdef AS_PHYSICAL + #include + #include + #include + #include + #include + #include + + vViewPosition = - mvPosition.xyz; + + #include + #include + #include +#endif //AS_PHYSICAL +#ifdef AS_DISTANCE + #include + #include + #include + #include + #include + #include + + vWorldPosition = worldPosition.xyz; +#endif //AS_DISTANCE +#ifdef AS_DEPTH + #include + #include + #include + #include + #include + #include +#endif //AS_DEPTH } diff --git a/js/glsl/shadow-fragment.glsl b/js/glsl/shadow-fragment.glsl new file mode 100644 index 00000000..e66a5cce --- /dev/null +++ b/js/glsl/shadow-fragment.glsl @@ -0,0 +1,12 @@ +uniform sampler2D map; +varying vec2 vUv; +#include + +void main () +{ + vec4 rgbaDepth = texture2D (map, vUv); + float fDepth = unpackRGBAToDepth(rgbaDepth); + gl_FragColor = vec4 (vec3 (fDepth), 1.0); + // gl_FragColor = vec4 (vec3 (rgbaDepth.w), 1.0); +} + diff --git a/js/glsl/shadow-vertex.glsl b/js/glsl/shadow-vertex.glsl new file mode 100644 index 00000000..c0de471f --- /dev/null +++ b/js/glsl/shadow-vertex.glsl @@ -0,0 +1,7 @@ +varying vec2 vUv; + +void main () +{ + vUv = vec2 (uv.x, 1.0 - uv.y); + gl_Position = projectionMatrix * modelViewMatrix * vec4 (position, 1.0); +} diff --git a/js/glsl/volr-fragment.glsl b/js/glsl/volr-fragment.glsl index 004b8468..22ba7f51 100644 --- a/js/glsl/volr-fragment.glsl +++ b/js/glsl/volr-fragment.glsl @@ -1,27 +1,18 @@ precision highp float; +#include +#include +#include +#include + +uniform mat3 normalMatrix; + uniform sampler2D back_tex; uniform sampler2D geometry_depth_tex; -// samplers in structs has bad support - -struct Volume -{ - float opacity_scale; - float brightness; - vec2 data_range; - vec2 show_range; - float rows; - float columns; - float slices; - vec2 size; - vec2 slice_size; - bool clamp_min; - bool clamp_max; - vec3 scale; - vec3 offset; - bool lighting; -}; +#include + +// samplers in structs has bad support, so we put it here #if (VOLUME_COUNT > 0) uniform sampler2D data[VOLUME_COUNT]; uniform sampler2D transfer_function[VOLUME_COUNT]; @@ -74,29 +65,6 @@ vec3 eye; uniform int steps; - -vec2 compute_slice_offset(float slice, float columns, vec2 uv_slice_spacing) { - return uv_slice_spacing * vec2(mod(slice, columns), floor(slice / columns)); -} -vec4 sample_as_3d_texture(sampler2D tex, vec2 tex_size, vec3 texCoord, vec2 slice_size, float slices, float rows, float columns) { - float slice = texCoord.z*slices*(slices-1.)/slices ; - float slice_z = floor(slice); - float slice_z_offset = fract(slice); - - vec2 pixel = 1./tex_size; - vec2 uv_slice_spacing = slice_size/tex_size; - - vec2 coord = vec2(texCoord.x, texCoord.y); - vec2 uv = pixel * 0.5 + coord * (uv_slice_spacing - pixel); - - vec2 slice0_offset = compute_slice_offset(slice_z, columns, uv_slice_spacing); - vec2 slice1_offset = compute_slice_offset(slice_z + 1.0, columns, uv_slice_spacing); - - vec4 slice0_color = texture2D(tex, slice0_offset + uv); - vec4 slice1_color = texture2D(tex, slice1_offset + uv); - return mix(slice0_color, slice1_color, slice_z_offset); -} - uniform float ambient_coefficient; uniform float diffuse_coefficient; uniform float specular_coefficient; @@ -119,6 +87,9 @@ vec2 sample(sampler2D data, Volume volume, vec3 ray_pos, inout vec3 normal) { return vec2(0.0); vec4 sample = sample_as_3d_texture(data, volume.size, pos_relative, volume.slice_size, volume.slices, volume.rows, volume.columns); normal = (-sample.xyz)*2.+1.; + // this seems to match observations, not fully sure why x and z are flipped. + normal.xyz = normal.zyx; + float raw_data_value = sample.a; //(sample.a - data_min) * data_scale; float scaled_data_value = (raw_data_value*(volume.data_range[1] - volume.data_range[0])) + volume.data_range[0]; float data_value = (scaled_data_value - volume.show_range[0])/(volume.show_range[1] - volume.show_range[0]); @@ -131,10 +102,46 @@ vec2 sample(sampler2D data, Volume volume, vec3 ray_pos, inout vec3 normal) { return vec2(data_value, 1); } -vec4 apply_lighting(vec4 color, vec3 normal) { - float cosangle_light = max((dot(light_dir, normal)), 0.); - float cosangle_eye = max((dot(eye, normal)), 0.); - vec4 result = vec4(color.rgb * (ambient_coefficient + diffuse_coefficient*cosangle_light + specular_coefficient * pow(cosangle_eye, specular_exponent)), color.a); +vec4 apply_lighting(vec4 color, vec3 objectNormal, vec3 position, Volume volume) { + // only do phong lighting when we have lights + #if ( NUM_POINT_LIGHTS > 0 ) || ( NUM_SPOT_LIGHTS > 0 ) || ( NUM_DIR_LIGHTS > 0 ) || ( NUM_RECT_AREA_LIGHTS > 0 ) || ( NUM_HEMI_LIGHTS > 0 ) + vec3 normal = normalize(normalMatrix * objectNormal); + vec3 vViewPosition = position; + vec3 emissive = volume.emissive; + + + // this is quite similar to meshphong_frag.glsl + vec4 diffuseColor = color; + ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) ); + vec3 totalEmissiveRadiance = emissive; + + + // the replacement for: #include + BlinnPhongMaterial material; + material.diffuseColor = diffuseColor.rgb; + material.specularColor = volume.specular; + material.specularShininess = volume.shininess; + material.specularStrength = 1.0; + + #include + // we don't support light maps + // #include + // no need to include this for Phong, but more consistent with mesh_phong_frag.glsl + #include + + // modulation (not supported) + #include + + vec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + reflectedLight.directSpecular + reflectedLight.indirectSpecular + totalEmissiveRadiance; + + // also not supported + // #include + + vec4 result = vec4( outgoingLight, diffuseColor.a ); + #else + vec4 result = color; + #endif + return result; } @@ -160,7 +167,7 @@ vec4 add_sample(sampler2D data, sampler2D transfer_function, Volume volume, vec3 vec4 color_sample = texture2D(transfer_function, vec2(data_value, 0.5)); if(volume.lighting) { - color_sample = apply_lighting(color_sample, normal); + color_sample = apply_lighting(color_sample, normal, ray_pos, volume); } // float intensity = color_sample.a; @@ -318,12 +325,30 @@ void main(void) { #else gl_FragColor = color; #endif - //gl_FragColor = vec4(ray_begin.xyz, 0.1) * brightness; + // code below is used for debugging purposes + // float x = floor((pixel.x *500. / 10.)); + // float y = floor((pixel.y *500. / 10.)); + // // gl_FragColor = vec4(x / 10., 0.0, 0.0, 1.0); + // // gl_FragColor = vec4(y / 10., 0.0, 0.0, 1.0); + // vec2 result; + // float eps = 1. - 1e-4; + // float modulo = mod(x, y * eps); + // float offset = x - modulo * y; + // offset = floor(x / y); + // gl_FragColor = vec4(mod(x, x) > 0. ? 1.0 : 0., 0.0, 0.0, 1.0); + // gl_FragColor = vec4(modulo >= x ? 1.0 : 0., 0.0, 0.0, 1.0); + // gl_FragColor = vec4(offset >= 0.5 ? 1.0 : 0., 0.0, 0.0, 1.0); + // gl_FragColor = vec4(offset/x, 0.0, 0.0, 1.0); + // eps = 0.; + // gl_FragColor = vec4(float(int(x / (y - eps))) / 1., 0.0, 0.0, 1.0); + // gl_FragColor = vec4(texture2D(data[0], pixel).a * 140., 0., 0., 1.0); + // gl_FragColor = vec4(ray_begin.xyz, 1.); + // gl_FragColor = vec4(ray_begin.xyz, 0.1) * brightness; //gl_FragColor = vec4(rotation[0], 1) * brightness; - //gl_FragColor = vec4(alpha_total, 0., 0., 1.); + // gl_FragColor = vec4(alpha_total, 0., 0., 1.); //gl_FragColor = texture2D(volume, vec2(ray_begin.x, ray_begin.y)); - // gl_FragColor = vec4(ray_pos.x, ray_pos.y, ray_pos.z, 1); - //gl_FragColor = texture2D(transfer_function, vec2(pixel.x, 0.5)); + // gl_FragColor = vec4(ray_begin.x, ray_begin.y, ray_begin.z, 1.); + // gl_FragColor = texture2D(transfer_function, vec2(pixel.x, 0.5)); //gl_FragColor = vec4(texture2D(volume, vec2(pixel.x, pixel.y)).rgb, 1.0); // gl_FragColor = vec4(pixel.x, pixel.y, 0, 1); // gl_FragColor = vec4(ray_end, 1.); @@ -360,7 +385,7 @@ void cast_ray_max(vec3 ray_begin, vec3 ray_end) { // the weight of the coordinate equals its opacity max_colors[{{.}}] = texture2D(transfer_function_max_int[{{.}}], vec2(max_values[{{.}}], 0.5)); if(volumes_max_int[{{.}}].lighting) - max_colors[{{.}}] = apply_lighting(max_colors[{{.}}], normal); + max_colors[{{.}}] = apply_lighting(max_colors[{{.}}], normal, ray_pos, volumes_max_int[{{.}}]); float alpha = clamp(max_colors[{{.}}].a * volumes_max_int[{{.}}].opacity_scale * 10., 0., 1.); max_colors[{{.}}].a = alpha; #ifdef COORDINATE diff --git a/js/karma.conf.js b/js/karma.conf.js index ce8a6321..58053783 100644 --- a/js/karma.conf.js +++ b/js/karma.conf.js @@ -1,42 +1,50 @@ // Karma configuration // Generated on Wed Jun 20 2018 16:46:14 GMT+0200 (CEST) var webpackConfig = require('./webpack.config.js'); +var webpack = require('webpack'); -module.exports = function(config) { - config.set({ - basePath: '', - frameworks: ['mocha', 'chai', 'sinon'], - files: [ - {pattern: 'test/**/*.ts'}, - ], - exclude: ['**/embed.js'], - preprocessors: { - 'test/**/*.ts': [ 'webpack'] - }, - webpack: { - module: webpackConfig[1].module, - resolve: webpackConfig[1].resolve, - }, - mime: { - 'text/x-typescript': ['ts'] - }, - reporters: ['progress'], - port: 9876, - colors: true, - // possible values: config.LOG_DISABLE || config.LOG_ERROR || config.LOG_WARN || config.LOG_INFO || config.LOG_DEBUG - logLevel: config.LOG_INFO, - autoWatch: true, - // available browser launchers: https://npmjs.org/browse/keyword/karma-launcher - browsers: ['HeadlessChrome'], - customLaunchers: { - HeadlessChrome: { - base: 'Chrome', - flags: ['--headless', '--disable-gpu', '--remote-debugging-port=9222'] - } - }, - // if true, Karma captures browsers, runs the tests and exits - singleRun: true, - // how many browser should be started simultaneous - concurrency: Infinity - }) -} \ No newline at end of file + +module.exports = function (config) { + config.set({ + basePath: '', + frameworks: ['mocha', 'chai', 'sinon'], + files: [ + // we use 1 bundle for testing + { pattern: 'lib/test/index.js' }, + ], + exclude: ['**/embed.js'], + preprocessors: { + // the bundle goes through webpack, and will emit (inline) source maps, which karma needs to read again + 'lib/test/index.js': ['webpack', 'sourcemap'], + }, + webpack: { + module: { + rules: webpackConfig[1].module.rules + }, + // source mapping without inline does not seem to work + devtool: 'inline-source-map', + mode: 'development', + resolve: { + extensions: ['.js'] + }, + }, + reporters: ['progress', 'mocha'], + port: 9876, + colors: true, + // possible values: config.LOG_DISABLE || config.LOG_ERROR || config.LOG_WARN || config.LOG_INFO || config.LOG_DEBUG + logLevel: config.LOG_INFO, + autoWatch: true, + // available browser launchers: https://npmjs.org/browse/keyword/karma-launcher + browsers: ['HeadlessChrome'], + customLaunchers: { + HeadlessChrome: { + base: 'Chrome', + flags: ['--headless', '--disable-gpu', '--remote-debugging-port=9222'] + } + }, + // if true, Karma captures browsers, runs the tests and exits + singleRun: true, + // how many browser should be started simultaneous + concurrency: Infinity + }) +} diff --git a/js/package-lock.json b/js/package-lock.json new file mode 100644 index 00000000..6d717128 --- /dev/null +++ b/js/package-lock.json @@ -0,0 +1,13004 @@ +{ + "name": "ipyvolume", + "version": "0.6.0-alpha.10", + "lockfileVersion": 1, + "requires": true, + "dependencies": { + "@babel/code-frame": { + "version": "7.5.5", + "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.5.5.tgz", + "integrity": "sha512-27d4lZoomVyo51VegxI20xZPuSHusqbQag/ztrBC7wegWoQ1nLREPVSKSW8byhTlzTKyNE4ifaTA6lCp7JjpFw==", + "requires": { + "@babel/highlight": "^7.0.0" + } + }, + "@babel/highlight": { + "version": "7.5.0", + "resolved": "https://registry.npmjs.org/@babel/highlight/-/highlight-7.5.0.tgz", + "integrity": "sha512-7dV4eu9gBxoM0dAnj/BCFDW9LFU0zvTrkq0ugM7pnHEgguOEeOz1so2ZghEdzviYzQEED0r4EAgpsBChKy1TRQ==", + "requires": { + "chalk": "^2.0.0", + "esutils": "^2.0.2", + "js-tokens": "^4.0.0" + }, + "dependencies": { + "ansi-styles": { + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz", + "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", + "requires": { + "color-convert": "^1.9.0" + } + }, + "chalk": { + "version": "2.4.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz", + "integrity": "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==", + "requires": { + "ansi-styles": "^3.2.1", + "escape-string-regexp": "^1.0.5", + "supports-color": "^5.3.0" + } + }, + "has-flag": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz", + "integrity": "sha1-tdRU3CGZriJWmfNGfloH87lVuv0=" + }, + "js-tokens": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz", + "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==" + }, + "supports-color": { + "version": "5.5.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz", + "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==", + "requires": { + "has-flag": "^3.0.0" + } + } + } + }, + "@discoveryjs/json-ext": { + "version": "0.5.3", + "resolved": "https://registry.npmjs.org/@discoveryjs/json-ext/-/json-ext-0.5.3.tgz", + "integrity": "sha512-Fxt+AfXgjMoin2maPIYzFZnQjAXjAL0PHscM5pRTtatFqB+vZxAM9tLp2Optnuw3QOQC40jTNeGYFOMvyf7v9g==", + "dev": true + }, + "@jupyter-widgets/base": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/@jupyter-widgets/base/-/base-2.0.2.tgz", + "integrity": "sha512-nNpD+RGJ0As74XxDSGMeObfXSZ8XPBFHJ1AyugzYxpmxIigB2n3DxTyonASkR/3hXwxl3/nXBxHGlxQGs/+nOA==", + "requires": { + "@jupyterlab/services": "^4.0.0", + "@phosphor/coreutils": "^1.2.0", + "@phosphor/messaging": "^1.2.1", + "@phosphor/widgets": "^1.3.0", + "@types/backbone": "^1.4.1", + "@types/lodash": "^4.14.134", + "backbone": "1.2.3", + "base64-js": "^1.2.1", + "jquery": "^3.1.1", + "lodash": "^4.17.4" + } + }, + "@jupyter-widgets/controls": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/@jupyter-widgets/controls/-/controls-2.0.0.tgz", + "integrity": "sha512-g0SRSXJ/P5yM23scZl+8zXR1Jz783Uf7H5tq6ucTibMk8mXxDIXn09Rgal4K17XH2LSesd0dkhTzMmlLPMAH7g==", + "requires": { + "@jupyter-widgets/base": "^3.0.0", + "@lumino/algorithm": "^1.1.0", + "@lumino/domutils": "^1.1.0", + "@lumino/messaging": "^1.2.1", + "@lumino/signaling": "^1.2.0", + "@lumino/widgets": "^1.3.0", + "d3-format": "^1.3.0", + "jquery": "^3.1.1", + "jquery-ui": "^1.12.1", + "underscore": "^1.8.3" + }, + "dependencies": { + "@jupyter-widgets/base": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/@jupyter-widgets/base/-/base-3.0.0.tgz", + "integrity": "sha512-un1ZTHALCwE/SAYk2gEaonYM1JoaFyhosN8a3y2bhl4N26yCB3dP1PqGHLsAFur6ZB7fwuWwBEkIZx+nOwstAQ==", + "requires": { + "@jupyterlab/services": "^5.0.0", + "@lumino/coreutils": "^1.2.0", + "@lumino/messaging": "^1.2.1", + "@lumino/widgets": "^1.3.0", + "@types/backbone": "^1.4.1", + "@types/lodash": "^4.14.134", + "backbone": "1.2.3", + "base64-js": "^1.2.1", + "jquery": "^3.1.1", + "lodash": "^4.17.4" + } + }, + "@jupyterlab/coreutils": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/@jupyterlab/coreutils/-/coreutils-4.1.0.tgz", + "integrity": "sha512-2lcXHd8ZCUuqoiZYK9Xs4HHX46jkdtsdmfgvgg/3odFXFMdv4Twau7fqr9URgRl5JYszPPpItGJIorAVipVfNQ==", + "requires": { + "@lumino/coreutils": "^1.4.2", + "@lumino/disposable": "^1.3.5", + "@lumino/signaling": "^1.3.5", + "minimist": "~1.2.0", + "moment": "^2.24.0", + "path-posix": "~1.0.0", + "url-parse": "~1.4.7" + } + }, + "@jupyterlab/observables": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/@jupyterlab/observables/-/observables-3.1.0.tgz", + "integrity": "sha512-4Dx6o5BzHVdWFFUPTAaeUkGngJfy5Qm0N37lbh/2NcWz1NZuuC6SrgREW3zcLSKwxdwkMAXo6En0T1UyrCFjTA==", + "requires": { + "@lumino/algorithm": "^1.2.3", + "@lumino/coreutils": "^1.4.2", + "@lumino/disposable": "^1.3.5", + "@lumino/messaging": "^1.3.3", + "@lumino/signaling": "^1.3.5" + } + }, + "@jupyterlab/services": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/@jupyterlab/services/-/services-5.1.0.tgz", + "integrity": "sha512-xhtDvAdgw+sWNSbpkExCYyJbHxlwhiZYqc07+zhOdYrpxO19k/ZmmyNoYCyfvNLcMQ4JWVBoczI714u1QNLj4w==", + "requires": { + "@jupyterlab/coreutils": "^4.1.0", + "@jupyterlab/nbformat": "^2.1.0", + "@jupyterlab/observables": "^3.1.0", + "@jupyterlab/settingregistry": "^2.1.0", + "@jupyterlab/statedb": "^2.1.0", + "@lumino/algorithm": "^1.2.3", + "@lumino/coreutils": "^1.4.2", + "@lumino/disposable": "^1.3.5", + "@lumino/polling": "^1.1.1", + "@lumino/signaling": "^1.3.5", + "node-fetch": "^2.6.0", + "ws": "^7.2.0" + } + } + } + }, + "@jupyterlab/builder": { + "version": "3.0.8", + "resolved": "https://registry.npmjs.org/@jupyterlab/builder/-/builder-3.0.8.tgz", + "integrity": "sha512-f5HPbH+oxxZGRt+/hxeuW/217cGyD2jCE2ksy8758WgQGspfQHSNWhshGgGufs/6PfUoKx8vIYY8dmPMn5WdeQ==", + "dev": true, + "requires": { + "@jupyterlab/buildutils": "^3.0.6", + "@lumino/algorithm": "^1.3.3", + "@lumino/application": "^1.13.1", + "@lumino/commands": "^1.12.0", + "@lumino/coreutils": "^1.5.3", + "@lumino/disposable": "^1.4.3", + "@lumino/domutils": "^1.2.3", + "@lumino/dragdrop": "^1.7.1", + "@lumino/messaging": "^1.4.3", + "@lumino/properties": "^1.2.3", + "@lumino/signaling": "^1.4.3", + "@lumino/virtualdom": "^1.8.0", + "@lumino/widgets": "^1.16.1", + "ajv": "^6.12.3", + "commander": "~6.0.0", + "css-loader": "^5.0.1", + "duplicate-package-checker-webpack-plugin": "^3.0.0", + "file-loader": "~6.0.0", + "fs-extra": "^9.0.1", + "glob": "~7.1.6", + "mini-css-extract-plugin": "~1.3.2", + "path-browserify": "^1.0.0", + "process": "^0.11.10", + "raw-loader": "~4.0.0", + "style-loader": "~2.0.0", + "supports-color": "^7.2.0", + "svg-url-loader": "~6.0.0", + "terser-webpack-plugin": "^4.1.0", + "to-string-loader": "^1.1.6", + "url-loader": "~4.1.0", + "webpack": "^5.3.1", + "webpack-cli": "^4.1.0", + "webpack-merge": "^5.1.2", + "worker-loader": "^3.0.2" + }, + "dependencies": { + "@lumino/algorithm": { + "version": "1.6.0", + "resolved": "https://registry.npmjs.org/@lumino/algorithm/-/algorithm-1.6.0.tgz", + "integrity": "sha512-NMOcm5Yr9nXz5gokS/K4jHBbUMQYBkvDXl1n51XWdcz0LY+oGuIKPhjazhUgmbNRehzdZBj5hMMd1+htYWeVKQ==", + "dev": true + }, + "@lumino/application": { + "version": "1.20.0", + "resolved": "https://registry.npmjs.org/@lumino/application/-/application-1.20.0.tgz", + "integrity": "sha512-FAoQcq4L3ZswTK0lWfLKnG1ecG26cwqjzg2fyoBeuWGBi1TG9BYjFBdV7ErTFMxW8jE1CLOLuxsZaKFLNErcKA==", + "dev": true, + "requires": { + "@lumino/commands": "^1.15.0", + "@lumino/coreutils": "^1.8.0", + "@lumino/widgets": "^1.23.0" + } + }, + "@lumino/collections": { + "version": "1.6.0", + "resolved": "https://registry.npmjs.org/@lumino/collections/-/collections-1.6.0.tgz", + "integrity": "sha512-ZETm0/xF0oUHV03sOXNOfFI1EEpS317HvN5n+fZBJvCNZIrJkWmKD8QuxcfwHb7AChKUhXlVHhDbWlb1LKnd7g==", + "dev": true, + "requires": { + "@lumino/algorithm": "^1.6.0" + } + }, + "@lumino/commands": { + "version": "1.15.0", + "resolved": "https://registry.npmjs.org/@lumino/commands/-/commands-1.15.0.tgz", + "integrity": "sha512-JOE68KfbR9xw5YTfcwo+9E0PSWidifEMAcOC/aXd7iSzfsCRknMTcMQIUGL277IU7J7CJvoe10DUE5QKwTmX+g==", + "dev": true, + "requires": { + "@lumino/algorithm": "^1.6.0", + "@lumino/coreutils": "^1.8.0", + "@lumino/disposable": "^1.7.0", + "@lumino/domutils": "^1.5.0", + "@lumino/keyboard": "^1.5.0", + "@lumino/signaling": "^1.7.0", + "@lumino/virtualdom": "^1.11.0" + } + }, + "@lumino/coreutils": { + "version": "1.8.0", + "resolved": "https://registry.npmjs.org/@lumino/coreutils/-/coreutils-1.8.0.tgz", + "integrity": "sha512-OvCsaASUqOE7R6Dxngyk4/b5QMOjyRUNxuZuuL+fx+JvGKZFZ/B2c9LYtAJ9mDmQ1BQiGNV/qSpL4o7x8PCfjw==", + "dev": true + }, + "@lumino/disposable": { + "version": "1.7.0", + "resolved": "https://registry.npmjs.org/@lumino/disposable/-/disposable-1.7.0.tgz", + "integrity": "sha512-3mWi11ko3XVY63BPwvys7MXrbFddA2i+gp72d0wAKM2NDDUopVPikMHhJpjGJcw+otjahzXYiTewxPDEau9dYg==", + "dev": true, + "requires": { + "@lumino/algorithm": "^1.6.0", + "@lumino/signaling": "^1.7.0" + } + }, + "@lumino/domutils": { + "version": "1.5.0", + "resolved": "https://registry.npmjs.org/@lumino/domutils/-/domutils-1.5.0.tgz", + "integrity": "sha512-dZ0Aa+/qhvfPc1aa5kX4LLGE3B6BW1XmJa0R1XVCEpAFY3cZiujuQWmhYHJtZPrOiqn0UtioT2OpqnWdtCWc0A==", + "dev": true + }, + "@lumino/dragdrop": { + "version": "1.10.0", + "resolved": "https://registry.npmjs.org/@lumino/dragdrop/-/dragdrop-1.10.0.tgz", + "integrity": "sha512-A3cNLcp09zygOprWmLTkLZCQYNq3dJfN+mhni4IZizqCTkKbTCEzo2/IwoCWvy+ABKft8d/A9Y40wFW6yJ9OyA==", + "dev": true, + "requires": { + "@lumino/coreutils": "^1.8.0", + "@lumino/disposable": "^1.7.0" + } + }, + "@lumino/keyboard": { + "version": "1.5.0", + "resolved": "https://registry.npmjs.org/@lumino/keyboard/-/keyboard-1.5.0.tgz", + "integrity": "sha512-/uF9xqHYVbIkser2Q6UIv7VWrzThr1fxAmSOShjSoKGocL0XHeaBaCOMezSaVxnJ1wm1ciNdhMsjscVM8Inp7g==", + "dev": true + }, + "@lumino/messaging": { + "version": "1.7.0", + "resolved": "https://registry.npmjs.org/@lumino/messaging/-/messaging-1.7.0.tgz", + "integrity": "sha512-QYWf9QGIGD0Oes104zw7mVln4S8yRije2mZhNNRBjkYcDuQlPW+eRSuC5LwAMsFnGymBlUPwPbKOUEO2RbhAtg==", + "dev": true, + "requires": { + "@lumino/algorithm": "^1.6.0", + "@lumino/collections": "^1.6.0" + } + }, + "@lumino/properties": { + "version": "1.5.0", + "resolved": "https://registry.npmjs.org/@lumino/properties/-/properties-1.5.0.tgz", + "integrity": "sha512-YqpJE6/1Wkjrie0E+ypu+yzd55B5RlvKYMnQs3Ox+SrJsnNBhA6Oj44EhVf8SUTuHgn1t/mm+LvbswKN5RM4+g==", + "dev": true + }, + "@lumino/signaling": { + "version": "1.7.0", + "resolved": "https://registry.npmjs.org/@lumino/signaling/-/signaling-1.7.0.tgz", + "integrity": "sha512-a5kd11Sf04jTfpzxCr7TOBD2o5YvItA4IGwiOoG+QR6sPR0Rwmcf47fPItqXo5st58iNIblC3F+c264N+Me+gg==", + "dev": true, + "requires": { + "@lumino/algorithm": "^1.6.0" + } + }, + "@lumino/virtualdom": { + "version": "1.11.0", + "resolved": "https://registry.npmjs.org/@lumino/virtualdom/-/virtualdom-1.11.0.tgz", + "integrity": "sha512-G0sIx4pLYbgJ4w+SIgsCYQgKP/GBrWgjh8wcumD6XpaYZNivJv4c01xITYYlh7FU61jZmMWMrxtZztArNRDSqg==", + "dev": true, + "requires": { + "@lumino/algorithm": "^1.6.0" + } + }, + "@lumino/widgets": { + "version": "1.23.0", + "resolved": "https://registry.npmjs.org/@lumino/widgets/-/widgets-1.23.0.tgz", + "integrity": "sha512-0Akt9ESgc06SJ3EJG3VK1Liw+AAjRWkKMfm8VUTwT/1QJYYGZ8kfHNO97mkBLv+0EkLEkZIeaQb8fIoU6vh7bw==", + "dev": true, + "requires": { + "@lumino/algorithm": "^1.6.0", + "@lumino/commands": "^1.15.0", + "@lumino/coreutils": "^1.8.0", + "@lumino/disposable": "^1.7.0", + "@lumino/domutils": "^1.5.0", + "@lumino/dragdrop": "^1.10.0", + "@lumino/keyboard": "^1.5.0", + "@lumino/messaging": "^1.7.0", + "@lumino/properties": "^1.5.0", + "@lumino/signaling": "^1.7.0", + "@lumino/virtualdom": "^1.11.0" + } + }, + "@webassemblyjs/ast": { + "version": "1.11.0", + "resolved": "https://registry.npmjs.org/@webassemblyjs/ast/-/ast-1.11.0.tgz", + "integrity": "sha512-kX2W49LWsbthrmIRMbQZuQDhGtjyqXfEmmHyEi4XWnSZtPmxY0+3anPIzsnRb45VH/J55zlOfWvZuY47aJZTJg==", + "dev": true, + "requires": { + "@webassemblyjs/helper-numbers": "1.11.0", + "@webassemblyjs/helper-wasm-bytecode": "1.11.0" + } + }, + "@webassemblyjs/helper-api-error": { + "version": "1.11.0", + "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-api-error/-/helper-api-error-1.11.0.tgz", + "integrity": "sha512-baT/va95eXiXb2QflSx95QGT5ClzWpGaa8L7JnJbgzoYeaA27FCvuBXU758l+KXWRndEmUXjP0Q5fibhavIn8w==", + "dev": true + }, + "@webassemblyjs/helper-buffer": { + "version": "1.11.0", + "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-buffer/-/helper-buffer-1.11.0.tgz", + "integrity": "sha512-u9HPBEl4DS+vA8qLQdEQ6N/eJQ7gT7aNvMIo8AAWvAl/xMrcOSiI2M0MAnMCy3jIFke7bEee/JwdX1nUpCtdyA==", + "dev": true + }, + "@webassemblyjs/helper-wasm-bytecode": { + "version": "1.11.0", + "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-wasm-bytecode/-/helper-wasm-bytecode-1.11.0.tgz", + "integrity": "sha512-MbmhvxXExm542tWREgSFnOVo07fDpsBJg3sIl6fSp9xuu75eGz5lz31q7wTLffwL3Za7XNRCMZy210+tnsUSEA==", + "dev": true + }, + "@webassemblyjs/helper-wasm-section": { + "version": "1.11.0", + "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-wasm-section/-/helper-wasm-section-1.11.0.tgz", + "integrity": "sha512-3Eb88hcbfY/FCukrg6i3EH8H2UsD7x8Vy47iVJrP967A9JGqgBVL9aH71SETPx1JrGsOUVLo0c7vMCN22ytJew==", + "dev": true, + "requires": { + "@webassemblyjs/ast": "1.11.0", + "@webassemblyjs/helper-buffer": "1.11.0", + "@webassemblyjs/helper-wasm-bytecode": "1.11.0", + "@webassemblyjs/wasm-gen": "1.11.0" + } + }, + "@webassemblyjs/ieee754": { + "version": "1.11.0", + "resolved": "https://registry.npmjs.org/@webassemblyjs/ieee754/-/ieee754-1.11.0.tgz", + "integrity": "sha512-KXzOqpcYQwAfeQ6WbF6HXo+0udBNmw0iXDmEK5sFlmQdmND+tr773Ti8/5T/M6Tl/413ArSJErATd8In3B+WBA==", + "dev": true, + "requires": { + "@xtuc/ieee754": "^1.2.0" + } + }, + "@webassemblyjs/leb128": { + "version": "1.11.0", + "resolved": "https://registry.npmjs.org/@webassemblyjs/leb128/-/leb128-1.11.0.tgz", + "integrity": "sha512-aqbsHa1mSQAbeeNcl38un6qVY++hh8OpCOzxhixSYgbRfNWcxJNJQwe2rezK9XEcssJbbWIkblaJRwGMS9zp+g==", + "dev": true, + "requires": { + "@xtuc/long": "4.2.2" + } + }, + "@webassemblyjs/utf8": { + "version": "1.11.0", + "resolved": "https://registry.npmjs.org/@webassemblyjs/utf8/-/utf8-1.11.0.tgz", + "integrity": "sha512-A/lclGxH6SpSLSyFowMzO/+aDEPU4hvEiooCMXQPcQFPPJaYcPQNKGOCLUySJsYJ4trbpr+Fs08n4jelkVTGVw==", + "dev": true + }, + "@webassemblyjs/wasm-edit": { + "version": "1.11.0", + "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-edit/-/wasm-edit-1.11.0.tgz", + "integrity": "sha512-JHQ0damXy0G6J9ucyKVXO2j08JVJ2ntkdJlq1UTiUrIgfGMmA7Ik5VdC/L8hBK46kVJgujkBIoMtT8yVr+yVOQ==", + "dev": true, + "requires": { + "@webassemblyjs/ast": "1.11.0", + "@webassemblyjs/helper-buffer": "1.11.0", + "@webassemblyjs/helper-wasm-bytecode": "1.11.0", + "@webassemblyjs/helper-wasm-section": "1.11.0", + "@webassemblyjs/wasm-gen": "1.11.0", + "@webassemblyjs/wasm-opt": "1.11.0", + "@webassemblyjs/wasm-parser": "1.11.0", + "@webassemblyjs/wast-printer": "1.11.0" + } + }, + "@webassemblyjs/wasm-gen": { + "version": "1.11.0", + "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-gen/-/wasm-gen-1.11.0.tgz", + "integrity": "sha512-BEUv1aj0WptCZ9kIS30th5ILASUnAPEvE3tVMTrItnZRT9tXCLW2LEXT8ezLw59rqPP9klh9LPmpU+WmRQmCPQ==", + "dev": true, + "requires": { + "@webassemblyjs/ast": "1.11.0", + "@webassemblyjs/helper-wasm-bytecode": "1.11.0", + "@webassemblyjs/ieee754": "1.11.0", + "@webassemblyjs/leb128": "1.11.0", + "@webassemblyjs/utf8": "1.11.0" + } + }, + "@webassemblyjs/wasm-opt": { + "version": "1.11.0", + "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-opt/-/wasm-opt-1.11.0.tgz", + "integrity": "sha512-tHUSP5F4ywyh3hZ0+fDQuWxKx3mJiPeFufg+9gwTpYp324mPCQgnuVKwzLTZVqj0duRDovnPaZqDwoyhIO8kYg==", + "dev": true, + "requires": { + "@webassemblyjs/ast": "1.11.0", + "@webassemblyjs/helper-buffer": "1.11.0", + "@webassemblyjs/wasm-gen": "1.11.0", + "@webassemblyjs/wasm-parser": "1.11.0" + } + }, + "@webassemblyjs/wasm-parser": { + "version": "1.11.0", + "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-parser/-/wasm-parser-1.11.0.tgz", + "integrity": "sha512-6L285Sgu9gphrcpDXINvm0M9BskznnzJTE7gYkjDbxET28shDqp27wpruyx3C2S/dvEwiigBwLA1cz7lNUi0kw==", + "dev": true, + "requires": { + "@webassemblyjs/ast": "1.11.0", + "@webassemblyjs/helper-api-error": "1.11.0", + "@webassemblyjs/helper-wasm-bytecode": "1.11.0", + "@webassemblyjs/ieee754": "1.11.0", + "@webassemblyjs/leb128": "1.11.0", + "@webassemblyjs/utf8": "1.11.0" + } + }, + "@webassemblyjs/wast-printer": { + "version": "1.11.0", + "resolved": "https://registry.npmjs.org/@webassemblyjs/wast-printer/-/wast-printer-1.11.0.tgz", + "integrity": "sha512-Fg5OX46pRdTgB7rKIUojkh9vXaVN6sGYCnEiJN1GYkb0RPwShZXp6KTDqmoMdQPKhcroOXh3fEzmkWmCYaKYhQ==", + "dev": true, + "requires": { + "@webassemblyjs/ast": "1.11.0", + "@xtuc/long": "4.2.2" + } + }, + "acorn": { + "version": "8.2.4", + "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.2.4.tgz", + "integrity": "sha512-Ibt84YwBDDA890eDiDCEqcbwvHlBvzzDkU2cGBBDDI1QWT12jTiXIOn2CIw5KK4i6N5Z2HUxwYjzriDyqaqqZg==", + "dev": true + }, + "ajv": { + "version": "6.12.6", + "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz", + "integrity": "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==", + "dev": true, + "requires": { + "fast-deep-equal": "^3.1.1", + "fast-json-stable-stringify": "^2.0.0", + "json-schema-traverse": "^0.4.1", + "uri-js": "^4.2.2" + } + }, + "ajv-keywords": { + "version": "3.5.2", + "resolved": "https://registry.npmjs.org/ajv-keywords/-/ajv-keywords-3.5.2.tgz", + "integrity": "sha512-5p6WTN0DdTGVQk6VjcEju19IgaHudalcfabD7yhDGeA6bcQnmL+CpveLJq/3hvfwd1aof6L386Ougkx6RfyMIQ==", + "dev": true + }, + "browserslist": { + "version": "4.16.6", + "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.16.6.tgz", + "integrity": "sha512-Wspk/PqO+4W9qp5iUTJsa1B/QrYn1keNCcEP5OvP7WBwT4KaDly0uONYmC6Xa3Z5IqnUgS0KcgLYu1l74x0ZXQ==", + "dev": true, + "requires": { + "caniuse-lite": "^1.0.30001219", + "colorette": "^1.2.2", + "electron-to-chromium": "^1.3.723", + "escalade": "^3.1.1", + "node-releases": "^1.1.71" + } + }, + "cacache": { + "version": "15.0.6", + "resolved": "https://registry.npmjs.org/cacache/-/cacache-15.0.6.tgz", + "integrity": "sha512-g1WYDMct/jzW+JdWEyjaX2zoBkZ6ZT9VpOyp2I/VMtDsNLffNat3kqPFfi1eDRSK9/SuKGyORDHcQMcPF8sQ/w==", + "dev": true, + "requires": { + "@npmcli/move-file": "^1.0.1", + "chownr": "^2.0.0", + "fs-minipass": "^2.0.0", + "glob": "^7.1.4", + "infer-owner": "^1.0.4", + "lru-cache": "^6.0.0", + "minipass": "^3.1.1", + "minipass-collect": "^1.0.2", + "minipass-flush": "^1.0.5", + "minipass-pipeline": "^1.2.2", + "mkdirp": "^1.0.3", + "p-map": "^4.0.0", + "promise-inflight": "^1.0.1", + "rimraf": "^3.0.2", + "ssri": "^8.0.1", + "tar": "^6.0.2", + "unique-filename": "^1.1.1" + } + }, + "camelcase": { + "version": "6.2.0", + "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-6.2.0.tgz", + "integrity": "sha512-c7wVvbw3f37nuobQNtgsgG9POC9qMbNuMQmTCqZv23b6MIz0fcYpBiOlv9gEN/hdLdnZTDQhg6e9Dq5M1vKvfg==", + "dev": true + }, + "chownr": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/chownr/-/chownr-2.0.0.tgz", + "integrity": "sha512-bIomtDF5KGpdogkLd9VspvFzk9KfpyyGlS8YFVZl7TGPBHL5snIOnxeshwVgPteQ9b4Eydl+pVbIyE1DcvCWgQ==", + "dev": true + }, + "commander": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/commander/-/commander-6.0.0.tgz", + "integrity": "sha512-s7EA+hDtTYNhuXkTlhqew4txMZVdszBmKWSPEMxGr8ru8JXR7bLUFIAtPhcSuFdJQ0ILMxnJi8GkQL0yvDy/YA==", + "dev": true + }, + "cross-spawn": { + "version": "7.0.3", + "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.3.tgz", + "integrity": "sha512-iRDPJKUPVEND7dHPO8rkbOnPpyDygcDFtWjpeWNCgy8WP2rXcxXL8TskReQl6OrB2G7+UJrags1q15Fudc7G6w==", + "dev": true, + "requires": { + "path-key": "^3.1.0", + "shebang-command": "^2.0.0", + "which": "^2.0.1" + } + }, + "css-loader": { + "version": "5.2.4", + "resolved": "https://registry.npmjs.org/css-loader/-/css-loader-5.2.4.tgz", + "integrity": "sha512-OFYGyINCKkdQsTrSYxzGSFnGS4gNjcXkKkQgWxK138jgnPt+lepxdjSZNc8sHAl5vP3DhsJUxufWIjOwI8PMMw==", + "dev": true, + "requires": { + "camelcase": "^6.2.0", + "icss-utils": "^5.1.0", + "loader-utils": "^2.0.0", + "postcss": "^8.2.10", + "postcss-modules-extract-imports": "^3.0.0", + "postcss-modules-local-by-default": "^4.0.0", + "postcss-modules-scope": "^3.0.0", + "postcss-modules-values": "^4.0.0", + "postcss-value-parser": "^4.1.0", + "schema-utils": "^3.0.0", + "semver": "^7.3.5" + } + }, + "cssesc": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/cssesc/-/cssesc-3.0.0.tgz", + "integrity": "sha512-/Tb/JcjK111nNScGob5MNtsntNM1aCNUDipB/TkwZFhyDrrE47SOx/18wF2bbjgc3ZzCSKW1T5nt5EbFoAz/Vg==", + "dev": true + }, + "electron-to-chromium": { + "version": "1.3.728", + "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.3.728.tgz", + "integrity": "sha512-SHv4ziXruBpb1Nz4aTuqEHBYi/9GNCJMYIJgDEXrp/2V01nFXMNFUTli5Z85f5ivSkioLilQatqBYFB44wNJrA==", + "dev": true + }, + "emojis-list": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/emojis-list/-/emojis-list-3.0.0.tgz", + "integrity": "sha512-/kyM18EfinwXZbno9FyUGeFh87KC8HRQBQGildHZbEuRyWFOmv1U10o9BBp8XVZDVNNuQKyIGIu5ZYAAXJ0V2Q==", + "dev": true + }, + "enhanced-resolve": { + "version": "5.8.2", + "resolved": "https://registry.npmjs.org/enhanced-resolve/-/enhanced-resolve-5.8.2.tgz", + "integrity": "sha512-F27oB3WuHDzvR2DOGNTaYy0D5o0cnrv8TeI482VM4kYgQd/FT9lUQwuNsJ0oOHtBUq7eiW5ytqzp7nBFknL+GA==", + "dev": true, + "requires": { + "graceful-fs": "^4.2.4", + "tapable": "^2.2.0" + }, + "dependencies": { + "graceful-fs": { + "version": "4.2.6", + "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.6.tgz", + "integrity": "sha512-nTnJ528pbqxYanhpDYsi4Rd8MAeaBA67+RZ10CM1m3bTAVFEDcd5AuA4a6W5YkGZ1iNXHzZz8T6TBKLeBuNriQ==", + "dev": true + } + } + }, + "eslint-scope": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-5.1.1.tgz", + "integrity": "sha512-2NxwbF/hZ0KpepYN0cNbo+FN6XoK7GaHlQhgx/hIZl6Va0bF45RQOOwhLIy8lQDbuCiadSLCBnH2CFYquit5bw==", + "dev": true, + "requires": { + "esrecurse": "^4.3.0", + "estraverse": "^4.1.1" + } + }, + "esrecurse": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/esrecurse/-/esrecurse-4.3.0.tgz", + "integrity": "sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==", + "dev": true, + "requires": { + "estraverse": "^5.2.0" + }, + "dependencies": { + "estraverse": { + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-5.2.0.tgz", + "integrity": "sha512-BxbNGGNm0RyRYvUdHpIwv9IWzeM9XClbOxwoATuFdOE7ZE6wHL+HQ5T8hoPM+zHvmKzzsEqhgy0GrQ5X13afiQ==", + "dev": true + } + } + }, + "events": { + "version": "3.3.0", + "resolved": "https://registry.npmjs.org/events/-/events-3.3.0.tgz", + "integrity": "sha512-mQw+2fkQbALzQ7V0MY0IqdnXNOeTtP4r0lN9z7AAawCXgqea7bDii20AYrIBrFd/Hx0M2Ocz6S111CaFkUcb0Q==", + "dev": true + }, + "execa": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/execa/-/execa-5.0.0.tgz", + "integrity": "sha512-ov6w/2LCiuyO4RLYGdpFGjkcs0wMTgGE8PrkTHikeUy5iJekXyPIKUjifk5CsE0pt7sMCrMZ3YNqoCj6idQOnQ==", + "dev": true, + "requires": { + "cross-spawn": "^7.0.3", + "get-stream": "^6.0.0", + "human-signals": "^2.1.0", + "is-stream": "^2.0.0", + "merge-stream": "^2.0.0", + "npm-run-path": "^4.0.1", + "onetime": "^5.1.2", + "signal-exit": "^3.0.3", + "strip-final-newline": "^2.0.0" + } + }, + "fast-deep-equal": { + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz", + "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==", + "dev": true + }, + "find-cache-dir": { + "version": "3.3.1", + "resolved": "https://registry.npmjs.org/find-cache-dir/-/find-cache-dir-3.3.1.tgz", + "integrity": "sha512-t2GDMt3oGC/v+BMwzmllWDuJF/xcDtE5j/fCGbqDD7OLuJkj0cfh1YSA5VKPvwMeLFLNDBkwOKZ2X85jGLVftQ==", + "dev": true, + "requires": { + "commondir": "^1.0.1", + "make-dir": "^3.0.2", + "pkg-dir": "^4.1.0" + } + }, + "find-up": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/find-up/-/find-up-4.1.0.tgz", + "integrity": "sha512-PpOwAdQ/YlXQ2vj8a3h8IipDuYRi3wceVQQGYWxNINccq40Anw7BlsEXCMbt1Zt+OLA6Fq9suIpIWD0OsnISlw==", + "dev": true, + "requires": { + "locate-path": "^5.0.0", + "path-exists": "^4.0.0" + } + }, + "fs-extra": { + "version": "9.1.0", + "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-9.1.0.tgz", + "integrity": "sha512-hcg3ZmepS30/7BSFqRvoo3DOMQu7IjqxO5nCDt+zM9XWjb33Wg7ziNT+Qvqbuc3+gWpzO02JubVyk2G4Zvo1OQ==", + "dev": true, + "requires": { + "at-least-node": "^1.0.0", + "graceful-fs": "^4.2.0", + "jsonfile": "^6.0.1", + "universalify": "^2.0.0" + } + }, + "get-stream": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-6.0.1.tgz", + "integrity": "sha512-ts6Wi+2j3jQjqi70w5AlN8DFnkSwC+MqmxEzdEALB2qXZYV3X/b1CTfgPLGJNMeAWxdPfU8FO1ms3NUfaHCPYg==", + "dev": true + }, + "glob": { + "version": "7.1.7", + "resolved": "https://registry.npmjs.org/glob/-/glob-7.1.7.tgz", + "integrity": "sha512-OvD9ENzPLbegENnYP5UUfJIirTg4+XwMWGaQfQTY0JenxNvvIKP3U3/tAQSPIu/lHxXYSZmpXlUHeqAIdKzBLQ==", + "dev": true, + "requires": { + "fs.realpath": "^1.0.0", + "inflight": "^1.0.4", + "inherits": "2", + "minimatch": "^3.0.4", + "once": "^1.3.0", + "path-is-absolute": "^1.0.0" + } + }, + "has-flag": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", + "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", + "dev": true + }, + "icss-utils": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/icss-utils/-/icss-utils-5.1.0.tgz", + "integrity": "sha512-soFhflCVWLfRNOPU3iv5Z9VUdT44xFRbzjLsEzSr5AQmgqPMTHdU3PMT1Cf1ssx8fLNJDA1juftYl+PUcv3MqA==", + "dev": true + }, + "import-local": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/import-local/-/import-local-3.0.2.tgz", + "integrity": "sha512-vjL3+w0oulAVZ0hBHnxa/Nm5TAurf9YLQJDhqRZyqb+VKGOB6LU8t9H1Nr5CIo16vh9XfJTOoHwU0B71S557gA==", + "dev": true, + "requires": { + "pkg-dir": "^4.2.0", + "resolve-cwd": "^3.0.0" + } + }, + "interpret": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/interpret/-/interpret-2.2.0.tgz", + "integrity": "sha512-Ju0Bz/cEia55xDwUWEa8+olFpCiQoypjnQySseKtmjNrnps3P+xfpUmGr90T7yjlVJmOtybRvPXhKMbHr+fWnw==", + "dev": true + }, + "is-stream": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/is-stream/-/is-stream-2.0.0.tgz", + "integrity": "sha512-XCoy+WlUr7d1+Z8GgSuXmpuUFC9fOhRXglJMx+dwLKTkL44Cjd4W1Z5P+BQZpr+cR93aGP4S/s7Ftw6Nd/kiEw==", + "dev": true + }, + "json5": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/json5/-/json5-2.2.0.tgz", + "integrity": "sha512-f+8cldu7X/y7RAJurMEJmdoKXGB/X550w2Nr3tTbezL6RwEE/iMcm+tZnXeoZtKuOq6ft8+CqzEkrIgx1fPoQA==", + "dev": true, + "requires": { + "minimist": "^1.2.5" + } + }, + "jsonfile": { + "version": "6.1.0", + "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.1.0.tgz", + "integrity": "sha512-5dgndWOriYSm5cnYaJNhalLNDKOqFwyDB/rr1E9ZsGciGvKPs8R2xYGCacuf3z6K1YKDz182fd+fY3cn3pMqXQ==", + "dev": true, + "requires": { + "graceful-fs": "^4.1.6", + "universalify": "^2.0.0" + } + }, + "loader-runner": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/loader-runner/-/loader-runner-4.2.0.tgz", + "integrity": "sha512-92+huvxMvYlMzMt0iIOukcwYBFpkYJdpl2xsZ7LrlayO7E8SOv+JJUEK17B/dJIHAOLMfh2dZZ/Y18WgmGtYNw==", + "dev": true + }, + "loader-utils": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/loader-utils/-/loader-utils-2.0.0.tgz", + "integrity": "sha512-rP4F0h2RaWSvPEkD7BLDFQnvSf+nK+wr3ESUjNTyAGobqrijmW92zc+SO6d4p4B1wh7+B/Jg1mkQe5NYUEHtHQ==", + "dev": true, + "requires": { + "big.js": "^5.2.2", + "emojis-list": "^3.0.0", + "json5": "^2.1.2" + } + }, + "locate-path": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-5.0.0.tgz", + "integrity": "sha512-t7hw9pI+WvuwNJXwk5zVHpyhIqzg2qTlklJOf0mVxGSbe3Fp2VieZcduNYjaLDoy6p9uGpQEGWG87WpMKlNq8g==", + "dev": true, + "requires": { + "p-locate": "^4.1.0" + } + }, + "lru-cache": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-6.0.0.tgz", + "integrity": "sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA==", + "dev": true, + "requires": { + "yallist": "^4.0.0" + } + }, + "make-dir": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/make-dir/-/make-dir-3.1.0.tgz", + "integrity": "sha512-g3FeP20LNwhALb/6Cz6Dd4F2ngze0jz7tbzrD2wAV+o9FeNHe4rL+yK2md0J/fiSf1sa1ADhXqi5+oVwOM/eGw==", + "dev": true, + "requires": { + "semver": "^6.0.0" + }, + "dependencies": { + "semver": { + "version": "6.3.0", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.0.tgz", + "integrity": "sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==", + "dev": true + } + } + }, + "mime-db": { + "version": "1.47.0", + "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.47.0.tgz", + "integrity": "sha512-QBmA/G2y+IfeS4oktet3qRZ+P5kPhCKRXxXnQEudYqUaEioAU1/Lq2us3D/t1Jfo4hE9REQPrbB7K5sOczJVIw==", + "dev": true + }, + "mime-types": { + "version": "2.1.30", + "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.30.tgz", + "integrity": "sha512-crmjA4bLtR8m9qLpHvgxSChT+XoSlZi8J4n/aIdn3z92e/U47Z0V/yl+Wh9W046GgFVAmoNR/fmdbZYcSSIUeg==", + "dev": true, + "requires": { + "mime-db": "1.47.0" + } + }, + "mimic-fn": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/mimic-fn/-/mimic-fn-2.1.0.tgz", + "integrity": "sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg==", + "dev": true + }, + "minimist": { + "version": "1.2.5", + "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.5.tgz", + "integrity": "sha512-FM9nNUYrRBAELZQT3xeZQ7fmMOBg6nWNmJKTcgsJeaLstP/UODVpGsr5OhXhhXg6f+qtJ8uiZ+PUxkDWcgIXLw==", + "dev": true + }, + "mkdirp": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-1.0.4.tgz", + "integrity": "sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw==", + "dev": true + }, + "neo-async": { + "version": "2.6.2", + "resolved": "https://registry.npmjs.org/neo-async/-/neo-async-2.6.2.tgz", + "integrity": "sha512-Yd3UES5mWCSqR+qNT93S3UoYUkqAZ9lLg8a7g9rimsWmYGK8cVToA4/sF3RrshdyV3sAGMXVUmpMYOw+dLpOuw==", + "dev": true + }, + "npm-run-path": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/npm-run-path/-/npm-run-path-4.0.1.tgz", + "integrity": "sha512-S48WzZW777zhNIrn7gxOlISNAqi9ZC/uQFnRdbeIHhZhCA6UqpkOT8T1G7BvfdgP4Er8gF4sUbaS0i7QvIfCWw==", + "dev": true, + "requires": { + "path-key": "^3.0.0" + } + }, + "onetime": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/onetime/-/onetime-5.1.2.tgz", + "integrity": "sha512-kbpaSSGJTWdAY5KPVeMOKXSrPtr8C8C7wodJbcsd51jRnmD+GZu8Y0VoU6Dm5Z4vWr0Ig/1NKuWRKf7j5aaYSg==", + "dev": true, + "requires": { + "mimic-fn": "^2.1.0" + } + }, + "p-limit": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz", + "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==", + "dev": true, + "requires": { + "yocto-queue": "^0.1.0" + } + }, + "p-locate": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-4.1.0.tgz", + "integrity": "sha512-R79ZZ/0wAxKGu3oYMlz8jy/kbhsNrS7SKZ7PxEHBgJ5+F2mtFW2fK2cOtBh1cHYkQsbzFV7I+EoRKe6Yt0oK7A==", + "dev": true, + "requires": { + "p-limit": "^2.2.0" + }, + "dependencies": { + "p-limit": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-2.3.0.tgz", + "integrity": "sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w==", + "dev": true, + "requires": { + "p-try": "^2.0.0" + } + } + } + }, + "p-try": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/p-try/-/p-try-2.2.0.tgz", + "integrity": "sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ==", + "dev": true + }, + "path-browserify": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/path-browserify/-/path-browserify-1.0.1.tgz", + "integrity": "sha512-b7uo2UCUOYZcnF/3ID0lulOJi/bafxa1xPe7ZPsammBSpjSWQkjNxlt635YGS2MiR9GjvuXCtz2emr3jbsz98g==", + "dev": true + }, + "path-exists": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz", + "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==", + "dev": true + }, + "path-key": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz", + "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==", + "dev": true + }, + "pkg-dir": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/pkg-dir/-/pkg-dir-4.2.0.tgz", + "integrity": "sha512-HRDzbaKjC+AOWVXxAU/x54COGeIv9eb+6CkDSQoNTt4XyWoIJvuPsXizxu/Fr23EiekbtZwmh1IcIG/l/a10GQ==", + "dev": true, + "requires": { + "find-up": "^4.0.0" + } + }, + "postcss": { + "version": "8.2.15", + "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.2.15.tgz", + "integrity": "sha512-2zO3b26eJD/8rb106Qu2o7Qgg52ND5HPjcyQiK2B98O388h43A448LCslC0dI2P97wCAQRJsFvwTRcXxTKds+Q==", + "dev": true, + "requires": { + "colorette": "^1.2.2", + "nanoid": "^3.1.23", + "source-map": "^0.6.1" + } + }, + "postcss-modules-extract-imports": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/postcss-modules-extract-imports/-/postcss-modules-extract-imports-3.0.0.tgz", + "integrity": "sha512-bdHleFnP3kZ4NYDhuGlVK+CMrQ/pqUm8bx/oGL93K6gVwiclvX5x0n76fYMKuIGKzlABOy13zsvqjb0f92TEXw==", + "dev": true + }, + "postcss-modules-local-by-default": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/postcss-modules-local-by-default/-/postcss-modules-local-by-default-4.0.0.tgz", + "integrity": "sha512-sT7ihtmGSF9yhm6ggikHdV0hlziDTX7oFoXtuVWeDd3hHObNkcHRo9V3yg7vCAY7cONyxJC/XXCmmiHHcvX7bQ==", + "dev": true, + "requires": { + "icss-utils": "^5.0.0", + "postcss-selector-parser": "^6.0.2", + "postcss-value-parser": "^4.1.0" + } + }, + "postcss-modules-scope": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/postcss-modules-scope/-/postcss-modules-scope-3.0.0.tgz", + "integrity": "sha512-hncihwFA2yPath8oZ15PZqvWGkWf+XUfQgUGamS4LqoP1anQLOsOJw0vr7J7IwLpoY9fatA2qiGUGmuZL0Iqlg==", + "dev": true, + "requires": { + "postcss-selector-parser": "^6.0.4" + } + }, + "postcss-modules-values": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/postcss-modules-values/-/postcss-modules-values-4.0.0.tgz", + "integrity": "sha512-RDxHkAiEGI78gS2ofyvCsu7iycRv7oqw5xMWn9iMoR0N/7mf9D50ecQqUo5BZ9Zh2vH4bCUR/ktCqbB9m8vJjQ==", + "dev": true, + "requires": { + "icss-utils": "^5.0.0" + } + }, + "postcss-selector-parser": { + "version": "6.0.6", + "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-6.0.6.tgz", + "integrity": "sha512-9LXrvaaX3+mcv5xkg5kFwqSzSH1JIObIx51PrndZwlmznwXRfxMddDvo9gve3gVR8ZTKgoFDdWkbRFmEhT4PMg==", + "dev": true, + "requires": { + "cssesc": "^3.0.0", + "util-deprecate": "^1.0.2" + } + }, + "postcss-value-parser": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/postcss-value-parser/-/postcss-value-parser-4.1.0.tgz", + "integrity": "sha512-97DXOFbQJhk71ne5/Mt6cOu6yxsSfM0QGQyl0L25Gca4yGWEGJaig7l7gbCX623VqTBNGLRLaVUCnNkcedlRSQ==", + "dev": true + }, + "raw-loader": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/raw-loader/-/raw-loader-4.0.2.tgz", + "integrity": "sha512-ZnScIV3ag9A4wPX/ZayxL/jZH+euYb6FcUinPcgiQW0+UBtEv0O6Q3lGd3cqJ+GHH+rksEv3Pj99oxJ3u3VIKA==", + "dev": true, + "requires": { + "loader-utils": "^2.0.0", + "schema-utils": "^3.0.0" + } + }, + "resolve-cwd": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/resolve-cwd/-/resolve-cwd-3.0.0.tgz", + "integrity": "sha512-OrZaX2Mb+rJCpH/6CpSqt9xFVpN++x01XnN2ie9g6P5/3xelLAkXWVADpdz1IHD/KFfEXyE6V0U01OQ3UO2rEg==", + "dev": true, + "requires": { + "resolve-from": "^5.0.0" + } + }, + "resolve-from": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-5.0.0.tgz", + "integrity": "sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw==", + "dev": true + }, + "rimraf": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-3.0.2.tgz", + "integrity": "sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==", + "dev": true, + "requires": { + "glob": "^7.1.3" + } + }, + "schema-utils": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/schema-utils/-/schema-utils-3.0.0.tgz", + "integrity": "sha512-6D82/xSzO094ajanoOSbe4YvXWMfn2A//8Y1+MUqFAJul5Bs+yn36xbK9OtNDcRVSBJ9jjeoXftM6CfztsjOAA==", + "dev": true, + "requires": { + "@types/json-schema": "^7.0.6", + "ajv": "^6.12.5", + "ajv-keywords": "^3.5.2" + } + }, + "semver": { + "version": "7.3.5", + "resolved": "https://registry.npmjs.org/semver/-/semver-7.3.5.tgz", + "integrity": "sha512-PoeGJYh8HK4BTO/a9Tf6ZG3veo/A7ZVsYrSA6J8ny9nb3B1VrpkuN+z9OE5wfE5p6H4LchYZsegiQgbJD94ZFQ==", + "dev": true, + "requires": { + "lru-cache": "^6.0.0" + } + }, + "serialize-javascript": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/serialize-javascript/-/serialize-javascript-5.0.1.tgz", + "integrity": "sha512-SaaNal9imEO737H2c05Og0/8LUXG7EnsZyMa8MzkmuHoELfT6txuj0cMqRj6zfPKnmQ1yasR4PCJc8x+M4JSPA==", + "dev": true, + "requires": { + "randombytes": "^2.1.0" + } + }, + "shebang-command": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz", + "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==", + "dev": true, + "requires": { + "shebang-regex": "^3.0.0" + } + }, + "shebang-regex": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz", + "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==", + "dev": true + }, + "signal-exit": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.3.tgz", + "integrity": "sha512-VUJ49FC8U1OxwZLxIbTTrDvLnf/6TDgxZcK8wxR8zs13xpx7xbG60ndBlhNrFi2EMuFRoeDoJO7wthSLq42EjA==", + "dev": true + }, + "source-map": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz", + "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==", + "dev": true + }, + "source-map-support": { + "version": "0.5.19", + "resolved": "https://registry.npmjs.org/source-map-support/-/source-map-support-0.5.19.tgz", + "integrity": "sha512-Wonm7zOCIJzBGQdB+thsPar0kYuCIzYvxZwlBa87yi/Mdjv7Tip2cyVbLj5o0cFPN4EVkuTwb3GDDyUx2DGnGw==", + "dev": true, + "requires": { + "buffer-from": "^1.0.0", + "source-map": "^0.6.0" + } + }, + "ssri": { + "version": "8.0.1", + "resolved": "https://registry.npmjs.org/ssri/-/ssri-8.0.1.tgz", + "integrity": "sha512-97qShzy1AiyxvPNIkLWoGua7xoQzzPjQ0HAH4B0rWKo7SZ6USuPcrUiAFrws0UH8RrbWmgq3LMTObhPIHbbBeQ==", + "dev": true, + "requires": { + "minipass": "^3.1.1" + } + }, + "style-loader": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/style-loader/-/style-loader-2.0.0.tgz", + "integrity": "sha512-Z0gYUJmzZ6ZdRUqpg1r8GsaFKypE+3xAzuFeMuoHgjc9KZv3wMyCRjQIWEbhoFSq7+7yoHXySDJyyWQaPajeiQ==", + "dev": true, + "requires": { + "loader-utils": "^2.0.0", + "schema-utils": "^3.0.0" + } + }, + "supports-color": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", + "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", + "dev": true, + "requires": { + "has-flag": "^4.0.0" + } + }, + "tapable": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/tapable/-/tapable-2.2.0.tgz", + "integrity": "sha512-FBk4IesMV1rBxX2tfiK8RAmogtWn53puLOQlvO8XuwlgxcYbP4mVPS9Ph4aeamSyyVjOl24aYWAuc8U5kCVwMw==", + "dev": true + }, + "terser": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/terser/-/terser-5.7.0.tgz", + "integrity": "sha512-HP5/9hp2UaZt5fYkuhNBR8YyRcT8juw8+uFbAme53iN9hblvKnLUTKkmwJG6ocWpIKf8UK4DoeWG4ty0J6S6/g==", + "dev": true, + "requires": { + "commander": "^2.20.0", + "source-map": "~0.7.2", + "source-map-support": "~0.5.19" + }, + "dependencies": { + "commander": { + "version": "2.20.3", + "resolved": "https://registry.npmjs.org/commander/-/commander-2.20.3.tgz", + "integrity": "sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ==", + "dev": true + }, + "source-map": { + "version": "0.7.3", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.7.3.tgz", + "integrity": "sha512-CkCj6giN3S+n9qrYiBTX5gystlENnRW5jZeNLHpe6aue+SrHcG5VYwujhW9s4dY31mEGsxBDrHR6oI69fTXsaQ==", + "dev": true + } + } + }, + "terser-webpack-plugin": { + "version": "4.2.3", + "resolved": "https://registry.npmjs.org/terser-webpack-plugin/-/terser-webpack-plugin-4.2.3.tgz", + "integrity": "sha512-jTgXh40RnvOrLQNgIkwEKnQ8rmHjHK4u+6UBEi+W+FPmvb+uo+chJXntKe7/3lW5mNysgSWD60KyesnhW8D6MQ==", + "dev": true, + "requires": { + "cacache": "^15.0.5", + "find-cache-dir": "^3.3.1", + "jest-worker": "^26.5.0", + "p-limit": "^3.0.2", + "schema-utils": "^3.0.0", + "serialize-javascript": "^5.0.1", + "source-map": "^0.6.1", + "terser": "^5.3.4", + "webpack-sources": "^1.4.3" + } + }, + "universalify": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.0.tgz", + "integrity": "sha512-hAZsKq7Yy11Zu1DE0OzWjw7nnLZmJZYTDZZyEFHZdUhV8FkH5MCfoU1XMaxXovpyW5nq5scPqq0ZDP9Zyl04oQ==", + "dev": true + }, + "url-loader": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/url-loader/-/url-loader-4.1.1.tgz", + "integrity": "sha512-3BTV812+AVHHOJQO8O5MkWgZ5aosP7GnROJwvzLS9hWDj00lZ6Z0wNak423Lp9PBZN05N+Jk/N5Si8jRAlGyWA==", + "dev": true, + "requires": { + "loader-utils": "^2.0.0", + "mime-types": "^2.1.27", + "schema-utils": "^3.0.0" + } + }, + "v8-compile-cache": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/v8-compile-cache/-/v8-compile-cache-2.3.0.tgz", + "integrity": "sha512-l8lCEmLcLYZh4nbunNZvQCJc5pv7+RCwa8q/LdUx8u7lsWvPDKmpodJAJNwkAhJC//dFY48KuIEmjtd4RViDrA==", + "dev": true + }, + "watchpack": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/watchpack/-/watchpack-2.1.1.tgz", + "integrity": "sha512-Oo7LXCmc1eE1AjyuSBmtC3+Wy4HcV8PxWh2kP6fOl8yTlNS7r0K9l1ao2lrrUza7V39Y3D/BbJgY8VeSlc5JKw==", + "dev": true, + "requires": { + "glob-to-regexp": "^0.4.1", + "graceful-fs": "^4.1.2" + } + }, + "webpack": { + "version": "5.37.0", + "resolved": "https://registry.npmjs.org/webpack/-/webpack-5.37.0.tgz", + "integrity": "sha512-yvdhgcI6QkQkDe1hINBAJ1UNevqNGTVaCkD2SSJcB8rcrNNl922RI8i2DXUAuNfANoxwsiXXEA4ZPZI9q2oGLA==", + "dev": true, + "requires": { + "@types/eslint-scope": "^3.7.0", + "@types/estree": "^0.0.47", + "@webassemblyjs/ast": "1.11.0", + "@webassemblyjs/wasm-edit": "1.11.0", + "@webassemblyjs/wasm-parser": "1.11.0", + "acorn": "^8.2.1", + "browserslist": "^4.14.5", + "chrome-trace-event": "^1.0.2", + "enhanced-resolve": "^5.8.0", + "es-module-lexer": "^0.4.0", + "eslint-scope": "^5.1.1", + "events": "^3.2.0", + "glob-to-regexp": "^0.4.1", + "graceful-fs": "^4.2.4", + "json-parse-better-errors": "^1.0.2", + "loader-runner": "^4.2.0", + "mime-types": "^2.1.27", + "neo-async": "^2.6.2", + "schema-utils": "^3.0.0", + "tapable": "^2.1.1", + "terser-webpack-plugin": "^5.1.1", + "watchpack": "^2.0.0", + "webpack-sources": "^2.1.1" + }, + "dependencies": { + "graceful-fs": { + "version": "4.2.6", + "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.6.tgz", + "integrity": "sha512-nTnJ528pbqxYanhpDYsi4Rd8MAeaBA67+RZ10CM1m3bTAVFEDcd5AuA4a6W5YkGZ1iNXHzZz8T6TBKLeBuNriQ==", + "dev": true + }, + "terser-webpack-plugin": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/terser-webpack-plugin/-/terser-webpack-plugin-5.1.2.tgz", + "integrity": "sha512-6QhDaAiVHIQr5Ab3XUWZyDmrIPCHMiqJVljMF91YKyqwKkL5QHnYMkrMBy96v9Z7ev1hGhSEw1HQZc2p/s5Z8Q==", + "dev": true, + "requires": { + "jest-worker": "^26.6.2", + "p-limit": "^3.1.0", + "schema-utils": "^3.0.0", + "serialize-javascript": "^5.0.1", + "source-map": "^0.6.1", + "terser": "^5.7.0" + } + }, + "webpack-sources": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/webpack-sources/-/webpack-sources-2.2.0.tgz", + "integrity": "sha512-bQsA24JLwcnWGArOKUxYKhX3Mz/nK1Xf6hxullKERyktjNMC4x8koOeaDNTA2fEJ09BdWLbM/iTW0ithREUP0w==", + "dev": true, + "requires": { + "source-list-map": "^2.0.1", + "source-map": "^0.6.1" + } + } + } + }, + "webpack-cli": { + "version": "4.7.0", + "resolved": "https://registry.npmjs.org/webpack-cli/-/webpack-cli-4.7.0.tgz", + "integrity": "sha512-7bKr9182/sGfjFm+xdZSwgQuFjgEcy0iCTIBxRUeteJ2Kr8/Wz0qNJX+jw60LU36jApt4nmMkep6+W5AKhok6g==", + "dev": true, + "requires": { + "@discoveryjs/json-ext": "^0.5.0", + "@webpack-cli/configtest": "^1.0.3", + "@webpack-cli/info": "^1.2.4", + "@webpack-cli/serve": "^1.4.0", + "colorette": "^1.2.1", + "commander": "^7.0.0", + "execa": "^5.0.0", + "fastest-levenshtein": "^1.0.12", + "import-local": "^3.0.2", + "interpret": "^2.2.0", + "rechoir": "^0.7.0", + "v8-compile-cache": "^2.2.0", + "webpack-merge": "^5.7.3" + }, + "dependencies": { + "commander": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/commander/-/commander-7.2.0.tgz", + "integrity": "sha512-QrWXB+ZQSVPmIWIhtEO9H+gwHaMGYiF5ChvoJ+K9ZGHG/sVsa6yiesAD1GC/x46sET00Xlwo1u49RVVVzvcSkw==", + "dev": true + } + } + }, + "which": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz", + "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==", + "dev": true, + "requires": { + "isexe": "^2.0.0" + } + }, + "yallist": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz", + "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==", + "dev": true + } + } + }, + "@jupyterlab/buildutils": { + "version": "3.0.6", + "resolved": "https://registry.npmjs.org/@jupyterlab/buildutils/-/buildutils-3.0.6.tgz", + "integrity": "sha512-S6Hnop5A5KjCCHQt1ob3ABy1VQ94ssbRPsYa04R7mUjVQu5NsIS8Kd0O/+yqtuSaWIJOqCKhRZEev3rgG+dHqw==", + "dev": true, + "requires": { + "@lumino/coreutils": "^1.5.3", + "@yarnpkg/lockfile": "^1.1.0", + "child_process": "~1.0.2", + "commander": "~6.0.0", + "crypto": "~1.0.1", + "dependency-graph": "^0.9.0", + "fs-extra": "^9.0.1", + "glob": "~7.1.6", + "inquirer": "^7.0.0", + "package-json": "^6.5.0", + "prettier": "^2.1.1", + "semver": "^7.3.2", + "sort-package-json": "~1.44.0", + "typescript": "~4.1.3" + }, + "dependencies": { + "@lumino/coreutils": { + "version": "1.8.0", + "resolved": "https://registry.npmjs.org/@lumino/coreutils/-/coreutils-1.8.0.tgz", + "integrity": "sha512-OvCsaASUqOE7R6Dxngyk4/b5QMOjyRUNxuZuuL+fx+JvGKZFZ/B2c9LYtAJ9mDmQ1BQiGNV/qSpL4o7x8PCfjw==", + "dev": true + }, + "ansi-escapes": { + "version": "4.3.2", + "resolved": "https://registry.npmjs.org/ansi-escapes/-/ansi-escapes-4.3.2.tgz", + "integrity": "sha512-gKXj5ALrKWQLsYG9jlTRmR/xKluxHV+Z9QEwNIgCfM1/uwPMCuzVVnh5mwTd+OuBZcwSIMbqssNWRm1lE51QaQ==", + "dev": true, + "requires": { + "type-fest": "^0.21.3" + } + }, + "ansi-regex": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.0.tgz", + "integrity": "sha512-bY6fj56OUQ0hU1KjFNDQuJFezqKdrAyFdIevADiqrWHwSlbmBNMHp5ak2f40Pm8JTFyM2mqxkG6ngkHO11f/lg==", + "dev": true + }, + "ansi-styles": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", + "dev": true, + "requires": { + "color-convert": "^2.0.1" + } + }, + "chalk": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.1.tgz", + "integrity": "sha512-diHzdDKxcU+bAsUboHLPEDQiw0qEe0qd7SYUn3HgcFlWgbDcfLGswOHYeGrHKzG9z6UYf01d9VFMfZxPM1xZSg==", + "dev": true, + "requires": { + "ansi-styles": "^4.1.0", + "supports-color": "^7.1.0" + } + }, + "cli-cursor": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/cli-cursor/-/cli-cursor-3.1.0.tgz", + "integrity": "sha512-I/zHAwsKf9FqGoXM4WWRACob9+SNukZTd94DWF57E4toouRulbCxcUh6RKUEOQlYTHJnzkPMySvPNaaSLNfLZw==", + "dev": true, + "requires": { + "restore-cursor": "^3.1.0" + } + }, + "cli-width": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/cli-width/-/cli-width-3.0.0.tgz", + "integrity": "sha512-FxqpkPPwu1HjuN93Omfm4h8uIanXofW0RxVEW3k5RKx+mJJYSthzNhp32Kzxxy3YAEZ/Dc/EWN1vZRY0+kOhbw==", + "dev": true + }, + "color-convert": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", + "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", + "dev": true, + "requires": { + "color-name": "~1.1.4" + } + }, + "color-name": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", + "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==", + "dev": true + }, + "commander": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/commander/-/commander-6.0.0.tgz", + "integrity": "sha512-s7EA+hDtTYNhuXkTlhqew4txMZVdszBmKWSPEMxGr8ru8JXR7bLUFIAtPhcSuFdJQ0ILMxnJi8GkQL0yvDy/YA==", + "dev": true + }, + "emoji-regex": { + "version": "8.0.0", + "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz", + "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==", + "dev": true + }, + "figures": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/figures/-/figures-3.2.0.tgz", + "integrity": "sha512-yaduQFRKLXYOGgEn6AZau90j3ggSOyiqXU0F9JZfeXYhNa+Jk4X+s45A2zg5jns87GAFa34BBm2kXw4XpNcbdg==", + "dev": true, + "requires": { + "escape-string-regexp": "^1.0.5" + } + }, + "fs-extra": { + "version": "9.1.0", + "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-9.1.0.tgz", + "integrity": "sha512-hcg3ZmepS30/7BSFqRvoo3DOMQu7IjqxO5nCDt+zM9XWjb33Wg7ziNT+Qvqbuc3+gWpzO02JubVyk2G4Zvo1OQ==", + "dev": true, + "requires": { + "at-least-node": "^1.0.0", + "graceful-fs": "^4.2.0", + "jsonfile": "^6.0.1", + "universalify": "^2.0.0" + } + }, + "glob": { + "version": "7.1.7", + "resolved": "https://registry.npmjs.org/glob/-/glob-7.1.7.tgz", + "integrity": "sha512-OvD9ENzPLbegENnYP5UUfJIirTg4+XwMWGaQfQTY0JenxNvvIKP3U3/tAQSPIu/lHxXYSZmpXlUHeqAIdKzBLQ==", + "dev": true, + "requires": { + "fs.realpath": "^1.0.0", + "inflight": "^1.0.4", + "inherits": "2", + "minimatch": "^3.0.4", + "once": "^1.3.0", + "path-is-absolute": "^1.0.0" + } + }, + "has-flag": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", + "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", + "dev": true + }, + "inquirer": { + "version": "7.3.3", + "resolved": "https://registry.npmjs.org/inquirer/-/inquirer-7.3.3.tgz", + "integrity": "sha512-JG3eIAj5V9CwcGvuOmoo6LB9kbAYT8HXffUl6memuszlwDC/qvFAJw49XJ5NROSFNPxp3iQg1GqkFhaY/CR0IA==", + "dev": true, + "requires": { + "ansi-escapes": "^4.2.1", + "chalk": "^4.1.0", + "cli-cursor": "^3.1.0", + "cli-width": "^3.0.0", + "external-editor": "^3.0.3", + "figures": "^3.0.0", + "lodash": "^4.17.19", + "mute-stream": "0.0.8", + "run-async": "^2.4.0", + "rxjs": "^6.6.0", + "string-width": "^4.1.0", + "strip-ansi": "^6.0.0", + "through": "^2.3.6" + } + }, + "is-fullwidth-code-point": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz", + "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==", + "dev": true + }, + "jsonfile": { + "version": "6.1.0", + "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.1.0.tgz", + "integrity": "sha512-5dgndWOriYSm5cnYaJNhalLNDKOqFwyDB/rr1E9ZsGciGvKPs8R2xYGCacuf3z6K1YKDz182fd+fY3cn3pMqXQ==", + "dev": true, + "requires": { + "graceful-fs": "^4.1.6", + "universalify": "^2.0.0" + } + }, + "lodash": { + "version": "4.17.21", + "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.21.tgz", + "integrity": "sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==", + "dev": true + }, + "lru-cache": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-6.0.0.tgz", + "integrity": "sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA==", + "dev": true, + "requires": { + "yallist": "^4.0.0" + } + }, + "mimic-fn": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/mimic-fn/-/mimic-fn-2.1.0.tgz", + "integrity": "sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg==", + "dev": true + }, + "mute-stream": { + "version": "0.0.8", + "resolved": "https://registry.npmjs.org/mute-stream/-/mute-stream-0.0.8.tgz", + "integrity": "sha512-nnbWWOkoWyUsTjKrhgD0dcz22mdkSnpYqbEjIm2nhwhuxlSkpywJmBo8h0ZqJdkp73mb90SssHkN4rsRaBAfAA==", + "dev": true + }, + "onetime": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/onetime/-/onetime-5.1.2.tgz", + "integrity": "sha512-kbpaSSGJTWdAY5KPVeMOKXSrPtr8C8C7wodJbcsd51jRnmD+GZu8Y0VoU6Dm5Z4vWr0Ig/1NKuWRKf7j5aaYSg==", + "dev": true, + "requires": { + "mimic-fn": "^2.1.0" + } + }, + "restore-cursor": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/restore-cursor/-/restore-cursor-3.1.0.tgz", + "integrity": "sha512-l+sSefzHpj5qimhFSE5a8nufZYAM3sBSVMAPtYkmC+4EH2anSGaEMXSD0izRQbu9nfyQ9y5JrVmp7E8oZrUjvA==", + "dev": true, + "requires": { + "onetime": "^5.1.0", + "signal-exit": "^3.0.2" + } + }, + "run-async": { + "version": "2.4.1", + "resolved": "https://registry.npmjs.org/run-async/-/run-async-2.4.1.tgz", + "integrity": "sha512-tvVnVv01b8c1RrA6Ep7JkStj85Guv/YrMcwqYQnwjsAS2cTmmPGBBjAjpCW7RrSodNSoE2/qg9O4bceNvUuDgQ==", + "dev": true + }, + "rxjs": { + "version": "6.6.7", + "resolved": "https://registry.npmjs.org/rxjs/-/rxjs-6.6.7.tgz", + "integrity": "sha512-hTdwr+7yYNIT5n4AMYp85KA6yw2Va0FLa3Rguvbpa4W3I5xynaBZo41cM3XM+4Q6fRMj3sBYIR1VAmZMXYJvRQ==", + "dev": true, + "requires": { + "tslib": "^1.9.0" + } + }, + "semver": { + "version": "7.3.5", + "resolved": "https://registry.npmjs.org/semver/-/semver-7.3.5.tgz", + "integrity": "sha512-PoeGJYh8HK4BTO/a9Tf6ZG3veo/A7ZVsYrSA6J8ny9nb3B1VrpkuN+z9OE5wfE5p6H4LchYZsegiQgbJD94ZFQ==", + "dev": true, + "requires": { + "lru-cache": "^6.0.0" + } + }, + "string-width": { + "version": "4.2.2", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.2.tgz", + "integrity": "sha512-XBJbT3N4JhVumXE0eoLU9DCjcaF92KLNqTmFCnG1pf8duUxFGwtP6AD6nkjw9a3IdiRtL3E2w3JDiE/xi3vOeA==", + "dev": true, + "requires": { + "emoji-regex": "^8.0.0", + "is-fullwidth-code-point": "^3.0.0", + "strip-ansi": "^6.0.0" + } + }, + "strip-ansi": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.0.tgz", + "integrity": "sha512-AuvKTrTfQNYNIctbR1K/YGTR1756GycPsg7b9bdV9Duqur4gv6aKqHXah67Z8ImS7WEz5QVcOtlfW2rZEugt6w==", + "dev": true, + "requires": { + "ansi-regex": "^5.0.0" + } + }, + "supports-color": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", + "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", + "dev": true, + "requires": { + "has-flag": "^4.0.0" + } + }, + "typescript": { + "version": "4.1.5", + "resolved": "https://registry.npmjs.org/typescript/-/typescript-4.1.5.tgz", + "integrity": "sha512-6OSu9PTIzmn9TCDiovULTnET6BgXtDYL4Gg4szY+cGsc3JP1dQL8qvE8kShTRx1NIw4Q9IBHlwODjkjWEtMUyA==", + "dev": true + }, + "universalify": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.0.tgz", + "integrity": "sha512-hAZsKq7Yy11Zu1DE0OzWjw7nnLZmJZYTDZZyEFHZdUhV8FkH5MCfoU1XMaxXovpyW5nq5scPqq0ZDP9Zyl04oQ==", + "dev": true + }, + "yallist": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz", + "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==", + "dev": true + } + } + }, + "@jupyterlab/coreutils": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/@jupyterlab/coreutils/-/coreutils-3.2.0.tgz", + "integrity": "sha512-LATiUsHuwze/h3JC2EZOBV+kGBoUKO3npqw/Pcgge4bz09xF/oTDrx4G8jl5eew3w1dCUNp9eLduNh8Orrw7xQ==", + "requires": { + "@phosphor/commands": "^1.7.0", + "@phosphor/coreutils": "^1.3.1", + "@phosphor/disposable": "^1.3.0", + "@phosphor/properties": "^1.1.3", + "@phosphor/signaling": "^1.3.0", + "ajv": "^6.5.5", + "json5": "^2.1.0", + "minimist": "~1.2.0", + "moment": "^2.24.0", + "path-posix": "~1.0.0", + "url-parse": "~1.4.3" + } + }, + "@jupyterlab/nbformat": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/@jupyterlab/nbformat/-/nbformat-2.1.0.tgz", + "integrity": "sha512-4NybeAvLTpGLZguARl6g4ENGzIPYwUaU+CZpcH2H0vq47oXrzRrZMsiWq5Dufrn0sIhOD9CINHXJ9mxIYzj/JA==", + "requires": { + "@lumino/coreutils": "^1.4.2" + } + }, + "@jupyterlab/observables": { + "version": "2.4.0", + "resolved": "https://registry.npmjs.org/@jupyterlab/observables/-/observables-2.4.0.tgz", + "integrity": "sha512-M/fhAnPqd6F4Zwt4IIsvHCkJmwbSw1Tko/hUXgdUQG86lPsJiTOh98sB3qwV1gtzb9oFF+kH21XsHnQZ6Yl6Pw==", + "requires": { + "@phosphor/algorithm": "^1.2.0", + "@phosphor/coreutils": "^1.3.1", + "@phosphor/disposable": "^1.3.0", + "@phosphor/messaging": "^1.3.0", + "@phosphor/signaling": "^1.3.0" + } + }, + "@jupyterlab/services": { + "version": "4.2.2", + "resolved": "https://registry.npmjs.org/@jupyterlab/services/-/services-4.2.2.tgz", + "integrity": "sha512-1CNSsPbaAWaRkb3s5a+qpqMq/62RjLggL3MoSlGlp0Mi7jfJ8EJFIrnlRn4/a9/QwY3E3vsOFXaQ13v49PMWfA==", + "requires": { + "@jupyterlab/coreutils": "^3.2.0", + "@jupyterlab/observables": "^2.4.0", + "@phosphor/algorithm": "^1.2.0", + "@phosphor/coreutils": "^1.3.1", + "@phosphor/disposable": "^1.3.0", + "@phosphor/signaling": "^1.3.0", + "node-fetch": "^2.6.0", + "ws": "^7.0.0" + } + }, + "@jupyterlab/settingregistry": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/@jupyterlab/settingregistry/-/settingregistry-2.1.0.tgz", + "integrity": "sha512-FkWKcg+7d4iWz/u7am3kmRWraJiVE5uidvzADE/PfByGhYQnwJ0ROjyJwaf/GFJv7yJZewxyr7Q4JXVuoIZwPg==", + "requires": { + "@jupyterlab/statedb": "^2.1.0", + "@lumino/commands": "^1.10.1", + "@lumino/coreutils": "^1.4.2", + "@lumino/disposable": "^1.3.5", + "@lumino/signaling": "^1.3.5", + "ajv": "^6.10.2", + "json5": "^2.1.1" + } + }, + "@jupyterlab/statedb": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/@jupyterlab/statedb/-/statedb-2.1.0.tgz", + "integrity": "sha512-3L0NGJvNeI2KeU6jrY97riEmxcKtHb1WRxbMU9ORIppR5Sb5x3K3qErep7r9qu0lV7XH9Zb95uMukX4bgj2GaA==", + "requires": { + "@lumino/commands": "^1.10.1", + "@lumino/coreutils": "^1.4.2", + "@lumino/disposable": "^1.3.5", + "@lumino/properties": "^1.1.6", + "@lumino/signaling": "^1.3.5" + } + }, + "@lumino/algorithm": { + "version": "1.2.3", + "resolved": "https://registry.npmjs.org/@lumino/algorithm/-/algorithm-1.2.3.tgz", + "integrity": "sha512-XBJ/homcm7o8Y9G6MzYvf0FF7SVqUCzvkIO01G2mZhCOnkZZhZ9c4uNOcE2VjSHNxHv2WU0l7d8rdhyKhmet+A==" + }, + "@lumino/collections": { + "version": "1.2.3", + "resolved": "https://registry.npmjs.org/@lumino/collections/-/collections-1.2.3.tgz", + "integrity": "sha512-lrSTb7kru/w8xww8qWqHHhHO3GkoQeXST2oNkOEbWNEO4wuBIHoKPSOmXpUwu58UykBUfd5hL5wbkeTzyNMONg==", + "requires": { + "@lumino/algorithm": "^1.2.3" + } + }, + "@lumino/commands": { + "version": "1.10.1", + "resolved": "https://registry.npmjs.org/@lumino/commands/-/commands-1.10.1.tgz", + "integrity": "sha512-HGtXtqKD1WZJszJ42u2DyM3sgxrLal66IoHSJjbn2ygcEVCKDK73NSzoaQtXFtiissMedzKl8aIRXB3uyeEOlw==", + "requires": { + "@lumino/algorithm": "^1.2.3", + "@lumino/coreutils": "^1.4.2", + "@lumino/disposable": "^1.3.5", + "@lumino/domutils": "^1.1.7", + "@lumino/keyboard": "^1.1.6", + "@lumino/signaling": "^1.3.5", + "@lumino/virtualdom": "^1.6.1" + } + }, + "@lumino/coreutils": { + "version": "1.4.2", + "resolved": "https://registry.npmjs.org/@lumino/coreutils/-/coreutils-1.4.2.tgz", + "integrity": "sha512-SmQ4YDANe25rZd0bLoW7LVAHmgySjkrJmyNPnPW0GrpBt2u4/6D+EQJ8PCCMNWuJvrljBCdlmgOFsT38qYhfcw==" + }, + "@lumino/disposable": { + "version": "1.3.5", + "resolved": "https://registry.npmjs.org/@lumino/disposable/-/disposable-1.3.5.tgz", + "integrity": "sha512-IWDAd+nysBnwLhEtW7M62PVk84OEex9OEktZsS6V+19n/o8/Rw4ccL0pt0GFby01CsVK0YcELDoDaMUZsMiAmA==", + "requires": { + "@lumino/algorithm": "^1.2.3", + "@lumino/signaling": "^1.3.5" + } + }, + "@lumino/domutils": { + "version": "1.1.7", + "resolved": "https://registry.npmjs.org/@lumino/domutils/-/domutils-1.1.7.tgz", + "integrity": "sha512-NPysY8XfpCvLNvDe+z1caIUPxOLXWRPQMUAjOj/EhggRyXadan6Lm/5uO6M9S5gW/v9QUXT4+1Sxe3WXz0nRCA==" + }, + "@lumino/dragdrop": { + "version": "1.5.1", + "resolved": "https://registry.npmjs.org/@lumino/dragdrop/-/dragdrop-1.5.1.tgz", + "integrity": "sha512-MFg/hy6hHdPwBZypBue5mlrBzjoNrtBQzzJW+kbM5ftAOvS99ZRgyMMlMQcbsHd+6yib9NOQ64Hd8P8uZEWTdw==", + "requires": { + "@lumino/coreutils": "^1.4.2", + "@lumino/disposable": "^1.3.5" + } + }, + "@lumino/keyboard": { + "version": "1.1.6", + "resolved": "https://registry.npmjs.org/@lumino/keyboard/-/keyboard-1.1.6.tgz", + "integrity": "sha512-W6pqe0TXRfGOoz1ZK1PRmuGZUWpmdoJArrzwmduUf0t2r06yl56S7w76gxrB7ExTidNPPaOWydGIosPgdgZf5A==" + }, + "@lumino/messaging": { + "version": "1.3.3", + "resolved": "https://registry.npmjs.org/@lumino/messaging/-/messaging-1.3.3.tgz", + "integrity": "sha512-J+0m1aywl64I9/dr9fzE9IwC+eq90T5gUi1hCXP1MFnZh4aLUymmRV5zFw1CNh/vYlNnEu72xxEuhfCfuhiy8g==", + "requires": { + "@lumino/algorithm": "^1.2.3", + "@lumino/collections": "^1.2.3" + } + }, + "@lumino/polling": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/@lumino/polling/-/polling-1.2.0.tgz", + "integrity": "sha512-RoFu3uWY7F+soWldtHah1BKOnG3la+HblAm3gS+XRUYHoj90DvnbcgxP2xmwXm0xAEb22yegz2y6wScEycppOQ==", + "requires": { + "@lumino/coreutils": "^1.4.2", + "@lumino/disposable": "^1.3.5", + "@lumino/signaling": "^1.3.5" + } + }, + "@lumino/properties": { + "version": "1.1.6", + "resolved": "https://registry.npmjs.org/@lumino/properties/-/properties-1.1.6.tgz", + "integrity": "sha512-QnZa1IB7sr4Tawf0OKvwgZAptxDRK7DUAMJ71zijXNXH4FlxyThzOWXef51HHFsISKYa8Rn3rysOwtc62XkmXw==" + }, + "@lumino/signaling": { + "version": "1.3.5", + "resolved": "https://registry.npmjs.org/@lumino/signaling/-/signaling-1.3.5.tgz", + "integrity": "sha512-6jniKrLrJOXKJmaJyU7hr6PBzE4GJ5Wms5hc/yzNKKDBxGSEPdtNJlW3wTNUuSTTtF/9ItN8A8ZC/G0yIu53Tw==", + "requires": { + "@lumino/algorithm": "^1.2.3" + } + }, + "@lumino/virtualdom": { + "version": "1.6.1", + "resolved": "https://registry.npmjs.org/@lumino/virtualdom/-/virtualdom-1.6.1.tgz", + "integrity": "sha512-+KdzSw8TCPwvK6qhZr4xTyp6HymvEb2Da0xPdi4RsVUNhYf2gBI03uidXHx76Vx5OIbEgCn1B+0srxvm2ZbWsQ==", + "requires": { + "@lumino/algorithm": "^1.2.3" + } + }, + "@lumino/widgets": { + "version": "1.12.0", + "resolved": "https://registry.npmjs.org/@lumino/widgets/-/widgets-1.12.0.tgz", + "integrity": "sha512-Lpvo2BEIQRIUf9l1+Q3cP+B15RKZ+MKdXDrxOz/Br6vF/Eo5FTo2WlgiU9TCSA3cafvZdn0jurXFeJ+U9qt2oQ==", + "requires": { + "@lumino/algorithm": "^1.2.3", + "@lumino/commands": "^1.10.1", + "@lumino/coreutils": "^1.4.2", + "@lumino/disposable": "^1.3.5", + "@lumino/domutils": "^1.1.7", + "@lumino/dragdrop": "^1.5.1", + "@lumino/keyboard": "^1.1.6", + "@lumino/messaging": "^1.3.3", + "@lumino/properties": "^1.1.6", + "@lumino/signaling": "^1.3.5", + "@lumino/virtualdom": "^1.6.1" + } + }, + "@nodelib/fs.scandir": { + "version": "2.1.4", + "resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.4.tgz", + "integrity": "sha512-33g3pMJk3bg5nXbL/+CY6I2eJDzZAni49PfJnL5fghPTggPvBd/pFNSgJsdAgWptuFu7qq/ERvOYFlhvsLTCKA==", + "dev": true, + "requires": { + "@nodelib/fs.stat": "2.0.4", + "run-parallel": "^1.1.9" + } + }, + "@nodelib/fs.stat": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/@nodelib/fs.stat/-/fs.stat-2.0.4.tgz", + "integrity": "sha512-IYlHJA0clt2+Vg7bccq+TzRdJvv19c2INqBSsoOLp1je7xjtr7J26+WXR72MCdvU9q1qTzIWDfhMf+DRvQJK4Q==", + "dev": true + }, + "@nodelib/fs.walk": { + "version": "1.2.6", + "resolved": "https://registry.npmjs.org/@nodelib/fs.walk/-/fs.walk-1.2.6.tgz", + "integrity": "sha512-8Broas6vTtW4GIXTAHDoE32hnN2M5ykgCpWGbuXHQ15vEMqr23pB76e/GZcYsZCHALv50ktd24qhEyKr6wBtow==", + "dev": true, + "requires": { + "@nodelib/fs.scandir": "2.1.4", + "fastq": "^1.6.0" + } + }, + "@npmcli/move-file": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/@npmcli/move-file/-/move-file-1.1.2.tgz", + "integrity": "sha512-1SUf/Cg2GzGDyaf15aR9St9TWlb+XvbZXWpDx8YKs7MLzMH/BCeopv+y9vzrzgkfykCGuWOlSu3mZhj2+FQcrg==", + "dev": true, + "requires": { + "mkdirp": "^1.0.4", + "rimraf": "^3.0.2" + }, + "dependencies": { + "mkdirp": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-1.0.4.tgz", + "integrity": "sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw==", + "dev": true + }, + "rimraf": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-3.0.2.tgz", + "integrity": "sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==", + "dev": true, + "requires": { + "glob": "^7.1.3" + } + } + } + }, + "@phosphor/algorithm": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/@phosphor/algorithm/-/algorithm-1.2.0.tgz", + "integrity": "sha512-C9+dnjXyU2QAkWCW6QVDGExk4hhwxzAKf5/FIuYlHAI9X5vFv99PYm0EREDxX1PbMuvfFBZhPNu0PvuSDQ7sFA==" + }, + "@phosphor/collections": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/@phosphor/collections/-/collections-1.2.0.tgz", + "integrity": "sha512-T9/0EjSuY6+ga2LIFRZ0xupciOR3Qnyy8Q95lhGTC0FXZUFwC8fl9e8On6IcwasCszS+1n8dtZUWSIynfgdpzw==", + "requires": { + "@phosphor/algorithm": "^1.2.0" + } + }, + "@phosphor/commands": { + "version": "1.7.2", + "resolved": "https://registry.npmjs.org/@phosphor/commands/-/commands-1.7.2.tgz", + "integrity": "sha512-iSyBIWMHsus323BVEARBhuVZNnVel8USo+FIPaAxGcq+icTSSe6+NtSxVQSmZblGN6Qm4iw6I6VtiSx0e6YDgQ==", + "requires": { + "@phosphor/algorithm": "^1.2.0", + "@phosphor/coreutils": "^1.3.1", + "@phosphor/disposable": "^1.3.1", + "@phosphor/domutils": "^1.1.4", + "@phosphor/keyboard": "^1.1.3", + "@phosphor/signaling": "^1.3.1" + } + }, + "@phosphor/coreutils": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/@phosphor/coreutils/-/coreutils-1.3.1.tgz", + "integrity": "sha512-9OHCn8LYRcPU/sbHm5v7viCA16Uev3gbdkwqoQqlV+EiauDHl70jmeL7XVDXdigl66Dz0LI11C99XOxp+s3zOA==" + }, + "@phosphor/disposable": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/@phosphor/disposable/-/disposable-1.3.1.tgz", + "integrity": "sha512-0NGzoTXTOizWizK/brKKd5EjJhuuEH4903tLika7q6wl/u0tgneJlTh7R+MBVeih0iNxtuJAfBa3IEY6Qmj+Sw==", + "requires": { + "@phosphor/algorithm": "^1.2.0", + "@phosphor/signaling": "^1.3.1" + } + }, + "@phosphor/domutils": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/@phosphor/domutils/-/domutils-1.1.4.tgz", + "integrity": "sha512-ivwq5TWjQpKcHKXO8PrMl+/cKqbgxPClPiCKc1gwbMd+6hnW5VLwNG0WBzJTxCzXK43HxX18oH+tOZ3E04wc3w==" + }, + "@phosphor/dragdrop": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/@phosphor/dragdrop/-/dragdrop-1.4.1.tgz", + "integrity": "sha512-77paMoubIWk7pdwA2GVFkqba1WP48hTZZvS17N30+KVOeWfSqBL3flPSnW2yC4y6FnOP2PFOCtuPIbQv+pYhCA==", + "requires": { + "@phosphor/coreutils": "^1.3.1", + "@phosphor/disposable": "^1.3.1" + } + }, + "@phosphor/keyboard": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/@phosphor/keyboard/-/keyboard-1.1.3.tgz", + "integrity": "sha512-dzxC/PyHiD6mXaESRy6PZTd9JeK+diwG1pyngkyUf127IXOEzubTIbu52VSdpGBklszu33ws05BAGDa4oBE4mQ==" + }, + "@phosphor/messaging": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/@phosphor/messaging/-/messaging-1.3.0.tgz", + "integrity": "sha512-k0JE+BTMKlkM335S2AmmJxoYYNRwOdW5jKBqLgjJdGRvUQkM0+2i60ahM45+J23atGJDv9esKUUBINiKHFhLew==", + "requires": { + "@phosphor/algorithm": "^1.2.0", + "@phosphor/collections": "^1.2.0" + } + }, + "@phosphor/properties": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/@phosphor/properties/-/properties-1.1.3.tgz", + "integrity": "sha512-GiglqzU77s6+tFVt6zPq9uuyu/PLQPFcqZt914ZhJ4cN/7yNI/SLyMzpYZ56IRMXvzK9TUgbRna6URE3XAwFUg==" + }, + "@phosphor/signaling": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/@phosphor/signaling/-/signaling-1.3.1.tgz", + "integrity": "sha512-Eq3wVCPQAhUd9+gUGaYygMr+ov7dhSGblSBXiDzpZlSIfa8OVD4P3cCvYXr/acDTNmZ/gHTcSFO8/n3rDkeXzg==", + "requires": { + "@phosphor/algorithm": "^1.2.0" + } + }, + "@phosphor/virtualdom": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/@phosphor/virtualdom/-/virtualdom-1.2.0.tgz", + "integrity": "sha512-L9mKNhK2XtVjzjuHLG2uYuepSz8uPyu6vhF4EgCP0rt0TiLYaZeHwuNu3XeFbul9DMOn49eBpye/tfQVd4Ks+w==", + "requires": { + "@phosphor/algorithm": "^1.2.0" + } + }, + "@phosphor/widgets": { + "version": "1.9.3", + "resolved": "https://registry.npmjs.org/@phosphor/widgets/-/widgets-1.9.3.tgz", + "integrity": "sha512-61jsxloDrW/+WWQs8wOgsS5waQ/MSsXBuhONt0o6mtdeL93HVz7CYO5krOoot5owammfF6oX1z0sDaUYIYgcPA==", + "requires": { + "@phosphor/algorithm": "^1.2.0", + "@phosphor/commands": "^1.7.2", + "@phosphor/coreutils": "^1.3.1", + "@phosphor/disposable": "^1.3.1", + "@phosphor/domutils": "^1.1.4", + "@phosphor/dragdrop": "^1.4.1", + "@phosphor/keyboard": "^1.1.3", + "@phosphor/messaging": "^1.3.0", + "@phosphor/properties": "^1.1.3", + "@phosphor/signaling": "^1.3.1", + "@phosphor/virtualdom": "^1.2.0" + } + }, + "@sindresorhus/is": { + "version": "0.14.0", + "resolved": "https://registry.npmjs.org/@sindresorhus/is/-/is-0.14.0.tgz", + "integrity": "sha512-9NET910DNaIPngYnLLPeg+Ogzqsi9uM4mSboU5y6p8S5DzMTVEsJZrawi+BoDNUVBa2DhJqQYUFvMDfgU062LQ==", + "dev": true + }, + "@szmarczak/http-timer": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/@szmarczak/http-timer/-/http-timer-1.1.2.tgz", + "integrity": "sha512-XIB2XbzHTN6ieIjfIMV9hlVcfPU26s2vafYWQcZHWXHOxiaRZYEDKEwdl129Zyg50+foYV2jCgtrqSA6qNuNSA==", + "dev": true, + "requires": { + "defer-to-connect": "^1.0.1" + } + }, + "@types/backbone": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/@types/backbone/-/backbone-1.4.1.tgz", + "integrity": "sha512-KYfGuQy4d2vvYXbn0uHFZ6brFLndatTMomxBlljpbWf4kFpA3BG/6LA3ec+J9iredrX6eAVI7sm9SVAvwiIM6g==", + "requires": { + "@types/jquery": "*", + "@types/underscore": "*" + } + }, + "@types/chai": { + "version": "4.2.4", + "resolved": "https://registry.npmjs.org/@types/chai/-/chai-4.2.4.tgz", + "integrity": "sha512-7qvf9F9tMTzo0akeswHPGqgUx/gIaJqrOEET/FCD8CFRkSUHlygQiM5yB6OvjrtdxBVLSyw7COJubsFYs0683g==", + "dev": true + }, + "@types/d3": { + "version": "5.7.2", + "resolved": "https://registry.npmjs.org/@types/d3/-/d3-5.7.2.tgz", + "integrity": "sha512-7/wClB8ycneWGy3jdvLfXKTd5SoTg9hji7IdJ0RuO9xTY54YpJ8zlcFADcXhY1J3kCBwxp+/1jeN6a5OMwgYOw==", + "dev": true, + "requires": { + "@types/d3-array": "^1", + "@types/d3-axis": "*", + "@types/d3-brush": "*", + "@types/d3-chord": "*", + "@types/d3-collection": "*", + "@types/d3-color": "*", + "@types/d3-contour": "*", + "@types/d3-dispatch": "*", + "@types/d3-drag": "*", + "@types/d3-dsv": "*", + "@types/d3-ease": "*", + "@types/d3-fetch": "*", + "@types/d3-force": "*", + "@types/d3-format": "*", + "@types/d3-geo": "*", + "@types/d3-hierarchy": "*", + "@types/d3-interpolate": "*", + "@types/d3-path": "*", + "@types/d3-polygon": "*", + "@types/d3-quadtree": "*", + "@types/d3-random": "*", + "@types/d3-scale": "*", + "@types/d3-scale-chromatic": "*", + "@types/d3-selection": "*", + "@types/d3-shape": "*", + "@types/d3-time": "*", + "@types/d3-time-format": "*", + "@types/d3-timer": "*", + "@types/d3-transition": "*", + "@types/d3-voronoi": "*", + "@types/d3-zoom": "*" + } + }, + "@types/d3-array": { + "version": "1.2.7", + "resolved": "https://registry.npmjs.org/@types/d3-array/-/d3-array-1.2.7.tgz", + "integrity": "sha512-51vHWuUyDOi+8XuwPrTw3cFqyh2Slg9y8COYkRfjCPG9TfYqY0hoNPzv/8BrcAy0FeQBzqEo/D/8Nk2caOQJnA==", + "dev": true + }, + "@types/d3-axis": { + "version": "1.0.12", + "resolved": "https://registry.npmjs.org/@types/d3-axis/-/d3-axis-1.0.12.tgz", + "integrity": "sha512-BZISgSD5M8TgURyNtcPAmUB9sk490CO1Thb6/gIn0WZTt3Y50IssX+2Z0vTccoqZksUDTep0b+o4ofXslvNbqg==", + "dev": true, + "requires": { + "@types/d3-selection": "*" + } + }, + "@types/d3-brush": { + "version": "1.0.10", + "resolved": "https://registry.npmjs.org/@types/d3-brush/-/d3-brush-1.0.10.tgz", + "integrity": "sha512-J8jREATIrfJaAfhJivqaEKPnJsRlwwrOPje+ABqZFgamADjll+q9zaDXnYyjiGPPsiJEU+Qq9jQi5rECxIOfhg==", + "dev": true, + "requires": { + "@types/d3-selection": "*" + } + }, + "@types/d3-chord": { + "version": "1.0.9", + "resolved": "https://registry.npmjs.org/@types/d3-chord/-/d3-chord-1.0.9.tgz", + "integrity": "sha512-UA6lI9CVW5cT5Ku/RV4hxoFn4mKySHm7HEgodtfRthAj1lt9rKZEPon58vyYfk+HIAm33DtJJgZwMXy2QgyPXw==", + "dev": true + }, + "@types/d3-collection": { + "version": "1.0.8", + "resolved": "https://registry.npmjs.org/@types/d3-collection/-/d3-collection-1.0.8.tgz", + "integrity": "sha512-y5lGlazdc0HNO0F3UUX2DPE7OmYvd9Kcym4hXwrJcNUkDaypR5pX+apuMikl9LfTxKItJsY9KYvzBulpCKyvuQ==", + "dev": true + }, + "@types/d3-color": { + "version": "1.2.2", + "resolved": "https://registry.npmjs.org/@types/d3-color/-/d3-color-1.2.2.tgz", + "integrity": "sha512-6pBxzJ8ZP3dYEQ4YjQ+NVbQaOflfgXq/JbDiS99oLobM2o72uAST4q6yPxHv6FOTCRC/n35ktuo8pvw/S4M7sw==", + "dev": true + }, + "@types/d3-contour": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/@types/d3-contour/-/d3-contour-1.3.0.tgz", + "integrity": "sha512-AUCUIjEnC5lCGBM9hS+MryRaFLIrPls4Rbv6ktqbd+TK/RXZPwOy9rtBWmGpbeXcSOYCJTUDwNJuEnmYPJRxHQ==", + "dev": true, + "requires": { + "@types/d3-array": "*", + "@types/geojson": "*" + } + }, + "@types/d3-dispatch": { + "version": "1.0.7", + "resolved": "https://registry.npmjs.org/@types/d3-dispatch/-/d3-dispatch-1.0.7.tgz", + "integrity": "sha512-M+z84G7UKwK6hEPnGCSccOg8zJ3Nk2hgDQ9sCstHXgsFU0sMxlIZVKqKB5oxUDbALqQG6ucg0G9e8cmOSlishg==", + "dev": true + }, + "@types/d3-drag": { + "version": "1.2.3", + "resolved": "https://registry.npmjs.org/@types/d3-drag/-/d3-drag-1.2.3.tgz", + "integrity": "sha512-rWB5SPvkYVxW3sqUxHOJUZwifD0KqvKwvt1bhNqcLpW6Azsd0BJgRNcyVW8GAferaAk5r8dzeZnf9zKlg9+xMQ==", + "dev": true, + "requires": { + "@types/d3-selection": "*" + } + }, + "@types/d3-dsv": { + "version": "1.0.36", + "resolved": "https://registry.npmjs.org/@types/d3-dsv/-/d3-dsv-1.0.36.tgz", + "integrity": "sha512-jbIWQ27QJcBNMZbQv0NSQMHnBDCmxghAxePxgyiPH1XPCRkOsTBei7jcdi3fDrUCGpCV3lKrSZFSlOkhUQVClA==", + "dev": true + }, + "@types/d3-ease": { + "version": "1.0.9", + "resolved": "https://registry.npmjs.org/@types/d3-ease/-/d3-ease-1.0.9.tgz", + "integrity": "sha512-U5ADevQ+W6fy32FVZZC9EXallcV/Mi12A5Tkd0My5MrC7T8soMQEhlDAg88XUWm0zoCQlB4XV0en/24LvuDB4Q==", + "dev": true + }, + "@types/d3-fetch": { + "version": "1.1.5", + "resolved": "https://registry.npmjs.org/@types/d3-fetch/-/d3-fetch-1.1.5.tgz", + "integrity": "sha512-o9c0ItT5/Gl3wbNuVpzRnYX1t3RghzeWAjHUVLuyZJudiTxC4f/fC0ZPFWLQ2lVY8pAMmxpV8TJ6ETYCgPeI3A==", + "dev": true, + "requires": { + "@types/d3-dsv": "*" + } + }, + "@types/d3-force": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/@types/d3-force/-/d3-force-1.2.1.tgz", + "integrity": "sha512-jqK+I36uz4kTBjyk39meed5y31Ab+tXYN/x1dn3nZEus9yOHCLc+VrcIYLc/aSQ0Y7tMPRlIhLetulME76EiiA==", + "dev": true + }, + "@types/d3-format": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/@types/d3-format/-/d3-format-1.3.1.tgz", + "integrity": "sha512-KAWvReOKMDreaAwOjdfQMm0HjcUMlQG47GwqdVKgmm20vTd2pucj0a70c3gUSHrnsmo6H2AMrkBsZU2UhJLq8A==", + "dev": true + }, + "@types/d3-geo": { + "version": "1.11.1", + "resolved": "https://registry.npmjs.org/@types/d3-geo/-/d3-geo-1.11.1.tgz", + "integrity": "sha512-Ox8WWOG3igDRoep/dNsGbOiSJYdUG3ew/6z0ETvHyAtXZVBjOE0S96zSSmzgl0gqQ3RdZjn2eeJOj9oRcMZPkQ==", + "dev": true, + "requires": { + "@types/geojson": "*" + } + }, + "@types/d3-hierarchy": { + "version": "1.1.6", + "resolved": "https://registry.npmjs.org/@types/d3-hierarchy/-/d3-hierarchy-1.1.6.tgz", + "integrity": "sha512-vvSaIDf/Ov0o3KwMT+1M8+WbnnlRiGjlGD5uvk83a1mPCTd/E5x12bUJ/oP55+wUY/4Kb5kc67rVpVGJ2KUHxg==", + "dev": true + }, + "@types/d3-interpolate": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/@types/d3-interpolate/-/d3-interpolate-1.3.1.tgz", + "integrity": "sha512-z8Zmi08XVwe8e62vP6wcA+CNuRhpuUU5XPEfqpG0hRypDE5BWNthQHB1UNWWDB7ojCbGaN4qBdsWp5kWxhT1IQ==", + "dev": true, + "requires": { + "@types/d3-color": "*" + } + }, + "@types/d3-path": { + "version": "1.0.8", + "resolved": "https://registry.npmjs.org/@types/d3-path/-/d3-path-1.0.8.tgz", + "integrity": "sha512-AZGHWslq/oApTAHu9+yH/Bnk63y9oFOMROtqPAtxl5uB6qm1x2lueWdVEjsjjV3Qc2+QfuzKIwIR5MvVBakfzA==", + "dev": true + }, + "@types/d3-polygon": { + "version": "1.0.7", + "resolved": "https://registry.npmjs.org/@types/d3-polygon/-/d3-polygon-1.0.7.tgz", + "integrity": "sha512-Xuw0eSjQQKs8jTiNbntWH0S+Xp+JyhqxmQ0YAQ3rDu6c3kKMFfgsaGN7Jv5u3zG6yVX/AsLP/Xs/QRjmi9g43Q==", + "dev": true + }, + "@types/d3-quadtree": { + "version": "1.0.7", + "resolved": "https://registry.npmjs.org/@types/d3-quadtree/-/d3-quadtree-1.0.7.tgz", + "integrity": "sha512-0ajFawWicfjsaCLh6NzxOyVDYhQAmMFbsiI3MPGLInorauHFEh9/Cl6UHNf+kt/J1jfoxKY/ZJaKAoDpbvde5Q==", + "dev": true + }, + "@types/d3-random": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/@types/d3-random/-/d3-random-1.1.2.tgz", + "integrity": "sha512-Jui+Zn28pQw/3EayPKaN4c/PqTvqNbIPjHkgIIFnxne1FdwNjfHtAIsZIBMKlquQNrrMjFzCrlF2gPs3xckqaA==", + "dev": true + }, + "@types/d3-scale": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/@types/d3-scale/-/d3-scale-2.1.1.tgz", + "integrity": "sha512-kNTkbZQ+N/Ip8oX9PByXfDLoCSaZYm+VUOasbmsa6KD850/ziMdYepg/8kLg2plHzoLANdMqPoYQbvExevLUHg==", + "dev": true, + "requires": { + "@types/d3-time": "*" + } + }, + "@types/d3-scale-chromatic": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/@types/d3-scale-chromatic/-/d3-scale-chromatic-1.3.1.tgz", + "integrity": "sha512-Ny3rLbV5tnmqgW7w/poCcef4kXP8mHPo/p8EjTS5d9OUk8MlqAeRaM8eF7Vyv7QMLiIXNE94Pa1cMLSPkXQBoQ==", + "dev": true + }, + "@types/d3-selection": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/@types/d3-selection/-/d3-selection-1.4.1.tgz", + "integrity": "sha512-bv8IfFYo/xG6dxri9OwDnK3yCagYPeRIjTlrcdYJSx+FDWlCeBDepIHUpqROmhPtZ53jyna0aUajZRk0I3rXNA==", + "dev": true + }, + "@types/d3-shape": { + "version": "1.3.2", + "resolved": "https://registry.npmjs.org/@types/d3-shape/-/d3-shape-1.3.2.tgz", + "integrity": "sha512-LtD8EaNYCaBRzHzaAiIPrfcL3DdIysc81dkGlQvv7WQP3+YXV7b0JJTtR1U3bzeRieS603KF4wUo+ZkJVenh8w==", + "dev": true, + "requires": { + "@types/d3-path": "*" + } + }, + "@types/d3-time": { + "version": "1.0.10", + "resolved": "https://registry.npmjs.org/@types/d3-time/-/d3-time-1.0.10.tgz", + "integrity": "sha512-aKf62rRQafDQmSiv1NylKhIMmznsjRN+MnXRXTqHoqm0U/UZzVpdrtRnSIfdiLS616OuC1soYeX1dBg2n1u8Xw==", + "dev": true + }, + "@types/d3-time-format": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/@types/d3-time-format/-/d3-time-format-2.1.1.tgz", + "integrity": "sha512-tJSyXta8ZyJ52wDDHA96JEsvkbL6jl7wowGmuf45+fAkj5Y+SQOnz0N7/H68OWmPshPsAaWMQh+GAws44IzH3g==", + "dev": true + }, + "@types/d3-timer": { + "version": "1.0.9", + "resolved": "https://registry.npmjs.org/@types/d3-timer/-/d3-timer-1.0.9.tgz", + "integrity": "sha512-WvfJ3LFxBbWjqRGz9n7GJt08RrTHPJDVsIwwoCMROlqF+iDacYiAFjf9oqnq0mXpb2juA2N/qjKP+MKdal3YNQ==", + "dev": true + }, + "@types/d3-transition": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/@types/d3-transition/-/d3-transition-1.1.4.tgz", + "integrity": "sha512-/vsmKVUIXEyCcIXYAlw7bnYkIs9/J/nZbptRJFKUN3FdXq/dF6j9z9xXzerkyU6TDHLrMrwx9eGwdKyTIy/j9w==", + "dev": true, + "requires": { + "@types/d3-selection": "*" + } + }, + "@types/d3-voronoi": { + "version": "1.1.9", + "resolved": "https://registry.npmjs.org/@types/d3-voronoi/-/d3-voronoi-1.1.9.tgz", + "integrity": "sha512-DExNQkaHd1F3dFPvGA/Aw2NGyjMln6E9QzsiqOcBgnE+VInYnFBHBBySbZQts6z6xD+5jTfKCP7M4OqMyVjdwQ==", + "dev": true + }, + "@types/d3-zoom": { + "version": "1.7.4", + "resolved": "https://registry.npmjs.org/@types/d3-zoom/-/d3-zoom-1.7.4.tgz", + "integrity": "sha512-5jnFo/itYhJeB2khO/lKe730kW/h2EbKMOvY0uNp3+7NdPm4w63DwPEMxifQZ7n902xGYK5DdU67FmToSoy4VA==", + "dev": true, + "requires": { + "@types/d3-interpolate": "*", + "@types/d3-selection": "*" + } + }, + "@types/eslint": { + "version": "7.2.10", + "resolved": "https://registry.npmjs.org/@types/eslint/-/eslint-7.2.10.tgz", + "integrity": "sha512-kUEPnMKrqbtpCq/KTaGFFKAcz6Ethm2EjCoKIDaCmfRBWLbFuTcOJfTlorwbnboXBzahqWLgUp1BQeKHiJzPUQ==", + "dev": true, + "requires": { + "@types/estree": "*", + "@types/json-schema": "*" + } + }, + "@types/eslint-scope": { + "version": "3.7.0", + "resolved": "https://registry.npmjs.org/@types/eslint-scope/-/eslint-scope-3.7.0.tgz", + "integrity": "sha512-O/ql2+rrCUe2W2rs7wMR+GqPRcgB6UiqN5RhrR5xruFlY7l9YLMn0ZkDzjoHLeiFkR8MCQZVudUuuvQ2BLC9Qw==", + "dev": true, + "requires": { + "@types/eslint": "*", + "@types/estree": "*" + } + }, + "@types/estree": { + "version": "0.0.47", + "resolved": "https://registry.npmjs.org/@types/estree/-/estree-0.0.47.tgz", + "integrity": "sha512-c5ciR06jK8u9BstrmJyO97m+klJrrhCf9u3rLu3DEAJBirxRqSCvDQoYKmxuYwQI5SZChAWu+tq9oVlGRuzPAg==", + "dev": true + }, + "@types/expect.js": { + "version": "0.3.29", + "resolved": "https://registry.npmjs.org/@types/expect.js/-/expect.js-0.3.29.tgz", + "integrity": "sha1-KN01kVW4S47LCUr8P0t0wyItyjs=", + "dev": true + }, + "@types/geojson": { + "version": "7946.0.7", + "resolved": "https://registry.npmjs.org/@types/geojson/-/geojson-7946.0.7.tgz", + "integrity": "sha512-wE2v81i4C4Ol09RtsWFAqg3BUitWbHSpSlIo+bNdsCJijO9sjme+zm+73ZMCa/qMC8UEERxzGbvmr1cffo2SiQ==", + "dev": true + }, + "@types/glob": { + "version": "7.1.3", + "resolved": "https://registry.npmjs.org/@types/glob/-/glob-7.1.3.tgz", + "integrity": "sha512-SEYeGAIQIQX8NN6LDKprLjbrd5dARM5EXsd8GI/A5l0apYI1fGMWgPHSe4ZKL4eozlAyI+doUE9XbYS4xCkQ1w==", + "dev": true, + "requires": { + "@types/minimatch": "*", + "@types/node": "*" + } + }, + "@types/jquery": { + "version": "3.3.31", + "resolved": "https://registry.npmjs.org/@types/jquery/-/jquery-3.3.31.tgz", + "integrity": "sha512-Lz4BAJihoFw5nRzKvg4nawXPzutkv7wmfQ5121avptaSIXlDNJCUuxZxX/G+9EVidZGuO0UBlk+YjKbwRKJigg==", + "requires": { + "@types/sizzle": "*" + } + }, + "@types/json-schema": { + "version": "7.0.7", + "resolved": "https://registry.npmjs.org/@types/json-schema/-/json-schema-7.0.7.tgz", + "integrity": "sha512-cxWFQVseBm6O9Gbw1IWb8r6OS4OhSt3hPZLkFApLjM8TEXROBuQGLAH2i2gZpcXdLBIrpXuTDhH7Vbm1iXmNGA==", + "dev": true + }, + "@types/lodash": { + "version": "4.14.144", + "resolved": "https://registry.npmjs.org/@types/lodash/-/lodash-4.14.144.tgz", + "integrity": "sha512-ogI4g9W5qIQQUhXAclq6zhqgqNUr7UlFaqDHbch7WLSLeeM/7d3CRaw7GLajxvyFvhJqw4Rpcz5bhoaYtIx6Tg==" + }, + "@types/minimatch": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/@types/minimatch/-/minimatch-3.0.4.tgz", + "integrity": "sha512-1z8k4wzFnNjVK/tlxvrWuK5WMt6mydWWP7+zvH5eFep4oj+UkrfiJTRtjCeBXNpwaA/FYqqtb4/QS4ianFpIRA==", + "dev": true + }, + "@types/mocha": { + "version": "2.2.48", + "resolved": "https://registry.npmjs.org/@types/mocha/-/mocha-2.2.48.tgz", + "integrity": "sha512-nlK/iyETgafGli8Zh9zJVCTicvU3iajSkRwOh3Hhiva598CMqNJ4NcVCGMTGKpGpTYj/9R8RLzS9NAykSSCqGw==", + "dev": true + }, + "@types/node": { + "version": "12.11.6", + "resolved": "https://registry.npmjs.org/@types/node/-/node-12.11.6.tgz", + "integrity": "sha512-4uPUyY1Aofo1YzoypalYHNd2SnKYxH2b6LzXwpryZCJKA2XlagZSynXx5C8sfPH0r1cSltUpaVHV2q5sYXschQ==", + "dev": true + }, + "@types/requirejs": { + "version": "2.1.31", + "resolved": "https://registry.npmjs.org/@types/requirejs/-/requirejs-2.1.31.tgz", + "integrity": "sha512-b2soeyuU76rMbcRJ4e0hEl0tbMhFwZeTC0VZnfuWlfGlk6BwWNsev6kFu/twKABPX29wkX84wU2o+cEJoXsiTw==", + "dev": true + }, + "@types/sizzle": { + "version": "2.3.2", + "resolved": "https://registry.npmjs.org/@types/sizzle/-/sizzle-2.3.2.tgz", + "integrity": "sha512-7EJYyKTL7tFR8+gDbB6Wwz/arpGa0Mywk1TJbNzKzHtzbwVmY4HR9WqS5VV7dsBUKQmPNr192jHr/VpBluj/hg==" + }, + "@types/three": { + "version": "0.93.31", + "resolved": "https://registry.npmjs.org/@types/three/-/three-0.93.31.tgz", + "integrity": "sha512-lR9eLY3gnrUDAdW4ujITgVTPEv1Oy2yoL3LlfKAnjQuzyjGSR+PvQuXuWmaDCD1IyWhkqbnol1nJwaW0MGe35A==", + "dev": true + }, + "@types/underscore": { + "version": "1.9.3", + "resolved": "https://registry.npmjs.org/@types/underscore/-/underscore-1.9.3.tgz", + "integrity": "sha512-SwbHKB2DPIDlvYqtK5O+0LFtZAyrUSw4c0q+HWwmH1Ve3KMQ0/5PlV3RX97+3dP7yMrnNQ8/bCWWvQpPl03Mug==" + }, + "@webassemblyjs/ast": { + "version": "1.8.5", + "resolved": "https://registry.npmjs.org/@webassemblyjs/ast/-/ast-1.8.5.tgz", + "integrity": "sha512-aJMfngIZ65+t71C3y2nBBg5FFG0Okt9m0XEgWZ7Ywgn1oMAT8cNwx00Uv1cQyHtidq0Xn94R4TAywO+LCQ+ZAQ==", + "dev": true, + "requires": { + "@webassemblyjs/helper-module-context": "1.8.5", + "@webassemblyjs/helper-wasm-bytecode": "1.8.5", + "@webassemblyjs/wast-parser": "1.8.5" + } + }, + "@webassemblyjs/floating-point-hex-parser": { + "version": "1.8.5", + "resolved": "https://registry.npmjs.org/@webassemblyjs/floating-point-hex-parser/-/floating-point-hex-parser-1.8.5.tgz", + "integrity": "sha512-9p+79WHru1oqBh9ewP9zW95E3XAo+90oth7S5Re3eQnECGq59ly1Ri5tsIipKGpiStHsUYmY3zMLqtk3gTcOtQ==", + "dev": true + }, + "@webassemblyjs/helper-api-error": { + "version": "1.8.5", + "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-api-error/-/helper-api-error-1.8.5.tgz", + "integrity": "sha512-Za/tnzsvnqdaSPOUXHyKJ2XI7PDX64kWtURyGiJJZKVEdFOsdKUCPTNEVFZq3zJ2R0G5wc2PZ5gvdTRFgm81zA==", + "dev": true + }, + "@webassemblyjs/helper-buffer": { + "version": "1.8.5", + "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-buffer/-/helper-buffer-1.8.5.tgz", + "integrity": "sha512-Ri2R8nOS0U6G49Q86goFIPNgjyl6+oE1abW1pS84BuhP1Qcr5JqMwRFT3Ah3ADDDYGEgGs1iyb1DGX+kAi/c/Q==", + "dev": true + }, + "@webassemblyjs/helper-code-frame": { + "version": "1.8.5", + "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-code-frame/-/helper-code-frame-1.8.5.tgz", + "integrity": "sha512-VQAadSubZIhNpH46IR3yWO4kZZjMxN1opDrzePLdVKAZ+DFjkGD/rf4v1jap744uPVU6yjL/smZbRIIJTOUnKQ==", + "dev": true, + "requires": { + "@webassemblyjs/wast-printer": "1.8.5" + } + }, + "@webassemblyjs/helper-fsm": { + "version": "1.8.5", + "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-fsm/-/helper-fsm-1.8.5.tgz", + "integrity": "sha512-kRuX/saORcg8se/ft6Q2UbRpZwP4y7YrWsLXPbbmtepKr22i8Z4O3V5QE9DbZK908dh5Xya4Un57SDIKwB9eow==", + "dev": true + }, + "@webassemblyjs/helper-module-context": { + "version": "1.8.5", + "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-module-context/-/helper-module-context-1.8.5.tgz", + "integrity": "sha512-/O1B236mN7UNEU4t9X7Pj38i4VoU8CcMHyy3l2cV/kIF4U5KoHXDVqcDuOs1ltkac90IM4vZdHc52t1x8Yfs3g==", + "dev": true, + "requires": { + "@webassemblyjs/ast": "1.8.5", + "mamacro": "^0.0.3" + } + }, + "@webassemblyjs/helper-numbers": { + "version": "1.11.0", + "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-numbers/-/helper-numbers-1.11.0.tgz", + "integrity": "sha512-DhRQKelIj01s5IgdsOJMKLppI+4zpmcMQ3XboFPLwCpSNH6Hqo1ritgHgD0nqHeSYqofA6aBN/NmXuGjM1jEfQ==", + "dev": true, + "requires": { + "@webassemblyjs/floating-point-hex-parser": "1.11.0", + "@webassemblyjs/helper-api-error": "1.11.0", + "@xtuc/long": "4.2.2" + }, + "dependencies": { + "@webassemblyjs/floating-point-hex-parser": { + "version": "1.11.0", + "resolved": "https://registry.npmjs.org/@webassemblyjs/floating-point-hex-parser/-/floating-point-hex-parser-1.11.0.tgz", + "integrity": "sha512-Q/aVYs/VnPDVYvsCBL/gSgwmfjeCb4LW8+TMrO3cSzJImgv8lxxEPM2JA5jMrivE7LSz3V+PFqtMbls3m1exDA==", + "dev": true + }, + "@webassemblyjs/helper-api-error": { + "version": "1.11.0", + "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-api-error/-/helper-api-error-1.11.0.tgz", + "integrity": "sha512-baT/va95eXiXb2QflSx95QGT5ClzWpGaa8L7JnJbgzoYeaA27FCvuBXU758l+KXWRndEmUXjP0Q5fibhavIn8w==", + "dev": true + } + } + }, + "@webassemblyjs/helper-wasm-bytecode": { + "version": "1.8.5", + "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-wasm-bytecode/-/helper-wasm-bytecode-1.8.5.tgz", + "integrity": "sha512-Cu4YMYG3Ddl72CbmpjU/wbP6SACcOPVbHN1dI4VJNJVgFwaKf1ppeFJrwydOG3NDHxVGuCfPlLZNyEdIYlQ6QQ==", + "dev": true + }, + "@webassemblyjs/helper-wasm-section": { + "version": "1.8.5", + "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-wasm-section/-/helper-wasm-section-1.8.5.tgz", + "integrity": "sha512-VV083zwR+VTrIWWtgIUpqfvVdK4ff38loRmrdDBgBT8ADXYsEZ5mPQ4Nde90N3UYatHdYoDIFb7oHzMncI02tA==", + "dev": true, + "requires": { + "@webassemblyjs/ast": "1.8.5", + "@webassemblyjs/helper-buffer": "1.8.5", + "@webassemblyjs/helper-wasm-bytecode": "1.8.5", + "@webassemblyjs/wasm-gen": "1.8.5" + } + }, + "@webassemblyjs/ieee754": { + "version": "1.8.5", + "resolved": "https://registry.npmjs.org/@webassemblyjs/ieee754/-/ieee754-1.8.5.tgz", + "integrity": "sha512-aaCvQYrvKbY/n6wKHb/ylAJr27GglahUO89CcGXMItrOBqRarUMxWLJgxm9PJNuKULwN5n1csT9bYoMeZOGF3g==", + "dev": true, + "requires": { + "@xtuc/ieee754": "^1.2.0" + } + }, + "@webassemblyjs/leb128": { + "version": "1.8.5", + "resolved": "https://registry.npmjs.org/@webassemblyjs/leb128/-/leb128-1.8.5.tgz", + "integrity": "sha512-plYUuUwleLIziknvlP8VpTgO4kqNaH57Y3JnNa6DLpu/sGcP6hbVdfdX5aHAV716pQBKrfuU26BJK29qY37J7A==", + "dev": true, + "requires": { + "@xtuc/long": "4.2.2" + } + }, + "@webassemblyjs/utf8": { + "version": "1.8.5", + "resolved": "https://registry.npmjs.org/@webassemblyjs/utf8/-/utf8-1.8.5.tgz", + "integrity": "sha512-U7zgftmQriw37tfD934UNInokz6yTmn29inT2cAetAsaU9YeVCveWEwhKL1Mg4yS7q//NGdzy79nlXh3bT8Kjw==", + "dev": true + }, + "@webassemblyjs/wasm-edit": { + "version": "1.8.5", + "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-edit/-/wasm-edit-1.8.5.tgz", + "integrity": "sha512-A41EMy8MWw5yvqj7MQzkDjU29K7UJq1VrX2vWLzfpRHt3ISftOXqrtojn7nlPsZ9Ijhp5NwuODuycSvfAO/26Q==", + "dev": true, + "requires": { + "@webassemblyjs/ast": "1.8.5", + "@webassemblyjs/helper-buffer": "1.8.5", + "@webassemblyjs/helper-wasm-bytecode": "1.8.5", + "@webassemblyjs/helper-wasm-section": "1.8.5", + "@webassemblyjs/wasm-gen": "1.8.5", + "@webassemblyjs/wasm-opt": "1.8.5", + "@webassemblyjs/wasm-parser": "1.8.5", + "@webassemblyjs/wast-printer": "1.8.5" + } + }, + "@webassemblyjs/wasm-gen": { + "version": "1.8.5", + "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-gen/-/wasm-gen-1.8.5.tgz", + "integrity": "sha512-BCZBT0LURC0CXDzj5FXSc2FPTsxwp3nWcqXQdOZE4U7h7i8FqtFK5Egia6f9raQLpEKT1VL7zr4r3+QX6zArWg==", + "dev": true, + "requires": { + "@webassemblyjs/ast": "1.8.5", + "@webassemblyjs/helper-wasm-bytecode": "1.8.5", + "@webassemblyjs/ieee754": "1.8.5", + "@webassemblyjs/leb128": "1.8.5", + "@webassemblyjs/utf8": "1.8.5" + } + }, + "@webassemblyjs/wasm-opt": { + "version": "1.8.5", + "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-opt/-/wasm-opt-1.8.5.tgz", + "integrity": "sha512-HKo2mO/Uh9A6ojzu7cjslGaHaUU14LdLbGEKqTR7PBKwT6LdPtLLh9fPY33rmr5wcOMrsWDbbdCHq4hQUdd37Q==", + "dev": true, + "requires": { + "@webassemblyjs/ast": "1.8.5", + "@webassemblyjs/helper-buffer": "1.8.5", + "@webassemblyjs/wasm-gen": "1.8.5", + "@webassemblyjs/wasm-parser": "1.8.5" + } + }, + "@webassemblyjs/wasm-parser": { + "version": "1.8.5", + "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-parser/-/wasm-parser-1.8.5.tgz", + "integrity": "sha512-pi0SYE9T6tfcMkthwcgCpL0cM9nRYr6/6fjgDtL6q/ZqKHdMWvxitRi5JcZ7RI4SNJJYnYNaWy5UUrHQy998lw==", + "dev": true, + "requires": { + "@webassemblyjs/ast": "1.8.5", + "@webassemblyjs/helper-api-error": "1.8.5", + "@webassemblyjs/helper-wasm-bytecode": "1.8.5", + "@webassemblyjs/ieee754": "1.8.5", + "@webassemblyjs/leb128": "1.8.5", + "@webassemblyjs/utf8": "1.8.5" + } + }, + "@webassemblyjs/wast-parser": { + "version": "1.8.5", + "resolved": "https://registry.npmjs.org/@webassemblyjs/wast-parser/-/wast-parser-1.8.5.tgz", + "integrity": "sha512-daXC1FyKWHF1i11obK086QRlsMsY4+tIOKgBqI1lxAnkp9xe9YMcgOxm9kLe+ttjs5aWV2KKE1TWJCN57/Btsg==", + "dev": true, + "requires": { + "@webassemblyjs/ast": "1.8.5", + "@webassemblyjs/floating-point-hex-parser": "1.8.5", + "@webassemblyjs/helper-api-error": "1.8.5", + "@webassemblyjs/helper-code-frame": "1.8.5", + "@webassemblyjs/helper-fsm": "1.8.5", + "@xtuc/long": "4.2.2" + } + }, + "@webassemblyjs/wast-printer": { + "version": "1.8.5", + "resolved": "https://registry.npmjs.org/@webassemblyjs/wast-printer/-/wast-printer-1.8.5.tgz", + "integrity": "sha512-w0U0pD4EhlnvRyeJzBqaVSJAo9w/ce7/WPogeXLzGkO6hzhr4GnQIZ4W4uUt5b9ooAaXPtnXlj0gzsXEOUNYMg==", + "dev": true, + "requires": { + "@webassemblyjs/ast": "1.8.5", + "@webassemblyjs/wast-parser": "1.8.5", + "@xtuc/long": "4.2.2" + } + }, + "@webpack-cli/configtest": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/@webpack-cli/configtest/-/configtest-1.0.3.tgz", + "integrity": "sha512-WQs0ep98FXX2XBAfQpRbY0Ma6ADw8JR6xoIkaIiJIzClGOMqVRvPCWqndTxf28DgFopWan0EKtHtg/5W1h0Zkw==", + "dev": true + }, + "@webpack-cli/info": { + "version": "1.2.4", + "resolved": "https://registry.npmjs.org/@webpack-cli/info/-/info-1.2.4.tgz", + "integrity": "sha512-ogE2T4+pLhTTPS/8MM3IjHn0IYplKM4HbVNMCWA9N4NrdPzunwenpCsqKEXyejMfRu6K8mhauIPYf8ZxWG5O6g==", + "dev": true, + "requires": { + "envinfo": "^7.7.3" + } + }, + "@webpack-cli/serve": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/@webpack-cli/serve/-/serve-1.4.0.tgz", + "integrity": "sha512-xgT/HqJ+uLWGX+Mzufusl3cgjAcnqYYskaB7o0vRcwOEfuu6hMzSILQpnIzFMGsTaeaX4Nnekl+6fadLbl1/Vg==", + "dev": true + }, + "@xtuc/ieee754": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/@xtuc/ieee754/-/ieee754-1.2.0.tgz", + "integrity": "sha512-DX8nKgqcGwsc0eJSqYt5lwP4DH5FlHnmuWWBRy7X0NcaGR0ZtuyeESgMwTYVEtxmsNGY+qit4QYT/MIYTOTPeA==", + "dev": true + }, + "@xtuc/long": { + "version": "4.2.2", + "resolved": "https://registry.npmjs.org/@xtuc/long/-/long-4.2.2.tgz", + "integrity": "sha512-NuHqBY1PB/D8xU6s/thBgOAiAP7HOYDQ32+BFZILJ8ivkUkAHQnWfn6WhL79Owj1qmUnoN/YPhktdIoucipkAQ==", + "dev": true + }, + "@yarnpkg/lockfile": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/@yarnpkg/lockfile/-/lockfile-1.1.0.tgz", + "integrity": "sha512-GpSwvyXOcOOlV70vbnzjj4fW5xW/FdUF6nQEt1ENy7m4ZCczi1+/buVUPAqmGfqznsORNFzUMjctTIp8a9tuCQ==", + "dev": true + }, + "accepts": { + "version": "1.3.7", + "resolved": "https://registry.npmjs.org/accepts/-/accepts-1.3.7.tgz", + "integrity": "sha512-Il80Qs2WjYlJIBNzNkK6KYqlVMTbZLXgHx2oT0pU/fjRHyEp+PEfEPY0R3WCwAGVOtauxh1hOxNgIf5bv7dQpA==", + "dev": true, + "requires": { + "mime-types": "~2.1.24", + "negotiator": "0.6.2" + } + }, + "acorn": { + "version": "6.3.0", + "resolved": "https://registry.npmjs.org/acorn/-/acorn-6.3.0.tgz", + "integrity": "sha512-/czfa8BwS88b9gWQVhc8eknunSA2DoJpJyTQkhheIf5E48u1N0R4q/YxxsAeqRrmK9TQ/uYfgLDfZo91UlANIA==", + "dev": true + }, + "acorn-jsx": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/acorn-jsx/-/acorn-jsx-5.1.0.tgz", + "integrity": "sha512-tMUqwBWfLFbJbizRmEcWSLw6HnFzfdJs2sOJEOwwtVPMoH/0Ay+E703oZz78VSXZiiDcZrQ5XKjPIUQixhmgVw==", + "dev": true + }, + "after": { + "version": "0.8.2", + "resolved": "https://registry.npmjs.org/after/-/after-0.8.2.tgz", + "integrity": "sha1-/ts5T58OAqqXaOcCvaI7UF+ufh8=", + "dev": true + }, + "aggregate-error": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/aggregate-error/-/aggregate-error-3.1.0.tgz", + "integrity": "sha512-4I7Td01quW/RpocfNayFdFVk1qSuoh0E7JrbRJ16nH01HhKFQ88INq9Sd+nd72zqRySlr9BmDA8xlEJ6vJMrYA==", + "dev": true, + "requires": { + "clean-stack": "^2.0.0", + "indent-string": "^4.0.0" + } + }, + "ajv": { + "version": "6.10.2", + "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.10.2.tgz", + "integrity": "sha512-TXtUUEYHuaTEbLZWIKUr5pmBuhDLy+8KYtPYdcV8qC+pOZL+NKqYwvWSRrVXHn+ZmRRAu8vJTAznH7Oag6RVRw==", + "requires": { + "fast-deep-equal": "^2.0.1", + "fast-json-stable-stringify": "^2.0.0", + "json-schema-traverse": "^0.4.1", + "uri-js": "^4.2.2" + } + }, + "ajv-errors": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/ajv-errors/-/ajv-errors-1.0.1.tgz", + "integrity": "sha512-DCRfO/4nQ+89p/RK43i8Ezd41EqdGIU4ld7nGF8OQ14oc/we5rEntLCUa7+jrn3nn83BosfwZA0wb4pon2o8iQ==", + "dev": true + }, + "ajv-keywords": { + "version": "3.4.1", + "resolved": "https://registry.npmjs.org/ajv-keywords/-/ajv-keywords-3.4.1.tgz", + "integrity": "sha512-RO1ibKvd27e6FEShVFfPALuHI3WjSVNeK5FIsmme/LYRNxjKuNj+Dt7bucLa6NdSv3JcVTyMlm9kGR84z1XpaQ==", + "dev": true + }, + "alphanum-sort": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/alphanum-sort/-/alphanum-sort-1.0.2.tgz", + "integrity": "sha1-l6ERlkmyEa0zaR2fn0hqjsn74KM=" + }, + "ansi": { + "version": "0.2.1", + "resolved": "https://registry.npmjs.org/ansi/-/ansi-0.2.1.tgz", + "integrity": "sha1-OrVo7BjNCrd1PIMRfVfa1oShwBc=" + }, + "ansi-escapes": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/ansi-escapes/-/ansi-escapes-3.2.0.tgz", + "integrity": "sha512-cBhpre4ma+U0T1oM5fXg7Dy1Jw7zzwv7lt/GoCpr+hDQJoYnKVPLL4dCvSEFMmQurOQvSrwT7SL/DAlhBI97RQ==", + "dev": true + }, + "ansi-regex": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-2.1.1.tgz", + "integrity": "sha1-w7M6te42DYbg5ijwRorn7yfWVN8=" + }, + "ansi-styles": { + "version": "2.2.1", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-2.2.1.tgz", + "integrity": "sha1-tDLdM1i2NM914eRmQ2gkBTPB3b4=" + }, + "anymatch": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.1.tgz", + "integrity": "sha512-mM8522psRCqzV+6LhomX5wgp25YVibjh8Wj23I5RPkPppSVSjyKD2A2mBJmWGa+KN7f2D6LNh9jkBCeyLktzjg==", + "dev": true, + "requires": { + "normalize-path": "^3.0.0", + "picomatch": "^2.0.4" + } + }, + "aproba": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/aproba/-/aproba-1.2.0.tgz", + "integrity": "sha512-Y9J6ZjXtoYh8RnXVCMOU/ttDmk1aBjunq9vO0ta5x85WDQiQfUF9sIPBITdbiiIVcBo03Hi3jMxigBtsddlXRw==", + "dev": true + }, + "argparse": { + "version": "1.0.10", + "resolved": "https://registry.npmjs.org/argparse/-/argparse-1.0.10.tgz", + "integrity": "sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==", + "requires": { + "sprintf-js": "~1.0.2" + } + }, + "arr-diff": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/arr-diff/-/arr-diff-4.0.0.tgz", + "integrity": "sha1-1kYQdP6/7HHn4VI1dhoyml3HxSA=", + "dev": true + }, + "arr-flatten": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/arr-flatten/-/arr-flatten-1.1.0.tgz", + "integrity": "sha512-L3hKV5R/p5o81R7O02IGnwpDmkp6E982XhtbuwSe3O4qOtMMMtodicASA1Cny2U+aCXcNpml+m4dPsvsJ3jatg==", + "dev": true + }, + "arr-union": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/arr-union/-/arr-union-3.1.0.tgz", + "integrity": "sha1-45sJrqne+Gao8gbiiK9jkZuuOcQ=", + "dev": true + }, + "array-find-index": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/array-find-index/-/array-find-index-1.0.2.tgz", + "integrity": "sha1-3wEKoSh+Fku9pvlyOwqWoexBh6E=", + "dev": true + }, + "array-includes": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/array-includes/-/array-includes-3.0.3.tgz", + "integrity": "sha1-GEtI9i2S10UrsxsyMWXH+L0CJm0=", + "dev": true, + "requires": { + "define-properties": "^1.1.2", + "es-abstract": "^1.7.0" + } + }, + "array-union": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/array-union/-/array-union-2.1.0.tgz", + "integrity": "sha512-HGyxoOTYUyCM6stUe6EJgnd4EoewAI7zMdfqO+kGjnlZmBDz/cR5pf8r/cR4Wq60sL/p0IkcjUEEPwS3GFrIyw==", + "dev": true + }, + "array-unique": { + "version": "0.3.2", + "resolved": "https://registry.npmjs.org/array-unique/-/array-unique-0.3.2.tgz", + "integrity": "sha1-qJS3XUvE9s1nnvMkSp/Y9Gri1Cg=", + "dev": true + }, + "arraybuffer.slice": { + "version": "0.0.7", + "resolved": "https://registry.npmjs.org/arraybuffer.slice/-/arraybuffer.slice-0.0.7.tgz", + "integrity": "sha512-wGUIVQXuehL5TCqQun8OW81jGzAWycqzFF8lFp+GOM5BXLYj3bKNsYC4daB7n6XjCqxQA/qgTJ+8ANR3acjrog==", + "dev": true + }, + "asn1.js": { + "version": "4.10.1", + "resolved": "https://registry.npmjs.org/asn1.js/-/asn1.js-4.10.1.tgz", + "integrity": "sha512-p32cOF5q0Zqs9uBiONKYLm6BClCoBCM5O9JfeUSlnQLBTxYdTK+pW+nXflm8UkKd2UYlEbYz5qEi0JuZR9ckSw==", + "dev": true, + "requires": { + "bn.js": "^4.0.0", + "inherits": "^2.0.1", + "minimalistic-assert": "^1.0.0" + } + }, + "assert": { + "version": "1.5.0", + "resolved": "https://registry.npmjs.org/assert/-/assert-1.5.0.tgz", + "integrity": "sha512-EDsgawzwoun2CZkCgtxJbv392v4nbk9XDD06zI+kQYoBM/3RBWLlEyJARDOmhAAosBjWACEkKL6S+lIZtcAubA==", + "dev": true, + "requires": { + "object-assign": "^4.1.1", + "util": "0.10.3" + }, + "dependencies": { + "inherits": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.1.tgz", + "integrity": "sha1-sX0I0ya0Qj5Wjv9xn5GwscvfafE=", + "dev": true + }, + "util": { + "version": "0.10.3", + "resolved": "https://registry.npmjs.org/util/-/util-0.10.3.tgz", + "integrity": "sha1-evsa/lCAUkZInj23/g7TeTNqwPk=", + "dev": true, + "requires": { + "inherits": "2.0.1" + } + } + } + }, + "assertion-error": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/assertion-error/-/assertion-error-1.1.0.tgz", + "integrity": "sha512-jgsaNduz+ndvGyFt3uSuWqvy4lCnIJiovtouQN5JZHOKCS2QuhEdbcQHFhVksz2N2U9hXJo8odG7ETyWlEeuDw==", + "dev": true + }, + "assign-symbols": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/assign-symbols/-/assign-symbols-1.0.0.tgz", + "integrity": "sha1-WWZ/QfrdTyDMvCu5a41Pf3jsA2c=", + "dev": true + }, + "astral-regex": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/astral-regex/-/astral-regex-1.0.0.tgz", + "integrity": "sha512-+Ryf6g3BKoRc7jfp7ad8tM4TtMiaWvbF/1/sQcZPkkS7ag3D5nMBCe2UfOTONtAkaG0tO0ij3C5Lwmf1EiyjHg==", + "dev": true + }, + "async": { + "version": "2.6.3", + "resolved": "https://registry.npmjs.org/async/-/async-2.6.3.tgz", + "integrity": "sha512-zflvls11DCy+dQWzTW2dzuilv8Z5X/pjfmZOWba6TNIVDm+2UDaJmXSOXlasHKfNBs8oo3M0aT50fDEWfKZjXg==", + "dev": true, + "requires": { + "lodash": "^4.17.14" + } + }, + "async-each": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/async-each/-/async-each-1.0.3.tgz", + "integrity": "sha512-z/WhQ5FPySLdvREByI2vZiTWwCnF0moMJ1hK9YQwDTHKh6I7/uSckMetoRGb5UBZPC1z0jlw+n/XCgjeH7y1AQ==", + "dev": true + }, + "async-limiter": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/async-limiter/-/async-limiter-1.0.1.tgz", + "integrity": "sha512-csOlWGAcRFJaI6m+F2WKdnMKr4HhdhFVBk0H/QbJFMCr+uO2kwohwXQPxw/9OCxp05r5ghVBFSyioixx3gfkNQ==" + }, + "at-least-node": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/at-least-node/-/at-least-node-1.0.0.tgz", + "integrity": "sha512-+q/t7Ekv1EDY2l6Gda6LLiX14rU9TV20Wa3ofeQmwPFZbOMo9DXrLbOjFaaclkXKWidIaopwAObQDqwWtGUjqg==", + "dev": true + }, + "atob": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/atob/-/atob-2.1.2.tgz", + "integrity": "sha512-Wm6ukoaOGJi/73p/cl2GvLjTI5JM1k/O14isD73YML8StrH/7/lRFgmg8nICZgD3bZZvjwCGxtMOD3wWNAu8cg==", + "dev": true + }, + "autoprefixer": { + "version": "6.7.7", + "resolved": "https://registry.npmjs.org/autoprefixer/-/autoprefixer-6.7.7.tgz", + "integrity": "sha1-Hb0cg1ZY41zj+ZhAmdsAWFx4IBQ=", + "requires": { + "browserslist": "^1.7.6", + "caniuse-db": "^1.0.30000634", + "normalize-range": "^0.1.2", + "num2fraction": "^1.2.2", + "postcss": "^5.2.16", + "postcss-value-parser": "^3.2.3" + } + }, + "babel-code-frame": { + "version": "6.26.0", + "resolved": "https://registry.npmjs.org/babel-code-frame/-/babel-code-frame-6.26.0.tgz", + "integrity": "sha1-Y/1D99weO7fONZR9uP42mj9Yx0s=", + "requires": { + "chalk": "^1.1.3", + "esutils": "^2.0.2", + "js-tokens": "^3.0.2" + } + }, + "babel-runtime": { + "version": "6.26.0", + "resolved": "https://registry.npmjs.org/babel-runtime/-/babel-runtime-6.26.0.tgz", + "integrity": "sha1-llxwWGaOgrVde/4E/yM3vItWR/4=", + "dev": true, + "requires": { + "core-js": "^2.4.0", + "regenerator-runtime": "^0.11.0" + } + }, + "backbone": { + "version": "1.2.3", + "resolved": "https://registry.npmjs.org/backbone/-/backbone-1.2.3.tgz", + "integrity": "sha1-wiz9B/yG676uYdGJKe0RXpmdZbk=", + "requires": { + "underscore": ">=1.7.0" + } + }, + "backo2": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/backo2/-/backo2-1.0.2.tgz", + "integrity": "sha1-MasayLEpNjRj41s+u2n038+6eUc=", + "dev": true + }, + "balanced-match": { + "version": "0.4.2", + "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-0.4.2.tgz", + "integrity": "sha1-yz8+PHMtwPAe5wtAPzAuYddwmDg=" + }, + "base": { + "version": "0.11.2", + "resolved": "https://registry.npmjs.org/base/-/base-0.11.2.tgz", + "integrity": "sha512-5T6P4xPgpp0YDFvSWwEZ4NoE3aM4QBQXDzmVbraCkFj8zHM+mba8SyqB5DbZWyR7mYHo6Y7BdQo3MoA4m0TeQg==", + "dev": true, + "requires": { + "cache-base": "^1.0.1", + "class-utils": "^0.3.5", + "component-emitter": "^1.2.1", + "define-property": "^1.0.0", + "isobject": "^3.0.1", + "mixin-deep": "^1.2.0", + "pascalcase": "^0.1.1" + }, + "dependencies": { + "define-property": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/define-property/-/define-property-1.0.0.tgz", + "integrity": "sha1-dp66rz9KY6rTr56NMEybvnm/sOY=", + "dev": true, + "requires": { + "is-descriptor": "^1.0.0" + } + }, + "is-accessor-descriptor": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-accessor-descriptor/-/is-accessor-descriptor-1.0.0.tgz", + "integrity": "sha512-m5hnHTkcVsPfqx3AKlyttIPb7J+XykHvJP2B9bZDjlhLIoEq4XoK64Vg7boZlVWYK6LUY94dYPEE7Lh0ZkZKcQ==", + "dev": true, + "requires": { + "kind-of": "^6.0.0" + } + }, + "is-data-descriptor": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-data-descriptor/-/is-data-descriptor-1.0.0.tgz", + "integrity": "sha512-jbRXy1FmtAoCjQkVmIVYwuuqDFUbaOeDjmed1tOGPrsMhtJA4rD9tkgA0F1qJ3gRFRXcHYVkdeaP50Q5rE/jLQ==", + "dev": true, + "requires": { + "kind-of": "^6.0.0" + } + }, + "is-descriptor": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/is-descriptor/-/is-descriptor-1.0.2.tgz", + "integrity": "sha512-2eis5WqQGV7peooDyLmNEPUrps9+SXX5c9pL3xEB+4e9HnGuDa7mB7kHxHw4CbqS9k1T2hOH3miL8n8WtiYVtg==", + "dev": true, + "requires": { + "is-accessor-descriptor": "^1.0.0", + "is-data-descriptor": "^1.0.0", + "kind-of": "^6.0.2" + } + } + } + }, + "base64-arraybuffer": { + "version": "0.1.5", + "resolved": "https://registry.npmjs.org/base64-arraybuffer/-/base64-arraybuffer-0.1.5.tgz", + "integrity": "sha1-c5JncZI7Whl0etZmqlzUv5xunOg=", + "dev": true + }, + "base64-js": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/base64-js/-/base64-js-1.3.1.tgz", + "integrity": "sha512-mLQ4i2QO1ytvGWFWmcngKO//JXAQueZvwEKtjgQFM4jIK0kU+ytMfplL8j+n5mspOfjHwoAg+9yhb7BwAHm36g==" + }, + "base64id": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/base64id/-/base64id-1.0.0.tgz", + "integrity": "sha1-R2iMuZu2gE8OBtPnY7HDLlfY5rY=", + "dev": true + }, + "better-assert": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/better-assert/-/better-assert-1.0.2.tgz", + "integrity": "sha1-QIZrnhueC1W0gYlDEeaPr/rrxSI=", + "dev": true, + "requires": { + "callsite": "1.0.0" + } + }, + "big.js": { + "version": "5.2.2", + "resolved": "https://registry.npmjs.org/big.js/-/big.js-5.2.2.tgz", + "integrity": "sha512-vyL2OymJxmarO8gxMr0mhChsO9QGwhynfuu4+MHTAW6czfq9humCB7rKpUjDd9YUiDPU4mzpyupFSvOClAwbmQ==" + }, + "binary-extensions": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/binary-extensions/-/binary-extensions-2.0.0.tgz", + "integrity": "sha512-Phlt0plgpIIBOGTT/ehfFnbNlfsDEiqmzE2KRXoX1bLIlir4X/MR+zSyBEkL05ffWgnRSf/DXv+WrUAVr93/ow==", + "dev": true + }, + "blob": { + "version": "0.0.5", + "resolved": "https://registry.npmjs.org/blob/-/blob-0.0.5.tgz", + "integrity": "sha512-gaqbzQPqOoamawKg0LGVd7SzLgXS+JH61oWprSLH+P+abTczqJbhTR8CmJ2u9/bUYNmHTGJx/UEmn6doAvvuig==", + "dev": true + }, + "bluebird": { + "version": "3.7.1", + "resolved": "https://registry.npmjs.org/bluebird/-/bluebird-3.7.1.tgz", + "integrity": "sha512-DdmyoGCleJnkbp3nkbxTLJ18rjDsE4yCggEwKNXkeV123sPNfOCYeDoeuOY+F2FrSjO1YXcTU+dsy96KMy+gcg==", + "dev": true + }, + "bn.js": { + "version": "4.11.8", + "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.11.8.tgz", + "integrity": "sha512-ItfYfPLkWHUjckQCk8xC+LwxgK8NYcXywGigJgSwOP8Y2iyWT4f2vsZnoOXTTbo+o5yXmIUJ4gn5538SO5S3gA==", + "dev": true + }, + "body-parser": { + "version": "1.19.0", + "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-1.19.0.tgz", + "integrity": "sha512-dhEPs72UPbDnAQJ9ZKMNTP6ptJaionhP5cBb541nXPlW60Jepo9RV/a4fX4XWW9CuFNK22krhrj1+rgzifNCsw==", + "dev": true, + "requires": { + "bytes": "3.1.0", + "content-type": "~1.0.4", + "debug": "2.6.9", + "depd": "~1.1.2", + "http-errors": "1.7.2", + "iconv-lite": "0.4.24", + "on-finished": "~2.3.0", + "qs": "6.7.0", + "raw-body": "2.4.0", + "type-is": "~1.6.17" + }, + "dependencies": { + "debug": { + "version": "2.6.9", + "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", + "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", + "dev": true, + "requires": { + "ms": "2.0.0" + } + }, + "ms": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", + "integrity": "sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g=", + "dev": true + } + } + }, + "bqplot": { + "version": "0.5.9", + "resolved": "https://registry.npmjs.org/bqplot/-/bqplot-0.5.9.tgz", + "integrity": "sha512-n37Hx9ZhfulcYhY82ZuNr1GlD1fv4Ln4URvWllK6k/C7EYPsVNvb3Am9f9Uy+m44Nisz079W2BaOQy56wlFJQw==", + "dev": true, + "requires": { + "@jupyter-widgets/base": "^2 || ^3", + "@phosphor/messaging": "^1", + "@phosphor/widgets": "^1", + "d3": "^5.7.0", + "d3-selection-multi": "^1.0.1", + "is-typedarray": "^1.0.0", + "popper.js": "^1.0.0", + "three": "^0.91.0", + "topojson": "^1.6.24", + "underscore": "^1.8.3" + }, + "dependencies": { + "three": { + "version": "0.91.0", + "resolved": "https://registry.npmjs.org/three/-/three-0.91.0.tgz", + "integrity": "sha512-dzikzdcddNROFZi3vkbV8YonBmqnonbJv2FxlQBEE2wKzZutddnjiS8qBZG2+EB40l505Xw8OMClQm+GmbwI/g==", + "dev": true + } + } + }, + "brace-expansion": { + "version": "1.1.11", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz", + "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==", + "requires": { + "balanced-match": "^1.0.0", + "concat-map": "0.0.1" + }, + "dependencies": { + "balanced-match": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.0.tgz", + "integrity": "sha1-ibTRmasr7kneFk6gK4nORi1xt2c=" + } + } + }, + "braces": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.2.tgz", + "integrity": "sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A==", + "dev": true, + "requires": { + "fill-range": "^7.0.1" + } + }, + "brfs": { + "version": "1.6.1", + "resolved": "https://registry.npmjs.org/brfs/-/brfs-1.6.1.tgz", + "integrity": "sha512-OfZpABRQQf+Xsmju8XE9bDjs+uU4vLREGolP7bDgcpsI17QREyZ4Bl+2KLxxx1kCgA0fAIhKQBaBYh+PEcCqYQ==", + "dev": true, + "requires": { + "quote-stream": "^1.0.1", + "resolve": "^1.1.5", + "static-module": "^2.2.0", + "through2": "^2.0.0" + } + }, + "brorand": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/brorand/-/brorand-1.1.0.tgz", + "integrity": "sha1-EsJe/kCkXjwyPrhnWgoM5XsiNx8=", + "dev": true + }, + "browser-stdout": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/browser-stdout/-/browser-stdout-1.3.0.tgz", + "integrity": "sha1-81HTKWnTL6XXpVZxVCY9korjvR8=", + "dev": true + }, + "browserify-aes": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/browserify-aes/-/browserify-aes-1.2.0.tgz", + "integrity": "sha512-+7CHXqGuspUn/Sl5aO7Ea0xWGAtETPXNSAjHo48JfLdPWcMng33Xe4znFvQweqc/uzk5zSOI3H52CYnjCfb5hA==", + "dev": true, + "requires": { + "buffer-xor": "^1.0.3", + "cipher-base": "^1.0.0", + "create-hash": "^1.1.0", + "evp_bytestokey": "^1.0.3", + "inherits": "^2.0.1", + "safe-buffer": "^5.0.1" + } + }, + "browserify-cipher": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/browserify-cipher/-/browserify-cipher-1.0.1.tgz", + "integrity": "sha512-sPhkz0ARKbf4rRQt2hTpAHqn47X3llLkUGn+xEJzLjwY8LRs2p0v7ljvI5EyoRO/mexrNunNECisZs+gw2zz1w==", + "dev": true, + "requires": { + "browserify-aes": "^1.0.4", + "browserify-des": "^1.0.0", + "evp_bytestokey": "^1.0.0" + } + }, + "browserify-des": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/browserify-des/-/browserify-des-1.0.2.tgz", + "integrity": "sha512-BioO1xf3hFwz4kc6iBhI3ieDFompMhrMlnDFC4/0/vd5MokpuAc3R+LYbwTA9A5Yc9pq9UYPqffKpW2ObuwX5A==", + "dev": true, + "requires": { + "cipher-base": "^1.0.1", + "des.js": "^1.0.0", + "inherits": "^2.0.1", + "safe-buffer": "^5.1.2" + } + }, + "browserify-rsa": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/browserify-rsa/-/browserify-rsa-4.0.1.tgz", + "integrity": "sha1-IeCr+vbyApzy+vsTNWenAdQTVSQ=", + "dev": true, + "requires": { + "bn.js": "^4.1.0", + "randombytes": "^2.0.1" + } + }, + "browserify-sign": { + "version": "4.0.4", + "resolved": "https://registry.npmjs.org/browserify-sign/-/browserify-sign-4.0.4.tgz", + "integrity": "sha1-qk62jl17ZYuqa/alfmMMvXqT0pg=", + "dev": true, + "requires": { + "bn.js": "^4.1.1", + "browserify-rsa": "^4.0.0", + "create-hash": "^1.1.0", + "create-hmac": "^1.1.2", + "elliptic": "^6.0.0", + "inherits": "^2.0.1", + "parse-asn1": "^5.0.0" + } + }, + "browserify-zlib": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/browserify-zlib/-/browserify-zlib-0.2.0.tgz", + "integrity": "sha512-Z942RysHXmJrhqk88FmKBVq/v5tqmSkDz7p54G/MGyjMnCFFnC79XWNbg+Vta8W6Wb2qtSZTSxIGkJrRpCFEiA==", + "dev": true, + "requires": { + "pako": "~1.0.5" + } + }, + "browserslist": { + "version": "1.7.7", + "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-1.7.7.tgz", + "integrity": "sha1-C9dnBCWL6CmyOYu1Dkti0aFmsLk=", + "requires": { + "caniuse-db": "^1.0.30000639", + "electron-to-chromium": "^1.2.7" + } + }, + "buffer": { + "version": "4.9.1", + "resolved": "https://registry.npmjs.org/buffer/-/buffer-4.9.1.tgz", + "integrity": "sha1-bRu2AbB6TvztlwlBMgkwJ8lbwpg=", + "dev": true, + "requires": { + "base64-js": "^1.0.2", + "ieee754": "^1.1.4", + "isarray": "^1.0.0" + } + }, + "buffer-alloc": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/buffer-alloc/-/buffer-alloc-1.2.0.tgz", + "integrity": "sha512-CFsHQgjtW1UChdXgbyJGtnm+O/uLQeZdtbDo8mfUgYXCHSM1wgrVxXm6bSyrUuErEb+4sYVGCzASBRot7zyrow==", + "dev": true, + "requires": { + "buffer-alloc-unsafe": "^1.1.0", + "buffer-fill": "^1.0.0" + } + }, + "buffer-alloc-unsafe": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/buffer-alloc-unsafe/-/buffer-alloc-unsafe-1.1.0.tgz", + "integrity": "sha512-TEM2iMIEQdJ2yjPJoSIsldnleVaAk1oW3DBVUykyOLsEsFmEc9kn+SFFPz+gl54KQNxlDnAwCXosOS9Okx2xAg==", + "dev": true + }, + "buffer-equal": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/buffer-equal/-/buffer-equal-0.0.1.tgz", + "integrity": "sha1-kbx0sR6kBbyRa8aqkI+q+ltKrEs=", + "dev": true + }, + "buffer-fill": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/buffer-fill/-/buffer-fill-1.0.0.tgz", + "integrity": "sha1-+PeLdniYiO858gXNY39o5wISKyw=", + "dev": true + }, + "buffer-from": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.1.tgz", + "integrity": "sha512-MQcXEUbCKtEo7bhqEs6560Hyd4XaovZlO/k9V3hjVUF/zwW7KBVdSK4gIt/bzwS9MbR5qob+F5jusZsb0YQK2A==", + "dev": true + }, + "buffer-xor": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/buffer-xor/-/buffer-xor-1.0.3.tgz", + "integrity": "sha1-JuYe0UIvtw3ULm42cp7VHYVf6Nk=", + "dev": true + }, + "builtin-modules": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/builtin-modules/-/builtin-modules-1.1.1.tgz", + "integrity": "sha1-Jw8HbFpywC9bZaR9+Uxf46J4iS8=" + }, + "builtin-status-codes": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/builtin-status-codes/-/builtin-status-codes-3.0.0.tgz", + "integrity": "sha1-hZgoeOIbmOHGZCXgPQF0eI9Wnug=", + "dev": true + }, + "bytes": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/bytes/-/bytes-3.1.0.tgz", + "integrity": "sha512-zauLjrfCG+xvoyaqLoV8bLVXXNGC4JqlxFCutSDWA6fJrTo2ZuvLYTqZ7aHBLZSMOopbzwv8f+wZcVzfVTI2Dg==", + "dev": true + }, + "cacache": { + "version": "12.0.3", + "resolved": "https://registry.npmjs.org/cacache/-/cacache-12.0.3.tgz", + "integrity": "sha512-kqdmfXEGFepesTuROHMs3MpFLWrPkSSpRqOw80RCflZXy/khxaArvFrQ7uJxSUduzAufc6G0g1VUCOZXxWavPw==", + "dev": true, + "requires": { + "bluebird": "^3.5.5", + "chownr": "^1.1.1", + "figgy-pudding": "^3.5.1", + "glob": "^7.1.4", + "graceful-fs": "^4.1.15", + "infer-owner": "^1.0.3", + "lru-cache": "^5.1.1", + "mississippi": "^3.0.0", + "mkdirp": "^0.5.1", + "move-concurrently": "^1.0.1", + "promise-inflight": "^1.0.1", + "rimraf": "^2.6.3", + "ssri": "^6.0.1", + "unique-filename": "^1.1.1", + "y18n": "^4.0.0" + }, + "dependencies": { + "lru-cache": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-5.1.1.tgz", + "integrity": "sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==", + "dev": true, + "requires": { + "yallist": "^3.0.2" + } + }, + "yallist": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-3.1.1.tgz", + "integrity": "sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==", + "dev": true + } + } + }, + "cache-base": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/cache-base/-/cache-base-1.0.1.tgz", + "integrity": "sha512-AKcdTnFSWATd5/GCPRxr2ChwIJ85CeyrEyjRHlKxQ56d4XJMGym0uAiKn0xbLOGOl3+yRpOTi484dVCEc5AUzQ==", + "dev": true, + "requires": { + "collection-visit": "^1.0.0", + "component-emitter": "^1.2.1", + "get-value": "^2.0.6", + "has-value": "^1.0.0", + "isobject": "^3.0.1", + "set-value": "^2.0.0", + "to-object-path": "^0.3.0", + "union-value": "^1.0.0", + "unset-value": "^1.0.0" + } + }, + "cacheable-request": { + "version": "6.1.0", + "resolved": "https://registry.npmjs.org/cacheable-request/-/cacheable-request-6.1.0.tgz", + "integrity": "sha512-Oj3cAGPCqOZX7Rz64Uny2GYAZNliQSqfbePrgAQ1wKAihYmCUnraBtJtKcGR4xz7wF+LoJC+ssFZvv5BgF9Igg==", + "dev": true, + "requires": { + "clone-response": "^1.0.2", + "get-stream": "^5.1.0", + "http-cache-semantics": "^4.0.0", + "keyv": "^3.0.0", + "lowercase-keys": "^2.0.0", + "normalize-url": "^4.1.0", + "responselike": "^1.0.2" + }, + "dependencies": { + "get-stream": { + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-5.2.0.tgz", + "integrity": "sha512-nBF+F1rAZVCu/p7rjzgA+Yb4lfYXrpl7a6VmJrU8wF9I1CKvP/QwPNZHnOlwbTkY6dvtFIzFMSyQXbLoTQPRpA==", + "dev": true, + "requires": { + "pump": "^3.0.0" + } + }, + "lowercase-keys": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/lowercase-keys/-/lowercase-keys-2.0.0.tgz", + "integrity": "sha512-tqNXrS78oMOE73NMxK4EMLQsQowWf8jKooH9g7xPavRT706R6bkQJ6DY2Te7QukaZsulxa30wQ7bk0pm4XiHmA==", + "dev": true + }, + "normalize-url": { + "version": "4.5.0", + "resolved": "https://registry.npmjs.org/normalize-url/-/normalize-url-4.5.0.tgz", + "integrity": "sha512-2s47yzUxdexf1OhyRi4Em83iQk0aPvwTddtFz4hnSSw9dCEsLEGf6SwIO8ss/19S9iBb5sJaOuTvTGDeZI00BQ==", + "dev": true + } + } + }, + "callsite": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/callsite/-/callsite-1.0.0.tgz", + "integrity": "sha1-KAOY5dZkvXQDi28JBRU+borxvCA=", + "dev": true + }, + "callsites": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz", + "integrity": "sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==", + "dev": true + }, + "camelcase": { + "version": "5.3.1", + "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-5.3.1.tgz", + "integrity": "sha512-L28STB170nwWS63UjtlEOE3dldQApaJXZkOI1uMFfzf3rRuPegHaHesyee+YxQ+W6SvRDQV6UrdOdRiR153wJg==", + "dev": true + }, + "caniuse-api": { + "version": "1.6.1", + "resolved": "https://registry.npmjs.org/caniuse-api/-/caniuse-api-1.6.1.tgz", + "integrity": "sha1-tTTnxzTE+B7F++isoq0kNUuWLGw=", + "requires": { + "browserslist": "^1.3.6", + "caniuse-db": "^1.0.30000529", + "lodash.memoize": "^4.1.2", + "lodash.uniq": "^4.5.0" + } + }, + "caniuse-db": { + "version": "1.0.30001004", + "resolved": "https://registry.npmjs.org/caniuse-db/-/caniuse-db-1.0.30001004.tgz", + "integrity": "sha512-VBTptWLoxsIhIGFZOEvtHhdRyhh+6JARUnVy2debGRNmrKfunVAa9cRuAvOnrQk4z/SDiNm5S2d6h32eIHZMoA==" + }, + "caniuse-lite": { + "version": "1.0.30001228", + "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001228.tgz", + "integrity": "sha512-QQmLOGJ3DEgokHbMSA8cj2a+geXqmnpyOFT0lhQV6P3/YOJvGDEwoedcwxEQ30gJIwIIunHIicunJ2rzK5gB2A==", + "dev": true + }, + "chai": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/chai/-/chai-4.2.0.tgz", + "integrity": "sha512-XQU3bhBukrOsQCuwZndwGcCVQHyZi53fQ6Ys1Fym7E4olpIqqZZhhoFJoaKVvV17lWQoXYwgWN2nF5crA8J2jw==", + "dev": true, + "requires": { + "assertion-error": "^1.1.0", + "check-error": "^1.0.2", + "deep-eql": "^3.0.1", + "get-func-name": "^2.0.0", + "pathval": "^1.1.0", + "type-detect": "^4.0.5" + } + }, + "chalk": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-1.1.3.tgz", + "integrity": "sha1-qBFcVeSnAv5NFQq9OHKCKn4J/Jg=", + "requires": { + "ansi-styles": "^2.2.1", + "escape-string-regexp": "^1.0.2", + "has-ansi": "^2.0.0", + "strip-ansi": "^3.0.0", + "supports-color": "^2.0.0" + } + }, + "chardet": { + "version": "0.7.0", + "resolved": "https://registry.npmjs.org/chardet/-/chardet-0.7.0.tgz", + "integrity": "sha512-mT8iDcrh03qDGRRmoA2hmBJnxpllMR+0/0qlzjqZES6NdiWDcZkCNAk4rPFZ9Q85r27unkiNNg8ZOiwZXBHwcA==", + "dev": true + }, + "check-error": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/check-error/-/check-error-1.0.2.tgz", + "integrity": "sha1-V00xLt2Iu13YkS6Sht1sCu1KrII=", + "dev": true + }, + "child_process": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/child_process/-/child_process-1.0.2.tgz", + "integrity": "sha1-sffn/HPSXn/R1FWtyU4UODAYK1o=", + "dev": true + }, + "chokidar": { + "version": "3.2.2", + "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-3.2.2.tgz", + "integrity": "sha512-bw3pm7kZ2Wa6+jQWYP/c7bAZy3i4GwiIiMO2EeRjrE48l8vBqC/WvFhSF0xyM8fQiPEGvwMY/5bqDG7sSEOuhg==", + "dev": true, + "requires": { + "anymatch": "~3.1.1", + "braces": "~3.0.2", + "fsevents": "~2.1.1", + "glob-parent": "~5.1.0", + "is-binary-path": "~2.1.0", + "is-glob": "~4.0.1", + "normalize-path": "~3.0.0", + "readdirp": "~3.2.0" + } + }, + "chownr": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/chownr/-/chownr-1.1.3.tgz", + "integrity": "sha512-i70fVHhmV3DtTl6nqvZOnIjbY0Pe4kAUjwHj8z0zAdgBtYrJyYwLKCCuRBQ5ppkyL0AkN7HKRnETdmdp1zqNXw==", + "dev": true + }, + "chrome-trace-event": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/chrome-trace-event/-/chrome-trace-event-1.0.2.tgz", + "integrity": "sha512-9e/zx1jw7B4CO+c/RXoCsfg/x1AfUBioy4owYH0bJprEYAx5hRFLRhWBqHAG57D0ZM4H7vxbP7bPe0VwhQRYDQ==", + "dev": true, + "requires": { + "tslib": "^1.9.0" + } + }, + "cipher-base": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/cipher-base/-/cipher-base-1.0.4.tgz", + "integrity": "sha512-Kkht5ye6ZGmwv40uUDZztayT2ThLQGfnj/T71N/XzeZeo3nf8foyW7zGTsPYkEya3m5f3cAypH+qe7YOrM1U2Q==", + "dev": true, + "requires": { + "inherits": "^2.0.1", + "safe-buffer": "^5.0.1" + } + }, + "clap": { + "version": "1.2.3", + "resolved": "https://registry.npmjs.org/clap/-/clap-1.2.3.tgz", + "integrity": "sha512-4CoL/A3hf90V3VIEjeuhSvlGFEHKzOz+Wfc2IVZc+FaUgU0ZQafJTP49fvnULipOPcAfqhyI2duwQyns6xqjYA==", + "requires": { + "chalk": "^1.1.3" + } + }, + "class-utils": { + "version": "0.3.6", + "resolved": "https://registry.npmjs.org/class-utils/-/class-utils-0.3.6.tgz", + "integrity": "sha512-qOhPa/Fj7s6TY8H8esGu5QNpMMQxz79h+urzrNYN6mn+9BnxlDGf5QZ+XeCDsxSjPqsSR56XOZOJmpeurnLMeg==", + "dev": true, + "requires": { + "arr-union": "^3.1.0", + "define-property": "^0.2.5", + "isobject": "^3.0.0", + "static-extend": "^0.1.1" + }, + "dependencies": { + "define-property": { + "version": "0.2.5", + "resolved": "https://registry.npmjs.org/define-property/-/define-property-0.2.5.tgz", + "integrity": "sha1-w1se+RjsPJkPmlvFe+BKrOxcgRY=", + "dev": true, + "requires": { + "is-descriptor": "^0.1.0" + } + } + } + }, + "clean-stack": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/clean-stack/-/clean-stack-2.2.0.tgz", + "integrity": "sha512-4diC9HaTE+KRAMWhDhrGOECgWZxoevMc5TlkObMqNSsVU62PYzXZ/SMTjzyGAFF1YusgxGcSWTEXBhp0CPwQ1A==", + "dev": true + }, + "cli-cursor": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/cli-cursor/-/cli-cursor-2.1.0.tgz", + "integrity": "sha1-s12sN2R5+sw+lHR9QdDQ9SOP/LU=", + "dev": true, + "requires": { + "restore-cursor": "^2.0.0" + } + }, + "cli-width": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/cli-width/-/cli-width-2.2.0.tgz", + "integrity": "sha1-/xnt6Kml5XkyQUewwR8PvLq+1jk=", + "dev": true + }, + "cliui": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/cliui/-/cliui-5.0.0.tgz", + "integrity": "sha512-PYeGSEmmHM6zvoef2w8TPzlrnNpXIjTipYK780YswmIP9vjxmd6Y2a3CB2Ks6/AU8NHjZugXvo8w3oWM2qnwXA==", + "dev": true, + "requires": { + "string-width": "^3.1.0", + "strip-ansi": "^5.2.0", + "wrap-ansi": "^5.1.0" + }, + "dependencies": { + "ansi-regex": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-4.1.0.tgz", + "integrity": "sha512-1apePfXM1UOSqw0o9IiFAovVz9M5S1Dg+4TrDwfMewQ6p/rmMueb7tWZjQ1rx4Loy1ArBggoqGpfqqdI4rondg==", + "dev": true + }, + "string-width": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-3.1.0.tgz", + "integrity": "sha512-vafcv6KjVZKSgz06oM/H6GDBrAtz8vdhQakGjFIvNrHA6y3HCF1CInLy+QLq8dTJPQ1b+KDUqDFctkdRW44e1w==", + "dev": true, + "requires": { + "emoji-regex": "^7.0.1", + "is-fullwidth-code-point": "^2.0.0", + "strip-ansi": "^5.1.0" + } + }, + "strip-ansi": { + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-5.2.0.tgz", + "integrity": "sha512-DuRs1gKbBqsMKIZlrffwlug8MHkcnpjs5VPmL1PAh+mA30U0DTotfDZ0d2UUsXpPmPmMMJ6W773MaA3J+lbiWA==", + "dev": true, + "requires": { + "ansi-regex": "^4.1.0" + } + } + } + }, + "clone": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/clone/-/clone-1.0.4.tgz", + "integrity": "sha1-2jCcwmPfFZlMaIypAheco8fNfH4=" + }, + "clone-deep": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/clone-deep/-/clone-deep-4.0.1.tgz", + "integrity": "sha512-neHB9xuzh/wk0dIHweyAXv2aPGZIVk3pLMe+/RNzINf17fe0OG96QroktYAUm7SM1PBnzTabaLboqqxDyMU+SQ==", + "dev": true, + "requires": { + "is-plain-object": "^2.0.4", + "kind-of": "^6.0.2", + "shallow-clone": "^3.0.0" + } + }, + "clone-response": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/clone-response/-/clone-response-1.0.2.tgz", + "integrity": "sha1-0dyXOSAxTfZ/vrlCI7TuNQI56Ws=", + "dev": true, + "requires": { + "mimic-response": "^1.0.0" + } + }, + "co": { + "version": "4.6.0", + "resolved": "https://registry.npmjs.org/co/-/co-4.6.0.tgz", + "integrity": "sha1-bqa989hTrlTMuOR7+gvz+QMfsYQ=" + }, + "coa": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/coa/-/coa-1.0.4.tgz", + "integrity": "sha1-qe8VNmDWqGqL3sAomlxoTSF0Mv0=", + "requires": { + "q": "^1.1.2" + } + }, + "collection-visit": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/collection-visit/-/collection-visit-1.0.0.tgz", + "integrity": "sha1-S8A3PBZLwykbTTaMgpzxqApZ3KA=", + "dev": true, + "requires": { + "map-visit": "^1.0.0", + "object-visit": "^1.0.0" + } + }, + "color": { + "version": "0.11.4", + "resolved": "https://registry.npmjs.org/color/-/color-0.11.4.tgz", + "integrity": "sha1-bXtcdPtl6EHNSHkq0e1eB7kE12Q=", + "requires": { + "clone": "^1.0.2", + "color-convert": "^1.3.0", + "color-string": "^0.3.0" + } + }, + "color-convert": { + "version": "1.9.3", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-1.9.3.tgz", + "integrity": "sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==", + "requires": { + "color-name": "1.1.3" + } + }, + "color-name": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz", + "integrity": "sha1-p9BVi9icQveV3UIyj3QIMcpTvCU=" + }, + "color-string": { + "version": "0.3.0", + "resolved": "https://registry.npmjs.org/color-string/-/color-string-0.3.0.tgz", + "integrity": "sha1-J9RvtnAlxcL6JZk7+/V55HhBuZE=", + "requires": { + "color-name": "^1.0.0" + } + }, + "colorette": { + "version": "1.2.2", + "resolved": "https://registry.npmjs.org/colorette/-/colorette-1.2.2.tgz", + "integrity": "sha512-MKGMzyfeuutC/ZJ1cba9NqcNpfeqMUcYmyF1ZFY6/Cn7CNSAKx6a+s48sqLqyAiZuaP2TcqMhoo+dlwFnVxT9w==", + "dev": true + }, + "colormin": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/colormin/-/colormin-1.1.2.tgz", + "integrity": "sha1-6i90IKcrlogaOKrlnsEkpvcpgTM=", + "requires": { + "color": "^0.11.0", + "css-color-names": "0.0.4", + "has": "^1.0.1" + } + }, + "colors": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/colors/-/colors-1.1.2.tgz", + "integrity": "sha1-FopHAXVran9RoSzgyXv6KMCE7WM=" + }, + "commander": { + "version": "2.20.3", + "resolved": "https://registry.npmjs.org/commander/-/commander-2.20.3.tgz", + "integrity": "sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ==" + }, + "commondir": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/commondir/-/commondir-1.0.1.tgz", + "integrity": "sha1-3dgA2gxmEnOTzKWVDqloo6rxJTs=", + "dev": true + }, + "component-bind": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/component-bind/-/component-bind-1.0.0.tgz", + "integrity": "sha1-AMYIq33Nk4l8AAllGx06jh5zu9E=", + "dev": true + }, + "component-emitter": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/component-emitter/-/component-emitter-1.2.1.tgz", + "integrity": "sha1-E3kY1teCg/ffemt8WmPhQOaUJeY=", + "dev": true + }, + "component-inherit": { + "version": "0.0.3", + "resolved": "https://registry.npmjs.org/component-inherit/-/component-inherit-0.0.3.tgz", + "integrity": "sha1-ZF/ErfWLcrZJ1crmUTVhnbJv8UM=", + "dev": true + }, + "concat-map": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz", + "integrity": "sha1-2Klr13/Wjfd5OnMDajug1UBdR3s=" + }, + "concat-stream": { + "version": "1.6.2", + "resolved": "https://registry.npmjs.org/concat-stream/-/concat-stream-1.6.2.tgz", + "integrity": "sha512-27HBghJxjiZtIk3Ycvn/4kbJk/1uZuJFfuPEns6LaEvpvG1f0hTea8lilrouyo9mVc2GWdcEZ8OLoGmSADlrCw==", + "dev": true, + "requires": { + "buffer-from": "^1.0.0", + "inherits": "^2.0.3", + "readable-stream": "^2.2.2", + "typedarray": "^0.0.6" + } + }, + "connect": { + "version": "3.7.0", + "resolved": "https://registry.npmjs.org/connect/-/connect-3.7.0.tgz", + "integrity": "sha512-ZqRXc+tZukToSNmh5C2iWMSoV3X1YUcPbqEM4DkEG5tNQXrQUZCNVGGv3IuicnkMtPfGf3Xtp8WCXs295iQ1pQ==", + "dev": true, + "requires": { + "debug": "2.6.9", + "finalhandler": "1.1.2", + "parseurl": "~1.3.3", + "utils-merge": "1.0.1" + }, + "dependencies": { + "debug": { + "version": "2.6.9", + "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", + "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", + "dev": true, + "requires": { + "ms": "2.0.0" + } + }, + "ms": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", + "integrity": "sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g=", + "dev": true + } + } + }, + "console-browserify": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/console-browserify/-/console-browserify-1.1.0.tgz", + "integrity": "sha1-8CQcRXMKn8YyOyBtvzjtx0HQuxA=", + "dev": true, + "requires": { + "date-now": "^0.1.4" + } + }, + "constants-browserify": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/constants-browserify/-/constants-browserify-1.0.0.tgz", + "integrity": "sha1-wguW2MYXdIqvHBYCF2DNJ/y4y3U=", + "dev": true + }, + "contains-path": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/contains-path/-/contains-path-0.1.0.tgz", + "integrity": "sha1-/ozxhP9mcLa67wGp1IYaXL7EEgo=", + "dev": true + }, + "content-type": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/content-type/-/content-type-1.0.4.tgz", + "integrity": "sha512-hIP3EEPs8tB9AT1L+NUqtwOAps4mk2Zob89MWXMHjHWg9milF/j4osnnQLXBCBFBk/tvIG/tUc9mOUJiPBhPXA==", + "dev": true + }, + "convert-source-map": { + "version": "1.7.0", + "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-1.7.0.tgz", + "integrity": "sha512-4FJkXzKXEDB1snCFZlLP4gpC3JILicCpGbzG9f9G7tGqGCzETQ2hWPrcinA9oU4wtf2biUaEH5065UnMeR33oA==", + "dev": true, + "requires": { + "safe-buffer": "~5.1.1" + }, + "dependencies": { + "safe-buffer": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz", + "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==", + "dev": true + } + } + }, + "cookie": { + "version": "0.3.1", + "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.3.1.tgz", + "integrity": "sha1-5+Ch+e9DtMi6klxcWpboBtFoc7s=", + "dev": true + }, + "copy-concurrently": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/copy-concurrently/-/copy-concurrently-1.0.5.tgz", + "integrity": "sha512-f2domd9fsVDFtaFcbaRZuYXwtdmnzqbADSwhSWYxYB/Q8zsdUUFMXVRwXGDMWmbEzAn1kdRrtI1T/KTFOL4X2A==", + "dev": true, + "requires": { + "aproba": "^1.1.1", + "fs-write-stream-atomic": "^1.0.8", + "iferr": "^0.1.5", + "mkdirp": "^0.5.1", + "rimraf": "^2.5.4", + "run-queue": "^1.0.0" + } + }, + "copy-descriptor": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/copy-descriptor/-/copy-descriptor-0.1.1.tgz", + "integrity": "sha1-Z29us8OZl8LuGsOpJP1hJHSPV40=", + "dev": true + }, + "core-js": { + "version": "2.6.10", + "resolved": "https://registry.npmjs.org/core-js/-/core-js-2.6.10.tgz", + "integrity": "sha512-I39t74+4t+zau64EN1fE5v2W31Adtc/REhzWN+gWRRXg6WH5qAsZm62DHpQ1+Yhe4047T55jvzz7MUqF/dBBlA==", + "dev": true + }, + "core-util-is": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/core-util-is/-/core-util-is-1.0.2.tgz", + "integrity": "sha1-tf1UIgqivFq1eqtxQMlAdUUDwac=", + "dev": true + }, + "create-ecdh": { + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/create-ecdh/-/create-ecdh-4.0.3.tgz", + "integrity": "sha512-GbEHQPMOswGpKXM9kCWVrremUcBmjteUaQ01T9rkKCPDXfUHX0IoP9LpHYo2NPFampa4e+/pFDc3jQdxrxQLaw==", + "dev": true, + "requires": { + "bn.js": "^4.1.0", + "elliptic": "^6.0.0" + } + }, + "create-hash": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/create-hash/-/create-hash-1.2.0.tgz", + "integrity": "sha512-z00bCGNHDG8mHAkP7CtT1qVu+bFQUPjYq/4Iv3C3kWjTFV10zIjfSoeqXo9Asws8gwSHDGj/hl2u4OGIjapeCg==", + "dev": true, + "requires": { + "cipher-base": "^1.0.1", + "inherits": "^2.0.1", + "md5.js": "^1.3.4", + "ripemd160": "^2.0.1", + "sha.js": "^2.4.0" + } + }, + "create-hmac": { + "version": "1.1.7", + "resolved": "https://registry.npmjs.org/create-hmac/-/create-hmac-1.1.7.tgz", + "integrity": "sha512-MJG9liiZ+ogc4TzUwuvbER1JRdgvUFSB5+VR/g5h82fGaIRWMWddtKBHi7/sVhfjQZ6SehlyhvQYrcYkaUIpLg==", + "dev": true, + "requires": { + "cipher-base": "^1.0.3", + "create-hash": "^1.1.0", + "inherits": "^2.0.1", + "ripemd160": "^2.0.0", + "safe-buffer": "^5.0.1", + "sha.js": "^2.4.8" + } + }, + "cross-spawn": { + "version": "6.0.5", + "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-6.0.5.tgz", + "integrity": "sha512-eTVLrBSt7fjbDygz805pMnstIs2VTBNkRm0qxZd+M7A5XDdxVRWO5MxGBXZhjY4cqLYLdtrGqRf8mBPmzwSpWQ==", + "dev": true, + "requires": { + "nice-try": "^1.0.4", + "path-key": "^2.0.1", + "semver": "^5.5.0", + "shebang-command": "^1.2.0", + "which": "^1.2.9" + } + }, + "crypto": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/crypto/-/crypto-1.0.1.tgz", + "integrity": "sha512-VxBKmeNcqQdiUQUW2Tzq0t377b54N2bMtXO/qiLa+6eRRmmC4qT3D4OnTGoT/U6O9aklQ/jTwbOtRMTTY8G0Ig==", + "dev": true + }, + "crypto-browserify": { + "version": "3.12.0", + "resolved": "https://registry.npmjs.org/crypto-browserify/-/crypto-browserify-3.12.0.tgz", + "integrity": "sha512-fz4spIh+znjO2VjL+IdhEpRJ3YN6sMzITSBijk6FK2UvTqruSQW+/cCZTSNsMiZNvUeq0CqurF+dAbyiGOY6Wg==", + "dev": true, + "requires": { + "browserify-cipher": "^1.0.0", + "browserify-sign": "^4.0.0", + "create-ecdh": "^4.0.0", + "create-hash": "^1.1.0", + "create-hmac": "^1.1.0", + "diffie-hellman": "^5.0.0", + "inherits": "^2.0.1", + "pbkdf2": "^3.0.3", + "public-encrypt": "^4.0.0", + "randombytes": "^2.0.0", + "randomfill": "^1.0.3" + } + }, + "css-color-names": { + "version": "0.0.4", + "resolved": "https://registry.npmjs.org/css-color-names/-/css-color-names-0.0.4.tgz", + "integrity": "sha1-gIrcLnnPhHOAabZGyyDsJ762KeA=" + }, + "css-loader": { + "version": "0.28.11", + "resolved": "https://registry.npmjs.org/css-loader/-/css-loader-0.28.11.tgz", + "integrity": "sha512-wovHgjAx8ZIMGSL8pTys7edA1ClmzxHeY6n/d97gg5odgsxEgKjULPR0viqyC+FWMCL9sfqoC/QCUBo62tLvPg==", + "requires": { + "babel-code-frame": "^6.26.0", + "css-selector-tokenizer": "^0.7.0", + "cssnano": "^3.10.0", + "icss-utils": "^2.1.0", + "loader-utils": "^1.0.2", + "lodash.camelcase": "^4.3.0", + "object-assign": "^4.1.1", + "postcss": "^5.0.6", + "postcss-modules-extract-imports": "^1.2.0", + "postcss-modules-local-by-default": "^1.2.0", + "postcss-modules-scope": "^1.1.0", + "postcss-modules-values": "^1.3.0", + "postcss-value-parser": "^3.3.0", + "source-list-map": "^2.0.0" + } + }, + "css-selector-tokenizer": { + "version": "0.7.1", + "resolved": "https://registry.npmjs.org/css-selector-tokenizer/-/css-selector-tokenizer-0.7.1.tgz", + "integrity": "sha512-xYL0AMZJ4gFzJQsHUKa5jiWWi2vH77WVNg7JYRyewwj6oPh4yb/y6Y9ZCw9dsj/9UauMhtuxR+ogQd//EdEVNA==", + "requires": { + "cssesc": "^0.1.0", + "fastparse": "^1.1.1", + "regexpu-core": "^1.0.0" + } + }, + "cssesc": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/cssesc/-/cssesc-0.1.0.tgz", + "integrity": "sha1-yBSQPkViM3GgR3tAEJqq++6t27Q=" + }, + "cssnano": { + "version": "3.10.0", + "resolved": "https://registry.npmjs.org/cssnano/-/cssnano-3.10.0.tgz", + "integrity": "sha1-Tzj2zqK5sX+gFJDyPx3GjqZcHDg=", + "requires": { + "autoprefixer": "^6.3.1", + "decamelize": "^1.1.2", + "defined": "^1.0.0", + "has": "^1.0.1", + "object-assign": "^4.0.1", + "postcss": "^5.0.14", + "postcss-calc": "^5.2.0", + "postcss-colormin": "^2.1.8", + "postcss-convert-values": "^2.3.4", + "postcss-discard-comments": "^2.0.4", + "postcss-discard-duplicates": "^2.0.1", + "postcss-discard-empty": "^2.0.1", + "postcss-discard-overridden": "^0.1.1", + "postcss-discard-unused": "^2.2.1", + "postcss-filter-plugins": "^2.0.0", + "postcss-merge-idents": "^2.1.5", + "postcss-merge-longhand": "^2.0.1", + "postcss-merge-rules": "^2.0.3", + "postcss-minify-font-values": "^1.0.2", + "postcss-minify-gradients": "^1.0.1", + "postcss-minify-params": "^1.0.4", + "postcss-minify-selectors": "^2.0.4", + "postcss-normalize-charset": "^1.1.0", + "postcss-normalize-url": "^3.0.7", + "postcss-ordered-values": "^2.1.0", + "postcss-reduce-idents": "^2.2.2", + "postcss-reduce-initial": "^1.0.0", + "postcss-reduce-transforms": "^1.0.3", + "postcss-svgo": "^2.1.1", + "postcss-unique-selectors": "^2.0.2", + "postcss-value-parser": "^3.2.3", + "postcss-zindex": "^2.0.1" + } + }, + "csso": { + "version": "2.3.2", + "resolved": "https://registry.npmjs.org/csso/-/csso-2.3.2.tgz", + "integrity": "sha1-3dUsWHAz9J6Utx/FVWnyUuj/X4U=", + "requires": { + "clap": "^1.0.9", + "source-map": "^0.5.3" + } + }, + "currently-unhandled": { + "version": "0.4.1", + "resolved": "https://registry.npmjs.org/currently-unhandled/-/currently-unhandled-0.4.1.tgz", + "integrity": "sha1-mI3zP+qxke95mmE2nddsF635V+o=", + "dev": true, + "requires": { + "array-find-index": "^1.0.1" + } + }, + "custom-event": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/custom-event/-/custom-event-1.0.1.tgz", + "integrity": "sha1-XQKkaFCt8bSjF5RqOSj8y1v9BCU=", + "dev": true + }, + "cwise-compiler": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/cwise-compiler/-/cwise-compiler-1.1.3.tgz", + "integrity": "sha1-9NZnQQ6FDToxOn0tt7HlBbsDTMU=", + "requires": { + "uniq": "^1.0.0" + } + }, + "cyclist": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/cyclist/-/cyclist-1.0.1.tgz", + "integrity": "sha1-WW6WmP0MgOEgOMK4LW6xs1tiJNk=", + "dev": true + }, + "d": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/d/-/d-1.0.1.tgz", + "integrity": "sha512-m62ShEObQ39CfralilEQRjH6oAMtNCV1xJyEx5LpRYUVN+EviphDgUc/F3hnYbADmkiNs67Y+3ylmlG7Lnu+FA==", + "dev": true, + "requires": { + "es5-ext": "^0.10.50", + "type": "^1.0.1" + } + }, + "d3": { + "version": "5.12.0", + "resolved": "https://registry.npmjs.org/d3/-/d3-5.12.0.tgz", + "integrity": "sha512-flYVMoVuhPFHd9zVCe2BxIszUWqBcd5fvQGMNRmSiBrgdnh6Vlruh60RJQTouAK9xPbOB0plxMvBm4MoyODXNg==", + "requires": { + "d3-array": "1", + "d3-axis": "1", + "d3-brush": "1", + "d3-chord": "1", + "d3-collection": "1", + "d3-color": "1", + "d3-contour": "1", + "d3-dispatch": "1", + "d3-drag": "1", + "d3-dsv": "1", + "d3-ease": "1", + "d3-fetch": "1", + "d3-force": "1", + "d3-format": "1", + "d3-geo": "1", + "d3-hierarchy": "1", + "d3-interpolate": "1", + "d3-path": "1", + "d3-polygon": "1", + "d3-quadtree": "1", + "d3-random": "1", + "d3-scale": "2", + "d3-scale-chromatic": "1", + "d3-selection": "1", + "d3-shape": "1", + "d3-time": "1", + "d3-time-format": "2", + "d3-timer": "1", + "d3-transition": "1", + "d3-voronoi": "1", + "d3-zoom": "1" + } + }, + "d3-array": { + "version": "1.2.4", + "resolved": "https://registry.npmjs.org/d3-array/-/d3-array-1.2.4.tgz", + "integrity": "sha512-KHW6M86R+FUPYGb3R5XiYjXPq7VzwxZ22buHhAEVG5ztoEcZZMLov530mmccaqA1GghZArjQV46fuc8kUqhhHw==" + }, + "d3-axis": { + "version": "1.0.12", + "resolved": "https://registry.npmjs.org/d3-axis/-/d3-axis-1.0.12.tgz", + "integrity": "sha512-ejINPfPSNdGFKEOAtnBtdkpr24c4d4jsei6Lg98mxf424ivoDP2956/5HDpIAtmHo85lqT4pruy+zEgvRUBqaQ==" + }, + "d3-brush": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/d3-brush/-/d3-brush-1.1.3.tgz", + "integrity": "sha512-v8bbYyCFKjyCzFk/tdWqXwDykY8YWqhXYjcYxfILIit085VZOpj4XJKOMccTsvWxgzSLMJQg5SiqHjslsipEDg==", + "requires": { + "d3-dispatch": "1", + "d3-drag": "1", + "d3-interpolate": "1", + "d3-selection": "1", + "d3-transition": "1" + } + }, + "d3-chord": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/d3-chord/-/d3-chord-1.0.6.tgz", + "integrity": "sha512-JXA2Dro1Fxw9rJe33Uv+Ckr5IrAa74TlfDEhE/jfLOaXegMQFQTAgAw9WnZL8+HxVBRXaRGCkrNU7pJeylRIuA==", + "requires": { + "d3-array": "1", + "d3-path": "1" + } + }, + "d3-collection": { + "version": "1.0.7", + "resolved": "https://registry.npmjs.org/d3-collection/-/d3-collection-1.0.7.tgz", + "integrity": "sha512-ii0/r5f4sjKNTfh84Di+DpztYwqKhEyUlKoPrzUFfeSkWxjW49xU2QzO9qrPrNkpdI0XJkfzvmTu8V2Zylln6A==" + }, + "d3-color": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/d3-color/-/d3-color-1.4.0.tgz", + "integrity": "sha512-TzNPeJy2+iEepfiL92LAAB7fvnp/dV2YwANPVHdDWmYMm23qIJBYww3qT8I8C1wXrmrg4UWs7BKc2tKIgyjzHg==" + }, + "d3-contour": { + "version": "1.3.2", + "resolved": "https://registry.npmjs.org/d3-contour/-/d3-contour-1.3.2.tgz", + "integrity": "sha512-hoPp4K/rJCu0ladiH6zmJUEz6+u3lgR+GSm/QdM2BBvDraU39Vr7YdDCicJcxP1z8i9B/2dJLgDC1NcvlF8WCg==", + "requires": { + "d3-array": "^1.1.1" + } + }, + "d3-dispatch": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/d3-dispatch/-/d3-dispatch-1.0.5.tgz", + "integrity": "sha512-vwKx+lAqB1UuCeklr6Jh1bvC4SZgbSqbkGBLClItFBIYH4vqDJCA7qfoy14lXmJdnBOdxndAMxjCbImJYW7e6g==" + }, + "d3-drag": { + "version": "1.2.4", + "resolved": "https://registry.npmjs.org/d3-drag/-/d3-drag-1.2.4.tgz", + "integrity": "sha512-ICPurDETFAelF1CTHdIyiUM4PsyZLaM+7oIBhmyP+cuVjze5vDZ8V//LdOFjg0jGnFIZD/Sfmk0r95PSiu78rw==", + "requires": { + "d3-dispatch": "1", + "d3-selection": "1" + } + }, + "d3-dsv": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/d3-dsv/-/d3-dsv-1.1.1.tgz", + "integrity": "sha512-1EH1oRGSkeDUlDRbhsFytAXU6cAmXFzc52YUe6MRlPClmWb85MP1J5x+YJRzya4ynZWnbELdSAvATFW/MbxaXw==", + "requires": { + "commander": "2", + "iconv-lite": "0.4", + "rw": "1" + } + }, + "d3-ease": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/d3-ease/-/d3-ease-1.0.5.tgz", + "integrity": "sha512-Ct1O//ly5y5lFM9YTdu+ygq7LleSgSE4oj7vUt9tPLHUi8VCV7QoizGpdWRWAwCO9LdYzIrQDg97+hGVdsSGPQ==" + }, + "d3-fetch": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/d3-fetch/-/d3-fetch-1.1.2.tgz", + "integrity": "sha512-S2loaQCV/ZeyTyIF2oP8D1K9Z4QizUzW7cWeAOAS4U88qOt3Ucf6GsmgthuYSdyB2HyEm4CeGvkQxWsmInsIVA==", + "requires": { + "d3-dsv": "1" + } + }, + "d3-force": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/d3-force/-/d3-force-1.2.1.tgz", + "integrity": "sha512-HHvehyaiUlVo5CxBJ0yF/xny4xoaxFxDnBXNvNcfW9adORGZfyNF1dj6DGLKyk4Yh3brP/1h3rnDzdIAwL08zg==", + "requires": { + "d3-collection": "1", + "d3-dispatch": "1", + "d3-quadtree": "1", + "d3-timer": "1" + } + }, + "d3-format": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/d3-format/-/d3-format-1.4.1.tgz", + "integrity": "sha512-TUswGe6hfguUX1CtKxyG2nymO+1lyThbkS1ifLX0Sr+dOQtAD5gkrffpHnx+yHNKUZ0Bmg5T4AjUQwugPDrm0g==" + }, + "d3-geo": { + "version": "1.11.6", + "resolved": "https://registry.npmjs.org/d3-geo/-/d3-geo-1.11.6.tgz", + "integrity": "sha512-z0J8InXR9e9wcgNtmVnPTj0TU8nhYT6lD/ak9may2PdKqXIeHUr8UbFLoCtrPYNsjv6YaLvSDQVl578k6nm7GA==", + "requires": { + "d3-array": "1" + } + }, + "d3-geo-projection": { + "version": "0.2.16", + "resolved": "https://registry.npmjs.org/d3-geo-projection/-/d3-geo-projection-0.2.16.tgz", + "integrity": "sha1-SZTs0QM92xUztsTFUoocgdzClCc=", + "dev": true, + "requires": { + "brfs": "^1.3.0" + } + }, + "d3-hierarchy": { + "version": "1.1.8", + "resolved": "https://registry.npmjs.org/d3-hierarchy/-/d3-hierarchy-1.1.8.tgz", + "integrity": "sha512-L+GHMSZNwTpiq4rt9GEsNcpLa4M96lXMR8M/nMG9p5hBE0jy6C+3hWtyZMenPQdwla249iJy7Nx0uKt3n+u9+w==" + }, + "d3-interpolate": { + "version": "1.3.2", + "resolved": "https://registry.npmjs.org/d3-interpolate/-/d3-interpolate-1.3.2.tgz", + "integrity": "sha512-NlNKGopqaz9qM1PXh9gBF1KSCVh+jSFErrSlD/4hybwoNX/gt1d8CDbDW+3i+5UOHhjC6s6nMvRxcuoMVNgL2w==", + "requires": { + "d3-color": "1" + } + }, + "d3-path": { + "version": "1.0.8", + "resolved": "https://registry.npmjs.org/d3-path/-/d3-path-1.0.8.tgz", + "integrity": "sha512-J6EfUNwcMQ+aM5YPOB8ZbgAZu6wc82f/0WFxrxwV6Ll8wBwLaHLKCqQ5Imub02JriCVVdPjgI+6P3a4EWJCxAg==" + }, + "d3-polygon": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/d3-polygon/-/d3-polygon-1.0.5.tgz", + "integrity": "sha512-RHhh1ZUJZfhgoqzWWuRhzQJvO7LavchhitSTHGu9oj6uuLFzYZVeBzaWTQ2qSO6bz2w55RMoOCf0MsLCDB6e0w==" + }, + "d3-quadtree": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/d3-quadtree/-/d3-quadtree-1.0.6.tgz", + "integrity": "sha512-NUgeo9G+ENQCQ1LsRr2qJg3MQ4DJvxcDNCiohdJGHt5gRhBW6orIB5m5FJ9kK3HNL8g9F4ERVoBzcEwQBfXWVA==" + }, + "d3-queue": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/d3-queue/-/d3-queue-2.0.3.tgz", + "integrity": "sha1-B/vaOsrlNYqcUpmq+ICt8JU+0sI=", + "dev": true + }, + "d3-random": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/d3-random/-/d3-random-1.1.2.tgz", + "integrity": "sha512-6AK5BNpIFqP+cx/sreKzNjWbwZQCSUatxq+pPRmFIQaWuoD+NrbVWw7YWpHiXpCQ/NanKdtGDuB+VQcZDaEmYQ==" + }, + "d3-scale": { + "version": "2.2.2", + "resolved": "https://registry.npmjs.org/d3-scale/-/d3-scale-2.2.2.tgz", + "integrity": "sha512-LbeEvGgIb8UMcAa0EATLNX0lelKWGYDQiPdHj+gLblGVhGLyNbaCn3EvrJf0A3Y/uOOU5aD6MTh5ZFCdEwGiCw==", + "requires": { + "d3-array": "^1.2.0", + "d3-collection": "1", + "d3-format": "1", + "d3-interpolate": "1", + "d3-time": "1", + "d3-time-format": "2" + } + }, + "d3-scale-chromatic": { + "version": "1.5.0", + "resolved": "https://registry.npmjs.org/d3-scale-chromatic/-/d3-scale-chromatic-1.5.0.tgz", + "integrity": "sha512-ACcL46DYImpRFMBcpk9HhtIyC7bTBR4fNOPxwVSl0LfulDAwyiHyPOTqcDG1+t5d4P9W7t/2NAuWu59aKko/cg==", + "requires": { + "d3-color": "1", + "d3-interpolate": "1" + } + }, + "d3-selection": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/d3-selection/-/d3-selection-1.4.0.tgz", + "integrity": "sha512-EYVwBxQGEjLCKF2pJ4+yrErskDnz5v403qvAid96cNdCMr8rmCYfY5RGzWz24mdIbxmDf6/4EAH+K9xperD5jg==" + }, + "d3-selection-multi": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/d3-selection-multi/-/d3-selection-multi-1.0.1.tgz", + "integrity": "sha1-zWwlQT0EosuXRw54byzYd/PjT1g=", + "dev": true, + "requires": { + "d3-selection": "1", + "d3-transition": "1" + } + }, + "d3-shape": { + "version": "1.3.5", + "resolved": "https://registry.npmjs.org/d3-shape/-/d3-shape-1.3.5.tgz", + "integrity": "sha512-VKazVR3phgD+MUCldapHD7P9kcrvPcexeX/PkMJmkUov4JM8IxsSg1DvbYoYich9AtdTsa5nNk2++ImPiDiSxg==", + "requires": { + "d3-path": "1" + } + }, + "d3-time": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/d3-time/-/d3-time-1.1.0.tgz", + "integrity": "sha512-Xh0isrZ5rPYYdqhAVk8VLnMEidhz5aP7htAADH6MfzgmmicPkTo8LhkLxci61/lCB7n7UmE3bN0leRt+qvkLxA==" + }, + "d3-time-format": { + "version": "2.2.1", + "resolved": "https://registry.npmjs.org/d3-time-format/-/d3-time-format-2.2.1.tgz", + "integrity": "sha512-VA6WqORO1+H1SvSzgl2oT0z3niANh3opa8Cencpen1LFthw/bEX71R/DgjPlWw78J4UHmD0jCPP1W0HpwMkhjg==", + "requires": { + "d3-time": "1" + } + }, + "d3-timer": { + "version": "1.0.9", + "resolved": "https://registry.npmjs.org/d3-timer/-/d3-timer-1.0.9.tgz", + "integrity": "sha512-rT34J5HnQUHhcLvhSB9GjCkN0Ddd5Y8nCwDBG2u6wQEeYxT/Lf51fTFFkldeib/sE/J0clIe0pnCfs6g/lRbyg==" + }, + "d3-transition": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/d3-transition/-/d3-transition-1.2.0.tgz", + "integrity": "sha512-VJ7cmX/FPIPJYuaL2r1o1EMHLttvoIuZhhuAlRoOxDzogV8iQS6jYulDm3xEU3TqL80IZIhI551/ebmCMrkvhw==", + "requires": { + "d3-color": "1", + "d3-dispatch": "1", + "d3-ease": "1", + "d3-interpolate": "1", + "d3-selection": "^1.1.0", + "d3-timer": "1" + } + }, + "d3-voronoi": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/d3-voronoi/-/d3-voronoi-1.1.4.tgz", + "integrity": "sha512-dArJ32hchFsrQ8uMiTBLq256MpnZjeuBtdHpaDlYuQyjU0CVzCJl/BVW+SkszaAeH95D/8gxqAhgx0ouAWAfRg==" + }, + "d3-zoom": { + "version": "1.8.3", + "resolved": "https://registry.npmjs.org/d3-zoom/-/d3-zoom-1.8.3.tgz", + "integrity": "sha512-VoLXTK4wvy1a0JpH2Il+F2CiOhVu7VRXWF5M/LroMIh3/zBAC3WAt7QoIvPibOavVo20hN6/37vwAsdBejLyKQ==", + "requires": { + "d3-dispatch": "1", + "d3-drag": "1", + "d3-interpolate": "1", + "d3-selection": "1", + "d3-transition": "1" + } + }, + "date-format": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/date-format/-/date-format-2.1.0.tgz", + "integrity": "sha512-bYQuGLeFxhkxNOF3rcMtiZxvCBAquGzZm6oWA1oZ0g2THUzivaRhv8uOhdr19LmoobSOLoIAxeUK2RdbM8IFTA==", + "dev": true + }, + "date-now": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/date-now/-/date-now-0.1.4.tgz", + "integrity": "sha1-6vQ5/U1ISK105cx9vvIAZyueNFs=", + "dev": true + }, + "debug": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/debug/-/debug-4.1.1.tgz", + "integrity": "sha512-pYAIzeRo8J6KPEaJ0VWOh5Pzkbw/RetuzehGM7QRRX5he4fPHx2rdKMB256ehJCkX+XRQm16eZLqLNS8RSZXZw==", + "dev": true, + "requires": { + "ms": "^2.1.1" + } + }, + "decamelize": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/decamelize/-/decamelize-1.2.0.tgz", + "integrity": "sha1-9lNNFRSCabIDUue+4m9QH5oZEpA=" + }, + "decode-uri-component": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/decode-uri-component/-/decode-uri-component-0.2.0.tgz", + "integrity": "sha1-6zkTMzRYd1y4TNGh+uBiEGu4dUU=", + "dev": true + }, + "decompress-response": { + "version": "3.3.0", + "resolved": "https://registry.npmjs.org/decompress-response/-/decompress-response-3.3.0.tgz", + "integrity": "sha1-gKTdMjdIOEv6JICDYirt7Jgq3/M=", + "dev": true, + "requires": { + "mimic-response": "^1.0.0" + } + }, + "deep-eql": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/deep-eql/-/deep-eql-3.0.1.tgz", + "integrity": "sha512-+QeIQyN5ZuO+3Uk5DYh6/1eKO0m0YmJFGNmFHGACpf1ClL1nmlV/p4gNgbl2pJGxgXb4faqo6UE+M5ACEMyVcw==", + "dev": true, + "requires": { + "type-detect": "^4.0.0" + } + }, + "deep-extend": { + "version": "0.6.0", + "resolved": "https://registry.npmjs.org/deep-extend/-/deep-extend-0.6.0.tgz", + "integrity": "sha512-LOHxIOaPYdHlJRtCQfDIVZtfw/ufM8+rVj649RIHzcm/vGwQRXFt6OPqIFWsm2XEMrNIEtWR64sY1LEKD2vAOA==", + "dev": true + }, + "deep-is": { + "version": "0.1.3", + "resolved": "https://registry.npmjs.org/deep-is/-/deep-is-0.1.3.tgz", + "integrity": "sha1-s2nW+128E+7PUk+RsHD+7cNXzzQ=", + "dev": true + }, + "defer-to-connect": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/defer-to-connect/-/defer-to-connect-1.1.3.tgz", + "integrity": "sha512-0ISdNousHvZT2EiFlZeZAHBUvSxmKswVCEf8hW7KWgG4a8MVEu/3Vb6uWYozkjylyCxe0JBIiRB1jV45S70WVQ==", + "dev": true + }, + "define-properties": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/define-properties/-/define-properties-1.1.3.tgz", + "integrity": "sha512-3MqfYKj2lLzdMSf8ZIZE/V+Zuy+BgD6f164e8K2w7dgnpKArBDerGYpM46IYYcjnkdPNMjPk9A6VFB8+3SKlXQ==", + "dev": true, + "requires": { + "object-keys": "^1.0.12" + } + }, + "define-property": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/define-property/-/define-property-2.0.2.tgz", + "integrity": "sha512-jwK2UV4cnPpbcG7+VRARKTZPUWowwXA8bzH5NP6ud0oeAxyYPuGZUAC7hMugpCdz4BeSZl2Dl9k66CHJ/46ZYQ==", + "dev": true, + "requires": { + "is-descriptor": "^1.0.2", + "isobject": "^3.0.1" + }, + "dependencies": { + "is-accessor-descriptor": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-accessor-descriptor/-/is-accessor-descriptor-1.0.0.tgz", + "integrity": "sha512-m5hnHTkcVsPfqx3AKlyttIPb7J+XykHvJP2B9bZDjlhLIoEq4XoK64Vg7boZlVWYK6LUY94dYPEE7Lh0ZkZKcQ==", + "dev": true, + "requires": { + "kind-of": "^6.0.0" + } + }, + "is-data-descriptor": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-data-descriptor/-/is-data-descriptor-1.0.0.tgz", + "integrity": "sha512-jbRXy1FmtAoCjQkVmIVYwuuqDFUbaOeDjmed1tOGPrsMhtJA4rD9tkgA0F1qJ3gRFRXcHYVkdeaP50Q5rE/jLQ==", + "dev": true, + "requires": { + "kind-of": "^6.0.0" + } + }, + "is-descriptor": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/is-descriptor/-/is-descriptor-1.0.2.tgz", + "integrity": "sha512-2eis5WqQGV7peooDyLmNEPUrps9+SXX5c9pL3xEB+4e9HnGuDa7mB7kHxHw4CbqS9k1T2hOH3miL8n8WtiYVtg==", + "dev": true, + "requires": { + "is-accessor-descriptor": "^1.0.0", + "is-data-descriptor": "^1.0.0", + "kind-of": "^6.0.2" + } + } + } + }, + "defined": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/defined/-/defined-1.0.0.tgz", + "integrity": "sha1-yY2bzvdWdBiOEQlpFRGZ45sfppM=" + }, + "depd": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/depd/-/depd-1.1.2.tgz", + "integrity": "sha1-m81S4UwJd2PnSbJ0xDRu0uVgtak=", + "dev": true + }, + "dependency-graph": { + "version": "0.9.0", + "resolved": "https://registry.npmjs.org/dependency-graph/-/dependency-graph-0.9.0.tgz", + "integrity": "sha512-9YLIBURXj4DJMFALxXw9K3Y3rwb5Fk0X5/8ipCzaN84+gKxoHK43tVKRNakCQbiEx07E8Uwhuq21BpUagFhZ8w==", + "dev": true + }, + "des.js": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/des.js/-/des.js-1.0.0.tgz", + "integrity": "sha1-wHTS4qpqipoH29YfmhXCzYPsjsw=", + "dev": true, + "requires": { + "inherits": "^2.0.1", + "minimalistic-assert": "^1.0.0" + } + }, + "detect-file": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/detect-file/-/detect-file-1.0.0.tgz", + "integrity": "sha1-8NZtA2cqglyxtzvbP+YjEMjlUrc=", + "dev": true + }, + "detect-indent": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/detect-indent/-/detect-indent-6.0.0.tgz", + "integrity": "sha512-oSyFlqaTHCItVRGK5RmrmjB+CmaMOW7IaNA/kdxqhoa6d17j/5ce9O9eWXmV/KEdRwqpQA+Vqe8a8Bsybu4YnA==", + "dev": true + }, + "detect-newline": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/detect-newline/-/detect-newline-3.1.0.tgz", + "integrity": "sha512-TLz+x/vEXm/Y7P7wn1EJFNLxYpUD4TgMosxY6fAVJUnJMbupHBOncxyWUG9OpTaH9EBD7uFI5LfEgmMOc54DsA==", + "dev": true + }, + "di": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/di/-/di-0.0.1.tgz", + "integrity": "sha1-gGZJMmzqp8qjMG112YXqJ0i6kTw=", + "dev": true + }, + "diff": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/diff/-/diff-3.2.0.tgz", + "integrity": "sha1-yc45Okt8vQsFinJck98pkCeGj/k=", + "dev": true + }, + "diffie-hellman": { + "version": "5.0.3", + "resolved": "https://registry.npmjs.org/diffie-hellman/-/diffie-hellman-5.0.3.tgz", + "integrity": "sha512-kqag/Nl+f3GwyK25fhUMYj81BUOrZ9IuJsjIcDE5icNM9FJHAVm3VcUDxdLPoQtTuUylWm6ZIknYJwwaPxsUzg==", + "dev": true, + "requires": { + "bn.js": "^4.1.0", + "miller-rabin": "^4.0.0", + "randombytes": "^2.0.0" + } + }, + "dir-glob": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/dir-glob/-/dir-glob-3.0.1.tgz", + "integrity": "sha512-WkrWp9GR4KXfKGYzOLmTuGVi1UWFfws377n9cc55/tb6DuqyF6pcQ5AbiHEshaDpY9v6oaSr2XCDidGmMwdzIA==", + "dev": true, + "requires": { + "path-type": "^4.0.0" + }, + "dependencies": { + "path-type": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/path-type/-/path-type-4.0.0.tgz", + "integrity": "sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw==", + "dev": true + } + } + }, + "doctrine": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/doctrine/-/doctrine-3.0.0.tgz", + "integrity": "sha512-yS+Q5i3hBf7GBkd4KG8a7eBNNWNGLTaEwwYWUijIYM7zrlYDM0BFXHjjPWlWZ1Rg7UaddZeIDmi9jF3HmqiQ2w==", + "dev": true, + "requires": { + "esutils": "^2.0.2" + } + }, + "dom-serialize": { + "version": "2.2.1", + "resolved": "https://registry.npmjs.org/dom-serialize/-/dom-serialize-2.2.1.tgz", + "integrity": "sha1-ViromZ9Evl6jB29UGdzVnrQ6yVs=", + "dev": true, + "requires": { + "custom-event": "~1.0.0", + "ent": "~2.2.0", + "extend": "^3.0.0", + "void-elements": "^2.0.0" + } + }, + "domain-browser": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/domain-browser/-/domain-browser-1.2.0.tgz", + "integrity": "sha512-jnjyiM6eRyZl2H+W8Q/zLMA481hzi0eszAaBUzIVnmYVDBbnLxVNnfu1HgEBvCbL+71FrxMl3E6lpKH7Ge3OXA==", + "dev": true + }, + "duplexer2": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/duplexer2/-/duplexer2-0.1.4.tgz", + "integrity": "sha1-ixLauHjA1p4+eJEFFmKjL8a93ME=", + "dev": true, + "requires": { + "readable-stream": "^2.0.2" + } + }, + "duplexer3": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/duplexer3/-/duplexer3-0.1.4.tgz", + "integrity": "sha1-7gHdHKwO08vH/b6jfcCo8c4ALOI=", + "dev": true + }, + "duplexify": { + "version": "3.7.1", + "resolved": "https://registry.npmjs.org/duplexify/-/duplexify-3.7.1.tgz", + "integrity": "sha512-07z8uv2wMyS51kKhD1KsdXJg5WQ6t93RneqRxUHnskXVtlYYkLqM0gqStQZ3pj073g687jPCHrqNfCzawLYh5g==", + "dev": true, + "requires": { + "end-of-stream": "^1.0.0", + "inherits": "^2.0.1", + "readable-stream": "^2.0.0", + "stream-shift": "^1.0.0" + } + }, + "duplicate-package-checker-webpack-plugin": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/duplicate-package-checker-webpack-plugin/-/duplicate-package-checker-webpack-plugin-3.0.0.tgz", + "integrity": "sha512-aO50/qPC7X2ChjRFniRiscxBLT/K01bALqfcDaf8Ih5OqQ1N4iT/Abx9Ofu3/ms446vHTm46FACIuJUmgUQcDQ==", + "dev": true, + "requires": { + "chalk": "^2.3.0", + "find-root": "^1.0.0", + "lodash": "^4.17.4", + "semver": "^5.4.1" + }, + "dependencies": { + "ansi-styles": { + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz", + "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", + "dev": true, + "requires": { + "color-convert": "^1.9.0" + } + }, + "chalk": { + "version": "2.4.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz", + "integrity": "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==", + "dev": true, + "requires": { + "ansi-styles": "^3.2.1", + "escape-string-regexp": "^1.0.5", + "supports-color": "^5.3.0" + } + }, + "has-flag": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz", + "integrity": "sha1-tdRU3CGZriJWmfNGfloH87lVuv0=", + "dev": true + }, + "supports-color": { + "version": "5.5.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz", + "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==", + "dev": true, + "requires": { + "has-flag": "^3.0.0" + } + } + } + }, + "ee-first": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/ee-first/-/ee-first-1.1.1.tgz", + "integrity": "sha1-WQxhFWsK4vTwJVcyoViyZrxWsh0=", + "dev": true + }, + "electron-to-chromium": { + "version": "1.3.295", + "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.3.295.tgz", + "integrity": "sha512-KxlGE9GcZTv7xGwYJGMEABHJq2JuTMNF7jD8NwHk6sBY226mW+Dyp9kZmA2Od9tKHMCS7ltPnqFg+zq3jTWN7Q==" + }, + "elliptic": { + "version": "6.5.1", + "resolved": "https://registry.npmjs.org/elliptic/-/elliptic-6.5.1.tgz", + "integrity": "sha512-xvJINNLbTeWQjrl6X+7eQCrIy/YPv5XCpKW6kB5mKvtnGILoLDcySuwomfdzt0BMdLNVnuRNTuzKNHj0bva1Cg==", + "dev": true, + "requires": { + "bn.js": "^4.4.0", + "brorand": "^1.0.1", + "hash.js": "^1.0.0", + "hmac-drbg": "^1.0.0", + "inherits": "^2.0.1", + "minimalistic-assert": "^1.0.0", + "minimalistic-crypto-utils": "^1.0.0" + } + }, + "emoji-regex": { + "version": "7.0.3", + "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-7.0.3.tgz", + "integrity": "sha512-CwBLREIQ7LvYFB0WyRvwhq5N5qPhc6PMjD6bYggFlI5YyDgl+0vxq5VHbMOFqLg7hfWzmu8T5Z1QofhmTIhItA==", + "dev": true + }, + "emojis-list": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/emojis-list/-/emojis-list-2.1.0.tgz", + "integrity": "sha1-TapNnbAPmBmIDHn6RXrlsJof04k=" + }, + "encodeurl": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-1.0.2.tgz", + "integrity": "sha1-rT/0yG7C0CkyL1oCw6mmBslbP1k=", + "dev": true + }, + "end-of-stream": { + "version": "1.4.4", + "resolved": "https://registry.npmjs.org/end-of-stream/-/end-of-stream-1.4.4.tgz", + "integrity": "sha512-+uw1inIHVPQoaVuHzRyXd21icM+cnt4CzD5rW+NC1wjOUSTOs+Te7FOv7AhN7vS9x/oIyhLP5PR1H+phQAHu5Q==", + "dev": true, + "requires": { + "once": "^1.4.0" + } + }, + "engine.io": { + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/engine.io/-/engine.io-3.2.1.tgz", + "integrity": "sha512-+VlKzHzMhaU+GsCIg4AoXF1UdDFjHHwMmMKqMJNDNLlUlejz58FCy4LBqB2YVJskHGYl06BatYWKP2TVdVXE5w==", + "dev": true, + "requires": { + "accepts": "~1.3.4", + "base64id": "1.0.0", + "cookie": "0.3.1", + "debug": "~3.1.0", + "engine.io-parser": "~2.1.0", + "ws": "~3.3.1" + }, + "dependencies": { + "debug": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/debug/-/debug-3.1.0.tgz", + "integrity": "sha512-OX8XqP7/1a9cqkxYw2yXss15f26NKWBpDXQd0/uK/KPqdQhxbPa994hnzjcE2VqQpDslf55723cKPUOGSmMY3g==", + "dev": true, + "requires": { + "ms": "2.0.0" + } + }, + "ms": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", + "integrity": "sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g=", + "dev": true + }, + "safe-buffer": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz", + "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==", + "dev": true + }, + "ws": { + "version": "3.3.3", + "resolved": "https://registry.npmjs.org/ws/-/ws-3.3.3.tgz", + "integrity": "sha512-nnWLa/NwZSt4KQJu51MYlCcSQ5g7INpOrOMt4XV8j4dqTXdmlUmSHQ8/oLC069ckre0fRsgfvsKwbTdtKLCDkA==", + "dev": true, + "requires": { + "async-limiter": "~1.0.0", + "safe-buffer": "~5.1.0", + "ultron": "~1.1.0" + } + } + } + }, + "engine.io-client": { + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/engine.io-client/-/engine.io-client-3.2.1.tgz", + "integrity": "sha512-y5AbkytWeM4jQr7m/koQLc5AxpRKC1hEVUb/s1FUAWEJq5AzJJ4NLvzuKPuxtDi5Mq755WuDvZ6Iv2rXj4PTzw==", + "dev": true, + "requires": { + "component-emitter": "1.2.1", + "component-inherit": "0.0.3", + "debug": "~3.1.0", + "engine.io-parser": "~2.1.1", + "has-cors": "1.1.0", + "indexof": "0.0.1", + "parseqs": "0.0.5", + "parseuri": "0.0.5", + "ws": "~3.3.1", + "xmlhttprequest-ssl": "~1.5.4", + "yeast": "0.1.2" + }, + "dependencies": { + "debug": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/debug/-/debug-3.1.0.tgz", + "integrity": "sha512-OX8XqP7/1a9cqkxYw2yXss15f26NKWBpDXQd0/uK/KPqdQhxbPa994hnzjcE2VqQpDslf55723cKPUOGSmMY3g==", + "dev": true, + "requires": { + "ms": "2.0.0" + } + }, + "ms": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", + "integrity": "sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g=", + "dev": true + }, + "safe-buffer": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz", + "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==", + "dev": true + }, + "ws": { + "version": "3.3.3", + "resolved": "https://registry.npmjs.org/ws/-/ws-3.3.3.tgz", + "integrity": "sha512-nnWLa/NwZSt4KQJu51MYlCcSQ5g7INpOrOMt4XV8j4dqTXdmlUmSHQ8/oLC069ckre0fRsgfvsKwbTdtKLCDkA==", + "dev": true, + "requires": { + "async-limiter": "~1.0.0", + "safe-buffer": "~5.1.0", + "ultron": "~1.1.0" + } + } + } + }, + "engine.io-parser": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/engine.io-parser/-/engine.io-parser-2.1.3.tgz", + "integrity": "sha512-6HXPre2O4Houl7c4g7Ic/XzPnHBvaEmN90vtRO9uLmwtRqQmTOw0QMevL1TOfL2Cpu1VzsaTmMotQgMdkzGkVA==", + "dev": true, + "requires": { + "after": "0.8.2", + "arraybuffer.slice": "~0.0.7", + "base64-arraybuffer": "0.1.5", + "blob": "0.0.5", + "has-binary2": "~1.0.2" + } + }, + "enhanced-resolve": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/enhanced-resolve/-/enhanced-resolve-4.1.1.tgz", + "integrity": "sha512-98p2zE+rL7/g/DzMHMTF4zZlCgeVdJ7yr6xzEpJRYwFYrGi9ANdn5DnJURg6RpBkyk60XYDnWIv51VfIhfNGuA==", + "dev": true, + "requires": { + "graceful-fs": "^4.1.2", + "memory-fs": "^0.5.0", + "tapable": "^1.0.0" + }, + "dependencies": { + "memory-fs": { + "version": "0.5.0", + "resolved": "https://registry.npmjs.org/memory-fs/-/memory-fs-0.5.0.tgz", + "integrity": "sha512-jA0rdU5KoQMC0e6ppoNRtpp6vjFq6+NY7r8hywnC7V+1Xj/MtHwGIbB1QaK/dunyjWteJzmkpd7ooeWg10T7GA==", + "dev": true, + "requires": { + "errno": "^0.1.3", + "readable-stream": "^2.0.1" + } + } + } + }, + "ent": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/ent/-/ent-2.2.0.tgz", + "integrity": "sha1-6WQhkyWiHQX0RGai9obtbOX13R0=", + "dev": true + }, + "envinfo": { + "version": "7.8.1", + "resolved": "https://registry.npmjs.org/envinfo/-/envinfo-7.8.1.tgz", + "integrity": "sha512-/o+BXHmB7ocbHEAs6F2EnG0ogybVVUdkRunTT2glZU9XAaGmhqskrvKwqXuDfNjEO0LZKWdejEEpnq8aM0tOaw==", + "dev": true + }, + "errno": { + "version": "0.1.7", + "resolved": "https://registry.npmjs.org/errno/-/errno-0.1.7.tgz", + "integrity": "sha512-MfrRBDWzIWifgq6tJj60gkAwtLNb6sQPlcFrSOflcP1aFmmruKQ2wRnze/8V6kgyz7H3FF8Npzv78mZ7XLLflg==", + "dev": true, + "requires": { + "prr": "~1.0.1" + } + }, + "error-ex": { + "version": "1.3.2", + "resolved": "https://registry.npmjs.org/error-ex/-/error-ex-1.3.2.tgz", + "integrity": "sha512-7dFHNmqeFSEt2ZBsCriorKnn3Z2pj+fd9kmI6QoWw4//DL+icEBfc0U7qJCisqrTsKTjw4fNFy2pW9OqStD84g==", + "dev": true, + "requires": { + "is-arrayish": "^0.2.1" + } + }, + "es-abstract": { + "version": "1.16.0", + "resolved": "https://registry.npmjs.org/es-abstract/-/es-abstract-1.16.0.tgz", + "integrity": "sha512-xdQnfykZ9JMEiasTAJZJdMWCQ1Vm00NBw79/AWi7ELfZuuPCSOMDZbT9mkOfSctVtfhb+sAAzrm+j//GjjLHLg==", + "dev": true, + "requires": { + "es-to-primitive": "^1.2.0", + "function-bind": "^1.1.1", + "has": "^1.0.3", + "has-symbols": "^1.0.0", + "is-callable": "^1.1.4", + "is-regex": "^1.0.4", + "object-inspect": "^1.6.0", + "object-keys": "^1.1.1", + "string.prototype.trimleft": "^2.1.0", + "string.prototype.trimright": "^2.1.0" + } + }, + "es-module-lexer": { + "version": "0.4.1", + "resolved": "https://registry.npmjs.org/es-module-lexer/-/es-module-lexer-0.4.1.tgz", + "integrity": "sha512-ooYciCUtfw6/d2w56UVeqHPcoCFAiJdz5XOkYpv/Txl1HMUozpXjz/2RIQgqwKdXNDPSF1W7mJCFse3G+HDyAA==", + "dev": true + }, + "es-to-primitive": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/es-to-primitive/-/es-to-primitive-1.2.0.tgz", + "integrity": "sha512-qZryBOJjV//LaxLTV6UC//WewneB3LcXOL9NP++ozKVXsIIIpm/2c13UDiD9Jp2eThsecw9m3jPqDwTyobcdbg==", + "dev": true, + "requires": { + "is-callable": "^1.1.4", + "is-date-object": "^1.0.1", + "is-symbol": "^1.0.2" + } + }, + "es5-ext": { + "version": "0.10.51", + "resolved": "https://registry.npmjs.org/es5-ext/-/es5-ext-0.10.51.tgz", + "integrity": "sha512-oRpWzM2WcLHVKpnrcyB7OW8j/s67Ba04JCm0WnNv3RiABSvs7mrQlutB8DBv793gKcp0XENR8Il8WxGTlZ73gQ==", + "dev": true, + "requires": { + "es6-iterator": "~2.0.3", + "es6-symbol": "~3.1.1", + "next-tick": "^1.0.0" + } + }, + "es6-iterator": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/es6-iterator/-/es6-iterator-2.0.3.tgz", + "integrity": "sha1-p96IkUGgWpSwhUQDstCg+/qY87c=", + "dev": true, + "requires": { + "d": "1", + "es5-ext": "^0.10.35", + "es6-symbol": "^3.1.1" + } + }, + "es6-symbol": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/es6-symbol/-/es6-symbol-3.1.2.tgz", + "integrity": "sha512-/ZypxQsArlv+KHpGvng52/Iz8by3EQPxhmbuz8yFG89N/caTFBSbcXONDw0aMjy827gQg26XAjP4uXFvnfINmQ==", + "dev": true, + "requires": { + "d": "^1.0.1", + "es5-ext": "^0.10.51" + } + }, + "escalade": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.1.1.tgz", + "integrity": "sha512-k0er2gUkLf8O0zKJiAhmkTnJlTvINGv7ygDNPbeIsX/TJjGJZHuh9B2UxbsaEkmlEo9MfhrSzmhIlhRlI2GXnw==", + "dev": true + }, + "escape-html": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/escape-html/-/escape-html-1.0.3.tgz", + "integrity": "sha1-Aljq5NPQwJdN4cFpGI7wBR0dGYg=", + "dev": true + }, + "escape-string-regexp": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz", + "integrity": "sha1-G2HAViGQqN/2rjuyzwIAyhMLhtQ=" + }, + "escodegen": { + "version": "1.9.1", + "resolved": "https://registry.npmjs.org/escodegen/-/escodegen-1.9.1.tgz", + "integrity": "sha512-6hTjO1NAWkHnDk3OqQ4YrCuwwmGHL9S3nPlzBOUG/R44rda3wLNrfvQ5fkSGjyhHFKM7ALPKcKGrwvCLe0lC7Q==", + "dev": true, + "requires": { + "esprima": "^3.1.3", + "estraverse": "^4.2.0", + "esutils": "^2.0.2", + "optionator": "^0.8.1", + "source-map": "~0.6.1" + }, + "dependencies": { + "esprima": { + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/esprima/-/esprima-3.1.3.tgz", + "integrity": "sha1-/cpRzuYTOJXjyI1TXOSdv/YqRjM=", + "dev": true + }, + "source-map": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz", + "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==", + "dev": true, + "optional": true + } + } + }, + "eslint": { + "version": "5.16.0", + "resolved": "https://registry.npmjs.org/eslint/-/eslint-5.16.0.tgz", + "integrity": "sha512-S3Rz11i7c8AA5JPv7xAH+dOyq/Cu/VXHiHXBPOU1k/JAM5dXqQPt3qcrhpHSorXmrpu2g0gkIBVXAqCpzfoZIg==", + "dev": true, + "requires": { + "@babel/code-frame": "^7.0.0", + "ajv": "^6.9.1", + "chalk": "^2.1.0", + "cross-spawn": "^6.0.5", + "debug": "^4.0.1", + "doctrine": "^3.0.0", + "eslint-scope": "^4.0.3", + "eslint-utils": "^1.3.1", + "eslint-visitor-keys": "^1.0.0", + "espree": "^5.0.1", + "esquery": "^1.0.1", + "esutils": "^2.0.2", + "file-entry-cache": "^5.0.1", + "functional-red-black-tree": "^1.0.1", + "glob": "^7.1.2", + "globals": "^11.7.0", + "ignore": "^4.0.6", + "import-fresh": "^3.0.0", + "imurmurhash": "^0.1.4", + "inquirer": "^6.2.2", + "js-yaml": "^3.13.0", + "json-stable-stringify-without-jsonify": "^1.0.1", + "levn": "^0.3.0", + "lodash": "^4.17.11", + "minimatch": "^3.0.4", + "mkdirp": "^0.5.1", + "natural-compare": "^1.4.0", + "optionator": "^0.8.2", + "path-is-inside": "^1.0.2", + "progress": "^2.0.0", + "regexpp": "^2.0.1", + "semver": "^5.5.1", + "strip-ansi": "^4.0.0", + "strip-json-comments": "^2.0.1", + "table": "^5.2.3", + "text-table": "^0.2.0" + }, + "dependencies": { + "ansi-regex": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-3.0.0.tgz", + "integrity": "sha1-7QMXwyIGT3lGbAKWa922Bas32Zg=", + "dev": true + }, + "ansi-styles": { + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz", + "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", + "dev": true, + "requires": { + "color-convert": "^1.9.0" + } + }, + "chalk": { + "version": "2.4.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz", + "integrity": "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==", + "dev": true, + "requires": { + "ansi-styles": "^3.2.1", + "escape-string-regexp": "^1.0.5", + "supports-color": "^5.3.0" + } + }, + "esprima": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/esprima/-/esprima-4.0.1.tgz", + "integrity": "sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==", + "dev": true + }, + "has-flag": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz", + "integrity": "sha1-tdRU3CGZriJWmfNGfloH87lVuv0=", + "dev": true + }, + "js-yaml": { + "version": "3.13.1", + "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-3.13.1.tgz", + "integrity": "sha512-YfbcO7jXDdyj0DGxYVSlSeQNHbD7XPWvrVWeVUujrQEoZzWJIRrCPoyk6kL6IAjAG2IolMK4T0hNUe0HOUs5Jw==", + "dev": true, + "requires": { + "argparse": "^1.0.7", + "esprima": "^4.0.0" + } + }, + "strip-ansi": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-4.0.0.tgz", + "integrity": "sha1-qEeQIusaw2iocTibY1JixQXuNo8=", + "dev": true, + "requires": { + "ansi-regex": "^3.0.0" + } + }, + "supports-color": { + "version": "5.5.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz", + "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==", + "dev": true, + "requires": { + "has-flag": "^3.0.0" + } + } + } + }, + "eslint-config-standard": { + "version": "12.0.0", + "resolved": "https://registry.npmjs.org/eslint-config-standard/-/eslint-config-standard-12.0.0.tgz", + "integrity": "sha512-COUz8FnXhqFitYj4DTqHzidjIL/t4mumGZto5c7DrBpvWoie+Sn3P4sLEzUGeYhRElWuFEf8K1S1EfvD1vixCQ==", + "dev": true + }, + "eslint-import-resolver-node": { + "version": "0.3.2", + "resolved": "https://registry.npmjs.org/eslint-import-resolver-node/-/eslint-import-resolver-node-0.3.2.tgz", + "integrity": "sha512-sfmTqJfPSizWu4aymbPr4Iidp5yKm8yDkHp+Ir3YiTHiiDfxh69mOUsmiqW6RZ9zRXFaF64GtYmN7e+8GHBv6Q==", + "dev": true, + "requires": { + "debug": "^2.6.9", + "resolve": "^1.5.0" + }, + "dependencies": { + "debug": { + "version": "2.6.9", + "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", + "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", + "dev": true, + "requires": { + "ms": "2.0.0" + } + }, + "ms": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", + "integrity": "sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g=", + "dev": true + } + } + }, + "eslint-module-utils": { + "version": "2.4.1", + "resolved": "https://registry.npmjs.org/eslint-module-utils/-/eslint-module-utils-2.4.1.tgz", + "integrity": "sha512-H6DOj+ejw7Tesdgbfs4jeS4YMFrT8uI8xwd1gtQqXssaR0EQ26L+2O/w6wkYFy2MymON0fTwHmXBvvfLNZVZEw==", + "dev": true, + "requires": { + "debug": "^2.6.8", + "pkg-dir": "^2.0.0" + }, + "dependencies": { + "debug": { + "version": "2.6.9", + "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", + "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", + "dev": true, + "requires": { + "ms": "2.0.0" + } + }, + "ms": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", + "integrity": "sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g=", + "dev": true + } + } + }, + "eslint-plugin-es": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/eslint-plugin-es/-/eslint-plugin-es-1.4.1.tgz", + "integrity": "sha512-5fa/gR2yR3NxQf+UXkeLeP8FBBl6tSgdrAz1+cF84v1FMM4twGwQoqTnn+QxFLcPOrF4pdKEJKDB/q9GoyJrCA==", + "dev": true, + "requires": { + "eslint-utils": "^1.4.2", + "regexpp": "^2.0.1" + } + }, + "eslint-plugin-import": { + "version": "2.18.2", + "resolved": "https://registry.npmjs.org/eslint-plugin-import/-/eslint-plugin-import-2.18.2.tgz", + "integrity": "sha512-5ohpsHAiUBRNaBWAF08izwUGlbrJoJJ+W9/TBwsGoR1MnlgfwMIKrFeSjWbt6moabiXW9xNvtFz+97KHRfI4HQ==", + "dev": true, + "requires": { + "array-includes": "^3.0.3", + "contains-path": "^0.1.0", + "debug": "^2.6.9", + "doctrine": "1.5.0", + "eslint-import-resolver-node": "^0.3.2", + "eslint-module-utils": "^2.4.0", + "has": "^1.0.3", + "minimatch": "^3.0.4", + "object.values": "^1.1.0", + "read-pkg-up": "^2.0.0", + "resolve": "^1.11.0" + }, + "dependencies": { + "debug": { + "version": "2.6.9", + "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", + "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", + "dev": true, + "requires": { + "ms": "2.0.0" + } + }, + "doctrine": { + "version": "1.5.0", + "resolved": "https://registry.npmjs.org/doctrine/-/doctrine-1.5.0.tgz", + "integrity": "sha1-N53Ocw9hZvds76TmcHoVmwLFpvo=", + "dev": true, + "requires": { + "esutils": "^2.0.2", + "isarray": "^1.0.0" + } + }, + "ms": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", + "integrity": "sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g=", + "dev": true + } + } + }, + "eslint-plugin-node": { + "version": "8.0.1", + "resolved": "https://registry.npmjs.org/eslint-plugin-node/-/eslint-plugin-node-8.0.1.tgz", + "integrity": "sha512-ZjOjbjEi6jd82rIpFSgagv4CHWzG9xsQAVp1ZPlhRnnYxcTgENUVBvhYmkQ7GvT1QFijUSo69RaiOJKhMu6i8w==", + "dev": true, + "requires": { + "eslint-plugin-es": "^1.3.1", + "eslint-utils": "^1.3.1", + "ignore": "^5.0.2", + "minimatch": "^3.0.4", + "resolve": "^1.8.1", + "semver": "^5.5.0" + }, + "dependencies": { + "ignore": { + "version": "5.1.4", + "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.1.4.tgz", + "integrity": "sha512-MzbUSahkTW1u7JpKKjY7LCARd1fU5W2rLdxlM4kdkayuCwZImjkpluF9CM1aLewYJguPDqewLam18Y6AU69A8A==", + "dev": true + } + } + }, + "eslint-plugin-promise": { + "version": "4.2.1", + "resolved": "https://registry.npmjs.org/eslint-plugin-promise/-/eslint-plugin-promise-4.2.1.tgz", + "integrity": "sha512-VoM09vT7bfA7D+upt+FjeBO5eHIJQBUWki1aPvB+vbNiHS3+oGIJGIeyBtKQTME6UPXXy3vV07OL1tHd3ANuDw==", + "dev": true + }, + "eslint-plugin-standard": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/eslint-plugin-standard/-/eslint-plugin-standard-4.0.1.tgz", + "integrity": "sha512-v/KBnfyaOMPmZc/dmc6ozOdWqekGp7bBGq4jLAecEfPGmfKiWS4sA8sC0LqiV9w5qmXAtXVn4M3p1jSyhY85SQ==", + "dev": true + }, + "eslint-scope": { + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-4.0.3.tgz", + "integrity": "sha512-p7VutNr1O/QrxysMo3E45FjYDTeXBy0iTltPFNSqKAIfjDSXC+4dj+qfyuD8bfAXrW/y6lW3O76VaYNPKfpKrg==", + "dev": true, + "requires": { + "esrecurse": "^4.1.0", + "estraverse": "^4.1.1" + } + }, + "eslint-utils": { + "version": "1.4.3", + "resolved": "https://registry.npmjs.org/eslint-utils/-/eslint-utils-1.4.3.tgz", + "integrity": "sha512-fbBN5W2xdY45KulGXmLHZ3c3FHfVYmKg0IrAKGOkT/464PQsx2UeIzfz1RmEci+KLm1bBaAzZAh8+/E+XAeZ8Q==", + "dev": true, + "requires": { + "eslint-visitor-keys": "^1.1.0" + } + }, + "eslint-visitor-keys": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-1.1.0.tgz", + "integrity": "sha512-8y9YjtM1JBJU/A9Kc+SbaOV4y29sSWckBwMHa+FGtVj5gN/sbnKDf6xJUl+8g7FAij9LVaP8C24DUiH/f/2Z9A==", + "dev": true + }, + "espree": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/espree/-/espree-5.0.1.tgz", + "integrity": "sha512-qWAZcWh4XE/RwzLJejfcofscgMc9CamR6Tn1+XRXNzrvUSSbiAjGOI/fggztjIi7y9VLPqnICMIPiGyr8JaZ0A==", + "dev": true, + "requires": { + "acorn": "^6.0.7", + "acorn-jsx": "^5.0.0", + "eslint-visitor-keys": "^1.0.0" + } + }, + "esprima": { + "version": "2.7.3", + "resolved": "https://registry.npmjs.org/esprima/-/esprima-2.7.3.tgz", + "integrity": "sha1-luO3DVd59q1JzQMmc9HDEnZ7pYE=" + }, + "esquery": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/esquery/-/esquery-1.0.1.tgz", + "integrity": "sha512-SmiyZ5zIWH9VM+SRUReLS5Q8a7GxtRdxEBVZpm98rJM7Sb+A9DVCndXfkeFUd3byderg+EbDkfnevfCwynWaNA==", + "dev": true, + "requires": { + "estraverse": "^4.0.0" + } + }, + "esrecurse": { + "version": "4.2.1", + "resolved": "https://registry.npmjs.org/esrecurse/-/esrecurse-4.2.1.tgz", + "integrity": "sha512-64RBB++fIOAXPw3P9cy89qfMlvZEXZkqqJkjqqXIvzP5ezRZjW+lPWjw35UX/3EhUPFYbg5ER4JYgDw4007/DQ==", + "dev": true, + "requires": { + "estraverse": "^4.1.0" + } + }, + "estraverse": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-4.3.0.tgz", + "integrity": "sha512-39nnKffWz8xN1BU/2c79n9nB9HDzo0niYUqx6xyqUnyoAnQyyWpOTdZEeiCch8BBu515t4wp9ZmgVfVhn9EBpw==", + "dev": true + }, + "esutils": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz", + "integrity": "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==" + }, + "eventemitter3": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/eventemitter3/-/eventemitter3-4.0.0.tgz", + "integrity": "sha512-qerSRB0p+UDEssxTtm6EDKcE7W4OaoisfIMl4CngyEhjpYglocpNg6UEqCvemdGhosAsg4sO2dXJOdyBifPGCg==", + "dev": true + }, + "events": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/events/-/events-3.0.0.tgz", + "integrity": "sha512-Dc381HFWJzEOhQ+d8pkNon++bk9h6cdAoAj4iE6Q4y6xgTzySWXlKn05/TVNpjnfRqi/X0EpJEJohPjNI3zpVA==", + "dev": true + }, + "evp_bytestokey": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/evp_bytestokey/-/evp_bytestokey-1.0.3.tgz", + "integrity": "sha512-/f2Go4TognH/KvCISP7OUsHn85hT9nUkxxA9BEWxFn+Oj9o8ZNLm/40hdlgSLyuOimsrTKLUMEorQexp/aPQeA==", + "dev": true, + "requires": { + "md5.js": "^1.3.4", + "safe-buffer": "^5.1.1" + } + }, + "execa": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/execa/-/execa-1.0.0.tgz", + "integrity": "sha512-adbxcyWV46qiHyvSp50TKt05tB4tK3HcmF7/nxfAdhnox83seTDbwnaqKO4sXRy7roHAIFqJP/Rw/AuEbX61LA==", + "dev": true, + "requires": { + "cross-spawn": "^6.0.0", + "get-stream": "^4.0.0", + "is-stream": "^1.1.0", + "npm-run-path": "^2.0.0", + "p-finally": "^1.0.0", + "signal-exit": "^3.0.0", + "strip-eof": "^1.0.0" + } + }, + "expand-brackets": { + "version": "2.1.4", + "resolved": "https://registry.npmjs.org/expand-brackets/-/expand-brackets-2.1.4.tgz", + "integrity": "sha1-t3c14xXOMPa27/D4OwQVGiJEliI=", + "dev": true, + "requires": { + "debug": "^2.3.3", + "define-property": "^0.2.5", + "extend-shallow": "^2.0.1", + "posix-character-classes": "^0.1.0", + "regex-not": "^1.0.0", + "snapdragon": "^0.8.1", + "to-regex": "^3.0.1" + }, + "dependencies": { + "debug": { + "version": "2.6.9", + "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", + "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", + "dev": true, + "requires": { + "ms": "2.0.0" + } + }, + "define-property": { + "version": "0.2.5", + "resolved": "https://registry.npmjs.org/define-property/-/define-property-0.2.5.tgz", + "integrity": "sha1-w1se+RjsPJkPmlvFe+BKrOxcgRY=", + "dev": true, + "requires": { + "is-descriptor": "^0.1.0" + } + }, + "extend-shallow": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz", + "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=", + "dev": true, + "requires": { + "is-extendable": "^0.1.0" + } + }, + "ms": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", + "integrity": "sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g=", + "dev": true + } + } + }, + "expand-tilde": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/expand-tilde/-/expand-tilde-2.0.2.tgz", + "integrity": "sha1-l+gBqgUt8CRU3kawK/YhZCzchQI=", + "dev": true, + "requires": { + "homedir-polyfill": "^1.0.1" + } + }, + "extend": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/extend/-/extend-3.0.2.tgz", + "integrity": "sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g==", + "dev": true + }, + "extend-shallow": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-3.0.2.tgz", + "integrity": "sha1-Jqcarwc7OfshJxcnRhMcJwQCjbg=", + "dev": true, + "requires": { + "assign-symbols": "^1.0.0", + "is-extendable": "^1.0.1" + }, + "dependencies": { + "is-extendable": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/is-extendable/-/is-extendable-1.0.1.tgz", + "integrity": "sha512-arnXMxT1hhoKo9k1LZdmlNyJdDDfy2v0fXjFlmok4+i8ul/6WlbVge9bhM74OpNPQPMGUToDtz+KXa1PneJxOA==", + "dev": true, + "requires": { + "is-plain-object": "^2.0.4" + } + } + } + }, + "external-editor": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/external-editor/-/external-editor-3.1.0.tgz", + "integrity": "sha512-hMQ4CX1p1izmuLYyZqLMO/qGNw10wSv9QDCPfzXfyFrOaCSSoRfqE1Kf1s5an66J5JZC62NewG+mK49jOCtQew==", + "dev": true, + "requires": { + "chardet": "^0.7.0", + "iconv-lite": "^0.4.24", + "tmp": "^0.0.33" + } + }, + "extglob": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/extglob/-/extglob-2.0.4.tgz", + "integrity": "sha512-Nmb6QXkELsuBr24CJSkilo6UHHgbekK5UiZgfE6UHD3Eb27YC6oD+bhcT+tJ6cl8dmsgdQxnWlcry8ksBIBLpw==", + "dev": true, + "requires": { + "array-unique": "^0.3.2", + "define-property": "^1.0.0", + "expand-brackets": "^2.1.4", + "extend-shallow": "^2.0.1", + "fragment-cache": "^0.2.1", + "regex-not": "^1.0.0", + "snapdragon": "^0.8.1", + "to-regex": "^3.0.1" + }, + "dependencies": { + "define-property": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/define-property/-/define-property-1.0.0.tgz", + "integrity": "sha1-dp66rz9KY6rTr56NMEybvnm/sOY=", + "dev": true, + "requires": { + "is-descriptor": "^1.0.0" + } + }, + "extend-shallow": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz", + "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=", + "dev": true, + "requires": { + "is-extendable": "^0.1.0" + } + }, + "is-accessor-descriptor": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-accessor-descriptor/-/is-accessor-descriptor-1.0.0.tgz", + "integrity": "sha512-m5hnHTkcVsPfqx3AKlyttIPb7J+XykHvJP2B9bZDjlhLIoEq4XoK64Vg7boZlVWYK6LUY94dYPEE7Lh0ZkZKcQ==", + "dev": true, + "requires": { + "kind-of": "^6.0.0" + } + }, + "is-data-descriptor": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-data-descriptor/-/is-data-descriptor-1.0.0.tgz", + "integrity": "sha512-jbRXy1FmtAoCjQkVmIVYwuuqDFUbaOeDjmed1tOGPrsMhtJA4rD9tkgA0F1qJ3gRFRXcHYVkdeaP50Q5rE/jLQ==", + "dev": true, + "requires": { + "kind-of": "^6.0.0" + } + }, + "is-descriptor": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/is-descriptor/-/is-descriptor-1.0.2.tgz", + "integrity": "sha512-2eis5WqQGV7peooDyLmNEPUrps9+SXX5c9pL3xEB+4e9HnGuDa7mB7kHxHw4CbqS9k1T2hOH3miL8n8WtiYVtg==", + "dev": true, + "requires": { + "is-accessor-descriptor": "^1.0.0", + "is-data-descriptor": "^1.0.0", + "kind-of": "^6.0.2" + } + } + } + }, + "falafel": { + "version": "2.2.4", + "resolved": "https://registry.npmjs.org/falafel/-/falafel-2.2.4.tgz", + "integrity": "sha512-0HXjo8XASWRmsS0X1EkhwEMZaD3Qvp7FfURwjLKjG1ghfRm/MGZl2r4cWUTv41KdNghTw4OUMmVtdGQp3+H+uQ==", + "dev": true, + "requires": { + "acorn": "^7.1.1", + "foreach": "^2.0.5", + "isarray": "^2.0.1", + "object-keys": "^1.0.6" + }, + "dependencies": { + "acorn": { + "version": "7.1.1", + "resolved": "https://registry.npmjs.org/acorn/-/acorn-7.1.1.tgz", + "integrity": "sha512-add7dgA5ppRPxCFJoAGfMDi7PIBXq1RtGo7BhbLaxwrXPOmw8gq48Y9ozT01hUKy9byMjlR20EJhu5zlkErEkg==", + "dev": true + }, + "isarray": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/isarray/-/isarray-2.0.5.tgz", + "integrity": "sha512-xHjhDr3cNBK0BzdUJSPXZntQUx/mwMS5Rw4A7lPJ90XGAO6ISP/ePDNuo0vhqOZU+UD5JoodwCAAoZQd3FeAKw==", + "dev": true + } + } + }, + "fast-deep-equal": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-2.0.1.tgz", + "integrity": "sha1-ewUhjd+WZ79/Nwv3/bLLFf3Qqkk=" + }, + "fast-glob": { + "version": "3.2.5", + "resolved": "https://registry.npmjs.org/fast-glob/-/fast-glob-3.2.5.tgz", + "integrity": "sha512-2DtFcgT68wiTTiwZ2hNdJfcHNke9XOfnwmBRWXhmeKM8rF0TGwmC/Qto3S7RoZKp5cilZbxzO5iTNTQsJ+EeDg==", + "dev": true, + "requires": { + "@nodelib/fs.stat": "^2.0.2", + "@nodelib/fs.walk": "^1.2.3", + "glob-parent": "^5.1.0", + "merge2": "^1.3.0", + "micromatch": "^4.0.2", + "picomatch": "^2.2.1" + }, + "dependencies": { + "micromatch": { + "version": "4.0.4", + "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.4.tgz", + "integrity": "sha512-pRmzw/XUcwXGpD9aI9q/0XOwLNygjETJ8y0ao0wdqprrzDa4YnxLcz7fQRZr8voh8V10kGhABbNcHVk5wHgWwg==", + "dev": true, + "requires": { + "braces": "^3.0.1", + "picomatch": "^2.2.3" + } + }, + "picomatch": { + "version": "2.2.3", + "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.2.3.tgz", + "integrity": "sha512-KpELjfwcCDUb9PeigTs2mBJzXUPzAuP2oPcA989He8Rte0+YUAjw1JVedDhuTKPkHjSYzMN3npC9luThGYEKdg==", + "dev": true + } + } + }, + "fast-json-stable-stringify": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.0.0.tgz", + "integrity": "sha1-1RQsDK7msRifh9OnYREGT4bIu/I=" + }, + "fast-levenshtein": { + "version": "2.0.6", + "resolved": "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz", + "integrity": "sha1-PYpcZog6FqMMqGQ+hR8Zuqd5eRc=", + "dev": true + }, + "fastest-levenshtein": { + "version": "1.0.12", + "resolved": "https://registry.npmjs.org/fastest-levenshtein/-/fastest-levenshtein-1.0.12.tgz", + "integrity": "sha512-On2N+BpYJ15xIC974QNVuYGMOlEVt4s0EOI3wwMqOmK1fdDY+FN/zltPV8vosq4ad4c/gJ1KHScUn/6AWIgiow==", + "dev": true + }, + "fastparse": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/fastparse/-/fastparse-1.1.2.tgz", + "integrity": "sha512-483XLLxTVIwWK3QTrMGRqUfUpoOs/0hbQrl2oz4J0pAcm3A3bu84wxTFqGqkJzewCLdME38xJLJAxBABfQT8sQ==" + }, + "fastq": { + "version": "1.11.0", + "resolved": "https://registry.npmjs.org/fastq/-/fastq-1.11.0.tgz", + "integrity": "sha512-7Eczs8gIPDrVzT+EksYBcupqMyxSHXXrHOLRRxU2/DicV8789MRBRR8+Hc2uWzUupOs4YS4JzBmBxjjCVBxD/g==", + "dev": true, + "requires": { + "reusify": "^1.0.4" + } + }, + "figgy-pudding": { + "version": "3.5.1", + "resolved": "https://registry.npmjs.org/figgy-pudding/-/figgy-pudding-3.5.1.tgz", + "integrity": "sha512-vNKxJHTEKNThjfrdJwHc7brvM6eVevuO5nTj6ez8ZQ1qbXTvGthucRF7S4vf2cr71QVnT70V34v0S1DyQsti0w==", + "dev": true + }, + "figures": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/figures/-/figures-2.0.0.tgz", + "integrity": "sha1-OrGi0qYsi/tDGgyUy3l6L84nyWI=", + "dev": true, + "requires": { + "escape-string-regexp": "^1.0.5" + } + }, + "file-entry-cache": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/file-entry-cache/-/file-entry-cache-5.0.1.tgz", + "integrity": "sha512-bCg29ictuBaKUwwArK4ouCaqDgLZcysCFLmM/Yn/FDoqndh/9vNuQfXRDvTuXKLxfD/JtZQGKFT8MGcJBK644g==", + "dev": true, + "requires": { + "flat-cache": "^2.0.1" + } + }, + "file-loader": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/file-loader/-/file-loader-6.0.0.tgz", + "integrity": "sha512-/aMOAYEFXDdjG0wytpTL5YQLfZnnTmLNjn+AIrJ/6HVnTfDqLsVKUUwkDf4I4kgex36BvjuXEn/TX9B/1ESyqQ==", + "dev": true, + "requires": { + "loader-utils": "^2.0.0", + "schema-utils": "^2.6.5" + }, + "dependencies": { + "ajv": { + "version": "6.12.6", + "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz", + "integrity": "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==", + "dev": true, + "requires": { + "fast-deep-equal": "^3.1.1", + "fast-json-stable-stringify": "^2.0.0", + "json-schema-traverse": "^0.4.1", + "uri-js": "^4.2.2" + } + }, + "ajv-keywords": { + "version": "3.5.2", + "resolved": "https://registry.npmjs.org/ajv-keywords/-/ajv-keywords-3.5.2.tgz", + "integrity": "sha512-5p6WTN0DdTGVQk6VjcEju19IgaHudalcfabD7yhDGeA6bcQnmL+CpveLJq/3hvfwd1aof6L386Ougkx6RfyMIQ==", + "dev": true + }, + "emojis-list": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/emojis-list/-/emojis-list-3.0.0.tgz", + "integrity": "sha512-/kyM18EfinwXZbno9FyUGeFh87KC8HRQBQGildHZbEuRyWFOmv1U10o9BBp8XVZDVNNuQKyIGIu5ZYAAXJ0V2Q==", + "dev": true + }, + "fast-deep-equal": { + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz", + "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==", + "dev": true + }, + "json5": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/json5/-/json5-2.2.0.tgz", + "integrity": "sha512-f+8cldu7X/y7RAJurMEJmdoKXGB/X550w2Nr3tTbezL6RwEE/iMcm+tZnXeoZtKuOq6ft8+CqzEkrIgx1fPoQA==", + "dev": true, + "requires": { + "minimist": "^1.2.5" + } + }, + "loader-utils": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/loader-utils/-/loader-utils-2.0.0.tgz", + "integrity": "sha512-rP4F0h2RaWSvPEkD7BLDFQnvSf+nK+wr3ESUjNTyAGobqrijmW92zc+SO6d4p4B1wh7+B/Jg1mkQe5NYUEHtHQ==", + "dev": true, + "requires": { + "big.js": "^5.2.2", + "emojis-list": "^3.0.0", + "json5": "^2.1.2" + } + }, + "minimist": { + "version": "1.2.5", + "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.5.tgz", + "integrity": "sha512-FM9nNUYrRBAELZQT3xeZQ7fmMOBg6nWNmJKTcgsJeaLstP/UODVpGsr5OhXhhXg6f+qtJ8uiZ+PUxkDWcgIXLw==", + "dev": true + }, + "schema-utils": { + "version": "2.7.1", + "resolved": "https://registry.npmjs.org/schema-utils/-/schema-utils-2.7.1.tgz", + "integrity": "sha512-SHiNtMOUGWBQJwzISiVYKu82GiV4QYGePp3odlY1tuKO7gPtphAT5R/py0fA6xtbgLL/RvtJZnU9b8s0F1q0Xg==", + "dev": true, + "requires": { + "@types/json-schema": "^7.0.5", + "ajv": "^6.12.4", + "ajv-keywords": "^3.5.2" + } + } + } + }, + "fill-range": { + "version": "7.0.1", + "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.0.1.tgz", + "integrity": "sha512-qOo9F+dMUmC2Lcb4BbVvnKJxTPjCm+RRpe4gDuGrzkL7mEVl/djYSu2OdQ2Pa302N4oqkSg9ir6jaLWJ2USVpQ==", + "dev": true, + "requires": { + "to-regex-range": "^5.0.1" + } + }, + "finalhandler": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/finalhandler/-/finalhandler-1.1.2.tgz", + "integrity": "sha512-aAWcW57uxVNrQZqFXjITpW3sIUQmHGG3qSb9mUah9MgMC4NeWhNOlNjXEYq3HjRAvL6arUviZGGJsBg6z0zsWA==", + "dev": true, + "requires": { + "debug": "2.6.9", + "encodeurl": "~1.0.2", + "escape-html": "~1.0.3", + "on-finished": "~2.3.0", + "parseurl": "~1.3.3", + "statuses": "~1.5.0", + "unpipe": "~1.0.0" + }, + "dependencies": { + "debug": { + "version": "2.6.9", + "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", + "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", + "dev": true, + "requires": { + "ms": "2.0.0" + } + }, + "ms": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", + "integrity": "sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g=", + "dev": true + } + } + }, + "find-cache-dir": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/find-cache-dir/-/find-cache-dir-2.1.0.tgz", + "integrity": "sha512-Tq6PixE0w/VMFfCgbONnkiQIVol/JJL7nRMi20fqzA4NRs9AfeqMGeRdPi3wIhYkxjeBaWh2rxwapn5Tu3IqOQ==", + "dev": true, + "requires": { + "commondir": "^1.0.1", + "make-dir": "^2.0.0", + "pkg-dir": "^3.0.0" + }, + "dependencies": { + "find-up": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/find-up/-/find-up-3.0.0.tgz", + "integrity": "sha512-1yD6RmLI1XBfxugvORwlck6f75tYL+iR0jqwsOrOxMZyGYqUuDhJ0l4AXdO1iX/FTs9cBAMEk1gWSEx1kSbylg==", + "dev": true, + "requires": { + "locate-path": "^3.0.0" + } + }, + "locate-path": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-3.0.0.tgz", + "integrity": "sha512-7AO748wWnIhNqAuaty2ZWHkQHRSNfPVIsPIfwEOWO22AmaoVrWavlOcMR5nzTLNYvp36X220/maaRsrec1G65A==", + "dev": true, + "requires": { + "p-locate": "^3.0.0", + "path-exists": "^3.0.0" + } + }, + "p-limit": { + "version": "2.2.1", + "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-2.2.1.tgz", + "integrity": "sha512-85Tk+90UCVWvbDavCLKPOLC9vvY8OwEX/RtKF+/1OADJMVlFfEHOiMTPVyxg7mk/dKa+ipdHm0OUkTvCpMTuwg==", + "dev": true, + "requires": { + "p-try": "^2.0.0" + } + }, + "p-locate": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-3.0.0.tgz", + "integrity": "sha512-x+12w/To+4GFfgJhBEpiDcLozRJGegY+Ei7/z0tSLkMmxGZNybVMSfWj9aJn8Z5Fc7dBUNJOOVgPv2H7IwulSQ==", + "dev": true, + "requires": { + "p-limit": "^2.0.0" + } + }, + "p-try": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/p-try/-/p-try-2.2.0.tgz", + "integrity": "sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ==", + "dev": true + }, + "pkg-dir": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/pkg-dir/-/pkg-dir-3.0.0.tgz", + "integrity": "sha512-/E57AYkoeQ25qkxMj5PBOVgF8Kiu/h7cYS30Z5+R7WaiCCBfLq58ZI/dSeaEKb9WVJV5n/03QwrN3IeWIFllvw==", + "dev": true, + "requires": { + "find-up": "^3.0.0" + } + } + } + }, + "find-root": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/find-root/-/find-root-1.1.0.tgz", + "integrity": "sha512-NKfW6bec6GfKc0SGx1e07QZY9PE99u0Bft/0rzSD5k3sO/vwkVUpDUKVm5Gpp5Ue3YfShPFTX2070tDs5kB9Ng==", + "dev": true + }, + "find-up": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/find-up/-/find-up-2.1.0.tgz", + "integrity": "sha1-RdG35QbHF93UgndaK3eSCjwMV6c=", + "dev": true, + "requires": { + "locate-path": "^2.0.0" + } + }, + "findup-sync": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/findup-sync/-/findup-sync-3.0.0.tgz", + "integrity": "sha512-YbffarhcicEhOrm4CtrwdKBdCuz576RLdhJDsIfvNtxUuhdRet1qZcsMjqbePtAseKdAnDyM/IyXbu7PRPRLYg==", + "dev": true, + "requires": { + "detect-file": "^1.0.0", + "is-glob": "^4.0.0", + "micromatch": "^3.0.4", + "resolve-dir": "^1.0.1" + } + }, + "flat-cache": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/flat-cache/-/flat-cache-2.0.1.tgz", + "integrity": "sha512-LoQe6yDuUMDzQAEH8sgmh4Md6oZnc/7PjtwjNFSzveXqSHt6ka9fPBuso7IGf9Rz4uqnSnWiFH2B/zj24a5ReA==", + "dev": true, + "requires": { + "flatted": "^2.0.0", + "rimraf": "2.6.3", + "write": "1.0.3" + } + }, + "flatted": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/flatted/-/flatted-2.0.1.tgz", + "integrity": "sha512-a1hQMktqW9Nmqr5aktAux3JMNqaucxGcjtjWnZLHX7yyPCmlSV3M54nGYbqT8K+0GhF3NBgmJCc3ma+WOgX8Jg==", + "dev": true + }, + "flatten": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/flatten/-/flatten-1.0.2.tgz", + "integrity": "sha1-2uRqnXj74lKSJYzB54CkHZXAN4I=" + }, + "flush-write-stream": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/flush-write-stream/-/flush-write-stream-1.1.1.tgz", + "integrity": "sha512-3Z4XhFZ3992uIq0XOqb9AreonueSYphE6oYbpt5+3u06JWklbsPkNv3ZKkP9Bz/r+1MWCaMoSQ28P85+1Yc77w==", + "dev": true, + "requires": { + "inherits": "^2.0.3", + "readable-stream": "^2.3.6" + } + }, + "follow-redirects": { + "version": "1.9.0", + "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.9.0.tgz", + "integrity": "sha512-CRcPzsSIbXyVDl0QI01muNDu69S8trU4jArW9LpOt2WtC6LyUJetcIrmfHsRBx7/Jb6GHJUiuqyYxPooFfNt6A==", + "dev": true, + "requires": { + "debug": "^3.0.0" + }, + "dependencies": { + "debug": { + "version": "3.2.6", + "resolved": "https://registry.npmjs.org/debug/-/debug-3.2.6.tgz", + "integrity": "sha512-mel+jf7nrtEl5Pn1Qx46zARXKDpBbvzezse7p7LqINmdoIk8PYP5SySaxEmYv6TZ0JyEKA1hsCId6DIhgITtWQ==", + "dev": true, + "requires": { + "ms": "^2.1.1" + } + } + } + }, + "for-in": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/for-in/-/for-in-1.0.2.tgz", + "integrity": "sha1-gQaNKVqBQuwKxybG4iAMMPttXoA=", + "dev": true + }, + "foreach": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/foreach/-/foreach-2.0.5.tgz", + "integrity": "sha1-C+4AUBiusmDQo6865ljdATbsG5k=", + "dev": true + }, + "formatio": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/formatio/-/formatio-1.2.0.tgz", + "integrity": "sha1-87IWfZBoxGmKjVH092CjmlTYGOs=", + "dev": true, + "requires": { + "samsam": "1.x" + } + }, + "fragment-cache": { + "version": "0.2.1", + "resolved": "https://registry.npmjs.org/fragment-cache/-/fragment-cache-0.2.1.tgz", + "integrity": "sha1-QpD60n8T6Jvn8zeZxrxaCr//DRk=", + "dev": true, + "requires": { + "map-cache": "^0.2.2" + } + }, + "from2": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/from2/-/from2-2.3.0.tgz", + "integrity": "sha1-i/tVAr3kpNNs/e6gB/zKIdfjgq8=", + "dev": true, + "requires": { + "inherits": "^2.0.1", + "readable-stream": "^2.0.0" + } + }, + "fs-access": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/fs-access/-/fs-access-1.0.1.tgz", + "integrity": "sha1-1qh/JiJxzv6+wwxVNAf7mV2od3o=", + "dev": true, + "requires": { + "null-check": "^1.0.0" + } + }, + "fs-extra": { + "version": "7.0.1", + "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-7.0.1.tgz", + "integrity": "sha512-YJDaCJZEnBmcbw13fvdAM9AwNOJwOzrE4pqMqBq5nFiEqXUqHwlK4B+3pUw6JNvfSPtX05xFHtYy/1ni01eGCw==", + "dev": true, + "requires": { + "graceful-fs": "^4.1.2", + "jsonfile": "^4.0.0", + "universalify": "^0.1.0" + } + }, + "fs-minipass": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/fs-minipass/-/fs-minipass-2.1.0.tgz", + "integrity": "sha512-V/JgOLFCS+R6Vcq0slCuaeWEdNC3ouDlJMNIsacH2VtALiu9mV4LPrHc5cDl8k5aw6J8jwgWWpiTo5RYhmIzvg==", + "dev": true, + "requires": { + "minipass": "^3.0.0" + } + }, + "fs-write-stream-atomic": { + "version": "1.0.10", + "resolved": "https://registry.npmjs.org/fs-write-stream-atomic/-/fs-write-stream-atomic-1.0.10.tgz", + "integrity": "sha1-tH31NJPvkR33VzHnCp3tAYnbQMk=", + "dev": true, + "requires": { + "graceful-fs": "^4.1.2", + "iferr": "^0.1.5", + "imurmurhash": "^0.1.4", + "readable-stream": "1 || 2" + } + }, + "fs.realpath": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz", + "integrity": "sha1-FQStJSMVjKpA20onh8sBQRmU6k8=" + }, + "fsevents": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.1.1.tgz", + "integrity": "sha512-4FRPXWETxtigtJW/gxzEDsX1LVbPAM93VleB83kZB+ellqbHMkyt2aJfuzNLRvFPnGi6bcE5SvfxgbXPeKteJw==", + "dev": true, + "optional": true + }, + "function-bind": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.1.tgz", + "integrity": "sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A==" + }, + "functional-red-black-tree": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/functional-red-black-tree/-/functional-red-black-tree-1.0.1.tgz", + "integrity": "sha1-GwqzvVU7Kg1jmdKcDj6gslIHgyc=", + "dev": true + }, + "get-caller-file": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz", + "integrity": "sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==", + "dev": true + }, + "get-func-name": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/get-func-name/-/get-func-name-2.0.0.tgz", + "integrity": "sha1-6td0q+5y4gQJQzoGY2YCPdaIekE=", + "dev": true + }, + "get-stream": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-4.1.0.tgz", + "integrity": "sha512-GMat4EJ5161kIy2HevLlr4luNjBgvmj413KaQA7jt4V8B4RDsfpHk7WQ9GVqfYyyx8OS/L66Kox+rJRNklLK7w==", + "dev": true, + "requires": { + "pump": "^3.0.0" + } + }, + "get-value": { + "version": "2.0.6", + "resolved": "https://registry.npmjs.org/get-value/-/get-value-2.0.6.tgz", + "integrity": "sha1-3BXKHGcjh8p2vTesCjlbogQqLCg=", + "dev": true + }, + "git-hooks-list": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/git-hooks-list/-/git-hooks-list-1.0.3.tgz", + "integrity": "sha512-Y7wLWcrLUXwk2noSka166byGCvhMtDRpgHdzCno1UQv/n/Hegp++a2xBWJL1lJarnKD3SWaljD+0z1ztqxuKyQ==", + "dev": true + }, + "gl-matrix": { + "version": "2.8.1", + "resolved": "https://registry.npmjs.org/gl-matrix/-/gl-matrix-2.8.1.tgz", + "integrity": "sha512-0YCjVpE3pS5XWlN3J4X7AiAx65+nqAI54LndtVFnQZB6G/FVLkZH8y8V6R3cIoOQR4pUdfwQGd1iwyoXHJ4Qfw==" + }, + "glob": { + "version": "7.1.5", + "resolved": "https://registry.npmjs.org/glob/-/glob-7.1.5.tgz", + "integrity": "sha512-J9dlskqUXK1OeTOYBEn5s8aMukWMwWfs+rPTn/jn50Ux4MNXVhubL1wu/j2t+H4NVI+cXEcCaYellqaPVGXNqQ==", + "requires": { + "fs.realpath": "^1.0.0", + "inflight": "^1.0.4", + "inherits": "2", + "minimatch": "^3.0.4", + "once": "^1.3.0", + "path-is-absolute": "^1.0.0" + } + }, + "glob-parent": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.0.tgz", + "integrity": "sha512-qjtRgnIVmOfnKUE3NJAQEdk+lKrxfw8t5ke7SXtfMTHcjsBfOfWXCQfdb30zfDoZQ2IRSIiidmjtbHZPZ++Ihw==", + "dev": true, + "requires": { + "is-glob": "^4.0.1" + } + }, + "glob-to-regexp": { + "version": "0.4.1", + "resolved": "https://registry.npmjs.org/glob-to-regexp/-/glob-to-regexp-0.4.1.tgz", + "integrity": "sha512-lkX1HJXwyMcprw/5YUZc2s7DrpAiHB21/V+E1rHUrVNokkvB6bqMzT0VfV6/86ZNabt1k14YOIaT7nDvOX3Iiw==", + "dev": true + }, + "global-modules": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/global-modules/-/global-modules-2.0.0.tgz", + "integrity": "sha512-NGbfmJBp9x8IxyJSd1P+otYK8vonoJactOogrVfFRIAEY1ukil8RSKDz2Yo7wh1oihl51l/r6W4epkeKJHqL8A==", + "dev": true, + "requires": { + "global-prefix": "^3.0.0" + }, + "dependencies": { + "global-prefix": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/global-prefix/-/global-prefix-3.0.0.tgz", + "integrity": "sha512-awConJSVCHVGND6x3tmMaKcQvwXLhjdkmomy2W+Goaui8YPgYgXJZewhg3fWC+DlfqqQuWg8AwqjGTD2nAPVWg==", + "dev": true, + "requires": { + "ini": "^1.3.5", + "kind-of": "^6.0.2", + "which": "^1.3.1" + } + } + } + }, + "global-prefix": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/global-prefix/-/global-prefix-1.0.2.tgz", + "integrity": "sha1-2/dDxsFJklk8ZVVoy2btMsASLr4=", + "dev": true, + "requires": { + "expand-tilde": "^2.0.2", + "homedir-polyfill": "^1.0.1", + "ini": "^1.3.4", + "is-windows": "^1.0.1", + "which": "^1.2.14" + } + }, + "globals": { + "version": "11.12.0", + "resolved": "https://registry.npmjs.org/globals/-/globals-11.12.0.tgz", + "integrity": "sha512-WOBp/EEGUiIsJSp7wcv/y6MO+lV9UoncWqxuFfm8eBwzWNgyfBd6Gz+IeKQ9jCmyhoH99g15M3T+QaVHFjizVA==", + "dev": true + }, + "globby": { + "version": "10.0.0", + "resolved": "https://registry.npmjs.org/globby/-/globby-10.0.0.tgz", + "integrity": "sha512-3LifW9M4joGZasyYPz2A1U74zbC/45fvpXUvO/9KbSa+VV0aGZarWkfdgKyR9sExNP0t0x0ss/UMJpNpcaTspw==", + "dev": true, + "requires": { + "@types/glob": "^7.1.1", + "array-union": "^2.1.0", + "dir-glob": "^3.0.1", + "fast-glob": "^3.0.3", + "glob": "^7.1.3", + "ignore": "^5.1.1", + "merge2": "^1.2.3", + "slash": "^3.0.0" + }, + "dependencies": { + "ignore": { + "version": "5.1.8", + "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.1.8.tgz", + "integrity": "sha512-BMpfD7PpiETpBl/A6S498BaIJ6Y/ABT93ETbby2fP00v4EbvPBXWEoaR1UBPKs3iR53pJY7EtZk5KACI57i1Uw==", + "dev": true + } + } + }, + "got": { + "version": "9.6.0", + "resolved": "https://registry.npmjs.org/got/-/got-9.6.0.tgz", + "integrity": "sha512-R7eWptXuGYxwijs0eV+v3o6+XH1IqVK8dJOEecQfTmkncw9AV4dcw/Dhxi8MdlqPthxxpZyizMzyg8RTmEsG+Q==", + "dev": true, + "requires": { + "@sindresorhus/is": "^0.14.0", + "@szmarczak/http-timer": "^1.1.2", + "cacheable-request": "^6.0.0", + "decompress-response": "^3.3.0", + "duplexer3": "^0.1.4", + "get-stream": "^4.1.0", + "lowercase-keys": "^1.0.1", + "mimic-response": "^1.0.1", + "p-cancelable": "^1.0.0", + "to-readable-stream": "^1.0.0", + "url-parse-lax": "^3.0.0" + } + }, + "graceful-fs": { + "version": "4.2.3", + "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.3.tgz", + "integrity": "sha512-a30VEBm4PEdx1dRB7MFK7BejejvCvBronbLjht+sHuGYj8PHs7M/5Z+rt5lw551vZ7yfTCj4Vuyy3mSJytDWRQ==", + "dev": true + }, + "graceful-readlink": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/graceful-readlink/-/graceful-readlink-1.0.1.tgz", + "integrity": "sha1-TK+tdrxi8C+gObL5Tpo906ORpyU=", + "dev": true + }, + "growl": { + "version": "1.9.2", + "resolved": "https://registry.npmjs.org/growl/-/growl-1.9.2.tgz", + "integrity": "sha1-Dqd0NxXbjY3ixe3hd14bRayFwC8=", + "dev": true + }, + "has": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/has/-/has-1.0.3.tgz", + "integrity": "sha512-f2dvO0VU6Oej7RkWJGrehjbzMAjFp5/VKPp5tTpWIV4JHHZK1/BxbFRtf/siA2SWTe09caDmVtYYzWEIbBS4zw==", + "requires": { + "function-bind": "^1.1.1" + } + }, + "has-ansi": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/has-ansi/-/has-ansi-2.0.0.tgz", + "integrity": "sha1-NPUEnOHs3ysGSa8+8k5F7TVBbZE=", + "requires": { + "ansi-regex": "^2.0.0" + } + }, + "has-binary2": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/has-binary2/-/has-binary2-1.0.3.tgz", + "integrity": "sha512-G1LWKhDSvhGeAQ8mPVQlqNcOB2sJdwATtZKl2pDKKHfpf/rYj24lkinxf69blJbnsvtqqNU+L3SL50vzZhXOnw==", + "dev": true, + "requires": { + "isarray": "2.0.1" + }, + "dependencies": { + "isarray": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/isarray/-/isarray-2.0.1.tgz", + "integrity": "sha1-o32U7ZzaLVmGXJ92/llu4fM4dB4=", + "dev": true + } + } + }, + "has-cors": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/has-cors/-/has-cors-1.1.0.tgz", + "integrity": "sha1-XkdHk/fqmEPRu5nCPu9J/xJv/zk=", + "dev": true + }, + "has-flag": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-1.0.0.tgz", + "integrity": "sha1-nZ55MWXOAXoA8AQYxD+UKnsdEfo=" + }, + "has-symbols": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.0.0.tgz", + "integrity": "sha1-uhqPGvKg/DllD1yFA2dwQSIGO0Q=", + "dev": true + }, + "has-value": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/has-value/-/has-value-1.0.0.tgz", + "integrity": "sha1-GLKB2lhbHFxR3vJMkw7SmgvmsXc=", + "dev": true, + "requires": { + "get-value": "^2.0.6", + "has-values": "^1.0.0", + "isobject": "^3.0.0" + } + }, + "has-values": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/has-values/-/has-values-1.0.0.tgz", + "integrity": "sha1-lbC2P+whRmGab+V/51Yo1aOe/k8=", + "dev": true, + "requires": { + "is-number": "^3.0.0", + "kind-of": "^4.0.0" + }, + "dependencies": { + "is-number": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/is-number/-/is-number-3.0.0.tgz", + "integrity": "sha1-JP1iAaR4LPUFYcgQJ2r8fRLXEZU=", + "dev": true, + "requires": { + "kind-of": "^3.0.2" + }, + "dependencies": { + "kind-of": { + "version": "3.2.2", + "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz", + "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=", + "dev": true, + "requires": { + "is-buffer": "^1.1.5" + } + } + } + }, + "kind-of": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-4.0.0.tgz", + "integrity": "sha1-IIE989cSkosgc3hpGkUGb65y3Vc=", + "dev": true, + "requires": { + "is-buffer": "^1.1.5" + } + } + } + }, + "hash-base": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/hash-base/-/hash-base-3.0.4.tgz", + "integrity": "sha1-X8hoaEfs1zSZQDMZprCj8/auSRg=", + "dev": true, + "requires": { + "inherits": "^2.0.1", + "safe-buffer": "^5.0.1" + } + }, + "hash.js": { + "version": "1.1.7", + "resolved": "https://registry.npmjs.org/hash.js/-/hash.js-1.1.7.tgz", + "integrity": "sha512-taOaskGt4z4SOANNseOviYDvjEJinIkRgmp7LbKP2YTTmVxWBl87s/uzK9r+44BclBSp2X7K1hqeNfz9JbBeXA==", + "dev": true, + "requires": { + "inherits": "^2.0.3", + "minimalistic-assert": "^1.0.1" + } + }, + "he": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/he/-/he-1.1.1.tgz", + "integrity": "sha1-k0EP0hsAlzUVH4howvJx80J+I/0=", + "dev": true + }, + "hmac-drbg": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/hmac-drbg/-/hmac-drbg-1.0.1.tgz", + "integrity": "sha1-0nRXAQJabHdabFRXk+1QL8DGSaE=", + "dev": true, + "requires": { + "hash.js": "^1.0.3", + "minimalistic-assert": "^1.0.0", + "minimalistic-crypto-utils": "^1.0.1" + } + }, + "homedir-polyfill": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/homedir-polyfill/-/homedir-polyfill-1.0.3.tgz", + "integrity": "sha512-eSmmWE5bZTK2Nou4g0AI3zZ9rswp7GRKoKXS1BLUkvPviOqs4YTN1djQIqrXy9k5gEtdLPy86JjRwsNM9tnDcA==", + "dev": true, + "requires": { + "parse-passwd": "^1.0.0" + } + }, + "hosted-git-info": { + "version": "2.8.5", + "resolved": "https://registry.npmjs.org/hosted-git-info/-/hosted-git-info-2.8.5.tgz", + "integrity": "sha512-kssjab8CvdXfcXMXVcvsXum4Hwdq9XGtRD3TteMEvEbq0LXyiNQr6AprqKqfeaDXze7SxWvRxdpwE6ku7ikLkg==", + "dev": true + }, + "html-comment-regex": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/html-comment-regex/-/html-comment-regex-1.1.2.tgz", + "integrity": "sha512-P+M65QY2JQ5Y0G9KKdlDpo0zK+/OHptU5AaBwUfAIDJZk1MYf32Frm84EcOytfJE0t5JvkAnKlmjsXDnWzCJmQ==" + }, + "http-cache-semantics": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/http-cache-semantics/-/http-cache-semantics-4.1.0.tgz", + "integrity": "sha512-carPklcUh7ROWRK7Cv27RPtdhYhUsela/ue5/jKzjegVvXDqM2ILE9Q2BGn9JZJh1g87cp56su/FgQSzcWS8cQ==", + "dev": true + }, + "http-errors": { + "version": "1.7.2", + "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-1.7.2.tgz", + "integrity": "sha512-uUQBt3H/cSIVfch6i1EuPNy/YsRSOUBXTVfZ+yR7Zjez3qjBz6i9+i4zjNaoqcoFVI4lQJ5plg63TvGfRSDCRg==", + "dev": true, + "requires": { + "depd": "~1.1.2", + "inherits": "2.0.3", + "setprototypeof": "1.1.1", + "statuses": ">= 1.5.0 < 2", + "toidentifier": "1.0.0" + }, + "dependencies": { + "inherits": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.3.tgz", + "integrity": "sha1-Yzwsg+PaQqUC9SRmAiSA9CCCYd4=", + "dev": true + } + } + }, + "http-proxy": { + "version": "1.18.0", + "resolved": "https://registry.npmjs.org/http-proxy/-/http-proxy-1.18.0.tgz", + "integrity": "sha512-84I2iJM/n1d4Hdgc6y2+qY5mDaz2PUVjlg9znE9byl+q0uC3DeByqBGReQu5tpLK0TAqTIXScRUV+dg7+bUPpQ==", + "dev": true, + "requires": { + "eventemitter3": "^4.0.0", + "follow-redirects": "^1.0.0", + "requires-port": "^1.0.0" + } + }, + "https-browserify": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/https-browserify/-/https-browserify-1.0.0.tgz", + "integrity": "sha1-7AbBDgo0wPL68Zn3/X/Hj//QPHM=", + "dev": true + }, + "human-signals": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/human-signals/-/human-signals-2.1.0.tgz", + "integrity": "sha512-B4FFZ6q/T2jhhksgkbEW3HBvWIfDW85snkQgawt07S7J5QXTk6BkNV+0yAeZrM5QpMAdYlocGoljn0sJ/WQkFw==", + "dev": true + }, + "iconv-lite": { + "version": "0.4.24", + "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.24.tgz", + "integrity": "sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==", + "requires": { + "safer-buffer": ">= 2.1.2 < 3" + } + }, + "icss-replace-symbols": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/icss-replace-symbols/-/icss-replace-symbols-1.1.0.tgz", + "integrity": "sha1-Bupvg2ead0njhs/h/oEq5dsiPe0=" + }, + "icss-utils": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/icss-utils/-/icss-utils-2.1.0.tgz", + "integrity": "sha1-g/Cg7DeL8yRheLbCrZE28TWxyWI=", + "requires": { + "postcss": "^6.0.1" + }, + "dependencies": { + "ansi-styles": { + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz", + "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", + "requires": { + "color-convert": "^1.9.0" + } + }, + "chalk": { + "version": "2.4.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz", + "integrity": "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==", + "requires": { + "ansi-styles": "^3.2.1", + "escape-string-regexp": "^1.0.5", + "supports-color": "^5.3.0" + } + }, + "has-flag": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz", + "integrity": "sha1-tdRU3CGZriJWmfNGfloH87lVuv0=" + }, + "postcss": { + "version": "6.0.23", + "resolved": "https://registry.npmjs.org/postcss/-/postcss-6.0.23.tgz", + "integrity": "sha512-soOk1h6J3VMTZtVeVpv15/Hpdl2cBLX3CAw4TAbkpTJiNPk9YP/zWcD1ND+xEtvyuuvKzbxliTOIyvkSeSJ6ag==", + "requires": { + "chalk": "^2.4.1", + "source-map": "^0.6.1", + "supports-color": "^5.4.0" + } + }, + "source-map": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz", + "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==" + }, + "supports-color": { + "version": "5.5.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz", + "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==", + "requires": { + "has-flag": "^3.0.0" + } + } + } + }, + "ieee754": { + "version": "1.1.13", + "resolved": "https://registry.npmjs.org/ieee754/-/ieee754-1.1.13.tgz", + "integrity": "sha512-4vf7I2LYV/HaWerSo3XmlMkp5eZ83i+/CDluXi/IGTs/O1sejBNhTtnxzmRZfvOUqj7lZjqHkeTvpgSFDlWZTg==", + "dev": true + }, + "iferr": { + "version": "0.1.5", + "resolved": "https://registry.npmjs.org/iferr/-/iferr-0.1.5.tgz", + "integrity": "sha1-xg7taebY/bazEEofy8ocGS3FtQE=", + "dev": true + }, + "ignore": { + "version": "4.0.6", + "resolved": "https://registry.npmjs.org/ignore/-/ignore-4.0.6.tgz", + "integrity": "sha512-cyFDKrqc/YdcWFniJhzI42+AzS+gNwmUzOSFcRCQYwySuBBBy/KjuxWLZ/FHEH6Moq1NizMOBWyTcv8O4OZIMg==", + "dev": true + }, + "import-fresh": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/import-fresh/-/import-fresh-3.1.0.tgz", + "integrity": "sha512-PpuksHKGt8rXfWEr9m9EHIpgyyaltBy8+eF6GJM0QCAxMgxCfucMF3mjecK2QsJr0amJW7gTqh5/wht0z2UhEQ==", + "dev": true, + "requires": { + "parent-module": "^1.0.0", + "resolve-from": "^4.0.0" + } + }, + "import-local": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/import-local/-/import-local-2.0.0.tgz", + "integrity": "sha512-b6s04m3O+s3CGSbqDIyP4R6aAwAeYlVq9+WUWep6iHa8ETRf9yei1U48C5MmfJmV9AiLYYBKPMq/W+/WRpQmCQ==", + "dev": true, + "requires": { + "pkg-dir": "^3.0.0", + "resolve-cwd": "^2.0.0" + }, + "dependencies": { + "find-up": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/find-up/-/find-up-3.0.0.tgz", + "integrity": "sha512-1yD6RmLI1XBfxugvORwlck6f75tYL+iR0jqwsOrOxMZyGYqUuDhJ0l4AXdO1iX/FTs9cBAMEk1gWSEx1kSbylg==", + "dev": true, + "requires": { + "locate-path": "^3.0.0" + } + }, + "locate-path": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-3.0.0.tgz", + "integrity": "sha512-7AO748wWnIhNqAuaty2ZWHkQHRSNfPVIsPIfwEOWO22AmaoVrWavlOcMR5nzTLNYvp36X220/maaRsrec1G65A==", + "dev": true, + "requires": { + "p-locate": "^3.0.0", + "path-exists": "^3.0.0" + } + }, + "p-limit": { + "version": "2.2.1", + "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-2.2.1.tgz", + "integrity": "sha512-85Tk+90UCVWvbDavCLKPOLC9vvY8OwEX/RtKF+/1OADJMVlFfEHOiMTPVyxg7mk/dKa+ipdHm0OUkTvCpMTuwg==", + "dev": true, + "requires": { + "p-try": "^2.0.0" + } + }, + "p-locate": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-3.0.0.tgz", + "integrity": "sha512-x+12w/To+4GFfgJhBEpiDcLozRJGegY+Ei7/z0tSLkMmxGZNybVMSfWj9aJn8Z5Fc7dBUNJOOVgPv2H7IwulSQ==", + "dev": true, + "requires": { + "p-limit": "^2.0.0" + } + }, + "p-try": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/p-try/-/p-try-2.2.0.tgz", + "integrity": "sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ==", + "dev": true + }, + "pkg-dir": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/pkg-dir/-/pkg-dir-3.0.0.tgz", + "integrity": "sha512-/E57AYkoeQ25qkxMj5PBOVgF8Kiu/h7cYS30Z5+R7WaiCCBfLq58ZI/dSeaEKb9WVJV5n/03QwrN3IeWIFllvw==", + "dev": true, + "requires": { + "find-up": "^3.0.0" + } + } + } + }, + "imurmurhash": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz", + "integrity": "sha1-khi5srkoojixPcT7a21XbyMUU+o=", + "dev": true + }, + "indent-string": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/indent-string/-/indent-string-4.0.0.tgz", + "integrity": "sha512-EdDDZu4A2OyIK7Lr/2zG+w5jmbuk1DVBnEwREQvBzspBJkCEbRa8GxU1lghYcaGJCnRWibjDXlq779X1/y5xwg==", + "dev": true + }, + "indexes-of": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/indexes-of/-/indexes-of-1.0.1.tgz", + "integrity": "sha1-8w9xbI4r00bHtn0985FVZqfAVgc=" + }, + "indexof": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/indexof/-/indexof-0.0.1.tgz", + "integrity": "sha1-gtwzbSMrkGIXnQWrMpOmYFn9Q10=", + "dev": true + }, + "infer-owner": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/infer-owner/-/infer-owner-1.0.4.tgz", + "integrity": "sha512-IClj+Xz94+d7irH5qRyfJonOdfTzuDaifE6ZPWfx0N0+/ATZCbuTPq2prFl526urkQd90WyUKIh1DfBQ2hMz9A==", + "dev": true + }, + "inflight": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz", + "integrity": "sha1-Sb1jMdfQLQwJvJEKEHW6gWW1bfk=", + "requires": { + "once": "^1.3.0", + "wrappy": "1" + } + }, + "inherits": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz", + "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==" + }, + "ini": { + "version": "1.3.5", + "resolved": "https://registry.npmjs.org/ini/-/ini-1.3.5.tgz", + "integrity": "sha512-RZY5huIKCMRWDUqZlEi72f/lmXKMvuszcMBduliQ3nnWbx9X/ZBQO7DijMEYS9EhHBb2qacRUMtC7svLwe0lcw==", + "dev": true + }, + "inquirer": { + "version": "6.5.2", + "resolved": "https://registry.npmjs.org/inquirer/-/inquirer-6.5.2.tgz", + "integrity": "sha512-cntlB5ghuB0iuO65Ovoi8ogLHiWGs/5yNrtUcKjFhSSiVeAIVpD7koaSU9RM8mpXw5YDi9RdYXGQMaOURB7ycQ==", + "dev": true, + "requires": { + "ansi-escapes": "^3.2.0", + "chalk": "^2.4.2", + "cli-cursor": "^2.1.0", + "cli-width": "^2.0.0", + "external-editor": "^3.0.3", + "figures": "^2.0.0", + "lodash": "^4.17.12", + "mute-stream": "0.0.7", + "run-async": "^2.2.0", + "rxjs": "^6.4.0", + "string-width": "^2.1.0", + "strip-ansi": "^5.1.0", + "through": "^2.3.6" + }, + "dependencies": { + "ansi-regex": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-4.1.0.tgz", + "integrity": "sha512-1apePfXM1UOSqw0o9IiFAovVz9M5S1Dg+4TrDwfMewQ6p/rmMueb7tWZjQ1rx4Loy1ArBggoqGpfqqdI4rondg==", + "dev": true + }, + "ansi-styles": { + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz", + "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", + "dev": true, + "requires": { + "color-convert": "^1.9.0" + } + }, + "chalk": { + "version": "2.4.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz", + "integrity": "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==", + "dev": true, + "requires": { + "ansi-styles": "^3.2.1", + "escape-string-regexp": "^1.0.5", + "supports-color": "^5.3.0" + } + }, + "has-flag": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz", + "integrity": "sha1-tdRU3CGZriJWmfNGfloH87lVuv0=", + "dev": true + }, + "strip-ansi": { + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-5.2.0.tgz", + "integrity": "sha512-DuRs1gKbBqsMKIZlrffwlug8MHkcnpjs5VPmL1PAh+mA30U0DTotfDZ0d2UUsXpPmPmMMJ6W773MaA3J+lbiWA==", + "dev": true, + "requires": { + "ansi-regex": "^4.1.0" + } + }, + "supports-color": { + "version": "5.5.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz", + "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==", + "dev": true, + "requires": { + "has-flag": "^3.0.0" + } + } + } + }, + "interpret": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/interpret/-/interpret-1.2.0.tgz", + "integrity": "sha512-mT34yGKMNceBQUoVn7iCDKDntA7SC6gycMAWzGx1z/CMCTV7b2AAtXlo3nRyHZ1FelRkQbQjprHSYGwzLtkVbw==", + "dev": true + }, + "invert-kv": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/invert-kv/-/invert-kv-2.0.0.tgz", + "integrity": "sha512-wPVv/y/QQ/Uiirj/vh3oP+1Ww+AWehmi1g5fFWGPF6IpCBCDVrhgHRMvrLfdYcwDh3QJbGXDW4JAuzxElLSqKA==", + "dev": true + }, + "iota-array": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/iota-array/-/iota-array-1.0.0.tgz", + "integrity": "sha1-ge9X/l0FgUzVjCSDYyqZwwoOgIc=" + }, + "is-absolute-url": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/is-absolute-url/-/is-absolute-url-2.1.0.tgz", + "integrity": "sha1-UFMN+4T8yap9vnhS6Do3uTufKqY=" + }, + "is-accessor-descriptor": { + "version": "0.1.6", + "resolved": "https://registry.npmjs.org/is-accessor-descriptor/-/is-accessor-descriptor-0.1.6.tgz", + "integrity": "sha1-qeEss66Nh2cn7u84Q/igiXtcmNY=", + "dev": true, + "requires": { + "kind-of": "^3.0.2" + }, + "dependencies": { + "kind-of": { + "version": "3.2.2", + "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz", + "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=", + "dev": true, + "requires": { + "is-buffer": "^1.1.5" + } + } + } + }, + "is-arrayish": { + "version": "0.2.1", + "resolved": "https://registry.npmjs.org/is-arrayish/-/is-arrayish-0.2.1.tgz", + "integrity": "sha1-d8mYQFJ6qOyxqLppe4BkWnqSap0=", + "dev": true + }, + "is-binary-path": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/is-binary-path/-/is-binary-path-2.1.0.tgz", + "integrity": "sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==", + "dev": true, + "requires": { + "binary-extensions": "^2.0.0" + } + }, + "is-buffer": { + "version": "1.1.6", + "resolved": "https://registry.npmjs.org/is-buffer/-/is-buffer-1.1.6.tgz", + "integrity": "sha512-NcdALwpXkTm5Zvvbk7owOUSvVvBKDgKP5/ewfXEznmQFfs4ZRmanOeKBTjRVjka3QFoN6XJ+9F3USqfHqTaU5w==" + }, + "is-callable": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/is-callable/-/is-callable-1.1.4.tgz", + "integrity": "sha512-r5p9sxJjYnArLjObpjA4xu5EKI3CuKHkJXMhT7kwbpUyIFD1n5PMAsoPvWnvtZiNz7LjkYDRZhd7FlI0eMijEA==", + "dev": true + }, + "is-data-descriptor": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/is-data-descriptor/-/is-data-descriptor-0.1.4.tgz", + "integrity": "sha1-C17mSDiOLIYCgueT8YVv7D8wG1Y=", + "dev": true, + "requires": { + "kind-of": "^3.0.2" + }, + "dependencies": { + "kind-of": { + "version": "3.2.2", + "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz", + "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=", + "dev": true, + "requires": { + "is-buffer": "^1.1.5" + } + } + } + }, + "is-date-object": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/is-date-object/-/is-date-object-1.0.1.tgz", + "integrity": "sha1-mqIOtq7rv/d/vTPnTKAbM1gdOhY=", + "dev": true + }, + "is-descriptor": { + "version": "0.1.6", + "resolved": "https://registry.npmjs.org/is-descriptor/-/is-descriptor-0.1.6.tgz", + "integrity": "sha512-avDYr0SB3DwO9zsMov0gKCESFYqCnE4hq/4z3TdUlukEy5t9C0YRq7HLrsN52NAcqXKaepeCD0n+B0arnVG3Hg==", + "dev": true, + "requires": { + "is-accessor-descriptor": "^0.1.6", + "is-data-descriptor": "^0.1.4", + "kind-of": "^5.0.0" + }, + "dependencies": { + "kind-of": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-5.1.0.tgz", + "integrity": "sha512-NGEErnH6F2vUuXDh+OlbcKW7/wOcfdRHaZ7VWtqCztfHri/++YKmP51OdWeGPuqCOba6kk2OTe5d02VmTB80Pw==", + "dev": true + } + } + }, + "is-extendable": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/is-extendable/-/is-extendable-0.1.1.tgz", + "integrity": "sha1-YrEQ4omkcUGOPsNqYX1HLjAd/Ik=", + "dev": true + }, + "is-extglob": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz", + "integrity": "sha1-qIwCU1eR8C7TfHahueqXc8gz+MI=", + "dev": true + }, + "is-fullwidth-code-point": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-2.0.0.tgz", + "integrity": "sha1-o7MKXE8ZkYMWeqq5O+764937ZU8=", + "dev": true + }, + "is-glob": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.1.tgz", + "integrity": "sha512-5G0tKtBTFImOqDnLB2hG6Bp2qcKEFduo4tZu9MT/H6NQv/ghhy30o55ufafxJ/LdH79LLs2Kfrn85TLKyA7BUg==", + "dev": true, + "requires": { + "is-extglob": "^2.1.1" + } + }, + "is-number": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz", + "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==", + "dev": true + }, + "is-plain-obj": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-1.1.0.tgz", + "integrity": "sha1-caUMhCnfync8kqOQpKA7OfzVHT4=" + }, + "is-plain-object": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/is-plain-object/-/is-plain-object-2.0.4.tgz", + "integrity": "sha512-h5PpgXkWitc38BBMYawTYMWJHFZJVnBquFE57xFpjB8pJFiF6gZ+bU+WyI/yqXiFR5mdLsgYNaPe8uao6Uv9Og==", + "dev": true, + "requires": { + "isobject": "^3.0.1" + } + }, + "is-promise": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/is-promise/-/is-promise-2.1.0.tgz", + "integrity": "sha1-eaKp7OfwlugPNtKy87wWwf9L8/o=", + "dev": true + }, + "is-regex": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/is-regex/-/is-regex-1.0.4.tgz", + "integrity": "sha1-VRdIm1RwkbCTDglWVM7SXul+lJE=", + "dev": true, + "requires": { + "has": "^1.0.1" + } + }, + "is-stream": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/is-stream/-/is-stream-1.1.0.tgz", + "integrity": "sha1-EtSj3U5o4Lec6428hBc66A2RykQ=", + "dev": true + }, + "is-svg": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/is-svg/-/is-svg-2.1.0.tgz", + "integrity": "sha1-z2EJDaDZ77yrhyLeum8DIgjbsOk=", + "requires": { + "html-comment-regex": "^1.1.0" + } + }, + "is-symbol": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/is-symbol/-/is-symbol-1.0.2.tgz", + "integrity": "sha512-HS8bZ9ox60yCJLH9snBpIwv9pYUAkcuLhSA1oero1UB5y9aiQpRA8y2ex945AOtCZL1lJDeIk3G5LthswI46Lw==", + "dev": true, + "requires": { + "has-symbols": "^1.0.0" + } + }, + "is-typedarray": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-typedarray/-/is-typedarray-1.0.0.tgz", + "integrity": "sha1-5HnICFjfDBsR3dppQPlgEfzaSpo=" + }, + "is-windows": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/is-windows/-/is-windows-1.0.2.tgz", + "integrity": "sha512-eXK1UInq2bPmjyX6e3VHIzMLobc4J94i4AWn+Hpq3OU5KkrRC96OAcR3PRJ/pGu6m8TRnBHP9dkXQVsT/COVIA==", + "dev": true + }, + "is-wsl": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/is-wsl/-/is-wsl-1.1.0.tgz", + "integrity": "sha1-HxbkqiKwTRM2tmGIpmrzxgDDpm0=", + "dev": true + }, + "isarray": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz", + "integrity": "sha1-u5NdSFgsuhaMBoNJV6VKPgcSTxE=", + "dev": true + }, + "isbinaryfile": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/isbinaryfile/-/isbinaryfile-3.0.3.tgz", + "integrity": "sha512-8cJBL5tTd2OS0dM4jz07wQd5g0dCCqIhUxPIGtZfa5L6hWlvV5MHTITy/DBAsF+Oe2LS1X3krBUhNwaGUWpWxw==", + "dev": true, + "requires": { + "buffer-alloc": "^1.2.0" + } + }, + "isexe": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz", + "integrity": "sha1-6PvzdNxVb/iUehDcsFctYz8s+hA=", + "dev": true + }, + "isobject": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/isobject/-/isobject-3.0.1.tgz", + "integrity": "sha1-TkMekrEalzFjaqH5yNHMvP2reN8=", + "dev": true + }, + "jest-worker": { + "version": "26.6.2", + "resolved": "https://registry.npmjs.org/jest-worker/-/jest-worker-26.6.2.tgz", + "integrity": "sha512-KWYVV1c4i+jbMpaBC+U++4Va0cp8OisU185o73T1vo99hqi7w8tSJfUXYswwqqrjzwxa6KpRK54WhPvwf5w6PQ==", + "dev": true, + "requires": { + "@types/node": "*", + "merge-stream": "^2.0.0", + "supports-color": "^7.0.0" + }, + "dependencies": { + "has-flag": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", + "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", + "dev": true + }, + "supports-color": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", + "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", + "dev": true, + "requires": { + "has-flag": "^4.0.0" + } + } + } + }, + "jquery": { + "version": "3.4.1", + "resolved": "https://registry.npmjs.org/jquery/-/jquery-3.4.1.tgz", + "integrity": "sha512-36+AdBzCL+y6qjw5Tx7HgzeGCzC81MDDgaUP8ld2zhx58HdqXGoBd+tHdrBMiyjGQs0Hxs/MLZTu/eHNJJuWPw==" + }, + "jquery-ui": { + "version": "1.12.1", + "resolved": "https://registry.npmjs.org/jquery-ui/-/jquery-ui-1.12.1.tgz", + "integrity": "sha1-vLQEXI3QU5wTS8FIjN0+dop6nlE=" + }, + "js-base64": { + "version": "2.5.1", + "resolved": "https://registry.npmjs.org/js-base64/-/js-base64-2.5.1.tgz", + "integrity": "sha512-M7kLczedRMYX4L8Mdh4MzyAMM9O5osx+4FcOQuTvr3A9F2D9S5JXheN0ewNbrvK2UatkTRhL5ejGmGSjNMiZuw==" + }, + "js-tokens": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-3.0.2.tgz", + "integrity": "sha1-mGbfOVECEw449/mWvOtlRDIJwls=" + }, + "js-yaml": { + "version": "3.7.0", + "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-3.7.0.tgz", + "integrity": "sha1-XJZ93YN6m/3KXy3oQlOr6KHAO4A=", + "requires": { + "argparse": "^1.0.7", + "esprima": "^2.6.0" + } + }, + "jsesc": { + "version": "0.5.0", + "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-0.5.0.tgz", + "integrity": "sha1-597mbjXW/Bb3EP6R1c9p9w8IkR0=" + }, + "jslink": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/jslink/-/jslink-1.1.3.tgz", + "integrity": "sha1-FKNC1JhiU/EEfM9/8Rdcq7AstZw=", + "requires": { + "ansi": "~0.2.1", + "esprima": "~1.0.4", + "walkdir": "0.0.7" + }, + "dependencies": { + "esprima": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/esprima/-/esprima-1.0.4.tgz", + "integrity": "sha1-n1V+CPw7TSbs6d00+Pv0drYlha0=" + } + } + }, + "json-buffer": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/json-buffer/-/json-buffer-3.0.0.tgz", + "integrity": "sha1-Wx85evx11ne96Lz8Dkfh+aPZqJg=", + "dev": true + }, + "json-loader": { + "version": "0.5.7", + "resolved": "https://registry.npmjs.org/json-loader/-/json-loader-0.5.7.tgz", + "integrity": "sha512-QLPs8Dj7lnf3e3QYS1zkCo+4ZwqOiF9d/nZnYozTISxXWCfNs9yuky5rJw4/W34s7POaNlbZmQGaB5NiXCbP4w==", + "dev": true + }, + "json-parse-better-errors": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/json-parse-better-errors/-/json-parse-better-errors-1.0.2.tgz", + "integrity": "sha512-mrqyZKfX5EhL7hvqcV6WG1yYjnjeuYDzDhhcAAUrq8Po85NBQBJP+ZDUT75qZQ98IkUoBqdkExkukOU7Ts2wrw==", + "dev": true + }, + "json-schema-traverse": { + "version": "0.4.1", + "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz", + "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==" + }, + "json-stable-stringify-without-jsonify": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz", + "integrity": "sha1-nbe1lJatPzz+8wp1FC0tkwrXJlE=", + "dev": true + }, + "json3": { + "version": "3.3.2", + "resolved": "https://registry.npmjs.org/json3/-/json3-3.3.2.tgz", + "integrity": "sha1-PAQ0dD35Pi9cQq7nsZvLSDV19OE=", + "dev": true + }, + "json5": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/json5/-/json5-2.1.1.tgz", + "integrity": "sha512-l+3HXD0GEI3huGq1njuqtzYK8OYJyXMkOLtQ53pjWh89tvWS2h6l+1zMkYWqlb57+SiQodKZyvMEFb2X+KrFhQ==", + "requires": { + "minimist": "^1.2.0" + } + }, + "jsonfile": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-4.0.0.tgz", + "integrity": "sha1-h3Gq4HmbZAdrdmQPygWPnBDjPss=", + "dev": true, + "requires": { + "graceful-fs": "^4.1.6" + } + }, + "jupyter-dataserializers": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/jupyter-dataserializers/-/jupyter-dataserializers-2.3.0.tgz", + "integrity": "sha512-juXyhDOBYDyziSRcPiRPUXFaAJ1iC3YHoddgd1jJNRfhKynPGKqBXrMVPMXHBO4YiqMZs6kPHpOpJUXsdxRnMg==", + "dev": true, + "requires": { + "@jupyter-widgets/base": "^1 || ^2 || ^3 || ^4", + "ndarray": "^1.0.18", + "pako": "^1.0.6" + } + }, + "jupyter-threejs": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/jupyter-threejs/-/jupyter-threejs-2.3.0.tgz", + "integrity": "sha512-AG3ylhlcslgbi4m8qZAXrc1CFAJxMzmMMuRPJRJlTyQC/q0Angy7j6vC3U4/TpthD9+Hbz7H4M7/5qY/iScCIA==", + "dev": true, + "requires": { + "@jupyter-widgets/base": "^1.2.5 || ^2.0.0 || ^3.0.0 || ^4.0.0", + "bluebird": "^3.5.5", + "jupyter-dataserializers": "^2.2.0", + "three": "^0.97.0", + "underscore": "^1.8.3" + } + }, + "karma": { + "version": "4.4.1", + "resolved": "https://registry.npmjs.org/karma/-/karma-4.4.1.tgz", + "integrity": "sha512-L5SIaXEYqzrh6b1wqYC42tNsFMx2PWuxky84pK9coK09MvmL7mxii3G3bZBh/0rvD27lqDd0le9jyhzvwif73A==", + "dev": true, + "requires": { + "bluebird": "^3.3.0", + "body-parser": "^1.16.1", + "braces": "^3.0.2", + "chokidar": "^3.0.0", + "colors": "^1.1.0", + "connect": "^3.6.0", + "di": "^0.0.1", + "dom-serialize": "^2.2.0", + "flatted": "^2.0.0", + "glob": "^7.1.1", + "graceful-fs": "^4.1.2", + "http-proxy": "^1.13.0", + "isbinaryfile": "^3.0.0", + "lodash": "^4.17.14", + "log4js": "^4.0.0", + "mime": "^2.3.1", + "minimatch": "^3.0.2", + "optimist": "^0.6.1", + "qjobs": "^1.1.4", + "range-parser": "^1.2.0", + "rimraf": "^2.6.0", + "safe-buffer": "^5.0.1", + "socket.io": "2.1.1", + "source-map": "^0.6.1", + "tmp": "0.0.33", + "useragent": "2.3.0" + }, + "dependencies": { + "source-map": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz", + "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==", + "dev": true + } + } + }, + "karma-chai": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/karma-chai/-/karma-chai-0.1.0.tgz", + "integrity": "sha1-vuWtQEAFF4Ea40u5RfdikJEIt5o=", + "dev": true + }, + "karma-chrome-launcher": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/karma-chrome-launcher/-/karma-chrome-launcher-2.2.0.tgz", + "integrity": "sha512-uf/ZVpAabDBPvdPdveyk1EPgbnloPvFFGgmRhYLTDH7gEB4nZdSBk8yTU47w1g/drLSx5uMOkjKk7IWKfWg/+w==", + "dev": true, + "requires": { + "fs-access": "^1.0.0", + "which": "^1.2.1" + } + }, + "karma-mocha": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/karma-mocha/-/karma-mocha-1.3.0.tgz", + "integrity": "sha1-7qrH/8DiAetjxGdEDStpx883eL8=", + "dev": true, + "requires": { + "minimist": "1.2.0" + } + }, + "karma-mocha-reporter": { + "version": "2.2.5", + "resolved": "https://registry.npmjs.org/karma-mocha-reporter/-/karma-mocha-reporter-2.2.5.tgz", + "integrity": "sha1-FRIAlejtgZGG5HoLAS8810GJVWA=", + "dev": true, + "requires": { + "chalk": "^2.1.0", + "log-symbols": "^2.1.0", + "strip-ansi": "^4.0.0" + }, + "dependencies": { + "ansi-regex": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-3.0.0.tgz", + "integrity": "sha1-7QMXwyIGT3lGbAKWa922Bas32Zg=", + "dev": true + }, + "ansi-styles": { + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz", + "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", + "dev": true, + "requires": { + "color-convert": "^1.9.0" + } + }, + "chalk": { + "version": "2.4.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz", + "integrity": "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==", + "dev": true, + "requires": { + "ansi-styles": "^3.2.1", + "escape-string-regexp": "^1.0.5", + "supports-color": "^5.3.0" + } + }, + "has-flag": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz", + "integrity": "sha1-tdRU3CGZriJWmfNGfloH87lVuv0=", + "dev": true + }, + "strip-ansi": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-4.0.0.tgz", + "integrity": "sha1-qEeQIusaw2iocTibY1JixQXuNo8=", + "dev": true, + "requires": { + "ansi-regex": "^3.0.0" + } + }, + "supports-color": { + "version": "5.5.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz", + "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==", + "dev": true, + "requires": { + "has-flag": "^3.0.0" + } + } + } + }, + "karma-sinon": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/karma-sinon/-/karma-sinon-1.0.5.tgz", + "integrity": "sha1-TjRD8oMP3s/2JNN0cWPxIX2qKpo=", + "dev": true + }, + "karma-sourcemap-loader": { + "version": "0.3.7", + "resolved": "https://registry.npmjs.org/karma-sourcemap-loader/-/karma-sourcemap-loader-0.3.7.tgz", + "integrity": "sha1-kTIsd/jxPUb+0GKwQuEAnUxFBdg=", + "dev": true, + "requires": { + "graceful-fs": "^4.1.2" + } + }, + "karma-webpack": { + "version": "3.0.5", + "resolved": "https://registry.npmjs.org/karma-webpack/-/karma-webpack-3.0.5.tgz", + "integrity": "sha512-nRudGJWstvVuA6Tbju9tyGUfXTtI1UXMXoRHVmM2/78D0q6s/Ye2IC157PKNDC15PWFGR0mVIRtWLAdcfsRJoA==", + "dev": true, + "requires": { + "async": "^2.0.0", + "babel-runtime": "^6.0.0", + "loader-utils": "^1.0.0", + "lodash": "^4.0.0", + "source-map": "^0.5.6", + "webpack-dev-middleware": "^2.0.6" + } + }, + "keyv": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/keyv/-/keyv-3.1.0.tgz", + "integrity": "sha512-9ykJ/46SN/9KPM/sichzQ7OvXyGDYKGTaDlKMGCAlg2UK8KRy4jb0d8sFc+0Tt0YYnThq8X2RZgCg74RPxgcVA==", + "dev": true, + "requires": { + "json-buffer": "3.0.0" + } + }, + "kind-of": { + "version": "6.0.2", + "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-6.0.2.tgz", + "integrity": "sha512-s5kLOcnH0XqDO+FvuaLX8DDjZ18CGFk7VygH40QoKPUQhW4e2rvM0rwUq0t8IQDOwYSeLK01U90OjzBTme2QqA==", + "dev": true + }, + "lcid": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/lcid/-/lcid-2.0.0.tgz", + "integrity": "sha512-avPEb8P8EGnwXKClwsNUgryVjllcRqtMYa49NTsbQagYuT1DcXnl1915oxWjoyGrXR6zH/Y0Zc96xWsPcoDKeA==", + "dev": true, + "requires": { + "invert-kv": "^2.0.0" + } + }, + "levn": { + "version": "0.3.0", + "resolved": "https://registry.npmjs.org/levn/-/levn-0.3.0.tgz", + "integrity": "sha1-OwmSTt+fCDwEkP3UwLxEIeBHZO4=", + "dev": true, + "requires": { + "prelude-ls": "~1.1.2", + "type-check": "~0.3.2" + } + }, + "load-json-file": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/load-json-file/-/load-json-file-2.0.0.tgz", + "integrity": "sha1-eUfkIUmvgNaWy/eXvKq8/h/inKg=", + "dev": true, + "requires": { + "graceful-fs": "^4.1.2", + "parse-json": "^2.2.0", + "pify": "^2.0.0", + "strip-bom": "^3.0.0" + } + }, + "loader-runner": { + "version": "2.4.0", + "resolved": "https://registry.npmjs.org/loader-runner/-/loader-runner-2.4.0.tgz", + "integrity": "sha512-Jsmr89RcXGIwivFY21FcRrisYZfvLMTWx5kOLc+JTxtpBOG6xML0vzbc6SEQG2FO9/4Fc3wW4LVcB5DmGflaRw==", + "dev": true + }, + "loader-utils": { + "version": "1.2.3", + "resolved": "https://registry.npmjs.org/loader-utils/-/loader-utils-1.2.3.tgz", + "integrity": "sha512-fkpz8ejdnEMG3s37wGL07iSBDg99O9D5yflE9RGNH3hRdx9SOwYfnGYdZOUIZitN8E+E2vkq3MUMYMvPYl5ZZA==", + "requires": { + "big.js": "^5.2.2", + "emojis-list": "^2.0.0", + "json5": "^1.0.1" + }, + "dependencies": { + "json5": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/json5/-/json5-1.0.1.tgz", + "integrity": "sha512-aKS4WQjPenRxiQsC93MNfjx+nbF4PAdYzmd/1JIj8HYzqfbu86beTuNgXDzPknWk0n0uARlyewZo4s++ES36Ow==", + "requires": { + "minimist": "^1.2.0" + } + } + } + }, + "locate-path": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-2.0.0.tgz", + "integrity": "sha1-K1aLJl7slExtnA3pw9u7ygNUzY4=", + "dev": true, + "requires": { + "p-locate": "^2.0.0", + "path-exists": "^3.0.0" + } + }, + "lodash": { + "version": "4.17.15", + "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.15.tgz", + "integrity": "sha512-8xOcRHvCjnocdS5cpwXQXVzmmh5e5+saE2QGoeQmbKmRS6J3VQppPOIt0MnmE+4xlZoumy0GPG0D0MVIQbNA1A==" + }, + "lodash._baseassign": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/lodash._baseassign/-/lodash._baseassign-3.2.0.tgz", + "integrity": "sha1-jDigmVAPIVrQnlnxci/QxSv+Ck4=", + "dev": true, + "requires": { + "lodash._basecopy": "^3.0.0", + "lodash.keys": "^3.0.0" + } + }, + "lodash._basecopy": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/lodash._basecopy/-/lodash._basecopy-3.0.1.tgz", + "integrity": "sha1-jaDmqHbPNEwK2KVIghEd08XHyjY=", + "dev": true + }, + "lodash._basecreate": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/lodash._basecreate/-/lodash._basecreate-3.0.3.tgz", + "integrity": "sha1-G8ZhYU2qf8MRt9A78WgGoCE8+CE=", + "dev": true + }, + "lodash._getnative": { + "version": "3.9.1", + "resolved": "https://registry.npmjs.org/lodash._getnative/-/lodash._getnative-3.9.1.tgz", + "integrity": "sha1-VwvH3t5G1hzc3mh9ZdPuy6o6r/U=", + "dev": true + }, + "lodash._isiterateecall": { + "version": "3.0.9", + "resolved": "https://registry.npmjs.org/lodash._isiterateecall/-/lodash._isiterateecall-3.0.9.tgz", + "integrity": "sha1-UgOte6Ql+uhCRg5pbbnPPmqsBXw=", + "dev": true + }, + "lodash.camelcase": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/lodash.camelcase/-/lodash.camelcase-4.3.0.tgz", + "integrity": "sha1-soqmKIorn8ZRA1x3EfZathkDMaY=" + }, + "lodash.create": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/lodash.create/-/lodash.create-3.1.1.tgz", + "integrity": "sha1-1/KEnw29p+BGgruM1yqwIkYd6+c=", + "dev": true, + "requires": { + "lodash._baseassign": "^3.0.0", + "lodash._basecreate": "^3.0.0", + "lodash._isiterateecall": "^3.0.0" + } + }, + "lodash.isarguments": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/lodash.isarguments/-/lodash.isarguments-3.1.0.tgz", + "integrity": "sha1-L1c9hcaiQon/AGY7SRwdM4/zRYo=", + "dev": true + }, + "lodash.isarray": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/lodash.isarray/-/lodash.isarray-3.0.4.tgz", + "integrity": "sha1-eeTriMNqgSKvhvhEqpvNhRtfu1U=", + "dev": true + }, + "lodash.keys": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/lodash.keys/-/lodash.keys-3.1.2.tgz", + "integrity": "sha1-TbwEcrFWvlCgsoaFXRvQsMZWCYo=", + "dev": true, + "requires": { + "lodash._getnative": "^3.0.0", + "lodash.isarguments": "^3.0.0", + "lodash.isarray": "^3.0.0" + } + }, + "lodash.memoize": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/lodash.memoize/-/lodash.memoize-4.1.2.tgz", + "integrity": "sha1-vMbEmkKihA7Zl/Mj6tpezRguC/4=" + }, + "lodash.uniq": { + "version": "4.5.0", + "resolved": "https://registry.npmjs.org/lodash.uniq/-/lodash.uniq-4.5.0.tgz", + "integrity": "sha1-0CJTc662Uq3BvILklFM5qEJ1R3M=" + }, + "log-symbols": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/log-symbols/-/log-symbols-2.2.0.tgz", + "integrity": "sha512-VeIAFslyIerEJLXHziedo2basKbMKtTw3vfn5IzG0XTjhAVEJyNHnL2p7vc+wBDSdQuUpNw3M2u6xb9QsAY5Eg==", + "dev": true, + "requires": { + "chalk": "^2.0.1" + }, + "dependencies": { + "ansi-styles": { + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz", + "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", + "dev": true, + "requires": { + "color-convert": "^1.9.0" + } + }, + "chalk": { + "version": "2.4.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz", + "integrity": "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==", + "dev": true, + "requires": { + "ansi-styles": "^3.2.1", + "escape-string-regexp": "^1.0.5", + "supports-color": "^5.3.0" + } + }, + "has-flag": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz", + "integrity": "sha1-tdRU3CGZriJWmfNGfloH87lVuv0=", + "dev": true + }, + "supports-color": { + "version": "5.5.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz", + "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==", + "dev": true, + "requires": { + "has-flag": "^3.0.0" + } + } + } + }, + "log4js": { + "version": "4.5.1", + "resolved": "https://registry.npmjs.org/log4js/-/log4js-4.5.1.tgz", + "integrity": "sha512-EEEgFcE9bLgaYUKuozyFfytQM2wDHtXn4tAN41pkaxpNjAykv11GVdeI4tHtmPWW4Xrgh9R/2d7XYghDVjbKKw==", + "dev": true, + "requires": { + "date-format": "^2.0.0", + "debug": "^4.1.1", + "flatted": "^2.0.0", + "rfdc": "^1.1.4", + "streamroller": "^1.0.6" + } + }, + "loglevelnext": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/loglevelnext/-/loglevelnext-1.0.5.tgz", + "integrity": "sha512-V/73qkPuJmx4BcBF19xPBr+0ZRVBhc4POxvZTZdMeXpJ4NItXSJ/MSwuFT0kQJlCbXvdlZoQQ/418bS1y9Jh6A==", + "dev": true, + "requires": { + "es6-symbol": "^3.1.1", + "object.assign": "^4.1.0" + } + }, + "lolex": { + "version": "1.6.0", + "resolved": "https://registry.npmjs.org/lolex/-/lolex-1.6.0.tgz", + "integrity": "sha1-OpoCg0UqR9dDnnJzG54H1zhuSfY=", + "dev": true + }, + "loud-rejection": { + "version": "1.6.0", + "resolved": "https://registry.npmjs.org/loud-rejection/-/loud-rejection-1.6.0.tgz", + "integrity": "sha1-W0b4AUft7leIcPCG0Eghz5mOVR8=", + "dev": true, + "requires": { + "currently-unhandled": "^0.4.1", + "signal-exit": "^3.0.0" + } + }, + "lowercase-keys": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/lowercase-keys/-/lowercase-keys-1.0.1.tgz", + "integrity": "sha512-G2Lj61tXDnVFFOi8VZds+SoQjtQC3dgokKdDG2mTm1tx4m50NUHBOZSBwQQHyy0V12A0JTG4icfZQH+xPyh8VA==", + "dev": true + }, + "lru-cache": { + "version": "4.1.5", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-4.1.5.tgz", + "integrity": "sha512-sWZlbEP2OsHNkXrMl5GYk/jKk70MBng6UU4YI/qGDYbgf6YbP4EvmqISbXCoJiRKs+1bSpFHVgQxvJ17F2li5g==", + "dev": true, + "requires": { + "pseudomap": "^1.0.2", + "yallist": "^2.1.2" + } + }, + "magic-string": { + "version": "0.22.5", + "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.22.5.tgz", + "integrity": "sha512-oreip9rJZkzvA8Qzk9HFs8fZGF/u7H/gtrE8EN6RjKJ9kh2HlC+yQ2QezifqTZfGyiuAV0dRv5a+y/8gBb1m9w==", + "dev": true, + "requires": { + "vlq": "^0.2.2" + } + }, + "make-dir": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/make-dir/-/make-dir-2.1.0.tgz", + "integrity": "sha512-LS9X+dc8KLxXCb8dni79fLIIUA5VyZoyjSMCwTluaXA0o27cCK0bhXkpgw+sTXVpPy/lSO57ilRixqk0vDmtRA==", + "dev": true, + "requires": { + "pify": "^4.0.1", + "semver": "^5.6.0" + }, + "dependencies": { + "pify": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/pify/-/pify-4.0.1.tgz", + "integrity": "sha512-uB80kBFb/tfd68bVleG9T5GGsGPjJrLAUpR5PZIrhBnIaRTQRjqdJSsIKkOP6OAIFbj7GOrcudc5pNjZ+geV2g==", + "dev": true + } + } + }, + "mamacro": { + "version": "0.0.3", + "resolved": "https://registry.npmjs.org/mamacro/-/mamacro-0.0.3.tgz", + "integrity": "sha512-qMEwh+UujcQ+kbz3T6V+wAmO2U8veoq2w+3wY8MquqwVA3jChfwY+Tk52GZKDfACEPjuZ7r2oJLejwpt8jtwTA==", + "dev": true + }, + "map-age-cleaner": { + "version": "0.1.3", + "resolved": "https://registry.npmjs.org/map-age-cleaner/-/map-age-cleaner-0.1.3.tgz", + "integrity": "sha512-bJzx6nMoP6PDLPBFmg7+xRKeFZvFboMrGlxmNj9ClvX53KrmvM5bXFXEWjbz4cz1AFn+jWJ9z/DJSz7hrs0w3w==", + "dev": true, + "requires": { + "p-defer": "^1.0.0" + } + }, + "map-cache": { + "version": "0.2.2", + "resolved": "https://registry.npmjs.org/map-cache/-/map-cache-0.2.2.tgz", + "integrity": "sha1-wyq9C9ZSXZsFFkW7TyasXcmKDb8=", + "dev": true + }, + "map-visit": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/map-visit/-/map-visit-1.0.0.tgz", + "integrity": "sha1-7Nyo8TFE5mDxtb1B8S80edmN+48=", + "dev": true, + "requires": { + "object-visit": "^1.0.0" + } + }, + "math-expression-evaluator": { + "version": "1.2.17", + "resolved": "https://registry.npmjs.org/math-expression-evaluator/-/math-expression-evaluator-1.2.17.tgz", + "integrity": "sha1-3oGf282E3M2PrlnGrreWFbnSZqw=" + }, + "md5.js": { + "version": "1.3.5", + "resolved": "https://registry.npmjs.org/md5.js/-/md5.js-1.3.5.tgz", + "integrity": "sha512-xitP+WxNPcTTOgnTJcrhM0xvdPepipPSf3I8EIpGKeFLjt3PlJLIDG3u8EX53ZIubkb+5U2+3rELYpEhHhzdkg==", + "dev": true, + "requires": { + "hash-base": "^3.0.0", + "inherits": "^2.0.1", + "safe-buffer": "^5.1.2" + } + }, + "media-typer": { + "version": "0.3.0", + "resolved": "https://registry.npmjs.org/media-typer/-/media-typer-0.3.0.tgz", + "integrity": "sha1-hxDXrwqmJvj/+hzgAWhUUmMlV0g=", + "dev": true + }, + "mem": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/mem/-/mem-4.3.0.tgz", + "integrity": "sha512-qX2bG48pTqYRVmDB37rn/6PT7LcR8T7oAX3bf99u1Tt1nzxYfxkgqDwUwolPlXweM0XzBOBFzSx4kfp7KP1s/w==", + "dev": true, + "requires": { + "map-age-cleaner": "^0.1.1", + "mimic-fn": "^2.0.0", + "p-is-promise": "^2.0.0" + }, + "dependencies": { + "mimic-fn": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/mimic-fn/-/mimic-fn-2.1.0.tgz", + "integrity": "sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg==", + "dev": true + } + } + }, + "memory-fs": { + "version": "0.4.1", + "resolved": "https://registry.npmjs.org/memory-fs/-/memory-fs-0.4.1.tgz", + "integrity": "sha1-OpoguEYlI+RHz7x+i7gO1me/xVI=", + "dev": true, + "requires": { + "errno": "^0.1.3", + "readable-stream": "^2.0.1" + } + }, + "memorystream": { + "version": "0.3.1", + "resolved": "https://registry.npmjs.org/memorystream/-/memorystream-0.3.1.tgz", + "integrity": "sha1-htcJCzDORV1j+64S3aUaR93K+bI=", + "dev": true + }, + "merge-source-map": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/merge-source-map/-/merge-source-map-1.0.4.tgz", + "integrity": "sha1-pd5GU42uhNQRTMXqArR3KmNGcB8=", + "dev": true, + "requires": { + "source-map": "^0.5.6" + } + }, + "merge-stream": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/merge-stream/-/merge-stream-2.0.0.tgz", + "integrity": "sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w==", + "dev": true + }, + "merge2": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/merge2/-/merge2-1.4.1.tgz", + "integrity": "sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==", + "dev": true + }, + "micromatch": { + "version": "3.1.10", + "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-3.1.10.tgz", + "integrity": "sha512-MWikgl9n9M3w+bpsY3He8L+w9eF9338xRl8IAO5viDizwSzziFEyUzo2xrrloB64ADbTf8uA8vRqqttDTOmccg==", + "dev": true, + "requires": { + "arr-diff": "^4.0.0", + "array-unique": "^0.3.2", + "braces": "^2.3.1", + "define-property": "^2.0.2", + "extend-shallow": "^3.0.2", + "extglob": "^2.0.4", + "fragment-cache": "^0.2.1", + "kind-of": "^6.0.2", + "nanomatch": "^1.2.9", + "object.pick": "^1.3.0", + "regex-not": "^1.0.0", + "snapdragon": "^0.8.1", + "to-regex": "^3.0.2" + }, + "dependencies": { + "braces": { + "version": "2.3.2", + "resolved": "https://registry.npmjs.org/braces/-/braces-2.3.2.tgz", + "integrity": "sha512-aNdbnj9P8PjdXU4ybaWLK2IF3jc/EoDYbC7AazW6to3TRsfXxscC9UXOB5iDiEQrkyIbWp2SLQda4+QAa7nc3w==", + "dev": true, + "requires": { + "arr-flatten": "^1.1.0", + "array-unique": "^0.3.2", + "extend-shallow": "^2.0.1", + "fill-range": "^4.0.0", + "isobject": "^3.0.1", + "repeat-element": "^1.1.2", + "snapdragon": "^0.8.1", + "snapdragon-node": "^2.0.1", + "split-string": "^3.0.2", + "to-regex": "^3.0.1" + }, + "dependencies": { + "extend-shallow": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz", + "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=", + "dev": true, + "requires": { + "is-extendable": "^0.1.0" + } + } + } + }, + "fill-range": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-4.0.0.tgz", + "integrity": "sha1-1USBHUKPmOsGpj3EAtJAPDKMOPc=", + "dev": true, + "requires": { + "extend-shallow": "^2.0.1", + "is-number": "^3.0.0", + "repeat-string": "^1.6.1", + "to-regex-range": "^2.1.0" + }, + "dependencies": { + "extend-shallow": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz", + "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=", + "dev": true, + "requires": { + "is-extendable": "^0.1.0" + } + } + } + }, + "is-number": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/is-number/-/is-number-3.0.0.tgz", + "integrity": "sha1-JP1iAaR4LPUFYcgQJ2r8fRLXEZU=", + "dev": true, + "requires": { + "kind-of": "^3.0.2" + }, + "dependencies": { + "kind-of": { + "version": "3.2.2", + "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz", + "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=", + "dev": true, + "requires": { + "is-buffer": "^1.1.5" + } + } + } + }, + "to-regex-range": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-2.1.1.tgz", + "integrity": "sha1-fIDBe53+vlmeJzZ+DU3VWQFB2zg=", + "dev": true, + "requires": { + "is-number": "^3.0.0", + "repeat-string": "^1.6.1" + } + } + } + }, + "miller-rabin": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/miller-rabin/-/miller-rabin-4.0.1.tgz", + "integrity": "sha512-115fLhvZVqWwHPbClyntxEVfVDfl9DLLTuJvq3g2O/Oxi8AiNouAHvDSzHS0viUJc+V5vm3eq91Xwqn9dp4jRA==", + "dev": true, + "requires": { + "bn.js": "^4.0.0", + "brorand": "^1.0.1" + } + }, + "mime": { + "version": "2.4.4", + "resolved": "https://registry.npmjs.org/mime/-/mime-2.4.4.tgz", + "integrity": "sha512-LRxmNwziLPT828z+4YkNzloCFC2YM4wrB99k+AV5ZbEyfGNWfG8SO1FUXLmLDBSo89NrJZ4DIWeLjy1CHGhMGA==", + "dev": true + }, + "mime-db": { + "version": "1.40.0", + "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.40.0.tgz", + "integrity": "sha512-jYdeOMPy9vnxEqFRRo6ZvTZ8d9oPb+k18PKoYNYUe2stVEBPPwsln/qWzdbmaIvnhZ9v2P+CuecK+fpUfsV2mA==", + "dev": true + }, + "mime-types": { + "version": "2.1.24", + "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.24.tgz", + "integrity": "sha512-WaFHS3MCl5fapm3oLxU4eYDw77IQM2ACcxQ9RIxfaC3ooc6PFuBMGZZsYpvoXS5D5QTWPieo1jjLdAm3TBP3cQ==", + "dev": true, + "requires": { + "mime-db": "1.40.0" + } + }, + "mimic-fn": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/mimic-fn/-/mimic-fn-1.2.0.tgz", + "integrity": "sha512-jf84uxzwiuiIVKiOLpfYk7N46TSy8ubTonmneY9vrpHNAnp0QBt2BxWV9dO3/j+BoVAb+a5G6YDPW3M5HOdMWQ==", + "dev": true + }, + "mimic-response": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/mimic-response/-/mimic-response-1.0.1.tgz", + "integrity": "sha512-j5EctnkH7amfV/q5Hgmoal1g2QHFJRraOtmx0JpIqkxhBhI/lJSl1nMpQ45hVarwNETOoWEimndZ4QK0RHxuxQ==", + "dev": true + }, + "mini-css-extract-plugin": { + "version": "1.3.9", + "resolved": "https://registry.npmjs.org/mini-css-extract-plugin/-/mini-css-extract-plugin-1.3.9.tgz", + "integrity": "sha512-Ac4s+xhVbqlyhXS5J/Vh/QXUz3ycXlCqoCPpg0vdfhsIBH9eg/It/9L1r1XhSCH737M1lqcWnMuWL13zcygn5A==", + "dev": true, + "requires": { + "loader-utils": "^2.0.0", + "schema-utils": "^3.0.0", + "webpack-sources": "^1.1.0" + }, + "dependencies": { + "ajv": { + "version": "6.12.6", + "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz", + "integrity": "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==", + "dev": true, + "requires": { + "fast-deep-equal": "^3.1.1", + "fast-json-stable-stringify": "^2.0.0", + "json-schema-traverse": "^0.4.1", + "uri-js": "^4.2.2" + } + }, + "ajv-keywords": { + "version": "3.5.2", + "resolved": "https://registry.npmjs.org/ajv-keywords/-/ajv-keywords-3.5.2.tgz", + "integrity": "sha512-5p6WTN0DdTGVQk6VjcEju19IgaHudalcfabD7yhDGeA6bcQnmL+CpveLJq/3hvfwd1aof6L386Ougkx6RfyMIQ==", + "dev": true + }, + "emojis-list": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/emojis-list/-/emojis-list-3.0.0.tgz", + "integrity": "sha512-/kyM18EfinwXZbno9FyUGeFh87KC8HRQBQGildHZbEuRyWFOmv1U10o9BBp8XVZDVNNuQKyIGIu5ZYAAXJ0V2Q==", + "dev": true + }, + "fast-deep-equal": { + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz", + "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==", + "dev": true + }, + "json5": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/json5/-/json5-2.2.0.tgz", + "integrity": "sha512-f+8cldu7X/y7RAJurMEJmdoKXGB/X550w2Nr3tTbezL6RwEE/iMcm+tZnXeoZtKuOq6ft8+CqzEkrIgx1fPoQA==", + "dev": true, + "requires": { + "minimist": "^1.2.5" + } + }, + "loader-utils": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/loader-utils/-/loader-utils-2.0.0.tgz", + "integrity": "sha512-rP4F0h2RaWSvPEkD7BLDFQnvSf+nK+wr3ESUjNTyAGobqrijmW92zc+SO6d4p4B1wh7+B/Jg1mkQe5NYUEHtHQ==", + "dev": true, + "requires": { + "big.js": "^5.2.2", + "emojis-list": "^3.0.0", + "json5": "^2.1.2" + } + }, + "minimist": { + "version": "1.2.5", + "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.5.tgz", + "integrity": "sha512-FM9nNUYrRBAELZQT3xeZQ7fmMOBg6nWNmJKTcgsJeaLstP/UODVpGsr5OhXhhXg6f+qtJ8uiZ+PUxkDWcgIXLw==", + "dev": true + }, + "schema-utils": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/schema-utils/-/schema-utils-3.0.0.tgz", + "integrity": "sha512-6D82/xSzO094ajanoOSbe4YvXWMfn2A//8Y1+MUqFAJul5Bs+yn36xbK9OtNDcRVSBJ9jjeoXftM6CfztsjOAA==", + "dev": true, + "requires": { + "@types/json-schema": "^7.0.6", + "ajv": "^6.12.5", + "ajv-keywords": "^3.5.2" + } + } + } + }, + "minimalistic-assert": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/minimalistic-assert/-/minimalistic-assert-1.0.1.tgz", + "integrity": "sha512-UtJcAD4yEaGtjPezWuO9wC4nwUnVH/8/Im3yEHQP4b67cXlD/Qr9hdITCU1xDbSEXg2XKNaP8jsReV7vQd00/A==", + "dev": true + }, + "minimalistic-crypto-utils": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/minimalistic-crypto-utils/-/minimalistic-crypto-utils-1.0.1.tgz", + "integrity": "sha1-9sAMHAsIIkblxNmd+4x8CDsrWCo=", + "dev": true + }, + "minimatch": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.0.4.tgz", + "integrity": "sha512-yJHVQEhyqPLUTgt9B83PXu6W3rx4MvvHvSUvToogpwoGDOUQ+yDrR0HRot+yOCdCO7u4hX3pWft6kWBBcqh0UA==", + "requires": { + "brace-expansion": "^1.1.7" + } + }, + "minimist": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.0.tgz", + "integrity": "sha1-o1AIsg9BOD7sH7kU9M1d95omQoQ=" + }, + "minipass": { + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/minipass/-/minipass-3.1.3.tgz", + "integrity": "sha512-Mgd2GdMVzY+x3IJ+oHnVM+KG3lA5c8tnabyJKmHSaG2kAGpudxuOf8ToDkhumF7UzME7DecbQE9uOZhNm7PuJg==", + "dev": true, + "requires": { + "yallist": "^4.0.0" + }, + "dependencies": { + "yallist": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz", + "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==", + "dev": true + } + } + }, + "minipass-collect": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/minipass-collect/-/minipass-collect-1.0.2.tgz", + "integrity": "sha512-6T6lH0H8OG9kITm/Jm6tdooIbogG9e0tLgpY6mphXSm/A9u8Nq1ryBG+Qspiub9LjWlBPsPS3tWQ/Botq4FdxA==", + "dev": true, + "requires": { + "minipass": "^3.0.0" + } + }, + "minipass-flush": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/minipass-flush/-/minipass-flush-1.0.5.tgz", + "integrity": "sha512-JmQSYYpPUqX5Jyn1mXaRwOda1uQ8HP5KAT/oDSLCzt1BYRhQU0/hDtsB1ufZfEEzMZ9aAVmsBw8+FWsIXlClWw==", + "dev": true, + "requires": { + "minipass": "^3.0.0" + } + }, + "minipass-pipeline": { + "version": "1.2.4", + "resolved": "https://registry.npmjs.org/minipass-pipeline/-/minipass-pipeline-1.2.4.tgz", + "integrity": "sha512-xuIq7cIOt09RPRJ19gdi4b+RiNvDFYe5JH+ggNvBqGqpQXcru3PcRmOZuHBKWK1Txf9+cQ+HMVN4d6z46LZP7A==", + "dev": true, + "requires": { + "minipass": "^3.0.0" + } + }, + "minizlib": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/minizlib/-/minizlib-2.1.2.tgz", + "integrity": "sha512-bAxsR8BVfj60DWXHE3u30oHzfl4G7khkSuPW+qvpd7jFRHm7dLxOjUk1EHACJ/hxLY8phGJ0YhYHZo7jil7Qdg==", + "dev": true, + "requires": { + "minipass": "^3.0.0", + "yallist": "^4.0.0" + }, + "dependencies": { + "yallist": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz", + "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==", + "dev": true + } + } + }, + "mississippi": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/mississippi/-/mississippi-3.0.0.tgz", + "integrity": "sha512-x471SsVjUtBRtcvd4BzKE9kFC+/2TeWgKCgw0bZcw1b9l2X3QX5vCWgF+KaZaYm87Ss//rHnWryupDrgLvmSkA==", + "dev": true, + "requires": { + "concat-stream": "^1.5.0", + "duplexify": "^3.4.2", + "end-of-stream": "^1.1.0", + "flush-write-stream": "^1.0.0", + "from2": "^2.1.0", + "parallel-transform": "^1.1.0", + "pump": "^3.0.0", + "pumpify": "^1.3.3", + "stream-each": "^1.1.0", + "through2": "^2.0.0" + } + }, + "mixin-deep": { + "version": "1.3.2", + "resolved": "https://registry.npmjs.org/mixin-deep/-/mixin-deep-1.3.2.tgz", + "integrity": "sha512-WRoDn//mXBiJ1H40rqa3vH0toePwSsGb45iInWlTySa+Uu4k3tYUSxa2v1KqAiLtvlrSzaExqS1gtk96A9zvEA==", + "dev": true, + "requires": { + "for-in": "^1.0.2", + "is-extendable": "^1.0.1" + }, + "dependencies": { + "is-extendable": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/is-extendable/-/is-extendable-1.0.1.tgz", + "integrity": "sha512-arnXMxT1hhoKo9k1LZdmlNyJdDDfy2v0fXjFlmok4+i8ul/6WlbVge9bhM74OpNPQPMGUToDtz+KXa1PneJxOA==", + "dev": true, + "requires": { + "is-plain-object": "^2.0.4" + } + } + } + }, + "mkdirp": { + "version": "0.5.1", + "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-0.5.1.tgz", + "integrity": "sha1-MAV0OOrGz3+MR2fzhkjWaX11yQM=", + "requires": { + "minimist": "0.0.8" + }, + "dependencies": { + "minimist": { + "version": "0.0.8", + "resolved": "https://registry.npmjs.org/minimist/-/minimist-0.0.8.tgz", + "integrity": "sha1-hX/Kv8M5fSYluCKCYuhqp6ARsF0=" + } + } + }, + "mocha": { + "version": "3.5.3", + "resolved": "https://registry.npmjs.org/mocha/-/mocha-3.5.3.tgz", + "integrity": "sha512-/6na001MJWEtYxHOV1WLfsmR4YIynkUEhBwzsb+fk2qmQ3iqsi258l/Q2MWHJMImAcNpZ8DEdYAK72NHoIQ9Eg==", + "dev": true, + "requires": { + "browser-stdout": "1.3.0", + "commander": "2.9.0", + "debug": "2.6.8", + "diff": "3.2.0", + "escape-string-regexp": "1.0.5", + "glob": "7.1.1", + "growl": "1.9.2", + "he": "1.1.1", + "json3": "3.3.2", + "lodash.create": "3.1.1", + "mkdirp": "0.5.1", + "supports-color": "3.1.2" + }, + "dependencies": { + "commander": { + "version": "2.9.0", + "resolved": "https://registry.npmjs.org/commander/-/commander-2.9.0.tgz", + "integrity": "sha1-nJkJQXbhIkDLItbFFGCYQA/g99Q=", + "dev": true, + "requires": { + "graceful-readlink": ">= 1.0.0" + } + }, + "debug": { + "version": "2.6.8", + "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.8.tgz", + "integrity": "sha1-5zFTHKLt4n0YgiJCfaF4IdaP9Pw=", + "dev": true, + "requires": { + "ms": "2.0.0" + } + }, + "glob": { + "version": "7.1.1", + "resolved": "https://registry.npmjs.org/glob/-/glob-7.1.1.tgz", + "integrity": "sha1-gFIR3wT6rxxjo2ADBs31reULLsg=", + "dev": true, + "requires": { + "fs.realpath": "^1.0.0", + "inflight": "^1.0.4", + "inherits": "2", + "minimatch": "^3.0.2", + "once": "^1.3.0", + "path-is-absolute": "^1.0.0" + } + }, + "ms": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", + "integrity": "sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g=", + "dev": true + }, + "supports-color": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-3.1.2.tgz", + "integrity": "sha1-cqJiiU2dQIuVbKBf83su2KbiotU=", + "dev": true, + "requires": { + "has-flag": "^1.0.0" + } + } + } + }, + "moment": { + "version": "2.24.0", + "resolved": "https://registry.npmjs.org/moment/-/moment-2.24.0.tgz", + "integrity": "sha512-bV7f+6l2QigeBBZSM/6yTNq4P2fNpSWj/0e7jQcy87A8e7o2nAfP/34/2ky5Vw4B9S446EtIhodAzkFCcR4dQg==" + }, + "move-concurrently": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/move-concurrently/-/move-concurrently-1.0.1.tgz", + "integrity": "sha1-viwAX9oy4LKa8fBdfEszIUxwH5I=", + "dev": true, + "requires": { + "aproba": "^1.1.1", + "copy-concurrently": "^1.0.0", + "fs-write-stream-atomic": "^1.0.8", + "mkdirp": "^0.5.1", + "rimraf": "^2.5.4", + "run-queue": "^1.0.3" + } + }, + "ms": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz", + "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==", + "dev": true + }, + "mustache": { + "version": "2.3.2", + "resolved": "https://registry.npmjs.org/mustache/-/mustache-2.3.2.tgz", + "integrity": "sha512-KpMNwdQsYz3O/SBS1qJ/o3sqUJ5wSb8gb0pul8CO0S56b9Y2ALm8zCfsjPXsqGFfoNBkDwZuZIAjhsZI03gYVQ==" + }, + "mute-stream": { + "version": "0.0.7", + "resolved": "https://registry.npmjs.org/mute-stream/-/mute-stream-0.0.7.tgz", + "integrity": "sha1-MHXOk7whuPq0PhvE2n6BFe0ee6s=", + "dev": true + }, + "nan": { + "version": "2.14.0", + "resolved": "https://registry.npmjs.org/nan/-/nan-2.14.0.tgz", + "integrity": "sha512-INOFj37C7k3AfaNTtX8RhsTw7qRy7eLET14cROi9+5HAVbbHuIWUHEauBv5qT4Av2tWasiTY1Jw6puUNqRJXQg==", + "dev": true, + "optional": true + }, + "nanoid": { + "version": "3.1.23", + "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.1.23.tgz", + "integrity": "sha512-FiB0kzdP0FFVGDKlRLEQ1BgDzU87dy5NnzjeW9YZNt+/c3+q82EQDUwniSAUxp/F0gFNI1ZhKU1FqYsMuqZVnw==", + "dev": true + }, + "nanomatch": { + "version": "1.2.13", + "resolved": "https://registry.npmjs.org/nanomatch/-/nanomatch-1.2.13.tgz", + "integrity": "sha512-fpoe2T0RbHwBTBUOftAfBPaDEi06ufaUai0mE6Yn1kacc3SnTErfb/h+X94VXzI64rKFHYImXSvdwGGCmwOqCA==", + "dev": true, + "requires": { + "arr-diff": "^4.0.0", + "array-unique": "^0.3.2", + "define-property": "^2.0.2", + "extend-shallow": "^3.0.2", + "fragment-cache": "^0.2.1", + "is-windows": "^1.0.2", + "kind-of": "^6.0.2", + "object.pick": "^1.3.0", + "regex-not": "^1.0.0", + "snapdragon": "^0.8.1", + "to-regex": "^3.0.1" + } + }, + "native-promise-only": { + "version": "0.8.1", + "resolved": "https://registry.npmjs.org/native-promise-only/-/native-promise-only-0.8.1.tgz", + "integrity": "sha1-IKMYwwy0X3H+et+/eyHJnBRy7xE=", + "dev": true + }, + "natural-compare": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/natural-compare/-/natural-compare-1.4.0.tgz", + "integrity": "sha1-Sr6/7tdUHywnrPspvbvRXI1bpPc=", + "dev": true + }, + "ndarray": { + "version": "1.0.18", + "resolved": "https://registry.npmjs.org/ndarray/-/ndarray-1.0.18.tgz", + "integrity": "sha1-tg06cyJOxVXQ+qeXEeUCRI/T95M=", + "requires": { + "iota-array": "^1.0.0", + "is-buffer": "^1.0.2" + } + }, + "ndarray-pack": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/ndarray-pack/-/ndarray-pack-1.2.1.tgz", + "integrity": "sha1-jK6+qqJNXs9w/4YCBjeXfajuWFo=", + "requires": { + "cwise-compiler": "^1.1.2", + "ndarray": "^1.0.13" + } + }, + "negotiator": { + "version": "0.6.2", + "resolved": "https://registry.npmjs.org/negotiator/-/negotiator-0.6.2.tgz", + "integrity": "sha512-hZXc7K2e+PgeI1eDBe/10Ard4ekbfrrqG8Ep+8Jmf4JID2bNg7NvCPOZN+kfF574pFQI7mum2AUqDidoKqcTOw==", + "dev": true + }, + "neo-async": { + "version": "2.6.1", + "resolved": "https://registry.npmjs.org/neo-async/-/neo-async-2.6.1.tgz", + "integrity": "sha512-iyam8fBuCUpWeKPGpaNMetEocMt364qkCsfL9JuhjXX6dRnguRVOfk2GZaDpPjcOKiiXCPINZC1GczQ7iTq3Zw==", + "dev": true + }, + "next-tick": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/next-tick/-/next-tick-1.0.0.tgz", + "integrity": "sha1-yobR/ogoFpsBICCOPchCS524NCw=", + "dev": true + }, + "nice-try": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/nice-try/-/nice-try-1.0.5.tgz", + "integrity": "sha512-1nh45deeb5olNY7eX82BkPO7SSxR5SSYJiPTrTdFUVYwAl8CKMA5N9PjTYkHiRjisVcxcQ1HXdLhx2qxxJzLNQ==", + "dev": true + }, + "node-fetch": { + "version": "2.6.0", + "resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-2.6.0.tgz", + "integrity": "sha512-8dG4H5ujfvFiqDmVu9fQ5bOHUC15JMjMY/Zumv26oOvvVJjM67KF8koCWIabKQ1GJIa9r2mMZscBq/TbdOcmNA==" + }, + "node-libs-browser": { + "version": "2.2.1", + "resolved": "https://registry.npmjs.org/node-libs-browser/-/node-libs-browser-2.2.1.tgz", + "integrity": "sha512-h/zcD8H9kaDZ9ALUWwlBUDo6TKF8a7qBSCSEGfjTVIYeqsioSKaAX+BN7NgiMGp6iSIXZ3PxgCu8KS3b71YK5Q==", + "dev": true, + "requires": { + "assert": "^1.1.1", + "browserify-zlib": "^0.2.0", + "buffer": "^4.3.0", + "console-browserify": "^1.1.0", + "constants-browserify": "^1.0.0", + "crypto-browserify": "^3.11.0", + "domain-browser": "^1.1.1", + "events": "^3.0.0", + "https-browserify": "^1.0.0", + "os-browserify": "^0.3.0", + "path-browserify": "0.0.1", + "process": "^0.11.10", + "punycode": "^1.2.4", + "querystring-es3": "^0.2.0", + "readable-stream": "^2.3.3", + "stream-browserify": "^2.0.1", + "stream-http": "^2.7.2", + "string_decoder": "^1.0.0", + "timers-browserify": "^2.0.4", + "tty-browserify": "0.0.0", + "url": "^0.11.0", + "util": "^0.11.0", + "vm-browserify": "^1.0.1" + }, + "dependencies": { + "punycode": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/punycode/-/punycode-1.4.1.tgz", + "integrity": "sha1-wNWmOycYgArY4esPpSachN1BhF4=", + "dev": true + } + } + }, + "node-releases": { + "version": "1.1.72", + "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-1.1.72.tgz", + "integrity": "sha512-LLUo+PpH3dU6XizX3iVoubUNheF/owjXCZZ5yACDxNnPtgFuludV1ZL3ayK1kVep42Rmm0+R9/Y60NQbZ2bifw==", + "dev": true + }, + "normalize-package-data": { + "version": "2.5.0", + "resolved": "https://registry.npmjs.org/normalize-package-data/-/normalize-package-data-2.5.0.tgz", + "integrity": "sha512-/5CMN3T0R4XTj4DcGaexo+roZSdSFW/0AOOTROrjxzCG1wrWXEsGbRKevjlIL+ZDE4sZlJr5ED4YW0yqmkK+eA==", + "dev": true, + "requires": { + "hosted-git-info": "^2.1.4", + "resolve": "^1.10.0", + "semver": "2 || 3 || 4 || 5", + "validate-npm-package-license": "^3.0.1" + } + }, + "normalize-path": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz", + "integrity": "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==", + "dev": true + }, + "normalize-range": { + "version": "0.1.2", + "resolved": "https://registry.npmjs.org/normalize-range/-/normalize-range-0.1.2.tgz", + "integrity": "sha1-LRDAa9/TEuqXd2laTShDlFa3WUI=" + }, + "normalize-url": { + "version": "1.9.1", + "resolved": "https://registry.npmjs.org/normalize-url/-/normalize-url-1.9.1.tgz", + "integrity": "sha1-LMDWazHqIwNkWENuNiDYWVTGbDw=", + "requires": { + "object-assign": "^4.0.1", + "prepend-http": "^1.0.0", + "query-string": "^4.1.0", + "sort-keys": "^1.0.0" + } + }, + "npm-run-all": { + "version": "4.1.5", + "resolved": "https://registry.npmjs.org/npm-run-all/-/npm-run-all-4.1.5.tgz", + "integrity": "sha512-Oo82gJDAVcaMdi3nuoKFavkIHBRVqQ1qvMb+9LHk/cF4P6B2m8aP04hGf7oL6wZ9BuGwX1onlLhpuoofSyoQDQ==", + "dev": true, + "requires": { + "ansi-styles": "^3.2.1", + "chalk": "^2.4.1", + "cross-spawn": "^6.0.5", + "memorystream": "^0.3.1", + "minimatch": "^3.0.4", + "pidtree": "^0.3.0", + "read-pkg": "^3.0.0", + "shell-quote": "^1.6.1", + "string.prototype.padend": "^3.0.0" + }, + "dependencies": { + "ansi-styles": { + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz", + "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", + "dev": true, + "requires": { + "color-convert": "^1.9.0" + } + }, + "chalk": { + "version": "2.4.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz", + "integrity": "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==", + "dev": true, + "requires": { + "ansi-styles": "^3.2.1", + "escape-string-regexp": "^1.0.5", + "supports-color": "^5.3.0" + } + }, + "has-flag": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz", + "integrity": "sha1-tdRU3CGZriJWmfNGfloH87lVuv0=", + "dev": true + }, + "load-json-file": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/load-json-file/-/load-json-file-4.0.0.tgz", + "integrity": "sha1-L19Fq5HjMhYjT9U62rZo607AmTs=", + "dev": true, + "requires": { + "graceful-fs": "^4.1.2", + "parse-json": "^4.0.0", + "pify": "^3.0.0", + "strip-bom": "^3.0.0" + } + }, + "parse-json": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/parse-json/-/parse-json-4.0.0.tgz", + "integrity": "sha1-vjX1Qlvh9/bHRxhPmKeIy5lHfuA=", + "dev": true, + "requires": { + "error-ex": "^1.3.1", + "json-parse-better-errors": "^1.0.1" + } + }, + "path-type": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/path-type/-/path-type-3.0.0.tgz", + "integrity": "sha512-T2ZUsdZFHgA3u4e5PfPbjd7HDDpxPnQb5jN0SrDsjNSuVXHJqtwTnWqG0B1jZrgmJ/7lj1EmVIByWt1gxGkWvg==", + "dev": true, + "requires": { + "pify": "^3.0.0" + } + }, + "pify": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/pify/-/pify-3.0.0.tgz", + "integrity": "sha1-5aSs0sEB/fPZpNB/DbxNtJ3SgXY=", + "dev": true + }, + "read-pkg": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/read-pkg/-/read-pkg-3.0.0.tgz", + "integrity": "sha1-nLxoaXj+5l0WwA4rGcI3/Pbjg4k=", + "dev": true, + "requires": { + "load-json-file": "^4.0.0", + "normalize-package-data": "^2.3.2", + "path-type": "^3.0.0" + } + }, + "supports-color": { + "version": "5.5.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz", + "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==", + "dev": true, + "requires": { + "has-flag": "^3.0.0" + } + } + } + }, + "npm-run-path": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/npm-run-path/-/npm-run-path-2.0.2.tgz", + "integrity": "sha1-NakjLfo11wZ7TLLd8jV7GHFTbF8=", + "dev": true, + "requires": { + "path-key": "^2.0.0" + } + }, + "null-check": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/null-check/-/null-check-1.0.0.tgz", + "integrity": "sha1-l33/1xdgErnsMNKjnbXPcqBDnt0=", + "dev": true + }, + "num2fraction": { + "version": "1.2.2", + "resolved": "https://registry.npmjs.org/num2fraction/-/num2fraction-1.2.2.tgz", + "integrity": "sha1-b2gragJ6Tp3fpFZM0lidHU5mnt4=" + }, + "object-assign": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz", + "integrity": "sha1-IQmtx5ZYh8/AXLvUQsrIv7s2CGM=" + }, + "object-component": { + "version": "0.0.3", + "resolved": "https://registry.npmjs.org/object-component/-/object-component-0.0.3.tgz", + "integrity": "sha1-8MaapQ78lbhmwYb0AKM3acsvEpE=", + "dev": true + }, + "object-copy": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/object-copy/-/object-copy-0.1.0.tgz", + "integrity": "sha1-fn2Fi3gb18mRpBupde04EnVOmYw=", + "dev": true, + "requires": { + "copy-descriptor": "^0.1.0", + "define-property": "^0.2.5", + "kind-of": "^3.0.3" + }, + "dependencies": { + "define-property": { + "version": "0.2.5", + "resolved": "https://registry.npmjs.org/define-property/-/define-property-0.2.5.tgz", + "integrity": "sha1-w1se+RjsPJkPmlvFe+BKrOxcgRY=", + "dev": true, + "requires": { + "is-descriptor": "^0.1.0" + } + }, + "kind-of": { + "version": "3.2.2", + "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz", + "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=", + "dev": true, + "requires": { + "is-buffer": "^1.1.5" + } + } + } + }, + "object-inspect": { + "version": "1.6.0", + "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.6.0.tgz", + "integrity": "sha512-GJzfBZ6DgDAmnuaM3104jR4s1Myxr3Y3zfIyN4z3UdqN69oSRacNK8UhnobDdC+7J2AHCjGwxQubNJfE70SXXQ==", + "dev": true + }, + "object-keys": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/object-keys/-/object-keys-1.1.1.tgz", + "integrity": "sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==", + "dev": true + }, + "object-visit": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/object-visit/-/object-visit-1.0.1.tgz", + "integrity": "sha1-95xEk68MU3e1n+OdOV5BBC3QRbs=", + "dev": true, + "requires": { + "isobject": "^3.0.0" + } + }, + "object.assign": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/object.assign/-/object.assign-4.1.0.tgz", + "integrity": "sha512-exHJeq6kBKj58mqGyTQ9DFvrZC/eR6OwxzoM9YRoGBqrXYonaFyGiFMuc9VZrXf7DarreEwMpurG3dd+CNyW5w==", + "dev": true, + "requires": { + "define-properties": "^1.1.2", + "function-bind": "^1.1.1", + "has-symbols": "^1.0.0", + "object-keys": "^1.0.11" + } + }, + "object.pick": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/object.pick/-/object.pick-1.3.0.tgz", + "integrity": "sha1-h6EKxMFpS9Lhy/U1kaZhQftd10c=", + "dev": true, + "requires": { + "isobject": "^3.0.1" + } + }, + "object.values": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/object.values/-/object.values-1.1.0.tgz", + "integrity": "sha512-8mf0nKLAoFX6VlNVdhGj31SVYpaNFtUnuoOXWyFEstsWRgU837AK+JYM0iAxwkSzGRbwn8cbFmgbyxj1j4VbXg==", + "dev": true, + "requires": { + "define-properties": "^1.1.3", + "es-abstract": "^1.12.0", + "function-bind": "^1.1.1", + "has": "^1.0.3" + } + }, + "on-finished": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/on-finished/-/on-finished-2.3.0.tgz", + "integrity": "sha1-IPEzZIGwg811M3mSoWlxqi2QaUc=", + "dev": true, + "requires": { + "ee-first": "1.1.1" + } + }, + "once": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz", + "integrity": "sha1-WDsap3WWHUsROsF9nFC6753Xa9E=", + "requires": { + "wrappy": "1" + } + }, + "onetime": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/onetime/-/onetime-2.0.1.tgz", + "integrity": "sha1-BnQoIw/WdEOyeUsiu6UotoZ5YtQ=", + "dev": true, + "requires": { + "mimic-fn": "^1.0.0" + } + }, + "optimist": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/optimist/-/optimist-0.6.1.tgz", + "integrity": "sha1-2j6nRob6IaGaERwybpDrFaAZZoY=", + "dev": true, + "requires": { + "minimist": "~0.0.1", + "wordwrap": "~0.0.2" + }, + "dependencies": { + "minimist": { + "version": "0.0.10", + "resolved": "https://registry.npmjs.org/minimist/-/minimist-0.0.10.tgz", + "integrity": "sha1-3j+YVD2/lggr5IrRoMfNqDYwHc8=", + "dev": true + }, + "wordwrap": { + "version": "0.0.3", + "resolved": "https://registry.npmjs.org/wordwrap/-/wordwrap-0.0.3.tgz", + "integrity": "sha1-o9XabNXAvAAI03I0u68b7WMFkQc=", + "dev": true + } + } + }, + "optionator": { + "version": "0.8.2", + "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.8.2.tgz", + "integrity": "sha1-NkxeQJ0/TWMB1sC0wFu6UBgK62Q=", + "dev": true, + "requires": { + "deep-is": "~0.1.3", + "fast-levenshtein": "~2.0.4", + "levn": "~0.3.0", + "prelude-ls": "~1.1.2", + "type-check": "~0.3.2", + "wordwrap": "~1.0.0" + } + }, + "os-browserify": { + "version": "0.3.0", + "resolved": "https://registry.npmjs.org/os-browserify/-/os-browserify-0.3.0.tgz", + "integrity": "sha1-hUNzx/XCMVkU/Jv8a9gjj92h7Cc=", + "dev": true + }, + "os-locale": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/os-locale/-/os-locale-3.1.0.tgz", + "integrity": "sha512-Z8l3R4wYWM40/52Z+S265okfFj8Kt2cC2MKY+xNi3kFs+XGI7WXu/I309QQQYbRW4ijiZ+yxs9pqEhJh0DqW3Q==", + "dev": true, + "requires": { + "execa": "^1.0.0", + "lcid": "^2.0.0", + "mem": "^4.0.0" + } + }, + "os-tmpdir": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/os-tmpdir/-/os-tmpdir-1.0.2.tgz", + "integrity": "sha1-u+Z0BseaqFxc/sdm/lc0VV36EnQ=", + "dev": true + }, + "p-cancelable": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/p-cancelable/-/p-cancelable-1.1.0.tgz", + "integrity": "sha512-s73XxOZ4zpt1edZYZzvhqFa6uvQc1vwUa0K0BdtIZgQMAJj9IbebH+JkgKZc9h+B05PKHLOTl4ajG1BmNrVZlw==", + "dev": true + }, + "p-defer": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/p-defer/-/p-defer-1.0.0.tgz", + "integrity": "sha1-n26xgvbJqozXQwBKfU+WsZaw+ww=", + "dev": true + }, + "p-finally": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/p-finally/-/p-finally-1.0.0.tgz", + "integrity": "sha1-P7z7FbiZpEEjs0ttzBi3JDNqLK4=", + "dev": true + }, + "p-is-promise": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/p-is-promise/-/p-is-promise-2.1.0.tgz", + "integrity": "sha512-Y3W0wlRPK8ZMRbNq97l4M5otioeA5lm1z7bkNkxCka8HSPjR0xRWmpCmc9utiaLP9Jb1eD8BgeIxTW4AIF45Pg==", + "dev": true + }, + "p-limit": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-1.3.0.tgz", + "integrity": "sha512-vvcXsLAJ9Dr5rQOPk7toZQZJApBl2K4J6dANSsEuh6QI41JYcsS/qhTGa9ErIUUgK3WNQoJYvylxvjqmiqEA9Q==", + "dev": true, + "requires": { + "p-try": "^1.0.0" + } + }, + "p-locate": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-2.0.0.tgz", + "integrity": "sha1-IKAQOyIqcMj9OcwuWAaA893l7EM=", + "dev": true, + "requires": { + "p-limit": "^1.1.0" + } + }, + "p-map": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/p-map/-/p-map-4.0.0.tgz", + "integrity": "sha512-/bjOqmgETBYB5BoEeGVea8dmvHb2m9GLy1E9W43yeyfP6QQCZGFNa+XRceJEuDB6zqr+gKpIAmlLebMpykw/MQ==", + "dev": true, + "requires": { + "aggregate-error": "^3.0.0" + } + }, + "p-try": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/p-try/-/p-try-1.0.0.tgz", + "integrity": "sha1-y8ec26+P1CKOE/Yh8rGiN8GyB7M=", + "dev": true + }, + "package-json": { + "version": "6.5.0", + "resolved": "https://registry.npmjs.org/package-json/-/package-json-6.5.0.tgz", + "integrity": "sha512-k3bdm2n25tkyxcjSKzB5x8kfVxlMdgsbPr0GkZcwHsLpba6cBjqCt1KlcChKEvxHIcTB1FVMuwoijZ26xex5MQ==", + "dev": true, + "requires": { + "got": "^9.6.0", + "registry-auth-token": "^4.0.0", + "registry-url": "^5.0.0", + "semver": "^6.2.0" + }, + "dependencies": { + "semver": { + "version": "6.3.0", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.0.tgz", + "integrity": "sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==", + "dev": true + } + } + }, + "pako": { + "version": "1.0.10", + "resolved": "https://registry.npmjs.org/pako/-/pako-1.0.10.tgz", + "integrity": "sha512-0DTvPVU3ed8+HNXOu5Bs+o//Mbdj9VNQMUOe9oKCwh8l0GNwpTDMKCWbRjgtD291AWnkAgkqA/LOnQS8AmS1tw==", + "dev": true + }, + "parallel-transform": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/parallel-transform/-/parallel-transform-1.2.0.tgz", + "integrity": "sha512-P2vSmIu38uIlvdcU7fDkyrxj33gTUy/ABO5ZUbGowxNCopBq/OoD42bP4UmMrJoPyk4Uqf0mu3mtWBhHCZD8yg==", + "dev": true, + "requires": { + "cyclist": "^1.0.1", + "inherits": "^2.0.3", + "readable-stream": "^2.1.5" + } + }, + "parent-module": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/parent-module/-/parent-module-1.0.1.tgz", + "integrity": "sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==", + "dev": true, + "requires": { + "callsites": "^3.0.0" + } + }, + "parse-asn1": { + "version": "5.1.5", + "resolved": "https://registry.npmjs.org/parse-asn1/-/parse-asn1-5.1.5.tgz", + "integrity": "sha512-jkMYn1dcJqF6d5CpU689bq7w/b5ALS9ROVSpQDPrZsqqesUJii9qutvoT5ltGedNXMO2e16YUWIghG9KxaViTQ==", + "dev": true, + "requires": { + "asn1.js": "^4.0.0", + "browserify-aes": "^1.0.0", + "create-hash": "^1.1.0", + "evp_bytestokey": "^1.0.0", + "pbkdf2": "^3.0.3", + "safe-buffer": "^5.1.1" + } + }, + "parse-json": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/parse-json/-/parse-json-2.2.0.tgz", + "integrity": "sha1-9ID0BDTvgHQfhGkJn43qGPVaTck=", + "dev": true, + "requires": { + "error-ex": "^1.2.0" + } + }, + "parse-passwd": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/parse-passwd/-/parse-passwd-1.0.0.tgz", + "integrity": "sha1-bVuTSkVpk7I9N/QKOC1vFmao5cY=", + "dev": true + }, + "parseqs": { + "version": "0.0.5", + "resolved": "https://registry.npmjs.org/parseqs/-/parseqs-0.0.5.tgz", + "integrity": "sha1-1SCKNzjkZ2bikbouoXNoSSGouJ0=", + "dev": true, + "requires": { + "better-assert": "~1.0.0" + } + }, + "parseuri": { + "version": "0.0.5", + "resolved": "https://registry.npmjs.org/parseuri/-/parseuri-0.0.5.tgz", + "integrity": "sha1-gCBKUNTbt3m/3G6+J3jZDkvOMgo=", + "dev": true, + "requires": { + "better-assert": "~1.0.0" + } + }, + "parseurl": { + "version": "1.3.3", + "resolved": "https://registry.npmjs.org/parseurl/-/parseurl-1.3.3.tgz", + "integrity": "sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ==", + "dev": true + }, + "pascalcase": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/pascalcase/-/pascalcase-0.1.1.tgz", + "integrity": "sha1-s2PlXoAGym/iF4TS2yK9FdeRfxQ=", + "dev": true + }, + "path-browserify": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/path-browserify/-/path-browserify-0.0.1.tgz", + "integrity": "sha512-BapA40NHICOS+USX9SN4tyhq+A2RrN/Ws5F0Z5aMHDp98Fl86lX8Oti8B7uN93L4Ifv4fHOEA+pQw87gmMO/lQ==", + "dev": true + }, + "path-dirname": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/path-dirname/-/path-dirname-1.0.2.tgz", + "integrity": "sha1-zDPSTVJeCZpTiMAzbG4yuRYGCeA=", + "dev": true + }, + "path-exists": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-3.0.0.tgz", + "integrity": "sha1-zg6+ql94yxiSXqfYENe1mwEP1RU=", + "dev": true + }, + "path-is-absolute": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz", + "integrity": "sha1-F0uSaHNVNP+8es5r9TpanhtcX18=" + }, + "path-is-inside": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/path-is-inside/-/path-is-inside-1.0.2.tgz", + "integrity": "sha1-NlQX3t5EQw0cEa9hAn+s8HS9/FM=", + "dev": true + }, + "path-key": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/path-key/-/path-key-2.0.1.tgz", + "integrity": "sha1-QRyttXTFoUDTpLGRDUDYDMn0C0A=", + "dev": true + }, + "path-parse": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.6.tgz", + "integrity": "sha512-GSmOT2EbHrINBf9SR7CDELwlJ8AENk3Qn7OikK4nFYAu3Ote2+JYNVvkpAEQm3/TLNEJFD/xZJjzyxg3KBWOzw==" + }, + "path-posix": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/path-posix/-/path-posix-1.0.0.tgz", + "integrity": "sha1-BrJhE/Vr6rBCVFojv6iAA8ysJg8=" + }, + "path-to-regexp": { + "version": "1.7.0", + "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-1.7.0.tgz", + "integrity": "sha1-Wf3g9DW62suhA6hOnTvGTpa5k30=", + "dev": true, + "requires": { + "isarray": "0.0.1" + }, + "dependencies": { + "isarray": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/isarray/-/isarray-0.0.1.tgz", + "integrity": "sha1-ihis/Kmo9Bd+Cav8YDiTmwXR7t8=", + "dev": true + } + } + }, + "path-type": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/path-type/-/path-type-2.0.0.tgz", + "integrity": "sha1-8BLMuEFbcJb8LaoQVMPXI4lZTHM=", + "dev": true, + "requires": { + "pify": "^2.0.0" + } + }, + "pathval": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/pathval/-/pathval-1.1.0.tgz", + "integrity": "sha1-uULm1L3mUwBe9rcTYd74cn0GReA=", + "dev": true + }, + "pbkdf2": { + "version": "3.0.17", + "resolved": "https://registry.npmjs.org/pbkdf2/-/pbkdf2-3.0.17.tgz", + "integrity": "sha512-U/il5MsrZp7mGg3mSQfn742na2T+1/vHDCG5/iTI3X9MKUuYUZVLQhyRsg06mCgDBTd57TxzgZt7P+fYfjRLtA==", + "dev": true, + "requires": { + "create-hash": "^1.1.2", + "create-hmac": "^1.1.4", + "ripemd160": "^2.0.1", + "safe-buffer": "^5.0.1", + "sha.js": "^2.4.8" + } + }, + "picomatch": { + "version": "2.0.7", + "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.0.7.tgz", + "integrity": "sha512-oLHIdio3tZ0qH76NybpeneBhYVj0QFTfXEFTc/B3zKQspYfYYkWYgFsmzo+4kvId/bQRcNkVeguI3y+CD22BtA==", + "dev": true + }, + "pidtree": { + "version": "0.3.0", + "resolved": "https://registry.npmjs.org/pidtree/-/pidtree-0.3.0.tgz", + "integrity": "sha512-9CT4NFlDcosssyg8KVFltgokyKZIFjoBxw8CTGy+5F38Y1eQWrt8tRayiUOXE+zVKQnYu5BR8JjCtvK3BcnBhg==", + "dev": true + }, + "pify": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/pify/-/pify-2.3.0.tgz", + "integrity": "sha1-7RQaasBDqEnqWISY59yosVMw6Qw=", + "dev": true + }, + "pkg-dir": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/pkg-dir/-/pkg-dir-2.0.0.tgz", + "integrity": "sha1-9tXREJ4Z1j7fQo4L1X4Sd3YVM0s=", + "dev": true, + "requires": { + "find-up": "^2.1.0" + } + }, + "popper.js": { + "version": "1.16.1", + "resolved": "https://registry.npmjs.org/popper.js/-/popper.js-1.16.1.tgz", + "integrity": "sha512-Wb4p1J4zyFTbM+u6WuO4XstYx4Ky9Cewe4DWrel7B0w6VVICvPwdOpotjzcf6eD8TsckVnIMNONQyPIUFOUbCQ==", + "dev": true + }, + "posix-character-classes": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/posix-character-classes/-/posix-character-classes-0.1.1.tgz", + "integrity": "sha1-AerA/jta9xoqbAL+q7jB/vfgDqs=", + "dev": true + }, + "postcss": { + "version": "5.2.18", + "resolved": "https://registry.npmjs.org/postcss/-/postcss-5.2.18.tgz", + "integrity": "sha512-zrUjRRe1bpXKsX1qAJNJjqZViErVuyEkMTRrwu4ud4sbTtIBRmtaYDrHmcGgmrbsW3MHfmtIf+vJumgQn+PrXg==", + "requires": { + "chalk": "^1.1.3", + "js-base64": "^2.1.9", + "source-map": "^0.5.6", + "supports-color": "^3.2.3" + }, + "dependencies": { + "supports-color": { + "version": "3.2.3", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-3.2.3.tgz", + "integrity": "sha1-ZawFBLOVQXHYpklGsq48u4pfVPY=", + "requires": { + "has-flag": "^1.0.0" + } + } + } + }, + "postcss-calc": { + "version": "5.3.1", + "resolved": "https://registry.npmjs.org/postcss-calc/-/postcss-calc-5.3.1.tgz", + "integrity": "sha1-d7rnypKK2FcW4v2kLyYb98HWW14=", + "requires": { + "postcss": "^5.0.2", + "postcss-message-helpers": "^2.0.0", + "reduce-css-calc": "^1.2.6" + } + }, + "postcss-colormin": { + "version": "2.2.2", + "resolved": "https://registry.npmjs.org/postcss-colormin/-/postcss-colormin-2.2.2.tgz", + "integrity": "sha1-ZjFBfV8OkJo9fsJrJMio0eT5bks=", + "requires": { + "colormin": "^1.0.5", + "postcss": "^5.0.13", + "postcss-value-parser": "^3.2.3" + } + }, + "postcss-convert-values": { + "version": "2.6.1", + "resolved": "https://registry.npmjs.org/postcss-convert-values/-/postcss-convert-values-2.6.1.tgz", + "integrity": "sha1-u9hZPFwf0uPRwyK7kl3K6Nrk1i0=", + "requires": { + "postcss": "^5.0.11", + "postcss-value-parser": "^3.1.2" + } + }, + "postcss-discard-comments": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/postcss-discard-comments/-/postcss-discard-comments-2.0.4.tgz", + "integrity": "sha1-vv6J+v1bPazlzM5Rt2uBUUvgDj0=", + "requires": { + "postcss": "^5.0.14" + } + }, + "postcss-discard-duplicates": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/postcss-discard-duplicates/-/postcss-discard-duplicates-2.1.0.tgz", + "integrity": "sha1-uavye4isGIFYpesSq8riAmO5GTI=", + "requires": { + "postcss": "^5.0.4" + } + }, + "postcss-discard-empty": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/postcss-discard-empty/-/postcss-discard-empty-2.1.0.tgz", + "integrity": "sha1-0rS9nVztXr2Nyt52QMfXzX9PkrU=", + "requires": { + "postcss": "^5.0.14" + } + }, + "postcss-discard-overridden": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/postcss-discard-overridden/-/postcss-discard-overridden-0.1.1.tgz", + "integrity": "sha1-ix6vVU9ob7KIzYdMVWZ7CqNmjVg=", + "requires": { + "postcss": "^5.0.16" + } + }, + "postcss-discard-unused": { + "version": "2.2.3", + "resolved": "https://registry.npmjs.org/postcss-discard-unused/-/postcss-discard-unused-2.2.3.tgz", + "integrity": "sha1-vOMLLMWR/8Y0Mitfs0ZLbZNPRDM=", + "requires": { + "postcss": "^5.0.14", + "uniqs": "^2.0.0" + } + }, + "postcss-filter-plugins": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/postcss-filter-plugins/-/postcss-filter-plugins-2.0.3.tgz", + "integrity": "sha512-T53GVFsdinJhgwm7rg1BzbeBRomOg9y5MBVhGcsV0CxurUdVj1UlPdKtn7aqYA/c/QVkzKMjq2bSV5dKG5+AwQ==", + "requires": { + "postcss": "^5.0.4" + } + }, + "postcss-merge-idents": { + "version": "2.1.7", + "resolved": "https://registry.npmjs.org/postcss-merge-idents/-/postcss-merge-idents-2.1.7.tgz", + "integrity": "sha1-TFUwMTwI4dWzu/PSu8dH4njuonA=", + "requires": { + "has": "^1.0.1", + "postcss": "^5.0.10", + "postcss-value-parser": "^3.1.1" + } + }, + "postcss-merge-longhand": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/postcss-merge-longhand/-/postcss-merge-longhand-2.0.2.tgz", + "integrity": "sha1-I9kM0Sewp3mUkVMyc5A0oaTz1lg=", + "requires": { + "postcss": "^5.0.4" + } + }, + "postcss-merge-rules": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/postcss-merge-rules/-/postcss-merge-rules-2.1.2.tgz", + "integrity": "sha1-0d9d+qexrMO+VT8OnhDofGG19yE=", + "requires": { + "browserslist": "^1.5.2", + "caniuse-api": "^1.5.2", + "postcss": "^5.0.4", + "postcss-selector-parser": "^2.2.2", + "vendors": "^1.0.0" + } + }, + "postcss-message-helpers": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/postcss-message-helpers/-/postcss-message-helpers-2.0.0.tgz", + "integrity": "sha1-pPL0+rbk/gAvCu0ABHjN9S+bpg4=" + }, + "postcss-minify-font-values": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/postcss-minify-font-values/-/postcss-minify-font-values-1.0.5.tgz", + "integrity": "sha1-S1jttWZB66fIR0qzUmyv17vey2k=", + "requires": { + "object-assign": "^4.0.1", + "postcss": "^5.0.4", + "postcss-value-parser": "^3.0.2" + } + }, + "postcss-minify-gradients": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/postcss-minify-gradients/-/postcss-minify-gradients-1.0.5.tgz", + "integrity": "sha1-Xb2hE3NwP4PPtKPqOIHY11/15uE=", + "requires": { + "postcss": "^5.0.12", + "postcss-value-parser": "^3.3.0" + } + }, + "postcss-minify-params": { + "version": "1.2.2", + "resolved": "https://registry.npmjs.org/postcss-minify-params/-/postcss-minify-params-1.2.2.tgz", + "integrity": "sha1-rSzgcTc7lDs9kwo/pZo1jCjW8fM=", + "requires": { + "alphanum-sort": "^1.0.1", + "postcss": "^5.0.2", + "postcss-value-parser": "^3.0.2", + "uniqs": "^2.0.0" + } + }, + "postcss-minify-selectors": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/postcss-minify-selectors/-/postcss-minify-selectors-2.1.1.tgz", + "integrity": "sha1-ssapjAByz5G5MtGkllCBFDEXNb8=", + "requires": { + "alphanum-sort": "^1.0.2", + "has": "^1.0.1", + "postcss": "^5.0.14", + "postcss-selector-parser": "^2.0.0" + } + }, + "postcss-modules-extract-imports": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/postcss-modules-extract-imports/-/postcss-modules-extract-imports-1.2.1.tgz", + "integrity": "sha512-6jt9XZwUhwmRUhb/CkyJY020PYaPJsCyt3UjbaWo6XEbH/94Hmv6MP7fG2C5NDU/BcHzyGYxNtHvM+LTf9HrYw==", + "requires": { + "postcss": "^6.0.1" + }, + "dependencies": { + "ansi-styles": { + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz", + "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", + "requires": { + "color-convert": "^1.9.0" + } + }, + "chalk": { + "version": "2.4.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz", + "integrity": "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==", + "requires": { + "ansi-styles": "^3.2.1", + "escape-string-regexp": "^1.0.5", + "supports-color": "^5.3.0" + } + }, + "has-flag": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz", + "integrity": "sha1-tdRU3CGZriJWmfNGfloH87lVuv0=" + }, + "postcss": { + "version": "6.0.23", + "resolved": "https://registry.npmjs.org/postcss/-/postcss-6.0.23.tgz", + "integrity": "sha512-soOk1h6J3VMTZtVeVpv15/Hpdl2cBLX3CAw4TAbkpTJiNPk9YP/zWcD1ND+xEtvyuuvKzbxliTOIyvkSeSJ6ag==", + "requires": { + "chalk": "^2.4.1", + "source-map": "^0.6.1", + "supports-color": "^5.4.0" + } + }, + "source-map": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz", + "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==" + }, + "supports-color": { + "version": "5.5.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz", + "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==", + "requires": { + "has-flag": "^3.0.0" + } + } + } + }, + "postcss-modules-local-by-default": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/postcss-modules-local-by-default/-/postcss-modules-local-by-default-1.2.0.tgz", + "integrity": "sha1-99gMOYxaOT+nlkRmvRlQCn1hwGk=", + "requires": { + "css-selector-tokenizer": "^0.7.0", + "postcss": "^6.0.1" + }, + "dependencies": { + "ansi-styles": { + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz", + "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", + "requires": { + "color-convert": "^1.9.0" + } + }, + "chalk": { + "version": "2.4.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz", + "integrity": "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==", + "requires": { + "ansi-styles": "^3.2.1", + "escape-string-regexp": "^1.0.5", + "supports-color": "^5.3.0" + } + }, + "has-flag": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz", + "integrity": "sha1-tdRU3CGZriJWmfNGfloH87lVuv0=" + }, + "postcss": { + "version": "6.0.23", + "resolved": "https://registry.npmjs.org/postcss/-/postcss-6.0.23.tgz", + "integrity": "sha512-soOk1h6J3VMTZtVeVpv15/Hpdl2cBLX3CAw4TAbkpTJiNPk9YP/zWcD1ND+xEtvyuuvKzbxliTOIyvkSeSJ6ag==", + "requires": { + "chalk": "^2.4.1", + "source-map": "^0.6.1", + "supports-color": "^5.4.0" + } + }, + "source-map": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz", + "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==" + }, + "supports-color": { + "version": "5.5.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz", + "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==", + "requires": { + "has-flag": "^3.0.0" + } + } + } + }, + "postcss-modules-scope": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/postcss-modules-scope/-/postcss-modules-scope-1.1.0.tgz", + "integrity": "sha1-1upkmUx5+XtipytCb75gVqGUu5A=", + "requires": { + "css-selector-tokenizer": "^0.7.0", + "postcss": "^6.0.1" + }, + "dependencies": { + "ansi-styles": { + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz", + "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", + "requires": { + "color-convert": "^1.9.0" + } + }, + "chalk": { + "version": "2.4.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz", + "integrity": "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==", + "requires": { + "ansi-styles": "^3.2.1", + "escape-string-regexp": "^1.0.5", + "supports-color": "^5.3.0" + } + }, + "has-flag": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz", + "integrity": "sha1-tdRU3CGZriJWmfNGfloH87lVuv0=" + }, + "postcss": { + "version": "6.0.23", + "resolved": "https://registry.npmjs.org/postcss/-/postcss-6.0.23.tgz", + "integrity": "sha512-soOk1h6J3VMTZtVeVpv15/Hpdl2cBLX3CAw4TAbkpTJiNPk9YP/zWcD1ND+xEtvyuuvKzbxliTOIyvkSeSJ6ag==", + "requires": { + "chalk": "^2.4.1", + "source-map": "^0.6.1", + "supports-color": "^5.4.0" + } + }, + "source-map": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz", + "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==" + }, + "supports-color": { + "version": "5.5.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz", + "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==", + "requires": { + "has-flag": "^3.0.0" + } + } + } + }, + "postcss-modules-values": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/postcss-modules-values/-/postcss-modules-values-1.3.0.tgz", + "integrity": "sha1-7P+p1+GSUYOJ9CrQ6D9yrsRW6iA=", + "requires": { + "icss-replace-symbols": "^1.1.0", + "postcss": "^6.0.1" + }, + "dependencies": { + "ansi-styles": { + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz", + "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", + "requires": { + "color-convert": "^1.9.0" + } + }, + "chalk": { + "version": "2.4.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz", + "integrity": "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==", + "requires": { + "ansi-styles": "^3.2.1", + "escape-string-regexp": "^1.0.5", + "supports-color": "^5.3.0" + } + }, + "has-flag": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz", + "integrity": "sha1-tdRU3CGZriJWmfNGfloH87lVuv0=" + }, + "postcss": { + "version": "6.0.23", + "resolved": "https://registry.npmjs.org/postcss/-/postcss-6.0.23.tgz", + "integrity": "sha512-soOk1h6J3VMTZtVeVpv15/Hpdl2cBLX3CAw4TAbkpTJiNPk9YP/zWcD1ND+xEtvyuuvKzbxliTOIyvkSeSJ6ag==", + "requires": { + "chalk": "^2.4.1", + "source-map": "^0.6.1", + "supports-color": "^5.4.0" + } + }, + "source-map": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz", + "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==" + }, + "supports-color": { + "version": "5.5.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz", + "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==", + "requires": { + "has-flag": "^3.0.0" + } + } + } + }, + "postcss-normalize-charset": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/postcss-normalize-charset/-/postcss-normalize-charset-1.1.1.tgz", + "integrity": "sha1-757nEhLX/nWceO0WL2HtYrXLk/E=", + "requires": { + "postcss": "^5.0.5" + } + }, + "postcss-normalize-url": { + "version": "3.0.8", + "resolved": "https://registry.npmjs.org/postcss-normalize-url/-/postcss-normalize-url-3.0.8.tgz", + "integrity": "sha1-EI90s/L82viRov+j6kWSJ5/HgiI=", + "requires": { + "is-absolute-url": "^2.0.0", + "normalize-url": "^1.4.0", + "postcss": "^5.0.14", + "postcss-value-parser": "^3.2.3" + } + }, + "postcss-ordered-values": { + "version": "2.2.3", + "resolved": "https://registry.npmjs.org/postcss-ordered-values/-/postcss-ordered-values-2.2.3.tgz", + "integrity": "sha1-7sbCpntsQSqNsgQud/6NpD+VwR0=", + "requires": { + "postcss": "^5.0.4", + "postcss-value-parser": "^3.0.1" + } + }, + "postcss-reduce-idents": { + "version": "2.4.0", + "resolved": "https://registry.npmjs.org/postcss-reduce-idents/-/postcss-reduce-idents-2.4.0.tgz", + "integrity": "sha1-wsbSDMlYKE9qv75j92Cb9AkFmtM=", + "requires": { + "postcss": "^5.0.4", + "postcss-value-parser": "^3.0.2" + } + }, + "postcss-reduce-initial": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/postcss-reduce-initial/-/postcss-reduce-initial-1.0.1.tgz", + "integrity": "sha1-aPgGlfBF0IJjqHmtJA343WT2ROo=", + "requires": { + "postcss": "^5.0.4" + } + }, + "postcss-reduce-transforms": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/postcss-reduce-transforms/-/postcss-reduce-transforms-1.0.4.tgz", + "integrity": "sha1-/3b02CEkN7McKYpC0uFEQCV3GuE=", + "requires": { + "has": "^1.0.1", + "postcss": "^5.0.8", + "postcss-value-parser": "^3.0.1" + } + }, + "postcss-selector-parser": { + "version": "2.2.3", + "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-2.2.3.tgz", + "integrity": "sha1-+UN3iGBsPJrO4W/+jYsWKX8nu5A=", + "requires": { + "flatten": "^1.0.2", + "indexes-of": "^1.0.1", + "uniq": "^1.0.1" + } + }, + "postcss-svgo": { + "version": "2.1.6", + "resolved": "https://registry.npmjs.org/postcss-svgo/-/postcss-svgo-2.1.6.tgz", + "integrity": "sha1-tt8YqmE7Zm4TPwittSGcJoSsEI0=", + "requires": { + "is-svg": "^2.0.0", + "postcss": "^5.0.14", + "postcss-value-parser": "^3.2.3", + "svgo": "^0.7.0" + } + }, + "postcss-unique-selectors": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/postcss-unique-selectors/-/postcss-unique-selectors-2.0.2.tgz", + "integrity": "sha1-mB1X0p3csz57Hf4f1DuGSfkzyh0=", + "requires": { + "alphanum-sort": "^1.0.1", + "postcss": "^5.0.4", + "uniqs": "^2.0.0" + } + }, + "postcss-value-parser": { + "version": "3.3.1", + "resolved": "https://registry.npmjs.org/postcss-value-parser/-/postcss-value-parser-3.3.1.tgz", + "integrity": "sha512-pISE66AbVkp4fDQ7VHBwRNXzAAKJjw4Vw7nWI/+Q3vuly7SNfgYXvm6i5IgFylHGK5sP/xHAbB7N49OS4gWNyQ==" + }, + "postcss-zindex": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/postcss-zindex/-/postcss-zindex-2.2.0.tgz", + "integrity": "sha1-0hCd3AVbka9n/EyzsCWUZjnSryI=", + "requires": { + "has": "^1.0.1", + "postcss": "^5.0.4", + "uniqs": "^2.0.0" + } + }, + "prelude-ls": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.1.2.tgz", + "integrity": "sha1-IZMqVJ9eUv/ZqCf1cOBL5iqX2lQ=", + "dev": true + }, + "prepend-http": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/prepend-http/-/prepend-http-1.0.4.tgz", + "integrity": "sha1-1PRWKwzjaW5BrFLQ4ALlemNdxtw=" + }, + "prettier": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/prettier/-/prettier-2.3.0.tgz", + "integrity": "sha512-kXtO4s0Lz/DW/IJ9QdWhAf7/NmPWQXkFr/r/WkR3vyI+0v8amTDxiaQSLzs8NBlytfLWX/7uQUMIW677yLKl4w==", + "dev": true + }, + "process": { + "version": "0.11.10", + "resolved": "https://registry.npmjs.org/process/-/process-0.11.10.tgz", + "integrity": "sha1-czIwDoQBYb2j5podHZGn1LwW8YI=", + "dev": true + }, + "process-nextick-args": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/process-nextick-args/-/process-nextick-args-2.0.1.tgz", + "integrity": "sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag==", + "dev": true + }, + "progress": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/progress/-/progress-2.0.3.tgz", + "integrity": "sha512-7PiHtLll5LdnKIMw100I+8xJXR5gW2QwWYkT6iJva0bXitZKa/XMrSbdmg3r2Xnaidz9Qumd0VPaMrZlF9V9sA==", + "dev": true + }, + "promise-inflight": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/promise-inflight/-/promise-inflight-1.0.1.tgz", + "integrity": "sha1-mEcocL8igTL8vdhoEputEsPAKeM=", + "dev": true + }, + "prr": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/prr/-/prr-1.0.1.tgz", + "integrity": "sha1-0/wRS6BplaRexok/SEzrHXj19HY=", + "dev": true + }, + "pseudomap": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/pseudomap/-/pseudomap-1.0.2.tgz", + "integrity": "sha1-8FKijacOYYkX7wqKw0wa5aaChrM=", + "dev": true + }, + "public-encrypt": { + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/public-encrypt/-/public-encrypt-4.0.3.tgz", + "integrity": "sha512-zVpa8oKZSz5bTMTFClc1fQOnyyEzpl5ozpi1B5YcvBrdohMjH2rfsBtyXcuNuwjsDIXmBYlF2N5FlJYhR29t8Q==", + "dev": true, + "requires": { + "bn.js": "^4.1.0", + "browserify-rsa": "^4.0.0", + "create-hash": "^1.1.0", + "parse-asn1": "^5.0.0", + "randombytes": "^2.0.1", + "safe-buffer": "^5.1.2" + } + }, + "pump": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/pump/-/pump-3.0.0.tgz", + "integrity": "sha512-LwZy+p3SFs1Pytd/jYct4wpv49HiYCqd9Rlc5ZVdk0V+8Yzv6jR5Blk3TRmPL1ft69TxP0IMZGJ+WPFU2BFhww==", + "dev": true, + "requires": { + "end-of-stream": "^1.1.0", + "once": "^1.3.1" + } + }, + "pumpify": { + "version": "1.5.1", + "resolved": "https://registry.npmjs.org/pumpify/-/pumpify-1.5.1.tgz", + "integrity": "sha512-oClZI37HvuUJJxSKKrC17bZ9Cu0ZYhEAGPsPUy9KlMUmv9dKX2o77RUmq7f3XjIxbwyGwYzbzQ1L2Ks8sIradQ==", + "dev": true, + "requires": { + "duplexify": "^3.6.0", + "inherits": "^2.0.3", + "pump": "^2.0.0" + }, + "dependencies": { + "pump": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/pump/-/pump-2.0.1.tgz", + "integrity": "sha512-ruPMNRkN3MHP1cWJc9OWr+T/xDP0jhXYCLfJcBuX54hhfIBnaQmAUMfDcG4DM5UMWByBbJY69QSphm3jtDKIkA==", + "dev": true, + "requires": { + "end-of-stream": "^1.1.0", + "once": "^1.3.1" + } + } + } + }, + "punycode": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.1.1.tgz", + "integrity": "sha512-XRsRjdf+j5ml+y/6GKHPZbrF/8p2Yga0JPtdqTIY2Xe5ohJPD9saDJJLPvp9+NSBprVvevdXZybnj2cv8OEd0A==" + }, + "q": { + "version": "1.5.1", + "resolved": "https://registry.npmjs.org/q/-/q-1.5.1.tgz", + "integrity": "sha1-fjL3W0E4EpHQRhHxvxQQmsAGUdc=" + }, + "qjobs": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/qjobs/-/qjobs-1.2.0.tgz", + "integrity": "sha512-8YOJEHtxpySA3fFDyCRxA+UUV+fA+rTWnuWvylOK/NCjhY+b4ocCtmu8TtsWb+mYeU+GCHf/S66KZF/AsteKHg==", + "dev": true + }, + "qs": { + "version": "6.7.0", + "resolved": "https://registry.npmjs.org/qs/-/qs-6.7.0.tgz", + "integrity": "sha512-VCdBRNFTX1fyE7Nb6FYoURo/SPe62QCaAyzJvUjwRaIsc+NePBEniHlvxFmmX56+HZphIGtV0XeCirBtpDrTyQ==", + "dev": true + }, + "query-string": { + "version": "4.3.4", + "resolved": "https://registry.npmjs.org/query-string/-/query-string-4.3.4.tgz", + "integrity": "sha1-u7aTucqRXCMlFbIosaArYJBD2+s=", + "requires": { + "object-assign": "^4.1.0", + "strict-uri-encode": "^1.0.0" + } + }, + "querystring": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/querystring/-/querystring-0.2.0.tgz", + "integrity": "sha1-sgmEkgO7Jd+CDadW50cAWHhSFiA=", + "dev": true + }, + "querystring-es3": { + "version": "0.2.1", + "resolved": "https://registry.npmjs.org/querystring-es3/-/querystring-es3-0.2.1.tgz", + "integrity": "sha1-nsYfeQSYdXB9aUFFlv2Qek1xHnM=", + "dev": true + }, + "querystringify": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/querystringify/-/querystringify-2.1.1.tgz", + "integrity": "sha512-w7fLxIRCRT7U8Qu53jQnJyPkYZIaR4n5151KMfcJlO/A9397Wxb1amJvROTK6TOnp7PfoAmg/qXiNHI+08jRfA==" + }, + "queue-microtask": { + "version": "1.2.3", + "resolved": "https://registry.npmjs.org/queue-microtask/-/queue-microtask-1.2.3.tgz", + "integrity": "sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==", + "dev": true + }, + "quote-stream": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/quote-stream/-/quote-stream-1.0.2.tgz", + "integrity": "sha1-hJY/jJwmuULhU/7rU6rnRlK34LI=", + "dev": true, + "requires": { + "buffer-equal": "0.0.1", + "minimist": "^1.1.3", + "through2": "^2.0.0" + } + }, + "randombytes": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/randombytes/-/randombytes-2.1.0.tgz", + "integrity": "sha512-vYl3iOX+4CKUWuxGi9Ukhie6fsqXqS9FE2Zaic4tNFD2N2QQaXOMFbuKK4QmDHC0JO6B1Zp41J0LpT0oR68amQ==", + "dev": true, + "requires": { + "safe-buffer": "^5.1.0" + } + }, + "randomfill": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/randomfill/-/randomfill-1.0.4.tgz", + "integrity": "sha512-87lcbR8+MhcWcUiQ+9e+Rwx8MyR2P7qnt15ynUlbm3TU/fjbgz4GsvfSUDTemtCCtVCqb4ZcEFlyPNTh9bBTLw==", + "dev": true, + "requires": { + "randombytes": "^2.0.5", + "safe-buffer": "^5.1.0" + } + }, + "range-parser": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/range-parser/-/range-parser-1.2.1.tgz", + "integrity": "sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg==", + "dev": true + }, + "raw-body": { + "version": "2.4.0", + "resolved": "https://registry.npmjs.org/raw-body/-/raw-body-2.4.0.tgz", + "integrity": "sha512-4Oz8DUIwdvoa5qMJelxipzi/iJIi40O5cGV1wNYp5hvZP8ZN0T+jiNkL0QepXs+EsQ9XJ8ipEDoiH70ySUJP3Q==", + "dev": true, + "requires": { + "bytes": "3.1.0", + "http-errors": "1.7.2", + "iconv-lite": "0.4.24", + "unpipe": "1.0.0" + } + }, + "raw-loader": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/raw-loader/-/raw-loader-3.0.0.tgz", + "integrity": "sha512-FsELYliOpX5HdPdxa7PzTmEc5OTchmLUs/r4f8oLDGCYE+xC2FjVbDXzdyLcBrdlDnvkx1x5wzphixcWpxJG5w==", + "dev": true, + "requires": { + "loader-utils": "^1.1.0", + "schema-utils": "^1.0.0" + }, + "dependencies": { + "schema-utils": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/schema-utils/-/schema-utils-1.0.0.tgz", + "integrity": "sha512-i27Mic4KovM/lnGsy8whRCHhc7VicJajAjTrYg11K9zfZXnYIt4k5F+kZkwjnrhKzLic/HLU4j11mjsz2G/75g==", + "dev": true, + "requires": { + "ajv": "^6.1.0", + "ajv-errors": "^1.0.0", + "ajv-keywords": "^3.1.0" + } + } + } + }, + "rc": { + "version": "1.2.8", + "resolved": "https://registry.npmjs.org/rc/-/rc-1.2.8.tgz", + "integrity": "sha512-y3bGgqKj3QBdxLbLkomlohkvsA8gdAiUQlSBJnBhfn+BPxg4bc62d8TcBW15wavDfgexCgccckhcZvywyQYPOw==", + "dev": true, + "requires": { + "deep-extend": "^0.6.0", + "ini": "~1.3.0", + "minimist": "^1.2.0", + "strip-json-comments": "~2.0.1" + } + }, + "read-pkg": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/read-pkg/-/read-pkg-2.0.0.tgz", + "integrity": "sha1-jvHAYjxqbbDcZxPEv6xGMysjaPg=", + "dev": true, + "requires": { + "load-json-file": "^2.0.0", + "normalize-package-data": "^2.3.2", + "path-type": "^2.0.0" + } + }, + "read-pkg-up": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/read-pkg-up/-/read-pkg-up-2.0.0.tgz", + "integrity": "sha1-a3KoBImE4MQeeVEP1en6mbO1Sb4=", + "dev": true, + "requires": { + "find-up": "^2.0.0", + "read-pkg": "^2.0.0" + } + }, + "readable-stream": { + "version": "2.3.6", + "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.6.tgz", + "integrity": "sha512-tQtKA9WIAhBF3+VLAseyMqZeBjW0AHJoxOtYqSUZNJxauErmLbVm2FW1y+J/YA9dUrAC39ITejlZWhVIwawkKw==", + "dev": true, + "requires": { + "core-util-is": "~1.0.0", + "inherits": "~2.0.3", + "isarray": "~1.0.0", + "process-nextick-args": "~2.0.0", + "safe-buffer": "~5.1.1", + "string_decoder": "~1.1.1", + "util-deprecate": "~1.0.1" + }, + "dependencies": { + "safe-buffer": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz", + "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==", + "dev": true + } + } + }, + "readdirp": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-3.2.0.tgz", + "integrity": "sha512-crk4Qu3pmXwgxdSgGhgA/eXiJAPQiX4GMOZZMXnqKxHX7TaoL+3gQVo/WeuAiogr07DpnfjIMpXXa+PAIvwPGQ==", + "dev": true, + "requires": { + "picomatch": "^2.0.4" + } + }, + "rechoir": { + "version": "0.7.0", + "resolved": "https://registry.npmjs.org/rechoir/-/rechoir-0.7.0.tgz", + "integrity": "sha512-ADsDEH2bvbjltXEP+hTIAmeFekTFK0V2BTxMkok6qILyAJEXV0AFfoWcAq4yfll5VdIMd/RVXq0lR+wQi5ZU3Q==", + "dev": true, + "requires": { + "resolve": "^1.9.0" + } + }, + "reduce-css-calc": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/reduce-css-calc/-/reduce-css-calc-1.3.0.tgz", + "integrity": "sha1-dHyRTgSWFKTJz7umKYca0dKSdxY=", + "requires": { + "balanced-match": "^0.4.2", + "math-expression-evaluator": "^1.2.14", + "reduce-function-call": "^1.0.1" + } + }, + "reduce-function-call": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/reduce-function-call/-/reduce-function-call-1.0.3.tgz", + "integrity": "sha512-Hl/tuV2VDgWgCSEeWMLwxLZqX7OK59eU1guxXsRKTAyeYimivsKdtcV4fu3r710tpG5GmDKDhQ0HSZLExnNmyQ==", + "requires": { + "balanced-match": "^1.0.0" + }, + "dependencies": { + "balanced-match": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.0.tgz", + "integrity": "sha1-ibTRmasr7kneFk6gK4nORi1xt2c=" + } + } + }, + "regenerate": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/regenerate/-/regenerate-1.4.0.tgz", + "integrity": "sha512-1G6jJVDWrt0rK99kBjvEtziZNCICAuvIPkSiUFIQxVP06RCVpq3dmDo2oi6ABpYaDYaTRr67BEhL8r1wgEZZKg==" + }, + "regenerator-runtime": { + "version": "0.11.1", + "resolved": "https://registry.npmjs.org/regenerator-runtime/-/regenerator-runtime-0.11.1.tgz", + "integrity": "sha512-MguG95oij0fC3QV3URf4V2SDYGJhJnJGqvIIgdECeODCT98wSWDAJ94SSuVpYQUoTcGUIL6L4yNB7j1DFFHSBg==", + "dev": true + }, + "regex-not": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/regex-not/-/regex-not-1.0.2.tgz", + "integrity": "sha512-J6SDjUgDxQj5NusnOtdFxDwN/+HWykR8GELwctJ7mdqhcyy1xEc4SRFHUXvxTp661YaVKAjfRLZ9cCqS6tn32A==", + "dev": true, + "requires": { + "extend-shallow": "^3.0.2", + "safe-regex": "^1.1.0" + } + }, + "regexpp": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/regexpp/-/regexpp-2.0.1.tgz", + "integrity": "sha512-lv0M6+TkDVniA3aD1Eg0DVpfU/booSu7Eev3TDO/mZKHBfVjgCGTV4t4buppESEYDtkArYFOxTJWv6S5C+iaNw==", + "dev": true + }, + "regexpu-core": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/regexpu-core/-/regexpu-core-1.0.0.tgz", + "integrity": "sha1-hqdj9Y7k18L2sQLkdkBQ3n7ZDGs=", + "requires": { + "regenerate": "^1.2.1", + "regjsgen": "^0.2.0", + "regjsparser": "^0.1.4" + } + }, + "registry-auth-token": { + "version": "4.2.1", + "resolved": "https://registry.npmjs.org/registry-auth-token/-/registry-auth-token-4.2.1.tgz", + "integrity": "sha512-6gkSb4U6aWJB4SF2ZvLb76yCBjcvufXBqvvEx1HbmKPkutswjW1xNVRY0+daljIYRbogN7O0etYSlbiaEQyMyw==", + "dev": true, + "requires": { + "rc": "^1.2.8" + } + }, + "registry-url": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/registry-url/-/registry-url-5.1.0.tgz", + "integrity": "sha512-8acYXXTI0AkQv6RAOjE3vOaIXZkT9wo4LOFbBKYQEEnnMNBpKqdUrI6S4NT0KPIo/WVvJ5tE/X5LF/TQUf0ekw==", + "dev": true, + "requires": { + "rc": "^1.2.8" + } + }, + "regjsgen": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/regjsgen/-/regjsgen-0.2.0.tgz", + "integrity": "sha1-bAFq3qxVT3WCP+N6wFuS1aTtsfc=" + }, + "regjsparser": { + "version": "0.1.5", + "resolved": "https://registry.npmjs.org/regjsparser/-/regjsparser-0.1.5.tgz", + "integrity": "sha1-fuj4Tcb6eS0/0K4ijSS9lJ6tIFw=", + "requires": { + "jsesc": "~0.5.0" + } + }, + "remove-trailing-separator": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/remove-trailing-separator/-/remove-trailing-separator-1.1.0.tgz", + "integrity": "sha1-wkvOKig62tW8P1jg1IJJuSN52O8=", + "dev": true + }, + "repeat-element": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/repeat-element/-/repeat-element-1.1.3.tgz", + "integrity": "sha512-ahGq0ZnV5m5XtZLMb+vP76kcAM5nkLqk0lpqAuojSKGgQtn4eRi4ZZGm2olo2zKFH+sMsWaqOCW1dqAnOru72g==", + "dev": true + }, + "repeat-string": { + "version": "1.6.1", + "resolved": "https://registry.npmjs.org/repeat-string/-/repeat-string-1.6.1.tgz", + "integrity": "sha1-jcrkcOHIirwtYA//Sndihtp15jc=", + "dev": true + }, + "require-directory": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz", + "integrity": "sha1-jGStX9MNqxyXbiNE/+f3kqam30I=", + "dev": true + }, + "require-main-filename": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/require-main-filename/-/require-main-filename-2.0.0.tgz", + "integrity": "sha512-NKN5kMDylKuldxYLSUfrbo5Tuzh4hd+2E8NPPX02mZtn1VuREQToYe/ZdlJy+J3uCpfaiGF05e7B8W0iXbQHmg==", + "dev": true + }, + "requires-port": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/requires-port/-/requires-port-1.0.0.tgz", + "integrity": "sha1-kl0mAdOaxIXgkc8NpcbmlNw9yv8=" + }, + "resolve": { + "version": "1.12.0", + "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.12.0.tgz", + "integrity": "sha512-B/dOmuoAik5bKcD6s6nXDCjzUKnaDvdkRyAk6rsmsKLipWj4797iothd7jmmUhWTfinVMU+wc56rYKsit2Qy4w==", + "requires": { + "path-parse": "^1.0.6" + } + }, + "resolve-cwd": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/resolve-cwd/-/resolve-cwd-2.0.0.tgz", + "integrity": "sha1-AKn3OHVW4nA46uIyyqNypqWbZlo=", + "dev": true, + "requires": { + "resolve-from": "^3.0.0" + }, + "dependencies": { + "resolve-from": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-3.0.0.tgz", + "integrity": "sha1-six699nWiBvItuZTM17rywoYh0g=", + "dev": true + } + } + }, + "resolve-dir": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/resolve-dir/-/resolve-dir-1.0.1.tgz", + "integrity": "sha1-eaQGRMNivoLybv/nOcm7U4IEb0M=", + "dev": true, + "requires": { + "expand-tilde": "^2.0.0", + "global-modules": "^1.0.0" + }, + "dependencies": { + "global-modules": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/global-modules/-/global-modules-1.0.0.tgz", + "integrity": "sha512-sKzpEkf11GpOFuw0Zzjzmt4B4UZwjOcG757PPvrfhxcLFbq0wpsgpOqxpxtxFiCG4DtG93M6XRVbF2oGdev7bg==", + "dev": true, + "requires": { + "global-prefix": "^1.0.1", + "is-windows": "^1.0.1", + "resolve-dir": "^1.0.0" + } + } + } + }, + "resolve-from": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-4.0.0.tgz", + "integrity": "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==", + "dev": true + }, + "resolve-url": { + "version": "0.2.1", + "resolved": "https://registry.npmjs.org/resolve-url/-/resolve-url-0.2.1.tgz", + "integrity": "sha1-LGN/53yJOv0qZj/iGqkIAGjiBSo=", + "dev": true + }, + "responselike": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/responselike/-/responselike-1.0.2.tgz", + "integrity": "sha1-kYcg7ztjHFZCvgaPFa3lpG9Loec=", + "dev": true, + "requires": { + "lowercase-keys": "^1.0.0" + } + }, + "restore-cursor": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/restore-cursor/-/restore-cursor-2.0.0.tgz", + "integrity": "sha1-n37ih/gv0ybU/RYpI9YhKe7g368=", + "dev": true, + "requires": { + "onetime": "^2.0.0", + "signal-exit": "^3.0.2" + } + }, + "ret": { + "version": "0.1.15", + "resolved": "https://registry.npmjs.org/ret/-/ret-0.1.15.tgz", + "integrity": "sha512-TTlYpa+OL+vMMNG24xSlQGEJ3B/RzEfUlLct7b5G/ytav+wPrplCpVMFuwzXbkecJrb6IYo1iFb0S9v37754mg==", + "dev": true + }, + "reusify": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/reusify/-/reusify-1.0.4.tgz", + "integrity": "sha512-U9nH88a3fc/ekCF1l0/UP1IosiuIjyTh7hBvXVMHYgVcfGvt897Xguj2UOLDeI5BG2m7/uwyaLVT6fbtCwTyzw==", + "dev": true + }, + "rfdc": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/rfdc/-/rfdc-1.1.4.tgz", + "integrity": "sha512-5C9HXdzK8EAqN7JDif30jqsBzavB7wLpaubisuQIGHWf2gUXSpzy6ArX/+Da8RjFpagWsCn+pIgxTMAmKw9Zug==", + "dev": true + }, + "rimraf": { + "version": "2.6.3", + "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-2.6.3.tgz", + "integrity": "sha512-mwqeW5XsA2qAejG46gYdENaxXjx9onRNCfn7L0duuP4hCuTIi/QO7PDK07KJfp1d+izWPrzEJDcSqBa0OZQriA==", + "dev": true, + "requires": { + "glob": "^7.1.3" + } + }, + "ripemd160": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/ripemd160/-/ripemd160-2.0.2.tgz", + "integrity": "sha512-ii4iagi25WusVoiC4B4lq7pbXfAp3D9v5CwfkY33vffw2+pkDjY1D8GaN7spsxvCSx8dkPqOZCEZyfxcmJG2IA==", + "dev": true, + "requires": { + "hash-base": "^3.0.0", + "inherits": "^2.0.1" + } + }, + "run-async": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/run-async/-/run-async-2.3.0.tgz", + "integrity": "sha1-A3GrSuC91yDUFm19/aZP96RFpsA=", + "dev": true, + "requires": { + "is-promise": "^2.1.0" + } + }, + "run-parallel": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/run-parallel/-/run-parallel-1.2.0.tgz", + "integrity": "sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==", + "dev": true, + "requires": { + "queue-microtask": "^1.2.2" + } + }, + "run-queue": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/run-queue/-/run-queue-1.0.3.tgz", + "integrity": "sha1-6Eg5bwV9Ij8kOGkkYY4laUFh7Ec=", + "dev": true, + "requires": { + "aproba": "^1.1.1" + } + }, + "rw": { + "version": "1.3.3", + "resolved": "https://registry.npmjs.org/rw/-/rw-1.3.3.tgz", + "integrity": "sha1-P4Yt+pGrdmsUiF700BEkv9oHT7Q=" + }, + "rxjs": { + "version": "6.5.3", + "resolved": "https://registry.npmjs.org/rxjs/-/rxjs-6.5.3.tgz", + "integrity": "sha512-wuYsAYYFdWTAnAaPoKGNhfpWwKZbJW+HgAJ+mImp+Epl7BG8oNWBCTyRM8gba9k4lk8BgWdoYm21Mo/RYhhbgA==", + "dev": true, + "requires": { + "tslib": "^1.9.0" + } + }, + "safe-buffer": { + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.0.tgz", + "integrity": "sha512-fZEwUGbVl7kouZs1jCdMLdt95hdIv0ZeHg6L7qPeciMZhZ+/gdesW4wgTARkrFWEpspjEATAzUGPG8N2jJiwbg==", + "dev": true + }, + "safe-regex": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/safe-regex/-/safe-regex-1.1.0.tgz", + "integrity": "sha1-QKNmnzsHfR6UPURinhV91IAjvy4=", + "dev": true, + "requires": { + "ret": "~0.1.10" + } + }, + "safer-buffer": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz", + "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==" + }, + "samsam": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/samsam/-/samsam-1.3.0.tgz", + "integrity": "sha512-1HwIYD/8UlOtFS3QO3w7ey+SdSDFE4HRNLZoZRYVQefrOY3l17epswImeB1ijgJFQJodIaHcwkp3r/myBjFVbg==", + "dev": true + }, + "sax": { + "version": "1.2.4", + "resolved": "https://registry.npmjs.org/sax/-/sax-1.2.4.tgz", + "integrity": "sha512-NqVDv9TpANUjFm0N8uM5GxL36UgKi9/atZw+x7YFnQ8ckwFGKrl4xX4yWtrey3UJm5nP1kUbnYgLopqWNSRhWw==" + }, + "schema-utils": { + "version": "0.3.0", + "resolved": "https://registry.npmjs.org/schema-utils/-/schema-utils-0.3.0.tgz", + "integrity": "sha1-9YdyIs4+kx7a4DnxfrNxbnE3+M8=", + "requires": { + "ajv": "^5.0.0" + }, + "dependencies": { + "ajv": { + "version": "5.5.2", + "resolved": "https://registry.npmjs.org/ajv/-/ajv-5.5.2.tgz", + "integrity": "sha1-c7Xuyj+rZT49P5Qis0GtQiBdyWU=", + "requires": { + "co": "^4.6.0", + "fast-deep-equal": "^1.0.0", + "fast-json-stable-stringify": "^2.0.0", + "json-schema-traverse": "^0.3.0" + } + }, + "fast-deep-equal": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-1.1.0.tgz", + "integrity": "sha1-wFNHeBfIa1HaqFPIHgWbcz0CNhQ=" + }, + "json-schema-traverse": { + "version": "0.3.1", + "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.3.1.tgz", + "integrity": "sha1-NJptRMU6Ud6JtAgFxdXlm0F9M0A=" + } + } + }, + "screenfull": { + "version": "3.3.3", + "resolved": "https://registry.npmjs.org/screenfull/-/screenfull-3.3.3.tgz", + "integrity": "sha512-DzYUuXr+OV2BDvYXaYzlYgJd4WXZZ2CW5NFC7Kw6TUCpzXJAx4MwlVD6CH+Mu6fi8rfAQIQfqdFZ4jtDsEkWig==" + }, + "sdp": { + "version": "2.10.0", + "resolved": "https://registry.npmjs.org/sdp/-/sdp-2.10.0.tgz", + "integrity": "sha512-H+VjfyQpRz9GezhshJmkXTtCAT9/2g9az3GFDPYfGOz0eAOQU1fCrL3S9Dq/eUT9FtOyLi/czdR9PzK3fKUYOQ==" + }, + "semver": { + "version": "5.7.1", + "resolved": "https://registry.npmjs.org/semver/-/semver-5.7.1.tgz", + "integrity": "sha512-sauaDf/PZdVgrLTNYHRtpXa1iRiKcaebiKQ1BJdpQlWH2lCvexQdX55snPFyK7QzpudqbCI0qXFfOasHdyNDGQ==" + }, + "serialize-javascript": { + "version": "1.9.1", + "resolved": "https://registry.npmjs.org/serialize-javascript/-/serialize-javascript-1.9.1.tgz", + "integrity": "sha512-0Vb/54WJ6k5v8sSWN09S0ora+Hnr+cX40r9F170nT+mSkaxltoE/7R3OrIdBSUv1OoiobH1QoWQbCnAO+e8J1A==", + "dev": true + }, + "set-blocking": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/set-blocking/-/set-blocking-2.0.0.tgz", + "integrity": "sha1-BF+XgtARrppoA93TgrJDkrPYkPc=", + "dev": true + }, + "set-value": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/set-value/-/set-value-2.0.1.tgz", + "integrity": "sha512-JxHc1weCN68wRY0fhCoXpyK55m/XPHafOmK4UWD7m2CI14GMcFypt4w/0+NV5f/ZMby2F6S2wwA7fgynh9gWSw==", + "dev": true, + "requires": { + "extend-shallow": "^2.0.1", + "is-extendable": "^0.1.1", + "is-plain-object": "^2.0.3", + "split-string": "^3.0.1" + }, + "dependencies": { + "extend-shallow": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz", + "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=", + "dev": true, + "requires": { + "is-extendable": "^0.1.0" + } + } + } + }, + "setimmediate": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/setimmediate/-/setimmediate-1.0.5.tgz", + "integrity": "sha1-KQy7Iy4waULX1+qbg3Mqt4VvgoU=", + "dev": true + }, + "setprototypeof": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/setprototypeof/-/setprototypeof-1.1.1.tgz", + "integrity": "sha512-JvdAWfbXeIGaZ9cILp38HntZSFSo3mWg6xGcJJsd+d4aRMOqauag1C63dJfDw7OaMYwEbHMOxEZ1lqVRYP2OAw==", + "dev": true + }, + "sha.js": { + "version": "2.4.11", + "resolved": "https://registry.npmjs.org/sha.js/-/sha.js-2.4.11.tgz", + "integrity": "sha512-QMEp5B7cftE7APOjk5Y6xgrbWu+WkLVQwk8JNjZ8nKRciZaByEW6MubieAiToS7+dwvrjGhH8jRXz3MVd0AYqQ==", + "dev": true, + "requires": { + "inherits": "^2.0.1", + "safe-buffer": "^5.0.1" + } + }, + "shallow-clone": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/shallow-clone/-/shallow-clone-3.0.1.tgz", + "integrity": "sha512-/6KqX+GVUdqPuPPd2LxDDxzX6CAbjJehAAOKlNpqqUpAqPM6HeL8f+o3a+JsyGjn2lv0WY8UsTgUJjU9Ok55NA==", + "dev": true, + "requires": { + "kind-of": "^6.0.2" + } + }, + "shallow-copy": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/shallow-copy/-/shallow-copy-0.0.1.tgz", + "integrity": "sha1-QV9CcC1z2BAzApLMXuhurhoRoXA=", + "dev": true + }, + "shapefile": { + "version": "0.3.1", + "resolved": "https://registry.npmjs.org/shapefile/-/shapefile-0.3.1.tgz", + "integrity": "sha1-m7mkKb1ghqDPsDli0Uz99CD/uhI=", + "dev": true, + "requires": { + "d3-queue": "1", + "iconv-lite": "0.2", + "optimist": "0.3" + }, + "dependencies": { + "d3-queue": { + "version": "1.2.3", + "resolved": "https://registry.npmjs.org/d3-queue/-/d3-queue-1.2.3.tgz", + "integrity": "sha1-FDpwHPpl/gISkvMhwQ0U6Yq9SRs=", + "dev": true + }, + "iconv-lite": { + "version": "0.2.11", + "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.2.11.tgz", + "integrity": "sha1-HOYKOleGSiktEyH/RgnKS7llrcg=", + "dev": true + }, + "optimist": { + "version": "0.3.7", + "resolved": "https://registry.npmjs.org/optimist/-/optimist-0.3.7.tgz", + "integrity": "sha1-yQlBrVnkJzMokjB00s8ufLxuwNk=", + "dev": true, + "requires": { + "wordwrap": "~0.0.2" + } + }, + "wordwrap": { + "version": "0.0.3", + "resolved": "https://registry.npmjs.org/wordwrap/-/wordwrap-0.0.3.tgz", + "integrity": "sha1-o9XabNXAvAAI03I0u68b7WMFkQc=", + "dev": true + } + } + }, + "shebang-command": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-1.2.0.tgz", + "integrity": "sha1-RKrGW2lbAzmJaMOfNj/uXer98eo=", + "dev": true, + "requires": { + "shebang-regex": "^1.0.0" + } + }, + "shebang-regex": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-1.0.0.tgz", + "integrity": "sha1-2kL0l0DAtC2yypcoVxyxkMmO/qM=", + "dev": true + }, + "shell-quote": { + "version": "1.7.2", + "resolved": "https://registry.npmjs.org/shell-quote/-/shell-quote-1.7.2.tgz", + "integrity": "sha512-mRz/m/JVscCrkMyPqHc/bczi3OQHkLTqXHEFu0zDhK/qfv3UcOA4SVmRCLmos4bhjr9ekVQubj/R7waKapmiQg==", + "dev": true + }, + "signal-exit": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.2.tgz", + "integrity": "sha1-tf3AjxKH6hF4Yo5BXiUTK3NkbG0=", + "dev": true + }, + "sinon": { + "version": "2.4.1", + "resolved": "https://registry.npmjs.org/sinon/-/sinon-2.4.1.tgz", + "integrity": "sha512-vFTrO9Wt0ECffDYIPSP/E5bBugt0UjcBQOfQUMh66xzkyPEnhl/vM2LRZi2ajuTdkH07sA6DzrM6KvdvGIH8xw==", + "dev": true, + "requires": { + "diff": "^3.1.0", + "formatio": "1.2.0", + "lolex": "^1.6.0", + "native-promise-only": "^0.8.1", + "path-to-regexp": "^1.7.0", + "samsam": "^1.1.3", + "text-encoding": "0.6.4", + "type-detect": "^4.0.0" + } + }, + "sinon-chai": { + "version": "2.14.0", + "resolved": "https://registry.npmjs.org/sinon-chai/-/sinon-chai-2.14.0.tgz", + "integrity": "sha512-9stIF1utB0ywNHNT7RgiXbdmen8QDCRsrTjw+G9TgKt1Yexjiv8TOWZ6WHsTPz57Yky3DIswZvEqX8fpuHNDtQ==", + "dev": true + }, + "slash": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/slash/-/slash-3.0.0.tgz", + "integrity": "sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q==", + "dev": true + }, + "slice-ansi": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/slice-ansi/-/slice-ansi-2.1.0.tgz", + "integrity": "sha512-Qu+VC3EwYLldKa1fCxuuvULvSJOKEgk9pi8dZeCVK7TqBfUNTH4sFkk4joj8afVSfAYgJoSOetjx9QWOJ5mYoQ==", + "dev": true, + "requires": { + "ansi-styles": "^3.2.0", + "astral-regex": "^1.0.0", + "is-fullwidth-code-point": "^2.0.0" + }, + "dependencies": { + "ansi-styles": { + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz", + "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", + "dev": true, + "requires": { + "color-convert": "^1.9.0" + } + } + } + }, + "snapdragon": { + "version": "0.8.2", + "resolved": "https://registry.npmjs.org/snapdragon/-/snapdragon-0.8.2.tgz", + "integrity": "sha512-FtyOnWN/wCHTVXOMwvSv26d+ko5vWlIDD6zoUJ7LW8vh+ZBC8QdljveRP+crNrtBwioEUWy/4dMtbBjA4ioNlg==", + "dev": true, + "requires": { + "base": "^0.11.1", + "debug": "^2.2.0", + "define-property": "^0.2.5", + "extend-shallow": "^2.0.1", + "map-cache": "^0.2.2", + "source-map": "^0.5.6", + "source-map-resolve": "^0.5.0", + "use": "^3.1.0" + }, + "dependencies": { + "debug": { + "version": "2.6.9", + "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", + "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", + "dev": true, + "requires": { + "ms": "2.0.0" + } + }, + "define-property": { + "version": "0.2.5", + "resolved": "https://registry.npmjs.org/define-property/-/define-property-0.2.5.tgz", + "integrity": "sha1-w1se+RjsPJkPmlvFe+BKrOxcgRY=", + "dev": true, + "requires": { + "is-descriptor": "^0.1.0" + } + }, + "extend-shallow": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz", + "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=", + "dev": true, + "requires": { + "is-extendable": "^0.1.0" + } + }, + "ms": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", + "integrity": "sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g=", + "dev": true + } + } + }, + "snapdragon-node": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/snapdragon-node/-/snapdragon-node-2.1.1.tgz", + "integrity": "sha512-O27l4xaMYt/RSQ5TR3vpWCAB5Kb/czIcqUFOM/C4fYcLnbZUc1PkjTAMjof2pBWaSTwOUd6qUHcFGVGj7aIwnw==", + "dev": true, + "requires": { + "define-property": "^1.0.0", + "isobject": "^3.0.0", + "snapdragon-util": "^3.0.1" + }, + "dependencies": { + "define-property": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/define-property/-/define-property-1.0.0.tgz", + "integrity": "sha1-dp66rz9KY6rTr56NMEybvnm/sOY=", + "dev": true, + "requires": { + "is-descriptor": "^1.0.0" + } + }, + "is-accessor-descriptor": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-accessor-descriptor/-/is-accessor-descriptor-1.0.0.tgz", + "integrity": "sha512-m5hnHTkcVsPfqx3AKlyttIPb7J+XykHvJP2B9bZDjlhLIoEq4XoK64Vg7boZlVWYK6LUY94dYPEE7Lh0ZkZKcQ==", + "dev": true, + "requires": { + "kind-of": "^6.0.0" + } + }, + "is-data-descriptor": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-data-descriptor/-/is-data-descriptor-1.0.0.tgz", + "integrity": "sha512-jbRXy1FmtAoCjQkVmIVYwuuqDFUbaOeDjmed1tOGPrsMhtJA4rD9tkgA0F1qJ3gRFRXcHYVkdeaP50Q5rE/jLQ==", + "dev": true, + "requires": { + "kind-of": "^6.0.0" + } + }, + "is-descriptor": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/is-descriptor/-/is-descriptor-1.0.2.tgz", + "integrity": "sha512-2eis5WqQGV7peooDyLmNEPUrps9+SXX5c9pL3xEB+4e9HnGuDa7mB7kHxHw4CbqS9k1T2hOH3miL8n8WtiYVtg==", + "dev": true, + "requires": { + "is-accessor-descriptor": "^1.0.0", + "is-data-descriptor": "^1.0.0", + "kind-of": "^6.0.2" + } + } + } + }, + "snapdragon-util": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/snapdragon-util/-/snapdragon-util-3.0.1.tgz", + "integrity": "sha512-mbKkMdQKsjX4BAL4bRYTj21edOf8cN7XHdYUJEe+Zn99hVEYcMvKPct1IqNe7+AZPirn8BCDOQBHQZknqmKlZQ==", + "dev": true, + "requires": { + "kind-of": "^3.2.0" + }, + "dependencies": { + "kind-of": { + "version": "3.2.2", + "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz", + "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=", + "dev": true, + "requires": { + "is-buffer": "^1.1.5" + } + } + } + }, + "socket.io": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/socket.io/-/socket.io-2.1.1.tgz", + "integrity": "sha512-rORqq9c+7W0DAK3cleWNSyfv/qKXV99hV4tZe+gGLfBECw3XEhBy7x85F3wypA9688LKjtwO9pX9L33/xQI8yA==", + "dev": true, + "requires": { + "debug": "~3.1.0", + "engine.io": "~3.2.0", + "has-binary2": "~1.0.2", + "socket.io-adapter": "~1.1.0", + "socket.io-client": "2.1.1", + "socket.io-parser": "~3.2.0" + }, + "dependencies": { + "debug": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/debug/-/debug-3.1.0.tgz", + "integrity": "sha512-OX8XqP7/1a9cqkxYw2yXss15f26NKWBpDXQd0/uK/KPqdQhxbPa994hnzjcE2VqQpDslf55723cKPUOGSmMY3g==", + "dev": true, + "requires": { + "ms": "2.0.0" + } + }, + "ms": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", + "integrity": "sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g=", + "dev": true + } + } + }, + "socket.io-adapter": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/socket.io-adapter/-/socket.io-adapter-1.1.1.tgz", + "integrity": "sha1-KoBeihTWNyEk3ZFZrUUC+MsH8Gs=", + "dev": true + }, + "socket.io-client": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/socket.io-client/-/socket.io-client-2.1.1.tgz", + "integrity": "sha512-jxnFyhAuFxYfjqIgduQlhzqTcOEQSn+OHKVfAxWaNWa7ecP7xSNk2Dx/3UEsDcY7NcFafxvNvKPmmO7HTwTxGQ==", + "dev": true, + "requires": { + "backo2": "1.0.2", + "base64-arraybuffer": "0.1.5", + "component-bind": "1.0.0", + "component-emitter": "1.2.1", + "debug": "~3.1.0", + "engine.io-client": "~3.2.0", + "has-binary2": "~1.0.2", + "has-cors": "1.1.0", + "indexof": "0.0.1", + "object-component": "0.0.3", + "parseqs": "0.0.5", + "parseuri": "0.0.5", + "socket.io-parser": "~3.2.0", + "to-array": "0.1.4" + }, + "dependencies": { + "debug": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/debug/-/debug-3.1.0.tgz", + "integrity": "sha512-OX8XqP7/1a9cqkxYw2yXss15f26NKWBpDXQd0/uK/KPqdQhxbPa994hnzjcE2VqQpDslf55723cKPUOGSmMY3g==", + "dev": true, + "requires": { + "ms": "2.0.0" + } + }, + "ms": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", + "integrity": "sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g=", + "dev": true + } + } + }, + "socket.io-parser": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/socket.io-parser/-/socket.io-parser-3.2.0.tgz", + "integrity": "sha512-FYiBx7rc/KORMJlgsXysflWx/RIvtqZbyGLlHZvjfmPTPeuD/I8MaW7cfFrj5tRltICJdgwflhfZ3NVVbVLFQA==", + "dev": true, + "requires": { + "component-emitter": "1.2.1", + "debug": "~3.1.0", + "isarray": "2.0.1" + }, + "dependencies": { + "debug": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/debug/-/debug-3.1.0.tgz", + "integrity": "sha512-OX8XqP7/1a9cqkxYw2yXss15f26NKWBpDXQd0/uK/KPqdQhxbPa994hnzjcE2VqQpDslf55723cKPUOGSmMY3g==", + "dev": true, + "requires": { + "ms": "2.0.0" + } + }, + "isarray": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/isarray/-/isarray-2.0.1.tgz", + "integrity": "sha1-o32U7ZzaLVmGXJ92/llu4fM4dB4=", + "dev": true + }, + "ms": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", + "integrity": "sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g=", + "dev": true + } + } + }, + "sort-keys": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/sort-keys/-/sort-keys-1.1.2.tgz", + "integrity": "sha1-RBttTTRnmPG05J6JIK37oOVD+a0=", + "requires": { + "is-plain-obj": "^1.0.0" + } + }, + "sort-object-keys": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/sort-object-keys/-/sort-object-keys-1.1.3.tgz", + "integrity": "sha512-855pvK+VkU7PaKYPc+Jjnmt4EzejQHyhhF33q31qG8x7maDzkeFhAAThdCYay11CISO+qAMwjOBP+fPZe0IPyg==", + "dev": true + }, + "sort-package-json": { + "version": "1.44.0", + "resolved": "https://registry.npmjs.org/sort-package-json/-/sort-package-json-1.44.0.tgz", + "integrity": "sha512-u9GUZvpavUCXV5SbEqXu9FRbsJrYU6WM10r3zA0gymGPufK5X82MblCLh9GW9l46pXKEZvK+FA3eVTqC4oMp4A==", + "dev": true, + "requires": { + "detect-indent": "^6.0.0", + "detect-newline": "3.1.0", + "git-hooks-list": "1.0.3", + "globby": "10.0.0", + "is-plain-obj": "2.1.0", + "sort-object-keys": "^1.1.3" + }, + "dependencies": { + "is-plain-obj": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-2.1.0.tgz", + "integrity": "sha512-YWnfyRwxL/+SsrWYfOpUtz5b3YD+nyfkHvjbcanzk8zgyO4ASD67uVMRt8k5bM4lLMDnXfriRhOpemw+NfT1eA==", + "dev": true + } + } + }, + "source-list-map": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/source-list-map/-/source-list-map-2.0.1.tgz", + "integrity": "sha512-qnQ7gVMxGNxsiL4lEuJwe/To8UnK7fAnmbGEEH8RpLouuKbeEm0lhbQVFIrNSuB+G7tVrAlVsZgETT5nljf+Iw==" + }, + "source-map": { + "version": "0.5.7", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.5.7.tgz", + "integrity": "sha1-igOdLRAh0i0eoUyA2OpGi6LvP8w=" + }, + "source-map-loader": { + "version": "0.2.4", + "resolved": "https://registry.npmjs.org/source-map-loader/-/source-map-loader-0.2.4.tgz", + "integrity": "sha512-OU6UJUty+i2JDpTItnizPrlpOIBLmQbWMuBg9q5bVtnHACqw1tn9nNwqJLbv0/00JjnJb/Ee5g5WS5vrRv7zIQ==", + "dev": true, + "requires": { + "async": "^2.5.0", + "loader-utils": "^1.1.0" + } + }, + "source-map-resolve": { + "version": "0.5.2", + "resolved": "https://registry.npmjs.org/source-map-resolve/-/source-map-resolve-0.5.2.tgz", + "integrity": "sha512-MjqsvNwyz1s0k81Goz/9vRBe9SZdB09Bdw+/zYyO+3CuPk6fouTaxscHkgtE8jKvf01kVfl8riHzERQ/kefaSA==", + "dev": true, + "requires": { + "atob": "^2.1.1", + "decode-uri-component": "^0.2.0", + "resolve-url": "^0.2.1", + "source-map-url": "^0.4.0", + "urix": "^0.1.0" + } + }, + "source-map-support": { + "version": "0.5.13", + "resolved": "https://registry.npmjs.org/source-map-support/-/source-map-support-0.5.13.tgz", + "integrity": "sha512-SHSKFHadjVA5oR4PPqhtAVdcBWwRYVd6g6cAXnIbRiIwc2EhPrTuKUBdSLvlEKyIP3GCf89fltvcZiP9MMFA1w==", + "dev": true, + "requires": { + "buffer-from": "^1.0.0", + "source-map": "^0.6.0" + }, + "dependencies": { + "source-map": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz", + "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==", + "dev": true + } + } + }, + "source-map-url": { + "version": "0.4.0", + "resolved": "https://registry.npmjs.org/source-map-url/-/source-map-url-0.4.0.tgz", + "integrity": "sha1-PpNdfd1zYxuXZZlW1VEo6HtQhKM=", + "dev": true + }, + "spdx-correct": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/spdx-correct/-/spdx-correct-3.1.0.tgz", + "integrity": "sha512-lr2EZCctC2BNR7j7WzJ2FpDznxky1sjfxvvYEyzxNyb6lZXHODmEoJeFu4JupYlkfha1KZpJyoqiJ7pgA1qq8Q==", + "dev": true, + "requires": { + "spdx-expression-parse": "^3.0.0", + "spdx-license-ids": "^3.0.0" + } + }, + "spdx-exceptions": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/spdx-exceptions/-/spdx-exceptions-2.2.0.tgz", + "integrity": "sha512-2XQACfElKi9SlVb1CYadKDXvoajPgBVPn/gOQLrTvHdElaVhr7ZEbqJaRnJLVNeaI4cMEAgVCeBMKF6MWRDCRA==", + "dev": true + }, + "spdx-expression-parse": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/spdx-expression-parse/-/spdx-expression-parse-3.0.0.tgz", + "integrity": "sha512-Yg6D3XpRD4kkOmTpdgbUiEJFKghJH03fiC1OPll5h/0sO6neh2jqRDVHOQ4o/LMea0tgCkbMgea5ip/e+MkWyg==", + "dev": true, + "requires": { + "spdx-exceptions": "^2.1.0", + "spdx-license-ids": "^3.0.0" + } + }, + "spdx-license-ids": { + "version": "3.0.5", + "resolved": "https://registry.npmjs.org/spdx-license-ids/-/spdx-license-ids-3.0.5.tgz", + "integrity": "sha512-J+FWzZoynJEXGphVIS+XEh3kFSjZX/1i9gFBaWQcB+/tmpe2qUsSBABpcxqxnAxFdiUFEgAX1bjYGQvIZmoz9Q==", + "dev": true + }, + "split-string": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/split-string/-/split-string-3.1.0.tgz", + "integrity": "sha512-NzNVhJDYpwceVVii8/Hu6DKfD2G+NrQHlS/V/qgv763EYudVwEcMQNxd2lh+0VrUByXN/oJkl5grOhYWvQUYiw==", + "dev": true, + "requires": { + "extend-shallow": "^3.0.0" + } + }, + "sprintf-js": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.0.3.tgz", + "integrity": "sha1-BOaSb2YolTVPPdAVIDYzuFcpfiw=" + }, + "ssri": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/ssri/-/ssri-6.0.1.tgz", + "integrity": "sha512-3Wge10hNcT1Kur4PDFwEieXSCMCJs/7WvSACcrMYrNp+b8kDL1/0wJch5Ni2WrtwEa2IO8OsVfeKIciKCDx/QA==", + "dev": true, + "requires": { + "figgy-pudding": "^3.5.1" + } + }, + "static-eval": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/static-eval/-/static-eval-2.0.5.tgz", + "integrity": "sha512-nNbV6LbGtMBgv7e9LFkt5JV8RVlRsyJrphfAt9tOtBBW/SfnzZDf2KnS72an8e434A+9e/BmJuTxeGPvrAK7KA==", + "dev": true, + "requires": { + "escodegen": "^1.11.1" + }, + "dependencies": { + "escodegen": { + "version": "1.14.1", + "resolved": "https://registry.npmjs.org/escodegen/-/escodegen-1.14.1.tgz", + "integrity": "sha512-Bmt7NcRySdIfNPfU2ZoXDrrXsG9ZjvDxcAlMfDUgRBjLOWTuIACXPBFJH7Z+cLb40JeQco5toikyc9t9P8E9SQ==", + "dev": true, + "requires": { + "esprima": "^4.0.1", + "estraverse": "^4.2.0", + "esutils": "^2.0.2", + "optionator": "^0.8.1", + "source-map": "~0.6.1" + } + }, + "esprima": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/esprima/-/esprima-4.0.1.tgz", + "integrity": "sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==", + "dev": true + }, + "source-map": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz", + "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==", + "dev": true, + "optional": true + } + } + }, + "static-extend": { + "version": "0.1.2", + "resolved": "https://registry.npmjs.org/static-extend/-/static-extend-0.1.2.tgz", + "integrity": "sha1-YICcOcv/VTNyJv1eC1IPNB8ftcY=", + "dev": true, + "requires": { + "define-property": "^0.2.5", + "object-copy": "^0.1.0" + }, + "dependencies": { + "define-property": { + "version": "0.2.5", + "resolved": "https://registry.npmjs.org/define-property/-/define-property-0.2.5.tgz", + "integrity": "sha1-w1se+RjsPJkPmlvFe+BKrOxcgRY=", + "dev": true, + "requires": { + "is-descriptor": "^0.1.0" + } + } + } + }, + "static-module": { + "version": "2.2.5", + "resolved": "https://registry.npmjs.org/static-module/-/static-module-2.2.5.tgz", + "integrity": "sha512-D8vv82E/Kpmz3TXHKG8PPsCPg+RAX6cbCOyvjM6x04qZtQ47EtJFVwRsdov3n5d6/6ynrOY9XB4JkaZwB2xoRQ==", + "dev": true, + "requires": { + "concat-stream": "~1.6.0", + "convert-source-map": "^1.5.1", + "duplexer2": "~0.1.4", + "escodegen": "~1.9.0", + "falafel": "^2.1.0", + "has": "^1.0.1", + "magic-string": "^0.22.4", + "merge-source-map": "1.0.4", + "object-inspect": "~1.4.0", + "quote-stream": "~1.0.2", + "readable-stream": "~2.3.3", + "shallow-copy": "~0.0.1", + "static-eval": "^2.0.0", + "through2": "~2.0.3" + }, + "dependencies": { + "object-inspect": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.4.1.tgz", + "integrity": "sha512-wqdhLpfCUbEsoEwl3FXwGyv8ief1k/1aUdIPCqVnupM6e8l63BEJdiF/0swtn04/8p05tG/T0FrpTlfwvljOdw==", + "dev": true + } + } + }, + "statuses": { + "version": "1.5.0", + "resolved": "https://registry.npmjs.org/statuses/-/statuses-1.5.0.tgz", + "integrity": "sha1-Fhx9rBd2Wf2YEfQ3cfqZOBR4Yow=", + "dev": true + }, + "stream-browserify": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/stream-browserify/-/stream-browserify-2.0.2.tgz", + "integrity": "sha512-nX6hmklHs/gr2FuxYDltq8fJA1GDlxKQCz8O/IM4atRqBH8OORmBNgfvW5gG10GT/qQ9u0CzIvr2X5Pkt6ntqg==", + "dev": true, + "requires": { + "inherits": "~2.0.1", + "readable-stream": "^2.0.2" + } + }, + "stream-each": { + "version": "1.2.3", + "resolved": "https://registry.npmjs.org/stream-each/-/stream-each-1.2.3.tgz", + "integrity": "sha512-vlMC2f8I2u/bZGqkdfLQW/13Zihpej/7PmSiMQsbYddxuTsJp8vRe2x2FvVExZg7FaOds43ROAuFJwPR4MTZLw==", + "dev": true, + "requires": { + "end-of-stream": "^1.1.0", + "stream-shift": "^1.0.0" + } + }, + "stream-http": { + "version": "2.8.3", + "resolved": "https://registry.npmjs.org/stream-http/-/stream-http-2.8.3.tgz", + "integrity": "sha512-+TSkfINHDo4J+ZobQLWiMouQYB+UVYFttRA94FpEzzJ7ZdqcL4uUUQ7WkdkI4DSozGmgBUE/a47L+38PenXhUw==", + "dev": true, + "requires": { + "builtin-status-codes": "^3.0.0", + "inherits": "^2.0.1", + "readable-stream": "^2.3.6", + "to-arraybuffer": "^1.0.0", + "xtend": "^4.0.0" + } + }, + "stream-shift": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/stream-shift/-/stream-shift-1.0.0.tgz", + "integrity": "sha1-1cdSgl5TZ+eG944Y5EXqIjoVWVI=", + "dev": true + }, + "streamroller": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/streamroller/-/streamroller-1.0.6.tgz", + "integrity": "sha512-3QC47Mhv3/aZNFpDDVO44qQb9gwB9QggMEE0sQmkTAwBVYdBRWISdsywlkfm5II1Q5y/pmrHflti/IgmIzdDBg==", + "dev": true, + "requires": { + "async": "^2.6.2", + "date-format": "^2.0.0", + "debug": "^3.2.6", + "fs-extra": "^7.0.1", + "lodash": "^4.17.14" + }, + "dependencies": { + "debug": { + "version": "3.2.6", + "resolved": "https://registry.npmjs.org/debug/-/debug-3.2.6.tgz", + "integrity": "sha512-mel+jf7nrtEl5Pn1Qx46zARXKDpBbvzezse7p7LqINmdoIk8PYP5SySaxEmYv6TZ0JyEKA1hsCId6DIhgITtWQ==", + "dev": true, + "requires": { + "ms": "^2.1.1" + } + } + } + }, + "strict-uri-encode": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/strict-uri-encode/-/strict-uri-encode-1.1.0.tgz", + "integrity": "sha1-J5siXfHVgrH1TmWt3UNS4Y+qBxM=" + }, + "string-width": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-2.1.1.tgz", + "integrity": "sha512-nOqH59deCq9SRHlxq1Aw85Jnt4w6KvLKqWVik6oA9ZklXLNIOlqg4F2yrT1MVaTjAqvVwdfeZ7w7aCvJD7ugkw==", + "dev": true, + "requires": { + "is-fullwidth-code-point": "^2.0.0", + "strip-ansi": "^4.0.0" + }, + "dependencies": { + "ansi-regex": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-3.0.0.tgz", + "integrity": "sha1-7QMXwyIGT3lGbAKWa922Bas32Zg=", + "dev": true + }, + "strip-ansi": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-4.0.0.tgz", + "integrity": "sha1-qEeQIusaw2iocTibY1JixQXuNo8=", + "dev": true, + "requires": { + "ansi-regex": "^3.0.0" + } + } + } + }, + "string.prototype.padend": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/string.prototype.padend/-/string.prototype.padend-3.0.0.tgz", + "integrity": "sha1-86rvfBcZ8XDF6rHDK/eA2W4h8vA=", + "dev": true, + "requires": { + "define-properties": "^1.1.2", + "es-abstract": "^1.4.3", + "function-bind": "^1.0.2" + } + }, + "string.prototype.trimleft": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/string.prototype.trimleft/-/string.prototype.trimleft-2.1.0.tgz", + "integrity": "sha512-FJ6b7EgdKxxbDxc79cOlok6Afd++TTs5szo+zJTUyow3ycrRfJVE2pq3vcN53XexvKZu/DJMDfeI/qMiZTrjTw==", + "dev": true, + "requires": { + "define-properties": "^1.1.3", + "function-bind": "^1.1.1" + } + }, + "string.prototype.trimright": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/string.prototype.trimright/-/string.prototype.trimright-2.1.0.tgz", + "integrity": "sha512-fXZTSV55dNBwv16uw+hh5jkghxSnc5oHq+5K/gXgizHwAvMetdAJlHqqoFC1FSDVPYWLkAKl2cxpUT41sV7nSg==", + "dev": true, + "requires": { + "define-properties": "^1.1.3", + "function-bind": "^1.1.1" + } + }, + "string_decoder": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz", + "integrity": "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==", + "dev": true, + "requires": { + "safe-buffer": "~5.1.0" + }, + "dependencies": { + "safe-buffer": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz", + "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==", + "dev": true + } + } + }, + "strip-ansi": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-3.0.1.tgz", + "integrity": "sha1-ajhfuIU9lS1f8F0Oiq+UJ43GPc8=", + "requires": { + "ansi-regex": "^2.0.0" + } + }, + "strip-bom": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/strip-bom/-/strip-bom-3.0.0.tgz", + "integrity": "sha1-IzTBjpx1n3vdVv3vfprj1YjmjtM=", + "dev": true + }, + "strip-eof": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/strip-eof/-/strip-eof-1.0.0.tgz", + "integrity": "sha1-u0P/VZim6wXYm1n80SnJgzE2Br8=", + "dev": true + }, + "strip-final-newline": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/strip-final-newline/-/strip-final-newline-2.0.0.tgz", + "integrity": "sha512-BrpvfNAE3dcvq7ll3xVumzjKjZQ5tI1sEUIKr3Uoks0XUl45St3FlatVqef9prk4jRDzhW6WZg+3bk93y6pLjA==", + "dev": true + }, + "strip-json-comments": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-2.0.1.tgz", + "integrity": "sha1-PFMZQukIwml8DsNEhYwobHygpgo=", + "dev": true + }, + "style-loader": { + "version": "0.18.2", + "resolved": "https://registry.npmjs.org/style-loader/-/style-loader-0.18.2.tgz", + "integrity": "sha512-WPpJPZGUxWYHWIUMNNOYqql7zh85zGmr84FdTVWq52WTIkqlW9xSxD3QYWi/T31cqn9UNSsietVEgGn2aaSCzw==", + "requires": { + "loader-utils": "^1.0.2", + "schema-utils": "^0.3.0" + } + }, + "supports-color": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-2.0.0.tgz", + "integrity": "sha1-U10EXOa2Nj+kARcIRimZXp3zJMc=" + }, + "svg-url-loader": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/svg-url-loader/-/svg-url-loader-6.0.0.tgz", + "integrity": "sha512-Qr5SCKxyxKcRnvnVrO3iQj9EX/v40UiGEMshgegzV7vpo3yc+HexELOdtWcA3MKjL8IyZZ1zOdcILmDEa/8JJQ==", + "dev": true, + "requires": { + "file-loader": "~6.0.0", + "loader-utils": "~2.0.0" + }, + "dependencies": { + "emojis-list": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/emojis-list/-/emojis-list-3.0.0.tgz", + "integrity": "sha512-/kyM18EfinwXZbno9FyUGeFh87KC8HRQBQGildHZbEuRyWFOmv1U10o9BBp8XVZDVNNuQKyIGIu5ZYAAXJ0V2Q==", + "dev": true + }, + "json5": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/json5/-/json5-2.2.0.tgz", + "integrity": "sha512-f+8cldu7X/y7RAJurMEJmdoKXGB/X550w2Nr3tTbezL6RwEE/iMcm+tZnXeoZtKuOq6ft8+CqzEkrIgx1fPoQA==", + "dev": true, + "requires": { + "minimist": "^1.2.5" + } + }, + "loader-utils": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/loader-utils/-/loader-utils-2.0.0.tgz", + "integrity": "sha512-rP4F0h2RaWSvPEkD7BLDFQnvSf+nK+wr3ESUjNTyAGobqrijmW92zc+SO6d4p4B1wh7+B/Jg1mkQe5NYUEHtHQ==", + "dev": true, + "requires": { + "big.js": "^5.2.2", + "emojis-list": "^3.0.0", + "json5": "^2.1.2" + } + }, + "minimist": { + "version": "1.2.5", + "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.5.tgz", + "integrity": "sha512-FM9nNUYrRBAELZQT3xeZQ7fmMOBg6nWNmJKTcgsJeaLstP/UODVpGsr5OhXhhXg6f+qtJ8uiZ+PUxkDWcgIXLw==", + "dev": true + } + } + }, + "svgo": { + "version": "0.7.2", + "resolved": "https://registry.npmjs.org/svgo/-/svgo-0.7.2.tgz", + "integrity": "sha1-n1dyQTlSE1xv779Ar+ak+qiLS7U=", + "requires": { + "coa": "~1.0.1", + "colors": "~1.1.2", + "csso": "~2.3.1", + "js-yaml": "~3.7.0", + "mkdirp": "~0.5.1", + "sax": "~1.2.1", + "whet.extend": "~0.9.9" + } + }, + "table": { + "version": "5.4.6", + "resolved": "https://registry.npmjs.org/table/-/table-5.4.6.tgz", + "integrity": "sha512-wmEc8m4fjnob4gt5riFRtTu/6+4rSe12TpAELNSqHMfF3IqnA+CH37USM6/YR3qRZv7e56kAEAtd6nKZaxe0Ug==", + "dev": true, + "requires": { + "ajv": "^6.10.2", + "lodash": "^4.17.14", + "slice-ansi": "^2.1.0", + "string-width": "^3.0.0" + }, + "dependencies": { + "ansi-regex": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-4.1.0.tgz", + "integrity": "sha512-1apePfXM1UOSqw0o9IiFAovVz9M5S1Dg+4TrDwfMewQ6p/rmMueb7tWZjQ1rx4Loy1ArBggoqGpfqqdI4rondg==", + "dev": true + }, + "string-width": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-3.1.0.tgz", + "integrity": "sha512-vafcv6KjVZKSgz06oM/H6GDBrAtz8vdhQakGjFIvNrHA6y3HCF1CInLy+QLq8dTJPQ1b+KDUqDFctkdRW44e1w==", + "dev": true, + "requires": { + "emoji-regex": "^7.0.1", + "is-fullwidth-code-point": "^2.0.0", + "strip-ansi": "^5.1.0" + } + }, + "strip-ansi": { + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-5.2.0.tgz", + "integrity": "sha512-DuRs1gKbBqsMKIZlrffwlug8MHkcnpjs5VPmL1PAh+mA30U0DTotfDZ0d2UUsXpPmPmMMJ6W773MaA3J+lbiWA==", + "dev": true, + "requires": { + "ansi-regex": "^4.1.0" + } + } + } + }, + "tapable": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/tapable/-/tapable-1.1.3.tgz", + "integrity": "sha512-4WK/bYZmj8xLr+HUCODHGF1ZFzsYffasLUgEiMBY4fgtltdO6B4WJtlSbPaDTLpYTcGVwM2qLnFTICEcNxs3kA==", + "dev": true + }, + "tar": { + "version": "6.1.0", + "resolved": "https://registry.npmjs.org/tar/-/tar-6.1.0.tgz", + "integrity": "sha512-DUCttfhsnLCjwoDoFcI+B2iJgYa93vBnDUATYEeRx6sntCTdN01VnqsIuTlALXla/LWooNg0yEGeB+Y8WdFxGA==", + "dev": true, + "requires": { + "chownr": "^2.0.0", + "fs-minipass": "^2.0.0", + "minipass": "^3.0.0", + "minizlib": "^2.1.1", + "mkdirp": "^1.0.3", + "yallist": "^4.0.0" + }, + "dependencies": { + "chownr": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/chownr/-/chownr-2.0.0.tgz", + "integrity": "sha512-bIomtDF5KGpdogkLd9VspvFzk9KfpyyGlS8YFVZl7TGPBHL5snIOnxeshwVgPteQ9b4Eydl+pVbIyE1DcvCWgQ==", + "dev": true + }, + "mkdirp": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-1.0.4.tgz", + "integrity": "sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw==", + "dev": true + }, + "yallist": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz", + "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==", + "dev": true + } + } + }, + "terser": { + "version": "4.3.9", + "resolved": "https://registry.npmjs.org/terser/-/terser-4.3.9.tgz", + "integrity": "sha512-NFGMpHjlzmyOtPL+fDw3G7+6Ueh/sz4mkaUYa4lJCxOPTNzd0Uj0aZJOmsDYoSQyfuVoWDMSWTPU3huyOm2zdA==", + "dev": true, + "requires": { + "commander": "^2.20.0", + "source-map": "~0.6.1", + "source-map-support": "~0.5.12" + }, + "dependencies": { + "source-map": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz", + "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==", + "dev": true + } + } + }, + "terser-webpack-plugin": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/terser-webpack-plugin/-/terser-webpack-plugin-1.4.1.tgz", + "integrity": "sha512-ZXmmfiwtCLfz8WKZyYUuuHf3dMYEjg8NrjHMb0JqHVHVOSkzp3cW2/XG1fP3tRhqEqSzMwzzRQGtAPbs4Cncxg==", + "dev": true, + "requires": { + "cacache": "^12.0.2", + "find-cache-dir": "^2.1.0", + "is-wsl": "^1.1.0", + "schema-utils": "^1.0.0", + "serialize-javascript": "^1.7.0", + "source-map": "^0.6.1", + "terser": "^4.1.2", + "webpack-sources": "^1.4.0", + "worker-farm": "^1.7.0" + }, + "dependencies": { + "schema-utils": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/schema-utils/-/schema-utils-1.0.0.tgz", + "integrity": "sha512-i27Mic4KovM/lnGsy8whRCHhc7VicJajAjTrYg11K9zfZXnYIt4k5F+kZkwjnrhKzLic/HLU4j11mjsz2G/75g==", + "dev": true, + "requires": { + "ajv": "^6.1.0", + "ajv-errors": "^1.0.0", + "ajv-keywords": "^3.1.0" + } + }, + "source-map": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz", + "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==", + "dev": true + } + } + }, + "text-encoding": { + "version": "0.6.4", + "resolved": "https://registry.npmjs.org/text-encoding/-/text-encoding-0.6.4.tgz", + "integrity": "sha1-45mpgiV6J22uQou5KEXLcb3CbRk=", + "dev": true + }, + "text-table": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/text-table/-/text-table-0.2.0.tgz", + "integrity": "sha1-f17oI66AUgfACvLfSoTsP8+lcLQ=", + "dev": true + }, + "three": { + "version": "0.97.0", + "resolved": "https://registry.npmjs.org/three/-/three-0.97.0.tgz", + "integrity": "sha512-ctZF79O1R2aMIDnz9cV5GUIONyFnYvfQKg4+EAwEVaEr1mgy99rglstH6hhRdIThu3SOa4Ns5da/Ee5fTbWc9A==" + }, + "three-text2d": { + "version": "0.4.1", + "resolved": "https://registry.npmjs.org/three-text2d/-/three-text2d-0.4.1.tgz", + "integrity": "sha512-Itc8/ORw9M4/sfcqwz/vv/VTzlkErMSP9T3JsCa3GPGvfpmq9PIFwWu11NIizf4Vrq19n8HCh3MEK3egX01xMA==" + }, + "through": { + "version": "2.3.8", + "resolved": "https://registry.npmjs.org/through/-/through-2.3.8.tgz", + "integrity": "sha1-DdTJ/6q8NXlgsbckEV1+Doai4fU=", + "dev": true + }, + "through2": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/through2/-/through2-2.0.5.tgz", + "integrity": "sha512-/mrRod8xqpA+IHSLyGCQ2s8SPHiCDEeQJSep1jqLYeEUClOFG2Qsh+4FU6G9VeqpZnGW/Su8LQGc4YKni5rYSQ==", + "dev": true, + "requires": { + "readable-stream": "~2.3.6", + "xtend": "~4.0.1" + } + }, + "timers-browserify": { + "version": "2.0.11", + "resolved": "https://registry.npmjs.org/timers-browserify/-/timers-browserify-2.0.11.tgz", + "integrity": "sha512-60aV6sgJ5YEbzUdn9c8kYGIqOubPoUdqQCul3SBAsRCZ40s6Y5cMcrW4dt3/k/EsbLVJNl9n6Vz3fTc+k2GeKQ==", + "dev": true, + "requires": { + "setimmediate": "^1.0.4" + } + }, + "tmp": { + "version": "0.0.33", + "resolved": "https://registry.npmjs.org/tmp/-/tmp-0.0.33.tgz", + "integrity": "sha512-jRCJlojKnZ3addtTOjdIqoRuPEKBvNXcGYqzO6zWZX8KfKEpnGY5jfggJQ3EjKuu8D4bJRr0y+cYJFmYbImXGw==", + "dev": true, + "requires": { + "os-tmpdir": "~1.0.2" + } + }, + "to-array": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/to-array/-/to-array-0.1.4.tgz", + "integrity": "sha1-F+bBH3PdTz10zaek/zI46a2b+JA=", + "dev": true + }, + "to-arraybuffer": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/to-arraybuffer/-/to-arraybuffer-1.0.1.tgz", + "integrity": "sha1-fSKbH8xjfkZsoIEYCDanqr/4P0M=", + "dev": true + }, + "to-object-path": { + "version": "0.3.0", + "resolved": "https://registry.npmjs.org/to-object-path/-/to-object-path-0.3.0.tgz", + "integrity": "sha1-KXWIt7Dn4KwI4E5nL4XB9JmeF68=", + "dev": true, + "requires": { + "kind-of": "^3.0.2" + }, + "dependencies": { + "kind-of": { + "version": "3.2.2", + "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz", + "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=", + "dev": true, + "requires": { + "is-buffer": "^1.1.5" + } + } + } + }, + "to-readable-stream": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/to-readable-stream/-/to-readable-stream-1.0.0.tgz", + "integrity": "sha512-Iq25XBt6zD5npPhlLVXGFN3/gyR2/qODcKNNyTMd4vbm39HUaOiAM4PMq0eMVC/Tkxz+Zjdsc55g9yyz+Yq00Q==", + "dev": true + }, + "to-regex": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/to-regex/-/to-regex-3.0.2.tgz", + "integrity": "sha512-FWtleNAtZ/Ki2qtqej2CXTOayOH9bHDQF+Q48VpWyDXjbYxA4Yz8iDB31zXOBUlOHHKidDbqGVrTUvQMPmBGBw==", + "dev": true, + "requires": { + "define-property": "^2.0.2", + "extend-shallow": "^3.0.2", + "regex-not": "^1.0.2", + "safe-regex": "^1.1.0" + } + }, + "to-regex-range": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz", + "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==", + "dev": true, + "requires": { + "is-number": "^7.0.0" + } + }, + "to-string-loader": { + "version": "1.1.6", + "resolved": "https://registry.npmjs.org/to-string-loader/-/to-string-loader-1.1.6.tgz", + "integrity": "sha512-VNg62//PS1WfNwrK3n7t6wtK5Vdtx/qeYLLEioW46VMlYUwAYT6wnfB+OwS2FMTCalIHu0tk79D3RXX8ttmZTQ==", + "dev": true, + "requires": { + "loader-utils": "^1.0.0" + } + }, + "toidentifier": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/toidentifier/-/toidentifier-1.0.0.tgz", + "integrity": "sha512-yaOH/Pk/VEhBWWTlhI+qXxDFXlejDGcQipMlyxda9nthulaxLZUNcUqFxokp0vcYnvteJln5FNQDRrxj3YcbVw==", + "dev": true + }, + "topojson": { + "version": "1.6.27", + "resolved": "https://registry.npmjs.org/topojson/-/topojson-1.6.27.tgz", + "integrity": "sha1-rb4zpn4vFnPTON8SZErSD8ILQu0=", + "dev": true, + "requires": { + "d3": "3", + "d3-geo-projection": "0.2", + "d3-queue": "2", + "optimist": "0.3", + "rw": "1", + "shapefile": "0.3" + }, + "dependencies": { + "d3": { + "version": "3.5.17", + "resolved": "https://registry.npmjs.org/d3/-/d3-3.5.17.tgz", + "integrity": "sha1-vEZ0gAQ3iyGjYMn8fPUjF5B2L7g=", + "dev": true + }, + "optimist": { + "version": "0.3.7", + "resolved": "https://registry.npmjs.org/optimist/-/optimist-0.3.7.tgz", + "integrity": "sha1-yQlBrVnkJzMokjB00s8ufLxuwNk=", + "dev": true, + "requires": { + "wordwrap": "~0.0.2" + } + }, + "wordwrap": { + "version": "0.0.3", + "resolved": "https://registry.npmjs.org/wordwrap/-/wordwrap-0.0.3.tgz", + "integrity": "sha1-o9XabNXAvAAI03I0u68b7WMFkQc=", + "dev": true + } + } + }, + "tslib": { + "version": "1.10.0", + "resolved": "https://registry.npmjs.org/tslib/-/tslib-1.10.0.tgz", + "integrity": "sha512-qOebF53frne81cf0S9B41ByenJ3/IuH8yJKngAX35CmiZySA0khhkovshKK+jGCaMnVomla7gVlIcc3EvKPbTQ==" + }, + "tslint": { + "version": "5.20.0", + "resolved": "https://registry.npmjs.org/tslint/-/tslint-5.20.0.tgz", + "integrity": "sha512-2vqIvkMHbnx8acMogAERQ/IuINOq6DFqgF8/VDvhEkBqQh/x6SP0Y+OHnKth9/ZcHQSroOZwUQSN18v8KKF0/g==", + "requires": { + "@babel/code-frame": "^7.0.0", + "builtin-modules": "^1.1.1", + "chalk": "^2.3.0", + "commander": "^2.12.1", + "diff": "^4.0.1", + "glob": "^7.1.1", + "js-yaml": "^3.13.1", + "minimatch": "^3.0.4", + "mkdirp": "^0.5.1", + "resolve": "^1.3.2", + "semver": "^5.3.0", + "tslib": "^1.8.0", + "tsutils": "^2.29.0" + }, + "dependencies": { + "ansi-styles": { + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz", + "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", + "requires": { + "color-convert": "^1.9.0" + } + }, + "chalk": { + "version": "2.4.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz", + "integrity": "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==", + "requires": { + "ansi-styles": "^3.2.1", + "escape-string-regexp": "^1.0.5", + "supports-color": "^5.3.0" + } + }, + "diff": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/diff/-/diff-4.0.1.tgz", + "integrity": "sha512-s2+XdvhPCOF01LRQBC8hf4vhbVmI2CGS5aZnxLJlT5FtdhPCDFq80q++zK2KlrVorVDdL5BOGZ/VfLrVtYNF+Q==" + }, + "esprima": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/esprima/-/esprima-4.0.1.tgz", + "integrity": "sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==" + }, + "has-flag": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz", + "integrity": "sha1-tdRU3CGZriJWmfNGfloH87lVuv0=" + }, + "js-yaml": { + "version": "3.13.1", + "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-3.13.1.tgz", + "integrity": "sha512-YfbcO7jXDdyj0DGxYVSlSeQNHbD7XPWvrVWeVUujrQEoZzWJIRrCPoyk6kL6IAjAG2IolMK4T0hNUe0HOUs5Jw==", + "requires": { + "argparse": "^1.0.7", + "esprima": "^4.0.0" + } + }, + "supports-color": { + "version": "5.5.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz", + "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==", + "requires": { + "has-flag": "^3.0.0" + } + } + } + }, + "tsutils": { + "version": "2.29.0", + "resolved": "https://registry.npmjs.org/tsutils/-/tsutils-2.29.0.tgz", + "integrity": "sha512-g5JVHCIJwzfISaXpXE1qvNalca5Jwob6FjI4AoPlqMusJ6ftFE7IkkFoMhVLRgK+4Kx3gkzb8UZK5t5yTTvEmA==", + "requires": { + "tslib": "^1.8.1" + } + }, + "tty-browserify": { + "version": "0.0.0", + "resolved": "https://registry.npmjs.org/tty-browserify/-/tty-browserify-0.0.0.tgz", + "integrity": "sha1-oVe6QC2iTpv5V/mqadUk7tQpAaY=", + "dev": true + }, + "type": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/type/-/type-1.2.0.tgz", + "integrity": "sha512-+5nt5AAniqsCnu2cEQQdpzCAh33kVx8n0VoFidKpB1dVVLAN/F+bgVOqOJqOnEnrhp222clB5p3vUlD+1QAnfg==", + "dev": true + }, + "type-check": { + "version": "0.3.2", + "resolved": "https://registry.npmjs.org/type-check/-/type-check-0.3.2.tgz", + "integrity": "sha1-WITKtRLPHTVeP7eE8wgEsrUg23I=", + "dev": true, + "requires": { + "prelude-ls": "~1.1.2" + } + }, + "type-detect": { + "version": "4.0.8", + "resolved": "https://registry.npmjs.org/type-detect/-/type-detect-4.0.8.tgz", + "integrity": "sha512-0fr/mIH1dlO+x7TlcMy+bIDqKPsw/70tVyeHW787goQjhmqaZe10uwLujubK9q9Lg6Fiho1KUKDYz0Z7k7g5/g==", + "dev": true + }, + "type-fest": { + "version": "0.21.3", + "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.21.3.tgz", + "integrity": "sha512-t0rzBq87m3fVcduHDUFhKmyyX+9eo6WQjZvf51Ea/M0Q7+T374Jp1aUiyUl0GKxp8M/OETVHSDvmkyPgvX+X2w==", + "dev": true + }, + "type-is": { + "version": "1.6.18", + "resolved": "https://registry.npmjs.org/type-is/-/type-is-1.6.18.tgz", + "integrity": "sha512-TkRKr9sUTxEH8MdfuCSP7VizJyzRNMjj2J2do2Jr3Kym598JVdEksuzPQCnlFPW4ky9Q+iA+ma9BGm06XQBy8g==", + "dev": true, + "requires": { + "media-typer": "0.3.0", + "mime-types": "~2.1.24" + } + }, + "typedarray": { + "version": "0.0.6", + "resolved": "https://registry.npmjs.org/typedarray/-/typedarray-0.0.6.tgz", + "integrity": "sha1-hnrHTjhkGHsdPUfZlqeOxciDB3c=", + "dev": true + }, + "typescript": { + "version": "3.6.4", + "resolved": "https://registry.npmjs.org/typescript/-/typescript-3.6.4.tgz", + "integrity": "sha512-unoCll1+l+YK4i4F8f22TaNVPRHcD9PA3yCuZ8g5e0qGqlVlJ/8FSateOLLSagn+Yg5+ZwuPkL8LFUc0Jcvksg==", + "dev": true + }, + "ultron": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/ultron/-/ultron-1.1.1.tgz", + "integrity": "sha512-UIEXBNeYmKptWH6z8ZnqTeS8fV74zG0/eRU9VGkpzz+LIJNs8W/zM/L+7ctCkRrgbNnnR0xxw4bKOr0cW0N0Og==", + "dev": true + }, + "underscore": { + "version": "1.9.1", + "resolved": "https://registry.npmjs.org/underscore/-/underscore-1.9.1.tgz", + "integrity": "sha512-5/4etnCkd9c8gwgowi5/om/mYO5ajCaOgdzj/oW+0eQV9WxKBDZw5+ycmKmeaTXjInS/W0BzpGLo2xR2aBwZdg==" + }, + "union-value": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/union-value/-/union-value-1.0.1.tgz", + "integrity": "sha512-tJfXmxMeWYnczCVs7XAEvIV7ieppALdyepWMkHkwciRpZraG/xwT+s2JN8+pr1+8jCRf80FFzvr+MpQeeoF4Xg==", + "dev": true, + "requires": { + "arr-union": "^3.1.0", + "get-value": "^2.0.6", + "is-extendable": "^0.1.1", + "set-value": "^2.0.1" + } + }, + "uniq": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/uniq/-/uniq-1.0.1.tgz", + "integrity": "sha1-sxxa6CVIRKOoKBVBzisEuGWnNP8=" + }, + "uniqs": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/uniqs/-/uniqs-2.0.0.tgz", + "integrity": "sha1-/+3ks2slKQaW5uFl1KWe25mOawI=" + }, + "unique-filename": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/unique-filename/-/unique-filename-1.1.1.tgz", + "integrity": "sha512-Vmp0jIp2ln35UTXuryvjzkjGdRyf9b2lTXuSYUiPmzRcl3FDtYqAwOnTJkAngD9SWhnoJzDbTKwaOrZ+STtxNQ==", + "dev": true, + "requires": { + "unique-slug": "^2.0.0" + } + }, + "unique-slug": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/unique-slug/-/unique-slug-2.0.2.tgz", + "integrity": "sha512-zoWr9ObaxALD3DOPfjPSqxt4fnZiWblxHIgeWqW8x7UqDzEtHEQLzji2cuJYQFCU6KmoJikOYAZlrTHHebjx2w==", + "dev": true, + "requires": { + "imurmurhash": "^0.1.4" + } + }, + "universalify": { + "version": "0.1.2", + "resolved": "https://registry.npmjs.org/universalify/-/universalify-0.1.2.tgz", + "integrity": "sha512-rBJeI5CXAlmy1pV+617WB9J63U6XcazHHF2f2dbJix4XzpUF0RS3Zbj0FGIOCAva5P/d/GBOYaACQ1w+0azUkg==", + "dev": true + }, + "unpipe": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/unpipe/-/unpipe-1.0.0.tgz", + "integrity": "sha1-sr9O6FFKrmFltIF4KdIbLvSZBOw=", + "dev": true + }, + "unset-value": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/unset-value/-/unset-value-1.0.0.tgz", + "integrity": "sha1-g3aHP30jNRef+x5vw6jtDfyKtVk=", + "dev": true, + "requires": { + "has-value": "^0.3.1", + "isobject": "^3.0.0" + }, + "dependencies": { + "has-value": { + "version": "0.3.1", + "resolved": "https://registry.npmjs.org/has-value/-/has-value-0.3.1.tgz", + "integrity": "sha1-ex9YutpiyoJ+wKIHgCVlSEWZXh8=", + "dev": true, + "requires": { + "get-value": "^2.0.3", + "has-values": "^0.1.4", + "isobject": "^2.0.0" + }, + "dependencies": { + "isobject": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/isobject/-/isobject-2.1.0.tgz", + "integrity": "sha1-8GVWEJaj8dou9GJy+BXIQNh+DIk=", + "dev": true, + "requires": { + "isarray": "1.0.0" + } + } + } + }, + "has-values": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/has-values/-/has-values-0.1.4.tgz", + "integrity": "sha1-bWHeldkd/Km5oCCJrThL/49it3E=", + "dev": true + } + } + }, + "upath": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/upath/-/upath-1.2.0.tgz", + "integrity": "sha512-aZwGpamFO61g3OlfT7OQCHqhGnW43ieH9WZeP7QxN/G/jS4jfqUkZxoryvJgVPEcrl5NL/ggHsSmLMHuH64Lhg==", + "dev": true + }, + "uri-js": { + "version": "4.2.2", + "resolved": "https://registry.npmjs.org/uri-js/-/uri-js-4.2.2.tgz", + "integrity": "sha512-KY9Frmirql91X2Qgjry0Wd4Y+YTdrdZheS8TFwvkbLWf/G5KNJDCh6pKL5OZctEW4+0Baa5idK2ZQuELRwPznQ==", + "requires": { + "punycode": "^2.1.0" + } + }, + "urix": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/urix/-/urix-0.1.0.tgz", + "integrity": "sha1-2pN/emLiH+wf0Y1Js1wpNQZ6bHI=", + "dev": true + }, + "url": { + "version": "0.11.0", + "resolved": "https://registry.npmjs.org/url/-/url-0.11.0.tgz", + "integrity": "sha1-ODjpfPxgUh63PFJajlW/3Z4uKPE=", + "dev": true, + "requires": { + "punycode": "1.3.2", + "querystring": "0.2.0" + }, + "dependencies": { + "punycode": { + "version": "1.3.2", + "resolved": "https://registry.npmjs.org/punycode/-/punycode-1.3.2.tgz", + "integrity": "sha1-llOgNvt8HuQjQvIyXM7v6jkmxI0=", + "dev": true + } + } + }, + "url-join": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/url-join/-/url-join-2.0.5.tgz", + "integrity": "sha1-WvIvGMBSoACkjXuCxenC4v7tpyg=", + "dev": true + }, + "url-loader": { + "version": "0.5.9", + "resolved": "https://registry.npmjs.org/url-loader/-/url-loader-0.5.9.tgz", + "integrity": "sha512-B7QYFyvv+fOBqBVeefsxv6koWWtjmHaMFT6KZWti4KRw8YUD/hOU+3AECvXuzyVawIBx3z7zQRejXCDSO5kk1Q==", + "dev": true, + "requires": { + "loader-utils": "^1.0.2", + "mime": "1.3.x" + }, + "dependencies": { + "mime": { + "version": "1.3.6", + "resolved": "https://registry.npmjs.org/mime/-/mime-1.3.6.tgz", + "integrity": "sha1-WR2E02U6awtKO5343lqoEI5y5eA=", + "dev": true + } + } + }, + "url-parse": { + "version": "1.4.7", + "resolved": "https://registry.npmjs.org/url-parse/-/url-parse-1.4.7.tgz", + "integrity": "sha512-d3uaVyzDB9tQoSXFvuSUNFibTd9zxd2bkVrDRvF5TmvWWQwqE4lgYJ5m+x1DbecWkw+LK4RNl2CU1hHuOKPVlg==", + "requires": { + "querystringify": "^2.1.1", + "requires-port": "^1.0.0" + } + }, + "url-parse-lax": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/url-parse-lax/-/url-parse-lax-3.0.0.tgz", + "integrity": "sha1-FrXK/Afb42dsGxmZF3gj1lA6yww=", + "dev": true, + "requires": { + "prepend-http": "^2.0.0" + }, + "dependencies": { + "prepend-http": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/prepend-http/-/prepend-http-2.0.0.tgz", + "integrity": "sha1-6SQ0v6XqjBn0HN/UAddBo8gZ2Jc=", + "dev": true + } + } + }, + "use": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/use/-/use-3.1.1.tgz", + "integrity": "sha512-cwESVXlO3url9YWlFW/TA9cshCEhtu7IKJ/p5soJ/gGpj7vbvFrAY/eIioQ6Dw23KjZhYgiIo8HOs1nQ2vr/oQ==", + "dev": true + }, + "useragent": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/useragent/-/useragent-2.3.0.tgz", + "integrity": "sha512-4AoH4pxuSvHCjqLO04sU6U/uE65BYza8l/KKBS0b0hnUPWi+cQ2BpeTEwejCSx9SPV5/U03nniDTrWx5NrmKdw==", + "dev": true, + "requires": { + "lru-cache": "4.1.x", + "tmp": "0.0.x" + } + }, + "util": { + "version": "0.11.1", + "resolved": "https://registry.npmjs.org/util/-/util-0.11.1.tgz", + "integrity": "sha512-HShAsny+zS2TZfaXxD9tYj4HQGlBezXZMZuM/S5PKLLoZkShZiGk9o5CzukI1LVHZvjdvZ2Sj1aW/Ndn2NB/HQ==", + "dev": true, + "requires": { + "inherits": "2.0.3" + }, + "dependencies": { + "inherits": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.3.tgz", + "integrity": "sha1-Yzwsg+PaQqUC9SRmAiSA9CCCYd4=", + "dev": true + } + } + }, + "util-deprecate": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz", + "integrity": "sha1-RQ1Nyfpw3nMnYvvS1KKJgUGaDM8=", + "dev": true + }, + "utils-merge": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/utils-merge/-/utils-merge-1.0.1.tgz", + "integrity": "sha1-n5VxD1CiZ5R7LMwSR0HBAoQn5xM=", + "dev": true + }, + "uuid": { + "version": "3.3.3", + "resolved": "https://registry.npmjs.org/uuid/-/uuid-3.3.3.tgz", + "integrity": "sha512-pW0No1RGHgzlpHJO1nsVrHKpOEIxkGg1xB+v0ZmdNH5OAeAwzAVrCnI2/6Mtx+Uys6iaylxa+D3g4j63IKKjSQ==", + "dev": true + }, + "v8-compile-cache": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/v8-compile-cache/-/v8-compile-cache-2.0.3.tgz", + "integrity": "sha512-CNmdbwQMBjwr9Gsmohvm0pbL954tJrNzf6gWL3K+QMQf00PF7ERGrEiLgjuU3mKreLC2MeGhUsNV9ybTbLgd3w==", + "dev": true + }, + "validate-npm-package-license": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/validate-npm-package-license/-/validate-npm-package-license-3.0.4.tgz", + "integrity": "sha512-DpKm2Ui/xN7/HQKCtpZxoRWBhZ9Z0kqtygG8XCgNQ8ZlDnxuQmWhj566j8fN4Cu3/JmbhsDo7fcAJq4s9h27Ew==", + "dev": true, + "requires": { + "spdx-correct": "^3.0.0", + "spdx-expression-parse": "^3.0.0" + } + }, + "vendors": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/vendors/-/vendors-1.0.3.tgz", + "integrity": "sha512-fOi47nsJP5Wqefa43kyWSg80qF+Q3XA6MUkgi7Hp1HQaKDQW4cQrK2D0P7mmbFtsV1N89am55Yru/nyEwRubcw==" + }, + "vlq": { + "version": "0.2.3", + "resolved": "https://registry.npmjs.org/vlq/-/vlq-0.2.3.tgz", + "integrity": "sha512-DRibZL6DsNhIgYQ+wNdWDL2SL3bKPlVrRiBqV5yuMm++op8W4kGFtaQfCs4KEJn0wBZcHVHJ3eoywX8983k1ow==", + "dev": true + }, + "vm-browserify": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/vm-browserify/-/vm-browserify-1.1.0.tgz", + "integrity": "sha512-iq+S7vZJE60yejDYM0ek6zg308+UZsdtPExWP9VZoCFCz1zkJoXFnAX7aZfd/ZwrkidzdUZL0C/ryW+JwAiIGw==", + "dev": true + }, + "void-elements": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/void-elements/-/void-elements-2.0.1.tgz", + "integrity": "sha1-wGavtYK7HLQSjWDqkjkulNXp2+w=", + "dev": true + }, + "walkdir": { + "version": "0.0.7", + "resolved": "https://registry.npmjs.org/walkdir/-/walkdir-0.0.7.tgz", + "integrity": "sha1-BNoCcKh6d4VAFzzb8KLbSZqNnik=" + }, + "watchpack": { + "version": "1.6.0", + "resolved": "https://registry.npmjs.org/watchpack/-/watchpack-1.6.0.tgz", + "integrity": "sha512-i6dHe3EyLjMmDlU1/bGQpEw25XSjkJULPuAVKCbNRefQVq48yXKUpwg538F7AZTf9kyr57zj++pQFltUa5H7yA==", + "dev": true, + "requires": { + "chokidar": "^2.0.2", + "graceful-fs": "^4.1.2", + "neo-async": "^2.5.0" + }, + "dependencies": { + "anymatch": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-2.0.0.tgz", + "integrity": "sha512-5teOsQWABXHHBFP9y3skS5P3d/WfWXpv3FUpy+LorMrNYaT9pI4oLMQX7jzQ2KklNpGpWHzdCXTDT2Y3XGlZBw==", + "dev": true, + "requires": { + "micromatch": "^3.1.4", + "normalize-path": "^2.1.1" + }, + "dependencies": { + "normalize-path": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-2.1.1.tgz", + "integrity": "sha1-GrKLVW4Zg2Oowab35vogE3/mrtk=", + "dev": true, + "requires": { + "remove-trailing-separator": "^1.0.1" + } + } + } + }, + "binary-extensions": { + "version": "1.13.1", + "resolved": "https://registry.npmjs.org/binary-extensions/-/binary-extensions-1.13.1.tgz", + "integrity": "sha512-Un7MIEDdUC5gNpcGDV97op1Ywk748MpHcFTHoYs6qnj1Z3j7I53VG3nwZhKzoBZmbdRNnb6WRdFlwl7tSDuZGw==", + "dev": true + }, + "braces": { + "version": "2.3.2", + "resolved": "https://registry.npmjs.org/braces/-/braces-2.3.2.tgz", + "integrity": "sha512-aNdbnj9P8PjdXU4ybaWLK2IF3jc/EoDYbC7AazW6to3TRsfXxscC9UXOB5iDiEQrkyIbWp2SLQda4+QAa7nc3w==", + "dev": true, + "requires": { + "arr-flatten": "^1.1.0", + "array-unique": "^0.3.2", + "extend-shallow": "^2.0.1", + "fill-range": "^4.0.0", + "isobject": "^3.0.1", + "repeat-element": "^1.1.2", + "snapdragon": "^0.8.1", + "snapdragon-node": "^2.0.1", + "split-string": "^3.0.2", + "to-regex": "^3.0.1" + } + }, + "chokidar": { + "version": "2.1.8", + "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-2.1.8.tgz", + "integrity": "sha512-ZmZUazfOzf0Nve7duiCKD23PFSCs4JPoYyccjUFF3aQkQadqBhfzhjkwBH2mNOG9cTBwhamM37EIsIkZw3nRgg==", + "dev": true, + "requires": { + "anymatch": "^2.0.0", + "async-each": "^1.0.1", + "braces": "^2.3.2", + "fsevents": "^1.2.7", + "glob-parent": "^3.1.0", + "inherits": "^2.0.3", + "is-binary-path": "^1.0.0", + "is-glob": "^4.0.0", + "normalize-path": "^3.0.0", + "path-is-absolute": "^1.0.0", + "readdirp": "^2.2.1", + "upath": "^1.1.1" + } + }, + "extend-shallow": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz", + "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=", + "dev": true, + "requires": { + "is-extendable": "^0.1.0" + } + }, + "fill-range": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-4.0.0.tgz", + "integrity": "sha1-1USBHUKPmOsGpj3EAtJAPDKMOPc=", + "dev": true, + "requires": { + "extend-shallow": "^2.0.1", + "is-number": "^3.0.0", + "repeat-string": "^1.6.1", + "to-regex-range": "^2.1.0" + } + }, + "fsevents": { + "version": "1.2.9", + "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-1.2.9.tgz", + "integrity": "sha512-oeyj2H3EjjonWcFjD5NvZNE9Rqe4UW+nQBU2HNeKw0koVLEFIhtyETyAakeAM3de7Z/SW5kcA+fZUait9EApnw==", + "dev": true, + "optional": true, + "requires": { + "nan": "^2.12.1", + "node-pre-gyp": "^0.12.0" + }, + "dependencies": { + "abbrev": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/abbrev/-/abbrev-1.1.1.tgz", + "integrity": "sha512-nne9/IiQ/hzIhY6pdDnbBtz7DjPTKrY00P/zvPSm5pOFkl6xuGrGnXn/VtTNNfNtAfZ9/1RtehkszU9qcTii0Q==", + "dev": true, + "optional": true + }, + "ansi-regex": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-2.1.1.tgz", + "integrity": "sha1-w7M6te42DYbg5ijwRorn7yfWVN8=", + "dev": true, + "optional": true + }, + "aproba": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/aproba/-/aproba-1.2.0.tgz", + "integrity": "sha512-Y9J6ZjXtoYh8RnXVCMOU/ttDmk1aBjunq9vO0ta5x85WDQiQfUF9sIPBITdbiiIVcBo03Hi3jMxigBtsddlXRw==", + "dev": true, + "optional": true + }, + "are-we-there-yet": { + "version": "1.1.5", + "resolved": "https://registry.npmjs.org/are-we-there-yet/-/are-we-there-yet-1.1.5.tgz", + "integrity": "sha512-5hYdAkZlcG8tOLujVDTgCT+uPX0VnpAH28gWsLfzpXYm7wP6mp5Q/gYyR7YQ0cKVJcXJnl3j2kpBan13PtQf6w==", + "dev": true, + "optional": true, + "requires": { + "delegates": "^1.0.0", + "readable-stream": "^2.0.6" + } + }, + "balanced-match": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.0.tgz", + "integrity": "sha1-ibTRmasr7kneFk6gK4nORi1xt2c=", + "dev": true, + "optional": true + }, + "brace-expansion": { + "version": "1.1.11", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz", + "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==", + "dev": true, + "optional": true, + "requires": { + "balanced-match": "^1.0.0", + "concat-map": "0.0.1" + } + }, + "chownr": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/chownr/-/chownr-1.1.1.tgz", + "integrity": "sha512-j38EvO5+LHX84jlo6h4UzmOwi0UgW61WRyPtJz4qaadK5eY3BTS5TY/S1Stc3Uk2lIM6TPevAlULiEJwie860g==", + "dev": true, + "optional": true + }, + "code-point-at": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/code-point-at/-/code-point-at-1.1.0.tgz", + "integrity": "sha1-DQcLTQQ6W+ozovGkDi7bPZpMz3c=", + "dev": true, + "optional": true + }, + "concat-map": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz", + "integrity": "sha1-2Klr13/Wjfd5OnMDajug1UBdR3s=", + "dev": true, + "optional": true + }, + "console-control-strings": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/console-control-strings/-/console-control-strings-1.1.0.tgz", + "integrity": "sha1-PXz0Rk22RG6mRL9LOVB/mFEAjo4=", + "dev": true, + "optional": true + }, + "core-util-is": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/core-util-is/-/core-util-is-1.0.2.tgz", + "integrity": "sha1-tf1UIgqivFq1eqtxQMlAdUUDwac=", + "dev": true, + "optional": true + }, + "debug": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/debug/-/debug-4.1.1.tgz", + "integrity": "sha512-pYAIzeRo8J6KPEaJ0VWOh5Pzkbw/RetuzehGM7QRRX5he4fPHx2rdKMB256ehJCkX+XRQm16eZLqLNS8RSZXZw==", + "dev": true, + "optional": true, + "requires": { + "ms": "^2.1.1" + } + }, + "deep-extend": { + "version": "0.6.0", + "resolved": "https://registry.npmjs.org/deep-extend/-/deep-extend-0.6.0.tgz", + "integrity": "sha512-LOHxIOaPYdHlJRtCQfDIVZtfw/ufM8+rVj649RIHzcm/vGwQRXFt6OPqIFWsm2XEMrNIEtWR64sY1LEKD2vAOA==", + "dev": true, + "optional": true + }, + "delegates": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/delegates/-/delegates-1.0.0.tgz", + "integrity": "sha1-hMbhWbgZBP3KWaDvRM2HDTElD5o=", + "dev": true, + "optional": true + }, + "detect-libc": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/detect-libc/-/detect-libc-1.0.3.tgz", + "integrity": "sha1-+hN8S9aY7fVc1c0CrFWfkaTEups=", + "dev": true, + "optional": true + }, + "fs-minipass": { + "version": "1.2.5", + "resolved": "https://registry.npmjs.org/fs-minipass/-/fs-minipass-1.2.5.tgz", + "integrity": "sha512-JhBl0skXjUPCFH7x6x61gQxrKyXsxB5gcgePLZCwfyCGGsTISMoIeObbrvVeP6Xmyaudw4TT43qV2Gz+iyd2oQ==", + "dev": true, + "optional": true, + "requires": { + "minipass": "^2.2.1" + } + }, + "fs.realpath": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz", + "integrity": "sha1-FQStJSMVjKpA20onh8sBQRmU6k8=", + "dev": true, + "optional": true + }, + "gauge": { + "version": "2.7.4", + "resolved": "https://registry.npmjs.org/gauge/-/gauge-2.7.4.tgz", + "integrity": "sha1-LANAXHU4w51+s3sxcCLjJfsBi/c=", + "dev": true, + "optional": true, + "requires": { + "aproba": "^1.0.3", + "console-control-strings": "^1.0.0", + "has-unicode": "^2.0.0", + "object-assign": "^4.1.0", + "signal-exit": "^3.0.0", + "string-width": "^1.0.1", + "strip-ansi": "^3.0.1", + "wide-align": "^1.1.0" + } + }, + "glob": { + "version": "7.1.3", + "resolved": "https://registry.npmjs.org/glob/-/glob-7.1.3.tgz", + "integrity": "sha512-vcfuiIxogLV4DlGBHIUOwI0IbrJ8HWPc4MU7HzviGeNho/UJDfi6B5p3sHeWIQ0KGIU0Jpxi5ZHxemQfLkkAwQ==", + "dev": true, + "optional": true, + "requires": { + "fs.realpath": "^1.0.0", + "inflight": "^1.0.4", + "inherits": "2", + "minimatch": "^3.0.4", + "once": "^1.3.0", + "path-is-absolute": "^1.0.0" + } + }, + "has-unicode": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/has-unicode/-/has-unicode-2.0.1.tgz", + "integrity": "sha1-4Ob+aijPUROIVeCG0Wkedx3iqLk=", + "dev": true, + "optional": true + }, + "iconv-lite": { + "version": "0.4.24", + "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.24.tgz", + "integrity": "sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==", + "dev": true, + "optional": true, + "requires": { + "safer-buffer": ">= 2.1.2 < 3" + } + }, + "ignore-walk": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/ignore-walk/-/ignore-walk-3.0.1.tgz", + "integrity": "sha512-DTVlMx3IYPe0/JJcYP7Gxg7ttZZu3IInhuEhbchuqneY9wWe5Ojy2mXLBaQFUQmo0AW2r3qG7m1mg86js+gnlQ==", + "dev": true, + "optional": true, + "requires": { + "minimatch": "^3.0.4" + } + }, + "inflight": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz", + "integrity": "sha1-Sb1jMdfQLQwJvJEKEHW6gWW1bfk=", + "dev": true, + "optional": true, + "requires": { + "once": "^1.3.0", + "wrappy": "1" + } + }, + "inherits": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.3.tgz", + "integrity": "sha1-Yzwsg+PaQqUC9SRmAiSA9CCCYd4=", + "dev": true, + "optional": true + }, + "ini": { + "version": "1.3.5", + "resolved": "https://registry.npmjs.org/ini/-/ini-1.3.5.tgz", + "integrity": "sha512-RZY5huIKCMRWDUqZlEi72f/lmXKMvuszcMBduliQ3nnWbx9X/ZBQO7DijMEYS9EhHBb2qacRUMtC7svLwe0lcw==", + "dev": true, + "optional": true + }, + "is-fullwidth-code-point": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-1.0.0.tgz", + "integrity": "sha1-754xOG8DGn8NZDr4L95QxFfvAMs=", + "dev": true, + "optional": true, + "requires": { + "number-is-nan": "^1.0.0" + } + }, + "isarray": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz", + "integrity": "sha1-u5NdSFgsuhaMBoNJV6VKPgcSTxE=", + "dev": true, + "optional": true + }, + "minimatch": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.0.4.tgz", + "integrity": "sha512-yJHVQEhyqPLUTgt9B83PXu6W3rx4MvvHvSUvToogpwoGDOUQ+yDrR0HRot+yOCdCO7u4hX3pWft6kWBBcqh0UA==", + "dev": true, + "optional": true, + "requires": { + "brace-expansion": "^1.1.7" + } + }, + "minimist": { + "version": "0.0.8", + "resolved": "https://registry.npmjs.org/minimist/-/minimist-0.0.8.tgz", + "integrity": "sha1-hX/Kv8M5fSYluCKCYuhqp6ARsF0=", + "dev": true, + "optional": true + }, + "minipass": { + "version": "2.3.5", + "resolved": "https://registry.npmjs.org/minipass/-/minipass-2.3.5.tgz", + "integrity": "sha512-Gi1W4k059gyRbyVUZQ4mEqLm0YIUiGYfvxhF6SIlk3ui1WVxMTGfGdQ2SInh3PDrRTVvPKgULkpJtT4RH10+VA==", + "dev": true, + "optional": true, + "requires": { + "safe-buffer": "^5.1.2", + "yallist": "^3.0.0" + } + }, + "minizlib": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/minizlib/-/minizlib-1.2.1.tgz", + "integrity": "sha512-7+4oTUOWKg7AuL3vloEWekXY2/D20cevzsrNT2kGWm+39J9hGTCBv8VI5Pm5lXZ/o3/mdR4f8rflAPhnQb8mPA==", + "dev": true, + "optional": true, + "requires": { + "minipass": "^2.2.1" + } + }, + "mkdirp": { + "version": "0.5.1", + "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-0.5.1.tgz", + "integrity": "sha1-MAV0OOrGz3+MR2fzhkjWaX11yQM=", + "dev": true, + "optional": true, + "requires": { + "minimist": "0.0.8" + } + }, + "ms": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.1.tgz", + "integrity": "sha512-tgp+dl5cGk28utYktBsrFqA7HKgrhgPsg6Z/EfhWI4gl1Hwq8B/GmY/0oXZ6nF8hDVesS/FpnYaD/kOWhYQvyg==", + "dev": true, + "optional": true + }, + "needle": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/needle/-/needle-2.3.0.tgz", + "integrity": "sha512-QBZu7aAFR0522EyaXZM0FZ9GLpq6lvQ3uq8gteiDUp7wKdy0lSd2hPlgFwVuW1CBkfEs9PfDQsQzZghLs/psdg==", + "dev": true, + "optional": true, + "requires": { + "debug": "^4.1.0", + "iconv-lite": "^0.4.4", + "sax": "^1.2.4" + } + }, + "node-pre-gyp": { + "version": "0.12.0", + "resolved": "https://registry.npmjs.org/node-pre-gyp/-/node-pre-gyp-0.12.0.tgz", + "integrity": "sha512-4KghwV8vH5k+g2ylT+sLTjy5wmUOb9vPhnM8NHvRf9dHmnW/CndrFXy2aRPaPST6dugXSdHXfeaHQm77PIz/1A==", + "dev": true, + "optional": true, + "requires": { + "detect-libc": "^1.0.2", + "mkdirp": "^0.5.1", + "needle": "^2.2.1", + "nopt": "^4.0.1", + "npm-packlist": "^1.1.6", + "npmlog": "^4.0.2", + "rc": "^1.2.7", + "rimraf": "^2.6.1", + "semver": "^5.3.0", + "tar": "^4" + } + }, + "nopt": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/nopt/-/nopt-4.0.1.tgz", + "integrity": "sha1-0NRoWv1UFRk8jHUFYC0NF81kR00=", + "dev": true, + "optional": true, + "requires": { + "abbrev": "1", + "osenv": "^0.1.4" + } + }, + "npm-bundled": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/npm-bundled/-/npm-bundled-1.0.6.tgz", + "integrity": "sha512-8/JCaftHwbd//k6y2rEWp6k1wxVfpFzB6t1p825+cUb7Ym2XQfhwIC5KwhrvzZRJu+LtDE585zVaS32+CGtf0g==", + "dev": true, + "optional": true + }, + "npm-packlist": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/npm-packlist/-/npm-packlist-1.4.1.tgz", + "integrity": "sha512-+TcdO7HJJ8peiiYhvPxsEDhF3PJFGUGRcFsGve3vxvxdcpO2Z4Z7rkosRM0kWj6LfbK/P0gu3dzk5RU1ffvFcw==", + "dev": true, + "optional": true, + "requires": { + "ignore-walk": "^3.0.1", + "npm-bundled": "^1.0.1" + } + }, + "npmlog": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/npmlog/-/npmlog-4.1.2.tgz", + "integrity": "sha512-2uUqazuKlTaSI/dC8AzicUck7+IrEaOnN/e0jd3Xtt1KcGpwx30v50mL7oPyr/h9bL3E4aZccVwpwP+5W9Vjkg==", + "dev": true, + "optional": true, + "requires": { + "are-we-there-yet": "~1.1.2", + "console-control-strings": "~1.1.0", + "gauge": "~2.7.3", + "set-blocking": "~2.0.0" + } + }, + "number-is-nan": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/number-is-nan/-/number-is-nan-1.0.1.tgz", + "integrity": "sha1-CXtgK1NCKlIsGvuHkDGDNpQaAR0=", + "dev": true, + "optional": true + }, + "object-assign": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz", + "integrity": "sha1-IQmtx5ZYh8/AXLvUQsrIv7s2CGM=", + "dev": true, + "optional": true + }, + "once": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz", + "integrity": "sha1-WDsap3WWHUsROsF9nFC6753Xa9E=", + "dev": true, + "optional": true, + "requires": { + "wrappy": "1" + } + }, + "os-homedir": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/os-homedir/-/os-homedir-1.0.2.tgz", + "integrity": "sha1-/7xJiDNuDoM94MFox+8VISGqf7M=", + "dev": true, + "optional": true + }, + "os-tmpdir": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/os-tmpdir/-/os-tmpdir-1.0.2.tgz", + "integrity": "sha1-u+Z0BseaqFxc/sdm/lc0VV36EnQ=", + "dev": true, + "optional": true + }, + "osenv": { + "version": "0.1.5", + "resolved": "https://registry.npmjs.org/osenv/-/osenv-0.1.5.tgz", + "integrity": "sha512-0CWcCECdMVc2Rw3U5w9ZjqX6ga6ubk1xDVKxtBQPK7wis/0F2r9T6k4ydGYhecl7YUBxBVxhL5oisPsNxAPe2g==", + "dev": true, + "optional": true, + "requires": { + "os-homedir": "^1.0.0", + "os-tmpdir": "^1.0.0" + } + }, + "path-is-absolute": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz", + "integrity": "sha1-F0uSaHNVNP+8es5r9TpanhtcX18=", + "dev": true, + "optional": true + }, + "process-nextick-args": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/process-nextick-args/-/process-nextick-args-2.0.0.tgz", + "integrity": "sha512-MtEC1TqN0EU5nephaJ4rAtThHtC86dNN9qCuEhtshvpVBkAW5ZO7BASN9REnF9eoXGcRub+pFuKEpOHE+HbEMw==", + "dev": true, + "optional": true + }, + "rc": { + "version": "1.2.8", + "resolved": "https://registry.npmjs.org/rc/-/rc-1.2.8.tgz", + "integrity": "sha512-y3bGgqKj3QBdxLbLkomlohkvsA8gdAiUQlSBJnBhfn+BPxg4bc62d8TcBW15wavDfgexCgccckhcZvywyQYPOw==", + "dev": true, + "optional": true, + "requires": { + "deep-extend": "^0.6.0", + "ini": "~1.3.0", + "minimist": "^1.2.0", + "strip-json-comments": "~2.0.1" + }, + "dependencies": { + "minimist": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.0.tgz", + "integrity": "sha1-o1AIsg9BOD7sH7kU9M1d95omQoQ=", + "dev": true, + "optional": true + } + } + }, + "readable-stream": { + "version": "2.3.6", + "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.6.tgz", + "integrity": "sha512-tQtKA9WIAhBF3+VLAseyMqZeBjW0AHJoxOtYqSUZNJxauErmLbVm2FW1y+J/YA9dUrAC39ITejlZWhVIwawkKw==", + "dev": true, + "optional": true, + "requires": { + "core-util-is": "~1.0.0", + "inherits": "~2.0.3", + "isarray": "~1.0.0", + "process-nextick-args": "~2.0.0", + "safe-buffer": "~5.1.1", + "string_decoder": "~1.1.1", + "util-deprecate": "~1.0.1" + } + }, + "rimraf": { + "version": "2.6.3", + "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-2.6.3.tgz", + "integrity": "sha512-mwqeW5XsA2qAejG46gYdENaxXjx9onRNCfn7L0duuP4hCuTIi/QO7PDK07KJfp1d+izWPrzEJDcSqBa0OZQriA==", + "dev": true, + "optional": true, + "requires": { + "glob": "^7.1.3" + } + }, + "safe-buffer": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz", + "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==", + "dev": true, + "optional": true + }, + "safer-buffer": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz", + "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==", + "dev": true, + "optional": true + }, + "sax": { + "version": "1.2.4", + "resolved": "https://registry.npmjs.org/sax/-/sax-1.2.4.tgz", + "integrity": "sha512-NqVDv9TpANUjFm0N8uM5GxL36UgKi9/atZw+x7YFnQ8ckwFGKrl4xX4yWtrey3UJm5nP1kUbnYgLopqWNSRhWw==", + "dev": true, + "optional": true + }, + "semver": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/semver/-/semver-5.7.0.tgz", + "integrity": "sha512-Ya52jSX2u7QKghxeoFGpLwCtGlt7j0oY9DYb5apt9nPlJ42ID+ulTXESnt/qAQcoSERyZ5sl3LDIOw0nAn/5DA==", + "dev": true, + "optional": true + }, + "set-blocking": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/set-blocking/-/set-blocking-2.0.0.tgz", + "integrity": "sha1-BF+XgtARrppoA93TgrJDkrPYkPc=", + "dev": true, + "optional": true + }, + "signal-exit": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.2.tgz", + "integrity": "sha1-tf3AjxKH6hF4Yo5BXiUTK3NkbG0=", + "dev": true, + "optional": true + }, + "string-width": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-1.0.2.tgz", + "integrity": "sha1-EYvfW4zcUaKn5w0hHgfisLmxB9M=", + "dev": true, + "optional": true, + "requires": { + "code-point-at": "^1.0.0", + "is-fullwidth-code-point": "^1.0.0", + "strip-ansi": "^3.0.0" + } + }, + "string_decoder": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz", + "integrity": "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==", + "dev": true, + "optional": true, + "requires": { + "safe-buffer": "~5.1.0" + } + }, + "strip-ansi": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-3.0.1.tgz", + "integrity": "sha1-ajhfuIU9lS1f8F0Oiq+UJ43GPc8=", + "dev": true, + "optional": true, + "requires": { + "ansi-regex": "^2.0.0" + } + }, + "strip-json-comments": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-2.0.1.tgz", + "integrity": "sha1-PFMZQukIwml8DsNEhYwobHygpgo=", + "dev": true, + "optional": true + }, + "tar": { + "version": "4.4.8", + "resolved": "https://registry.npmjs.org/tar/-/tar-4.4.8.tgz", + "integrity": "sha512-LzHF64s5chPQQS0IYBn9IN5h3i98c12bo4NCO7e0sGM2llXQ3p2FGC5sdENN4cTW48O915Sh+x+EXx7XW96xYQ==", + "dev": true, + "optional": true, + "requires": { + "chownr": "^1.1.1", + "fs-minipass": "^1.2.5", + "minipass": "^2.3.4", + "minizlib": "^1.1.1", + "mkdirp": "^0.5.0", + "safe-buffer": "^5.1.2", + "yallist": "^3.0.2" + } + }, + "util-deprecate": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz", + "integrity": "sha1-RQ1Nyfpw3nMnYvvS1KKJgUGaDM8=", + "dev": true, + "optional": true + }, + "wide-align": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/wide-align/-/wide-align-1.1.3.tgz", + "integrity": "sha512-QGkOQc8XL6Bt5PwnsExKBPuMKBxnGxWWW3fU55Xt4feHozMUhdUMaBCk290qpm/wG5u/RSKzwdAC4i51YigihA==", + "dev": true, + "optional": true, + "requires": { + "string-width": "^1.0.2 || 2" + } + }, + "wrappy": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz", + "integrity": "sha1-tSQ9jz7BqjXxNkYFvA0QNuMKtp8=", + "dev": true, + "optional": true + }, + "yallist": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-3.0.3.tgz", + "integrity": "sha512-S+Zk8DEWE6oKpV+vI3qWkaK+jSbIK86pCwe2IF/xwIpQ8jEuxpw9NyaGjmp9+BoJv5FV2piqCDcoCtStppiq2A==", + "dev": true, + "optional": true + } + } + }, + "glob-parent": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-3.1.0.tgz", + "integrity": "sha1-nmr2KZ2NO9K9QEMIMr0RPfkGxa4=", + "dev": true, + "requires": { + "is-glob": "^3.1.0", + "path-dirname": "^1.0.0" + }, + "dependencies": { + "is-glob": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-3.1.0.tgz", + "integrity": "sha1-e6WuJCF4BKxwcHuWkiVnSGzD6Eo=", + "dev": true, + "requires": { + "is-extglob": "^2.1.0" + } + } + } + }, + "is-binary-path": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/is-binary-path/-/is-binary-path-1.0.1.tgz", + "integrity": "sha1-dfFmQrSA8YenEcgUFh/TpKdlWJg=", + "dev": true, + "requires": { + "binary-extensions": "^1.0.0" + } + }, + "is-number": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/is-number/-/is-number-3.0.0.tgz", + "integrity": "sha1-JP1iAaR4LPUFYcgQJ2r8fRLXEZU=", + "dev": true, + "requires": { + "kind-of": "^3.0.2" + } + }, + "kind-of": { + "version": "3.2.2", + "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz", + "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=", + "dev": true, + "requires": { + "is-buffer": "^1.1.5" + } + }, + "readdirp": { + "version": "2.2.1", + "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-2.2.1.tgz", + "integrity": "sha512-1JU/8q+VgFZyxwrJ+SVIOsh+KywWGpds3NTqikiKpDMZWScmAYyKIgqkO+ARvNWJfXeXR1zxz7aHF4u4CyH6vQ==", + "dev": true, + "requires": { + "graceful-fs": "^4.1.11", + "micromatch": "^3.1.10", + "readable-stream": "^2.0.2" + } + }, + "to-regex-range": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-2.1.1.tgz", + "integrity": "sha1-fIDBe53+vlmeJzZ+DU3VWQFB2zg=", + "dev": true, + "requires": { + "is-number": "^3.0.0", + "repeat-string": "^1.6.1" + } + } + } + }, + "webpack": { + "version": "4.41.2", + "resolved": "https://registry.npmjs.org/webpack/-/webpack-4.41.2.tgz", + "integrity": "sha512-Zhw69edTGfbz9/8JJoyRQ/pq8FYUoY0diOXqW0T6yhgdhCv6wr0hra5DwwWexNRns2Z2+gsnrNcbe9hbGBgk/A==", + "dev": true, + "requires": { + "@webassemblyjs/ast": "1.8.5", + "@webassemblyjs/helper-module-context": "1.8.5", + "@webassemblyjs/wasm-edit": "1.8.5", + "@webassemblyjs/wasm-parser": "1.8.5", + "acorn": "^6.2.1", + "ajv": "^6.10.2", + "ajv-keywords": "^3.4.1", + "chrome-trace-event": "^1.0.2", + "enhanced-resolve": "^4.1.0", + "eslint-scope": "^4.0.3", + "json-parse-better-errors": "^1.0.2", + "loader-runner": "^2.4.0", + "loader-utils": "^1.2.3", + "memory-fs": "^0.4.1", + "micromatch": "^3.1.10", + "mkdirp": "^0.5.1", + "neo-async": "^2.6.1", + "node-libs-browser": "^2.2.1", + "schema-utils": "^1.0.0", + "tapable": "^1.1.3", + "terser-webpack-plugin": "^1.4.1", + "watchpack": "^1.6.0", + "webpack-sources": "^1.4.1" + }, + "dependencies": { + "schema-utils": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/schema-utils/-/schema-utils-1.0.0.tgz", + "integrity": "sha512-i27Mic4KovM/lnGsy8whRCHhc7VicJajAjTrYg11K9zfZXnYIt4k5F+kZkwjnrhKzLic/HLU4j11mjsz2G/75g==", + "dev": true, + "requires": { + "ajv": "^6.1.0", + "ajv-errors": "^1.0.0", + "ajv-keywords": "^3.1.0" + } + } + } + }, + "webpack-cli": { + "version": "3.3.9", + "resolved": "https://registry.npmjs.org/webpack-cli/-/webpack-cli-3.3.9.tgz", + "integrity": "sha512-xwnSxWl8nZtBl/AFJCOn9pG7s5CYUYdZxmmukv+fAHLcBIHM36dImfpQg3WfShZXeArkWlf6QRw24Klcsv8a5A==", + "dev": true, + "requires": { + "chalk": "2.4.2", + "cross-spawn": "6.0.5", + "enhanced-resolve": "4.1.0", + "findup-sync": "3.0.0", + "global-modules": "2.0.0", + "import-local": "2.0.0", + "interpret": "1.2.0", + "loader-utils": "1.2.3", + "supports-color": "6.1.0", + "v8-compile-cache": "2.0.3", + "yargs": "13.2.4" + }, + "dependencies": { + "ansi-styles": { + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz", + "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", + "dev": true, + "requires": { + "color-convert": "^1.9.0" + } + }, + "chalk": { + "version": "2.4.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz", + "integrity": "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==", + "dev": true, + "requires": { + "ansi-styles": "^3.2.1", + "escape-string-regexp": "^1.0.5", + "supports-color": "^5.3.0" + }, + "dependencies": { + "supports-color": { + "version": "5.5.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz", + "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==", + "dev": true, + "requires": { + "has-flag": "^3.0.0" + } + } + } + }, + "enhanced-resolve": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/enhanced-resolve/-/enhanced-resolve-4.1.0.tgz", + "integrity": "sha512-F/7vkyTtyc/llOIn8oWclcB25KdRaiPBpZYDgJHgh/UHtpgT2p2eldQgtQnLtUvfMKPKxbRaQM/hHkvLHt1Vng==", + "dev": true, + "requires": { + "graceful-fs": "^4.1.2", + "memory-fs": "^0.4.0", + "tapable": "^1.0.0" + } + }, + "has-flag": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz", + "integrity": "sha1-tdRU3CGZriJWmfNGfloH87lVuv0=", + "dev": true + }, + "supports-color": { + "version": "6.1.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-6.1.0.tgz", + "integrity": "sha512-qe1jfm1Mg7Nq/NSh6XE24gPXROEVsWHxC1LIx//XNlD9iw7YZQGjZNjYN7xGaEG6iKdA8EtNFW6R0gjnVXp+wQ==", + "dev": true, + "requires": { + "has-flag": "^3.0.0" + } + } + } + }, + "webpack-dev-middleware": { + "version": "2.0.6", + "resolved": "https://registry.npmjs.org/webpack-dev-middleware/-/webpack-dev-middleware-2.0.6.tgz", + "integrity": "sha512-tj5LLD9r4tDuRIDa5Mu9lnY2qBBehAITv6A9irqXhw/HQquZgTx3BCd57zYbU2gMDnncA49ufK2qVQSbaKJwOw==", + "dev": true, + "requires": { + "loud-rejection": "^1.6.0", + "memory-fs": "~0.4.1", + "mime": "^2.1.0", + "path-is-absolute": "^1.0.0", + "range-parser": "^1.0.3", + "url-join": "^2.0.2", + "webpack-log": "^1.0.1" + } + }, + "webpack-log": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/webpack-log/-/webpack-log-1.2.0.tgz", + "integrity": "sha512-U9AnICnu50HXtiqiDxuli5gLB5PGBo7VvcHx36jRZHwK4vzOYLbImqT4lwWwoMHdQWwEKw736fCHEekokTEKHA==", + "dev": true, + "requires": { + "chalk": "^2.1.0", + "log-symbols": "^2.1.0", + "loglevelnext": "^1.0.1", + "uuid": "^3.1.0" + }, + "dependencies": { + "ansi-styles": { + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz", + "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", + "dev": true, + "requires": { + "color-convert": "^1.9.0" + } + }, + "chalk": { + "version": "2.4.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz", + "integrity": "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==", + "dev": true, + "requires": { + "ansi-styles": "^3.2.1", + "escape-string-regexp": "^1.0.5", + "supports-color": "^5.3.0" + } + }, + "has-flag": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz", + "integrity": "sha1-tdRU3CGZriJWmfNGfloH87lVuv0=", + "dev": true + }, + "supports-color": { + "version": "5.5.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz", + "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==", + "dev": true, + "requires": { + "has-flag": "^3.0.0" + } + } + } + }, + "webpack-merge": { + "version": "5.7.3", + "resolved": "https://registry.npmjs.org/webpack-merge/-/webpack-merge-5.7.3.tgz", + "integrity": "sha512-6/JUQv0ELQ1igjGDzHkXbVDRxkfA57Zw7PfiupdLFJYrgFqY5ZP8xxbpp2lU3EPwYx89ht5Z/aDkD40hFCm5AA==", + "dev": true, + "requires": { + "clone-deep": "^4.0.1", + "wildcard": "^2.0.0" + } + }, + "webpack-sources": { + "version": "1.4.3", + "resolved": "https://registry.npmjs.org/webpack-sources/-/webpack-sources-1.4.3.tgz", + "integrity": "sha512-lgTS3Xhv1lCOKo7SA5TjKXMjpSM4sBjNV5+q2bqesbSPs5FjGmU6jjtBSkX9b4qW87vDIsCIlUPOEhbZrMdjeQ==", + "dev": true, + "requires": { + "source-list-map": "^2.0.0", + "source-map": "~0.6.1" + }, + "dependencies": { + "source-map": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz", + "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==", + "dev": true + } + } + }, + "webrtc-adapter": { + "version": "4.2.2", + "resolved": "https://registry.npmjs.org/webrtc-adapter/-/webrtc-adapter-4.2.2.tgz", + "integrity": "sha1-F4lsBHCE/UxWeVigzUMh4X8ydzw=", + "requires": { + "sdp": "^2.1.0" + } + }, + "whet.extend": { + "version": "0.9.9", + "resolved": "https://registry.npmjs.org/whet.extend/-/whet.extend-0.9.9.tgz", + "integrity": "sha1-+HfVv2SMl+WqVC+twW1qJZucEaE=" + }, + "which": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/which/-/which-1.3.1.tgz", + "integrity": "sha512-HxJdYWq1MTIQbJ3nw0cqssHoTNU267KlrDuGZ1WYlxDStUtKUhOaJmh112/TZmHxxUfuJqPXSOm7tDyas0OSIQ==", + "dev": true, + "requires": { + "isexe": "^2.0.0" + } + }, + "which-module": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/which-module/-/which-module-2.0.0.tgz", + "integrity": "sha1-2e8H3Od7mQK4o6j6SzHD4/fm6Ho=", + "dev": true + }, + "wildcard": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/wildcard/-/wildcard-2.0.0.tgz", + "integrity": "sha512-JcKqAHLPxcdb9KM49dufGXn2x3ssnfjbcaQdLlfZsL9rH9wgDQjUtDxbo8NE0F6SFvydeu1VhZe7hZuHsB2/pw==", + "dev": true + }, + "wordwrap": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/wordwrap/-/wordwrap-1.0.0.tgz", + "integrity": "sha1-J1hIEIkUVqQXHI0CJkQa3pDLyus=", + "dev": true + }, + "worker-farm": { + "version": "1.7.0", + "resolved": "https://registry.npmjs.org/worker-farm/-/worker-farm-1.7.0.tgz", + "integrity": "sha512-rvw3QTZc8lAxyVrqcSGVm5yP/IJ2UcB3U0graE3LCFoZ0Yn2x4EoVSqJKdB/T5M+FLcRPjz4TDacRf3OCfNUzw==", + "dev": true, + "requires": { + "errno": "~0.1.7" + } + }, + "worker-loader": { + "version": "3.0.8", + "resolved": "https://registry.npmjs.org/worker-loader/-/worker-loader-3.0.8.tgz", + "integrity": "sha512-XQyQkIFeRVC7f7uRhFdNMe/iJOdO6zxAaR3EWbDp45v3mDhrTi+++oswKNxShUNjPC/1xUp5DB29YKLhFo129g==", + "dev": true, + "requires": { + "loader-utils": "^2.0.0", + "schema-utils": "^3.0.0" + }, + "dependencies": { + "ajv": { + "version": "6.12.6", + "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz", + "integrity": "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==", + "dev": true, + "requires": { + "fast-deep-equal": "^3.1.1", + "fast-json-stable-stringify": "^2.0.0", + "json-schema-traverse": "^0.4.1", + "uri-js": "^4.2.2" + } + }, + "ajv-keywords": { + "version": "3.5.2", + "resolved": "https://registry.npmjs.org/ajv-keywords/-/ajv-keywords-3.5.2.tgz", + "integrity": "sha512-5p6WTN0DdTGVQk6VjcEju19IgaHudalcfabD7yhDGeA6bcQnmL+CpveLJq/3hvfwd1aof6L386Ougkx6RfyMIQ==", + "dev": true + }, + "emojis-list": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/emojis-list/-/emojis-list-3.0.0.tgz", + "integrity": "sha512-/kyM18EfinwXZbno9FyUGeFh87KC8HRQBQGildHZbEuRyWFOmv1U10o9BBp8XVZDVNNuQKyIGIu5ZYAAXJ0V2Q==", + "dev": true + }, + "fast-deep-equal": { + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz", + "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==", + "dev": true + }, + "json5": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/json5/-/json5-2.2.0.tgz", + "integrity": "sha512-f+8cldu7X/y7RAJurMEJmdoKXGB/X550w2Nr3tTbezL6RwEE/iMcm+tZnXeoZtKuOq6ft8+CqzEkrIgx1fPoQA==", + "dev": true, + "requires": { + "minimist": "^1.2.5" + } + }, + "loader-utils": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/loader-utils/-/loader-utils-2.0.0.tgz", + "integrity": "sha512-rP4F0h2RaWSvPEkD7BLDFQnvSf+nK+wr3ESUjNTyAGobqrijmW92zc+SO6d4p4B1wh7+B/Jg1mkQe5NYUEHtHQ==", + "dev": true, + "requires": { + "big.js": "^5.2.2", + "emojis-list": "^3.0.0", + "json5": "^2.1.2" + } + }, + "minimist": { + "version": "1.2.5", + "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.5.tgz", + "integrity": "sha512-FM9nNUYrRBAELZQT3xeZQ7fmMOBg6nWNmJKTcgsJeaLstP/UODVpGsr5OhXhhXg6f+qtJ8uiZ+PUxkDWcgIXLw==", + "dev": true + }, + "schema-utils": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/schema-utils/-/schema-utils-3.0.0.tgz", + "integrity": "sha512-6D82/xSzO094ajanoOSbe4YvXWMfn2A//8Y1+MUqFAJul5Bs+yn36xbK9OtNDcRVSBJ9jjeoXftM6CfztsjOAA==", + "dev": true, + "requires": { + "@types/json-schema": "^7.0.6", + "ajv": "^6.12.5", + "ajv-keywords": "^3.5.2" + } + } + } + }, + "wrap-ansi": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-5.1.0.tgz", + "integrity": "sha512-QC1/iN/2/RPVJ5jYK8BGttj5z83LmSKmvbvrXPNCLZSEb32KKVDJDl/MOt2N01qU2H/FkzEa9PKto1BqDjtd7Q==", + "dev": true, + "requires": { + "ansi-styles": "^3.2.0", + "string-width": "^3.0.0", + "strip-ansi": "^5.0.0" + }, + "dependencies": { + "ansi-regex": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-4.1.0.tgz", + "integrity": "sha512-1apePfXM1UOSqw0o9IiFAovVz9M5S1Dg+4TrDwfMewQ6p/rmMueb7tWZjQ1rx4Loy1ArBggoqGpfqqdI4rondg==", + "dev": true + }, + "ansi-styles": { + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz", + "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", + "dev": true, + "requires": { + "color-convert": "^1.9.0" + } + }, + "string-width": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-3.1.0.tgz", + "integrity": "sha512-vafcv6KjVZKSgz06oM/H6GDBrAtz8vdhQakGjFIvNrHA6y3HCF1CInLy+QLq8dTJPQ1b+KDUqDFctkdRW44e1w==", + "dev": true, + "requires": { + "emoji-regex": "^7.0.1", + "is-fullwidth-code-point": "^2.0.0", + "strip-ansi": "^5.1.0" + } + }, + "strip-ansi": { + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-5.2.0.tgz", + "integrity": "sha512-DuRs1gKbBqsMKIZlrffwlug8MHkcnpjs5VPmL1PAh+mA30U0DTotfDZ0d2UUsXpPmPmMMJ6W773MaA3J+lbiWA==", + "dev": true, + "requires": { + "ansi-regex": "^4.1.0" + } + } + } + }, + "wrappy": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz", + "integrity": "sha1-tSQ9jz7BqjXxNkYFvA0QNuMKtp8=" + }, + "write": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/write/-/write-1.0.3.tgz", + "integrity": "sha512-/lg70HAjtkUgWPVZhZcm+T4hkL8Zbtp1nFNOn3lRrxnlv50SRBv7cR7RqR+GMsd3hUXy9hWBo4CHTbFTcOYwig==", + "dev": true, + "requires": { + "mkdirp": "^0.5.1" + } + }, + "ws": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/ws/-/ws-7.2.0.tgz", + "integrity": "sha512-+SqNqFbwTm/0DC18KYzIsMTnEWpLwJsiasW/O17la4iDRRIO9uaHbvKiAS3AHgTiuuWerK/brj4O6MYZkei9xg==", + "requires": { + "async-limiter": "^1.0.0" + } + }, + "xmlhttprequest-ssl": { + "version": "1.5.5", + "resolved": "https://registry.npmjs.org/xmlhttprequest-ssl/-/xmlhttprequest-ssl-1.5.5.tgz", + "integrity": "sha1-wodrBhaKrcQOV9l+gRkayPQ5iz4=", + "dev": true + }, + "xtend": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/xtend/-/xtend-4.0.2.tgz", + "integrity": "sha512-LKYU1iAXJXUgAXn9URjiu+MWhyUXHsvfp7mcuYm9dSUKK0/CjtrUwFAxD82/mCWbtLsGjFIad0wIsod4zrTAEQ==", + "dev": true + }, + "y18n": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/y18n/-/y18n-4.0.0.tgz", + "integrity": "sha512-r9S/ZyXu/Xu9q1tYlpsLIsa3EeLXXk0VwlxqTcFRfg9EhMW+17kbt9G0NrgCmhGb5vT2hyhJZLfDGx+7+5Uj/w==", + "dev": true + }, + "yallist": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-2.1.2.tgz", + "integrity": "sha1-HBH5IY8HYImkfdUS+TxmmaaoHVI=", + "dev": true + }, + "yargs": { + "version": "13.2.4", + "resolved": "https://registry.npmjs.org/yargs/-/yargs-13.2.4.tgz", + "integrity": "sha512-HG/DWAJa1PAnHT9JAhNa8AbAv3FPaiLzioSjCcmuXXhP8MlpHO5vwls4g4j6n30Z74GVQj8Xa62dWVx1QCGklg==", + "dev": true, + "requires": { + "cliui": "^5.0.0", + "find-up": "^3.0.0", + "get-caller-file": "^2.0.1", + "os-locale": "^3.1.0", + "require-directory": "^2.1.1", + "require-main-filename": "^2.0.0", + "set-blocking": "^2.0.0", + "string-width": "^3.0.0", + "which-module": "^2.0.0", + "y18n": "^4.0.0", + "yargs-parser": "^13.1.0" + }, + "dependencies": { + "ansi-regex": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-4.1.0.tgz", + "integrity": "sha512-1apePfXM1UOSqw0o9IiFAovVz9M5S1Dg+4TrDwfMewQ6p/rmMueb7tWZjQ1rx4Loy1ArBggoqGpfqqdI4rondg==", + "dev": true + }, + "find-up": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/find-up/-/find-up-3.0.0.tgz", + "integrity": "sha512-1yD6RmLI1XBfxugvORwlck6f75tYL+iR0jqwsOrOxMZyGYqUuDhJ0l4AXdO1iX/FTs9cBAMEk1gWSEx1kSbylg==", + "dev": true, + "requires": { + "locate-path": "^3.0.0" + } + }, + "locate-path": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-3.0.0.tgz", + "integrity": "sha512-7AO748wWnIhNqAuaty2ZWHkQHRSNfPVIsPIfwEOWO22AmaoVrWavlOcMR5nzTLNYvp36X220/maaRsrec1G65A==", + "dev": true, + "requires": { + "p-locate": "^3.0.0", + "path-exists": "^3.0.0" + } + }, + "p-limit": { + "version": "2.2.1", + "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-2.2.1.tgz", + "integrity": "sha512-85Tk+90UCVWvbDavCLKPOLC9vvY8OwEX/RtKF+/1OADJMVlFfEHOiMTPVyxg7mk/dKa+ipdHm0OUkTvCpMTuwg==", + "dev": true, + "requires": { + "p-try": "^2.0.0" + } + }, + "p-locate": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-3.0.0.tgz", + "integrity": "sha512-x+12w/To+4GFfgJhBEpiDcLozRJGegY+Ei7/z0tSLkMmxGZNybVMSfWj9aJn8Z5Fc7dBUNJOOVgPv2H7IwulSQ==", + "dev": true, + "requires": { + "p-limit": "^2.0.0" + } + }, + "p-try": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/p-try/-/p-try-2.2.0.tgz", + "integrity": "sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ==", + "dev": true + }, + "string-width": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-3.1.0.tgz", + "integrity": "sha512-vafcv6KjVZKSgz06oM/H6GDBrAtz8vdhQakGjFIvNrHA6y3HCF1CInLy+QLq8dTJPQ1b+KDUqDFctkdRW44e1w==", + "dev": true, + "requires": { + "emoji-regex": "^7.0.1", + "is-fullwidth-code-point": "^2.0.0", + "strip-ansi": "^5.1.0" + } + }, + "strip-ansi": { + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-5.2.0.tgz", + "integrity": "sha512-DuRs1gKbBqsMKIZlrffwlug8MHkcnpjs5VPmL1PAh+mA30U0DTotfDZ0d2UUsXpPmPmMMJ6W773MaA3J+lbiWA==", + "dev": true, + "requires": { + "ansi-regex": "^4.1.0" + } + } + } + }, + "yargs-parser": { + "version": "13.1.1", + "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-13.1.1.tgz", + "integrity": "sha512-oVAVsHz6uFrg3XQheFII8ESO2ssAf9luWuAd6Wexsu4F3OtIW0o8IribPXYrD4WC24LWtPrJlGy87y5udK+dxQ==", + "dev": true, + "requires": { + "camelcase": "^5.0.0", + "decamelize": "^1.2.0" + } + }, + "yeast": { + "version": "0.1.2", + "resolved": "https://registry.npmjs.org/yeast/-/yeast-0.1.2.tgz", + "integrity": "sha1-AI4G2AlDIMNy28L47XagymyKxBk=", + "dev": true + }, + "yocto-queue": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz", + "integrity": "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==", + "dev": true + } + } +} diff --git a/js/package.json b/js/package.json index a7f9cf55..15329560 100644 --- a/js/package.json +++ b/js/package.json @@ -1,6 +1,6 @@ { "name": "ipyvolume", - "version": "0.6.0-dev.1", + "version": "0.6.3", "description": "IPython widget for rendering 3d volumes", "author": "Maarten A. Breddels", "main": "lib/index.js", @@ -14,29 +14,40 @@ "ipython", "ipywidgets" ], + "license": "MIT", "scripts": { - "prepublish": "webpack --mode=production", "install-test": "npm install && karma start --single-run", "test": "karma start --single-run", + "build": "npm run build:lib && npm run build:labextension && webpack --mode=production", "build:lib": "tsc --project .", - "prepare": "npm run build:lib", + "build:labextension": "jupyter labextension build .", + "prepare": "npm run build", "watch": "npm-run-all -p watch:*", "watch:lib": "tsc -w --project .", - "watch:nbextension": "webpack --watch --mode=development" + "watch:nbextension": "webpack --watch --mode=development", + "watch:labextension": "jupyter labextension watch .", + "watch:dev": "npm-run-all -p watch:lib watch:nbextension" }, "jupyterlab": { - "extension": "lib/labplugin" + "extension": "lib/labplugin", + "outputDir": "../share/jupyter/labextensions/ipyvolume", + "sharedPackages": { + "@jupyter-widgets/base": { + "bundled": false, + "singleton": true + } + } }, "devDependencies": { + "@jupyterlab/builder": "^3.0.0", "@types/chai": "^4.1.4", + "@types/d3": "^5.7.2", "@types/expect.js": "^0.3.29", "@types/mocha": "^2.2.48", + "@types/node": "^12.0.2", "@types/requirejs": "^2.1.31", - "@types/three": "^0.92.4", - "babel-loader": "7.1.1", - "babel-preset-es2015": "^6.24.1", - "babel-preset-es2015-without-strict": "0.0.4", - "cache-loader": "^1.2.2", + "@types/three": "^0.93.4", + "bqplot": "^0.5.0", "chai": "^4.1.2", "eslint": "^5.13.0", "eslint-config-standard": "^12.0.0", @@ -45,35 +56,36 @@ "eslint-plugin-promise": "^4.0.1", "eslint-plugin-standard": "^4.0.0", "json-loader": "^0.5.4", - "karma": "^2.0.5", + "jupyter-threejs": "^2.3.0", + "karma": "^4.0.0", "karma-chai": "^0.1.0", "karma-chrome-launcher": "^2.0.0", "karma-mocha": "^1.3.0", + "karma-mocha-reporter": "^2.2.5", "karma-sinon": "^1.0.5", "karma-sourcemap-loader": "^0.3.7", - "karma-typescript": "^3.0.12", - "karma-typescript-es6-transform": "^1.0.4", - "karma-webpack": "^2.0.3", + "karma-webpack": "^3.0.5", "mocha": "^3.5.3", "npm-run-all": "^4.1.3", - "raw-loader": "^0.5.1", + "raw-loader": "~3.0.0", "sinon": "^2.4.1", "sinon-chai": "^2.11.0", - "thread-loader": "^1.2.0", - "ts-loader": "^4.4.2", - "typescript": "~3.0.0", + "source-map-loader": "^0.2.4", + "typescript": "^3.5.2", "url-loader": "^0.5.7", "webpack": "^4.29.1", "webpack-cli": "^3.2.3" }, "dependencies": { - "@jupyter-widgets/base": "^1.0.0", + "@jupyter-widgets/base": "^1 || ^2.0.2 || ^3 || ^4 || ^5 || ^6", + "@jupyter-widgets/controls": "^1 || ^2", "css-loader": "^0.28.4", - "d3": "~4.6.0", + "d3": "^5.7.0", "gl-matrix": "^2.0.0", "is-typedarray": "~1.0.0", "jquery": "^3.1.1", - "mqtt": "^2.11.0", + "jslink": "^1.1.3", + "lodash": "^4.17.15", "mustache": "^2.3.1", "ndarray": "~1.0.18", "ndarray-pack": "^1.2.1", @@ -81,6 +93,7 @@ "style-loader": "^0.18.2", "three": "^0.97.0", "three-text2d": "~0.4.1", + "tslint": "^5.20.0", "underscore": "^1.8.3", "webrtc-adapter": "^4.2.2" }, @@ -88,7 +101,8 @@ "dist/", "css/", "src/", - "lib/", + "lib/*.js", + "lib/three/*.js", "data/", "glsl/" ] diff --git a/js/src/embed.js b/js/src/embed.ts similarity index 50% rename from js/src/embed.js rename to js/src/embed.ts index a896b800..9966492b 100644 --- a/js/src/embed.js +++ b/js/src/embed.ts @@ -5,7 +5,12 @@ // already be loaded by the notebook otherwise. // Export widget models and views, and the npm package version number. -var _ = require('underscore') -// Export widget models and views, and the npm package version number. -module.exports = _.extend({}, require('./figure.js'), require('./tf.js'), require('./scatter.js'), require('./mesh.js'), require('./volume.js'), require('./utils.js')); -module.exports['version'] = require('../package.json').version; +export * from "./figure"; +export * from "./tf"; +export * from "./scatter"; +export * from "./volume"; +export * from "./mesh"; +export * from "./utils"; +export * from "./selectors"; +export * from "./values"; +export {semver_range as version} from "./utils"; diff --git a/js/src/extension.js b/js/src/extension.ts similarity index 69% rename from js/src/extension.js rename to js/src/extension.ts index 3738cd74..02adaf3c 100644 --- a/js/src/extension.js +++ b/js/src/extension.ts @@ -3,18 +3,17 @@ // which is required for any notebook extension. // Configure requirejs -if (window.require) { - window.require.config({ +if ((window as any).require) { + (window as any).require.config({ map: { "*" : { "ipyvolume": "nbextensions/ipyvolume/index", - "jupyter-js-widgets": "nbextensions/jupyter-js-widgets/extension" - } - } + "jupyter-js-widgets": "nbextensions/jupyter-js-widgets/extension", + }, + }, }); } // Export the required load_ipython_extention -module.exports = { - load_ipython_extension: function() {} -}; +// tslint:disable-next-line: no-empty +export function load_ipython_extension() {} diff --git a/js/src/figure.js b/js/src/figure.js deleted file mode 100644 index dc2eac92..00000000 --- a/js/src/figure.js +++ /dev/null @@ -1,2034 +0,0 @@ -var widgets = require("@jupyter-widgets/base") -var _ = require("underscore") -var THREE = require("three") -var THREEtext2d = require("three-text2d") -var glm = require("gl-matrix") -var d3 = require("d3") -var screenfull = require("screenfull") -var Mustache = require("mustache"); -require('../css/style.css') - -// same strategy as: ipywidgets/jupyter-js-widgets/src/widget_core.ts, except we use ~ -// so that N.M.x is allowed (we don't care about x, but we assume 0.2.x is not compatible with 0.3.x -var semver_range = require('./utils.js').semver_range; -var axis_names = ['x', 'y', 'z'] -var styles = require('../data/style.json') - -var scatter = require('./scatter.js') -var mesh = require('./mesh.js') -var volume = require('./volume.js') - -window.THREE = THREE; - -require("./three/OrbitControls.js") -require("./three/TrackballControls.js") -require("./three/DeviceOrientationControls.js") -require("./three/StereoEffect.js") -require("./three/THREEx.FullScreen.js") -require("./three/CombinedCamera.js") -ndarray = require('ndarray') - -var shaders = {} -shaders["screen_fragment"] = require('raw-loader!../glsl/screen-fragment.glsl'); -shaders["screen_vertex"] = require('raw-loader!../glsl/screen-vertex.glsl'); -shaders["volr_fragment"] = require('raw-loader!../glsl/volr-fragment.glsl'); -shaders["volr_vertex"] = require('raw-loader!../glsl/volr-vertex.glsl'); - -// similar to _.bind, except it -// puts this as first argument to f, followed be other arguments, and make context f's this -function bind_d3(f, context) { - return function() { - var args = [this].concat([].slice.call(arguments)) // convert argument to array - f.apply(context, args) - } -} - -function download_image(data) { - var a = document.createElement('a') - a.download = 'ipyvolume.png' - a.href = data - // see https://stackoverflow.com/questions/18480474/how-to-save-an-image-from-canvas - if (document.createEvent) { - e = document.createEvent("MouseEvents"); - e.initMouseEvent("click", true, true, window, - 0, 0, 0, 0, 0, false, false, false, - false, 0, null); - - a.dispatchEvent(e); - } else if (lnk.fireEvent) { - a.fireEvent("onclick"); - } -} - -function select_text(element) { - var doc = document; - if (doc.body.createTextRange) { - var range = document.body.createTextRange(); - range.moveToElementText(element); - range.select(); - } else if (window.getSelection) { - var selection = window.getSelection(); - var range = document.createRange(); - range.selectNodeContents(element); - selection.removeAllRanges(); - selection.addRange(range); - } -} - -function copy_image_to_clipboard(data) { - // https://stackoverflow.com/questions/27863617/is-it-possible-to-copy-a-canvas-image-to-the-clipboard - var img = document.createElement('img'); - img.contentEditable = true; - img.src = data - - var div = document.createElement('div'); - div.contentEditable = true; - div.appendChild(img); - document.body.appendChild(div); - - // do copy - select_text(img); - document.execCommand('Copy'); - document.body.removeChild(div); -} - -var ToolIcon = function(className, parent) { - this.a = document.createElement('a') - this.a.className = 'ipyvolume-toolicon' - this.a.setAttribute('href', 'javascript:void(0)') - this.li = document.createElement('li') - this.li.className = 'fa ' + className - this.sub = document.createElement('div') - this.sub.className = 'ipyvolume-toolicon-dropdown-container' - this.a.appendChild(this.li) - this.a.appendChild(this.sub) - parent.appendChild(this.a) - this.active = (state) => { - if (state) - this.li.classList.remove('fa-inactive') - else - this.li.classList.add('fa-inactive') - } -} - -var ToolIconDropdown = function(className, parent, text) { - this.a = document.createElement('a') - this.a.className = 'ipyvolume-toolicon-dropdown' - this.a.setAttribute('href', 'javascript:void(0)') - this.li = document.createElement('li') - this.li.className = 'fa ' + className; - this.span_text = document.createElement('span') - this.span_text.innerText = text - this.a.appendChild(this.li) - this.li.appendChild(this.span_text) - parent.appendChild(this.a) - this.active = (state) => { - if (state) - this.a.classList.remove('ipyvolume-toolicon-inactive') - else - this.a.classList.add('ipyvolume-toolicon-inactive') - } -} - -import {selectors} from './selectors'; - -var FigureView = widgets.DOMWidgetView.extend({ - render: function() { - this.transitions = [] - this._update_requested = false - this.update_counter = 0 - var width = this.model.get("width"); - var height = this.model.get("height"); - - this.toolbar_div = document.createElement('div') - this.el.appendChild(this.toolbar_div) - - var keydown = _.bind(this._special_keys_down, this); - var keyup = _.bind(this._special_keys_up, this) - document.addEventListener("keydown", keydown); - document.addEventListener("keyup", keyup); - this.once('remove', () => { - //console.log('remove key listeners') - document.removeEventListener('keydown', keydown) - document.removeEventListener('keyup', keyup) - }) - // set up fullscreen button - // this is per view, so it's not exposed on the python side - // which is ok, since it can only be triggered from a UI action - this.fullscreen_icon = new ToolIcon('fa-arrows-alt', this.toolbar_div) - this.fullscreen_icon.a.title = 'Fullscreen' - this.fullscreen_icon.a.onclick = _.bind(function() { - var el = this.renderer.domElement - var old_width = el.style.width - var old_height = el.style.height - var restore = _.bind(function() { - if (!screenfull.isFullscreen) { - el.style.width = old_width; - el.style.height = old_height - screenfull.off('change', restore) - } else { - el.style.width = '100vw' - el.style.height = '100vh' - } - this.update_size() - }, this) - screenfull.onchange(restore) - screenfull.request(el); - }, this); - - this.stereo_icon = new ToolIcon('fa-eye', this.toolbar_div) - this.stereo_icon.a.title = 'Stereoscopic view' - this.stereo_icon.a.onclick = _.bind(function() { - this.model.set('stereo', !this.model.get('stereo')) - this.model.save_changes() - }, this) - this.stereo_icon.active(this.model.get('stereo')) - this.model.on('change:stereo', () => { - this.stereo_icon.active(this.model.get('stereo')) - }) - - this.screenshot_icon = new ToolIcon('fa-picture-o', this.toolbar_div) - this.screenshot_icon.a.title = 'Take a screenshot (hold shift to copy to clipboard)' - this.screenshot_icon.a.onclick = (event) => { - try { - var data = this.screenshot() - if (event.shiftKey) { - copy_image_to_clipboard(data) - } else { - download_image(data) - } - } finally { // make sure we don't open a new window when we hold shift - event.preventDefault() - return false; - } - } - window.ipvss = () => { - var data = this.screenshot() - return data - } - - this.camera_control_icon = new ToolIcon('fa-arrow-up', this.toolbar_div) - this.camera_control_icon.a.title = 'Camera locked to \'up\' axis (orbit), instead of trackball mode' - this.camera_control_icon.a.onclick = () => { - var mode = this.model.get('camera_control') - if (mode == 'trackball') { - var mode = this.model.get('camera_control') - this.model.set('camera_control', 'orbit') - this.camera_control_icon.active(true) - } else { - this.model.set('camera_control', 'trackball') - this.camera_control_icon.active(false) - } - this.touch() - } - this.camera_control_icon.active(false) - - this.select_icon = new ToolIcon('fa-pencil-square-o', this.toolbar_div) - this.select_icon.a.title = 'Select mode (auto when control key is pressed)' - this.select_icon.a.onclick = () => { - if (this.model.get('mouse_mode') == 'select') { - this.model.set('mouse_mode', 'normal'); - } else { - this.model.set('mouse_mode', 'select'); - } - this.update_icons() - this.touch() - } - this.select_icon.active(false) - - this.select_icon_lasso = new ToolIconDropdown('fa-vine', this.select_icon.sub, 'Lasso selector') - this.select_icon_circle = new ToolIconDropdown('fa-circle', this.select_icon.sub, 'Circle selector') - this.select_icon_rectangle = new ToolIconDropdown('fa-square', this.select_icon.sub, 'Rectangle selector') - this.select_icon_lasso.a.onclick = (event) => { - event.stopPropagation() - this.model.set('mouse_mode', 'select'); - this.model.set('selector', 'lasso') - this.touch() - } - this.select_icon_circle.a.onclick = (event) => { - event.stopPropagation() - this.model.set('mouse_mode', 'select'); - this.model.set('selector', 'circle') - this.touch() - } - this.select_icon_rectangle.a.onclick = (event) => { - event.stopPropagation() - this.model.set('mouse_mode', 'select'); - this.model.set('selector', 'rectangle') - this.touch() - } - - this.zoom_icon = new ToolIcon('fa-search-plus', this.toolbar_div) - this.zoom_icon.a.title = 'Zoom mode (auto when control key is pressed, use scrolling)' - this.zoom_icon.a.onclick = () => { - if (this.model.get('mouse_mode') == 'zoom') { - this.model.set('mouse_mode', 'normal'); - } else { - this.model.set('mouse_mode', 'zoom'); - } - this.touch() - } - - // this.zoom_icon.active(false) - // using ctrl and shift, you can quickly change mode - // remember the previous mode so we can restore it - this.quick_mouse_mode_change = false; - this.quick_mouse_previous_mode = this.model.get('mouse_mode'); - - this.update_icons() - this.model.on('change:mouse_mode change:selector', this.update_icons, this) - this.model.on('change:mouse_mode change:selector', this.update_mouse_mode, this) - - this.reset_icon = new ToolIcon('fa-home', this.toolbar_div) - this.reset_icon.a.title = 'Reset view' - var initial_fov = this.model.get("camera_fov") - this.reset_icon.a.onclick = () => { - this.camera.copy(this.camera_initial) - if (this.camera.ipymodel) - this.camera.ipymodel.syncToModel(true) - } - - this.setting_icon = new ToolIcon('fa-cog', this.toolbar_div) - this.setting_icon_180 = new ToolIconDropdown('fa-circle', this.setting_icon.sub, '180 degrees') - this.setting_icon_360 = new ToolIconDropdown('fa-circle', this.setting_icon.sub, '360 degrees') - var add_resolution = (name, x, y, stereo) => { - var tool = new ToolIconDropdown('fa-cogs', this.setting_icon.sub, name + ' (' + x + 'x' + y + ')') - tool.a.onclick = (event) => { - this.model.set('width', x); - this.model.set('height', y); - this.touch(); - } - } - add_resolution('default', this.model.get('width'), this.model.get('height')) - add_resolution('small', 500, 400) - add_resolution('medium', 640, 480) - add_resolution('large', 800, 600) - add_resolution('HD 720', 1280, 720) - add_resolution('HD', 1920, 1080) - add_resolution('2k', 2048, 1080) - add_resolution('2k x 2k', 2048, 2048) - add_resolution('4k UHD ', 3840, 2160) - add_resolution('4k', 4096, 2160) - add_resolution('4k x 4k', 4096, 4096) - // add_resolution('8k UHD', 7680, 4320) - var add_scaling = (x) => { - var tool = new ToolIconDropdown('fa-compress', this.setting_icon.sub, 'Scale canvas (down) by ' + x) - tool.a.onclick = (event) => { - this.model.set('displayscale', 1 / x); - this.touch(); - } - } - add_scaling(1) - add_scaling(2) - add_scaling(4) - add_scaling(8) - this.setting_icon_180.a.onclick = (event) => { - event.stopPropagation() - if (this.model.get('panorama_mode') == '180') - this.model.set('panorama_mode', 'no'); - else - this.model.set('panorama_mode', '180'); - this.touch() - } - this.setting_icon_360.a.onclick = (event) => { - event.stopPropagation() - if (this.model.get('panorama_mode') == '360') - this.model.set('panorama_mode', 'no'); - else - this.model.set('panorama_mode', '360'); - this.touch() - } - this.setting_icon_360.active(this.model.get('panorama_mode') == '360') - this.setting_icon_180.active(this.model.get('panorama_mode') == '180') - this.model.on('change:panorama_mode', () => { - this.setting_icon_360.active(this.model.get('panorama_mode') == '360') - this.setting_icon_180.active(this.model.get('panorama_mode') == '180') - this.update_panorama() - }) - - this.el.classList.add("jupyter-widgets"); - // set up WebGL using threejs, with an overlay canvas for 2d drawing - this.canvas_container = document.createElement("div") - this.canvas_overlay_container = document.createElement("div") - this.canvas_overlay = document.createElement("canvas") - this.canvas_overlay_container.appendChild(this.canvas_overlay); - this.canvas_container.appendChild(this.canvas_overlay_container); - - this.renderer = new THREE.WebGLRenderer({alpha: true, antialias: true}); - var update_pixel_ratio = () => { - this.renderer.setPixelRatio(this.model.get('pixel_ratio') || window.devicePixelRatio) - this._update_size() - } - this.renderer.setPixelRatio(this.model.get('pixel_ratio') || window.devicePixelRatio) - this.listenTo(this.model, "change:pixel_ratio", update_pixel_ratio) - - this.canvas_renderer_container = document.createElement("div") - this.canvas_renderer_container.appendChild(this.renderer.domElement); - - this.canvas_container.appendChild(this.canvas_renderer_container); - this.canvas_container.appendChild(this.canvas_overlay_container); - this.canvas_overlay_container.style = 'position: absolute; z-index: 2; pointer-events: none;' - this.canvas_renderer_container.style = 'position: absolute; z-index: 1' - this.canvas_container.style = 'position: relative' - this.el.appendChild(this.canvas_container); - this.el.setAttribute('tabindex', '1') // make sure we can have focus - - // el_mirror is a 'mirror' dom tree that d3 needs - // we use it to attach axes and tickmarks to the dom - // which reflect the objects in the scene - this.el_mirror = document.createElement("div") - this.el.appendChild(this.el_mirror); - this.el_axes = document.createElement("div") - this.el_mirror.appendChild(this.el_axes); - - this.renderer.domElement.addEventListener('wheel', this.mousewheel.bind(this), false); - - - // const VIEW_ANGLE = this.model.get("camera_fov"); - // const aspect = width / height; - const NEAR = 0.01; - const FAR = 10000; - const orthoNEAR = -500; - const orthoFAR = 1000; - - if (this.model.get('camera')) { - this.camera = this.model.get('camera').obj - this.model.get('camera').on('change', () => { - // the threejs' lookAt ignore the quaternion, and uses the up vector - // we manually set it ourselve - var up = new THREE.Vector3(0, 1, 0); - up.applyQuaternion(this.camera.quaternion); - this.camera.up = up; - this.camera.lookAt(0, 0, 0); - // TODO: shouldn't we do the same with the orbit control? - this.control_trackball.position0 = this.camera.position.clone(); - this.control_trackball.up0 = this.camera.up.clone(); - // TODO: if we implement figure.look_at, we should update control's target as well - this.update(); - }); - } else { - this.camera = new THREE.PerspectiveCamera(46, 1, NEAR, FAR); - // same default as the Python version - var z = 2 * Math.tan(45. / 2. * Math.PI / 180.) / Math.tan(this.model.get('camera_fov') / 2. * Math.PI / 180.); - this.camera.position.z = z; - } - - this.camera_initial = this.camera.clone(); - this.cube_camera = new THREE.CubeCamera(this.camera.near, this.camera.far, this.model.get('cube_resolution')); - - this.camera_stereo = new THREE.StereoCamera() - this.renderer.setSize(width, height); - - this.renderer_stereo = new THREE.StereoEffect(this.renderer); - this.renderer_selected = this.renderer_stereo; - - var make_line = function(x1, y1, z1, x2, y2, z2, material) { - var geometry = new THREE.Geometry(); - geometry.vertices.push(new THREE.Vector3(x1, y1, z1), new THREE.Vector3(x2, y2, z2)); - return new THREE.Line(geometry, material); - } - - var make_axis = function(x, y, z, material) { - return make_line(-0.5, -0.5, -0.5, -0.5 + x, -0.5 + y, -0.5 + z, material); - } - - var linewidth = 1; - this.axes_material = new THREE.LineBasicMaterial({ - color: "cyan", - linewidth: linewidth - }); - this.xaxes_material = new THREE.LineBasicMaterial({ - color: "red", - linewidth: linewidth - }); - this.yaxes_material = new THREE.LineBasicMaterial({ - color: "green", - linewidth: linewidth - }); - this.zaxes_material = new THREE.LineBasicMaterial({ - color: "blue", - linewidth: linewidth - }); - - this.x_axis = make_axis(1, 0, 0, this.xaxes_material); - this.y_axis = make_axis(0, 1, 0, this.yaxes_material); - this.z_axis = make_axis(0, 0, 1, this.zaxes_material); - - this.axes = new THREE.Object3D(); - this.axes.add(this.x_axis); - this.axes.add(this.y_axis); - this.axes.add(this.z_axis); - - this.wire_box = new THREE.Object3D() - this.wire_box_x_line = make_line(-0.5, -0.5, -0.5, -0.5 + 1, -0.5, -0.5, this.axes_material) - this.wire_box.add(this.wire_box_x_line) - this.wire_box.add(make_line(-0.5, -0.5 + 1, -0.5, -0.5 + 1, -0.5 + 1, -0.5, this.axes_material)) - this.wire_box.add(make_line(-0.5, -0.5, -0.5 + 1, -0.5 + 1, -0.5, -0.5 + 1, this.axes_material)) - this.wire_box.add(make_line(-0.5, -0.5 + 1, -0.5 + 1, -0.5 + 1, -0.5 + 1, -0.5 + 1, this.axes_material)) - - this.wire_box_y_line = make_line(-0.5, -0.5, -0.5, -0.5, -0.5 + 1, -0.5, this.axes_material) - this.wire_box.add(this.wire_box_y_line) - this.wire_box.add(make_line(-0.5 + 1, -0.5, -0.5, -0.5 + 1, -0.5 + 1, -0.5, this.axes_material)) - this.wire_box.add(make_line(-0.5, -0.5, -0.5 + 1, -0.5, -0.5 + 1, -0.5 + 1, this.axes_material)) - this.wire_box.add(make_line(-0.5 + 1, -0.5, -0.5 + 1, -0.5 + 1, -0.5 + 1, -0.5 + 1, this.axes_material)) - - this.wire_box_z_line = make_line(-0.5, -0.5, -0.5, -0.5, -0.5, -0.5 + 1, this.axes_material) - this.wire_box.add(this.wire_box_z_line) - this.wire_box.add(make_line(-0.5 + 1, -0.5, -0.5, -0.5 + 1, -0.5, -0.5 + 1, this.axes_material)) - this.wire_box.add(make_line(-0.5, -0.5 + 1, -0.5, -0.5, -0.5 + 1, -0.5 + 1, this.axes_material)) - this.wire_box.add(make_line(-0.5 + 1, -0.5 + 1, -0.5, -0.5 + 1, -0.5 + 1, -0.5 + 1, this.axes_material)) - - // d3 data - this.axes_data = [{ - name: 'x', - label: 'x', - object: null, - object_label: null, - translate: [0.0, -0.5, -0.5], - rotate: [Math.PI / 4., 0, 0], - rotation_order: 'XYZ' - }, { - name: 'y', - label: 'y', - object: null, - object_label: null, - translate: [-0.5, 0.0, -0.5], - rotate: [Math.PI * 3. / 4., 0, Math.PI / 2.], - rotation_order: 'ZXY' - }, { - name: 'z', - label: 'z', - object: null, - object_label: null, - translate: [-0.5, -0.5, 0.0], - rotate: [-Math.PI / 8., -Math.PI / 2., 0], - rotation_order: 'YZX' - }]; - - this.ticks = 5; //hardcoded for now - - // we have our 'private' scene, if we use the real scene, it gives buggy - // results in the volume rendering when we have two views - this.scene_volume = new THREE.Scene(); - // could be removed when https://github.com/jovyan/pythreejs/issues/176 is solved - // the default for pythreejs is white, which leads the volume rendering pass to make everything white - this.scene_volume.background = null - - if (this.model.get('scene')) { - this.shared_scene = this.model.get('scene').obj - this.model.get('scene').on('rerender', () => this.update()) - } else { - this.shared_scene = new THREE.Scene(); - } - - this.scene_volume.add(this.camera); - // the threejs animation system looks at the parent of the camera and sends rerender msg'es - this.shared_scene.add(this.camera); - - this.scene_scatter = new THREE.Scene(); - this.scene_opaque = new THREE.Scene(); - - this.scene_opaque.add(this.wire_box) - this.scene_opaque.add(this.axes) - - this.mesh_views = {}; - this.scatter_views = {}; - this.volume_views = {}; - - var render_width = width; - var render_height = height; - - if (this.model.get("stereo")) - render_width /= 2; - - // Render pass targets - // float texture for better depth data, prev name back_texture - this.volume_back_target = new THREE.WebGLRenderTarget(render_width, render_height, { - minFilter: THREE.LinearFilter, - magFilter: THREE.LinearFilter, - type: THREE.FloatType, - format: THREE.RGBAFormat, - generateMipmaps: false - }); - - this.geometry_depth_target = new THREE.WebGLRenderTarget(render_width, render_height, { - minFilter: THREE.LinearFilter, - magFilter: THREE.LinearFilter, - format: THREE.RGBAFormat, - generateMipmaps: false, - depthTexture: new THREE.DepthTexture() - }); - this.geometry_depth_target.depthTexture.type = THREE.UnsignedShortType; - - this.color_pass_target = new THREE.WebGLRenderTarget(render_width, render_height, { - minFilter: THREE.LinearFilter, - magFilter: THREE.LinearFilter - }); - - this.screen_pass_target = new THREE.WebGLRenderTarget(render_width, render_height, { - minFilter: THREE.LinearFilter, - magFilter: THREE.LinearFilter - }); - - this.coordinate_texture = new THREE.WebGLRenderTarget(render_width, render_height, { - minFilter: THREE.LinearFilter, - magFilter: THREE.NearestFilter - }); - - this.screen_texture = this.color_pass_target.texture; - this.screen_scene = new THREE.Scene(); - this.screen_scene_cube = new THREE.Scene(); - this.screen_plane = new THREE.PlaneBufferGeometry(1.0, 1.0); - - this.screen_material = new THREE.ShaderMaterial({ - uniforms: { - tex: { - type: 't', - value: this.screen_pass_target.texture - } - }, - vertexShader: shaders["screen_vertex"], - fragmentShader: shaders["screen_fragment"], - depthWrite: false - }); - - this.screen_material_cube = new THREE.ShaderMaterial({ - uniforms: { - tex: { - type: 't', - value: this.cube_camera.renderTarget.texture - } - }, - vertexShader: shaders["screen_vertex"], - fragmentShader: shaders["screen_fragment"], - defines: {}, - depthWrite: false - }); - - this.screen_mesh = new THREE.Mesh(this.screen_plane, this.screen_material); - this.screen_mesh_cube = new THREE.Mesh(this.screen_plane, this.screen_material_cube); - this.screen_scene.add(this.screen_mesh) - this.screen_scene_cube.add(this.screen_mesh_cube) - this.screen_camera = new THREE.OrthographicCamera(-0.5, 0.5, 0.5, -0.5, -10000., 10000.); - this.screen_camera.position.z = 10; - this.update_panorama() - this.on('change:panorama_mode', this.update_panorama, this) - - // we rely here on these events listeners to be executed before those of the controls - // since we disable the controls, seems to work on chrome - this.renderer.domElement.addEventListener('mousedown', _.bind(this._mouse_down, this), false); - this.renderer.domElement.addEventListener('mousemove', _.bind(this._mouse_move, this), false); - this.renderer.domElement.addEventListener('dblclick', this._mouse_dbl_click.bind(this), false) - this.renderer.domElement.addEventListener('contextmenu', (event) => { - event.preventDefault(); - event.stopPropagation(); - }, false); - - window.addEventListener('mouseup', _.bind(this._mouse_up, this), false); - this.mouse_inside = false; - this.mouse_trail = [] // list of x, y positions - this.select_overlay = null; // lasso or sth else? - - this.control_trackball = new THREE.TrackballControls(this.camera, this.renderer.domElement); - this.control_orbit = new THREE.OrbitControls(this.camera, this.renderer.domElement); - this.control_trackball.dynamicDampingFactor = 1. - this.control_trackball.noPan = true; - this.control_orbit.enablePan = false; - this.control_orbit.dampingFactor = 1. - this.update_mouse_mode() - - this.control_orbit.rotateSpeed = 0.5 - this.control_trackball.rotateSpeed = 0.5 - this.control_trackball.zoomSpeed = 3. - - window.addEventListener('deviceorientation', _.bind(this.on_orientationchange, this), false); - - var render_size = this.getRenderSize() - - this.material_multivolume = new THREE.ShaderMaterial({ - uniforms: { - back_tex: { - type: 't', - value: this.volume_back_target.texture - }, - geometry_depth_tex: { - type: 't', - value: this.geometry_depth_target.depthTexture - }, - - volumes: { - type: 'tv', - value: [{}] - }, - data: { - type: 'tv', - value: [] - }, - transfer_function: { - type: 'tv', - value: [] - }, - - volumes_max_int: { - type: 'tv', - value: [{}] - }, - data_max_int: { - type: 'tv', - value: [] - }, - transfer_function_max_int: { - type: 'tv', - value: [] - }, - - ambient_coefficient: { - type: "f", - value: this.model.get("ambient_coefficient") - }, - diffuse_coefficient: { - type: "f", - value: this.model.get("diffuse_coefficient") - }, - specular_coefficient: { - type: "f", - value: this.model.get("specular_coefficient") - }, - specular_exponent: { - type: "f", - value: this.model.get("specular_exponent") - }, - - brightness: { - type: "f", - value: 2. - }, - render_size: { - type: "2f", - value: render_size - }, - - steps: { - type: 'f', - value: 10 - } - }, - blending: THREE.CustomBlending, - blendSrc: THREE.OneFactor, - blendDst: THREE.OneMinusSrcAlphaFactor, - blendEquation: THREE.AddEquation, - transparent: true, - defines: {}, - side: THREE.FrontSide - }); - - // a clone of the box_material_volr, with a different define (faster to render) - this.material_multivolume_depth = new THREE.ShaderMaterial({ - uniforms: this.material_multivolume.uniforms, - blending: THREE.NoBlending, - defines: { - COORDINATE: true - }, - side: THREE.FrontSide - }); - - this.model.on('change:scatters', this.update_scatters, this) - this.update_scatters() - this.model.on('change:meshes', this.update_meshes, this) - this.update_meshes() - this.model.on('change:volumes', this.update_volumes, this) - this.update_volumes() - - this.update_size() - - var that = this; - - this.el.addEventListener('change', _.bind(this.update, this)); // remove when using animation loop - - // TODO: remove this when we fully depend on the camera worldMatrix - var update_matrix_world_scale = () => { - this.model.set('matrix_world', this._get_view_matrix().elements.slice()) - this.touch() - } - - this.model.on('change:xlim change:ylim change:zlim', () => { - update_matrix_world_scale() - }) - - if (this.model.get('camera')) { - this.model.get('camera').on('change:matrixWorld', () => { - update_matrix_world_scale() - }) - update_matrix_world_scale() - - var update_matrix_projection = () => { - this.model.set('matrix_projection', this.camera.projectionMatrix.elements.slice()) - } - update_matrix_projection() - this.model.get('camera').on('change:projectionMatrix', () => { - update_matrix_projection() - }) - update_matrix_projection() - } - - this.model.on('change:camera_control', this.update_mouse_mode, this) - this.model.on('change:xlabel change:ylabel change:zlabel', this.update, this); - this.model.on('change:render_continuous', this.update, this) - this.model.on('change:style', this.update, this); - this.model.on('change:xlim change:ylim change:zlim ', this.update, this); - this.model.on('change:xlim change:ylim change:zlim ', this._save_matrices, this); - this.model.on('change:stereo', this.update_size, this); - - this.model.on('change:eye_separation', this.update, this) - - this.model.on('change:camera_fov', this.update_current_control, this) - - this.model.on('change:width', this.update_size, this); - this.model.on('change:height', this.update_size, this); - this.model.on('change:displayscale', this.update_size, this); - - this.model.on('change:ambient_coefficient', this.update_light, this); - this.model.on('change:diffuse_coefficient', this.update_light, this); - this.model.on('change:specular_coefficient', this.update_light, this); - this.model.on('change:specular_exponent', this.update_light, this); - - var update_center = () => { - // WARNING: we cheat a little by setting the scene positions (hence the minus) since it is - // easier, might get us in trouble later? - _.each([this.scene_volume, this.scene_opaque, this.scene_scatter], scene => { - var pos = this.model.get('camera_center'); - scene.position.set(-pos[0], -pos[1], -pos[2]) - }); - this.update(); - } - - this.model.on('change:camera_center', update_center) - update_center() - - this.model.on('change:tf', this.tf_set, this) - this.listenTo(this.model, 'msg:custom', _.bind(this.custom_msg, this)); - - this.control_trackball.addEventListener('end', _.bind(this.update_angles, this)); - this.control_orbit.addEventListener('end', _.bind(this.update_angles, this)); - this.control_trackball.addEventListener('change', _.bind(this.update, this)); - this.control_orbit.addEventListener('change', _.bind(this.update, this)); - - this.renderer.domElement.addEventListener('resize', _.bind(this.on_canvas_resize, this), false); - this.update(); - - // ensure initial sync of view with figure model - this.update_current_control(); - this.update_light(); - - if (this.model.get('capture_fps')) - var stream = this.renderer.domElement.captureStream(this.model.get('capture_fps')); - else - var stream = this.renderer.domElement.captureStream(); - - this.model.stream = Promise.resolve(stream); - window.last_figure_stream = (stream); - window.last_figure = this; - - // keep track over hover status manually - this.renderer.domElement.onmouseover = () => { - this.hover = true - }; - - this.renderer.domElement.onmouseleave = () => { - this.hover = false - }; - }, - - setStyle: function() { - // ignore original style setting, our style != a style widget - }, - - update_icons: function() { - var select_mode = this.model.get('mouse_mode') == 'select' - this.select_icon_lasso.active(this.model.get('selector') == 'lasso' && select_mode) - this.select_icon_circle.active(this.model.get('selector') == 'circle' && select_mode) - this.select_icon_rectangle.active(this.model.get('selector') == 'rectangle' && select_mode) - this.select_icon.active(select_mode) - var zoom_mode = this.model.get('mouse_mode') == 'zoom' - this.zoom_icon.active(zoom_mode) - }, - - update_mouse_mode: function() { - var normal_mode = this.model.get('mouse_mode') == 'normal'; - this.control_trackball.enabled = this.model.get('camera_control') == 'trackball' && normal_mode; - this.control_orbit.enabled = this.model.get('camera_control') == 'orbit' && normal_mode; - }, - - mousewheel: function(e) { - if (this.model.get('mouse_mode') != 'zoom') return; - e.preventDefault(); - e.stopPropagation(); - var amount = event.deltaY * 0.00025; - if (event.deltaMode == 2) // pages - amount = event.deltaY * 0.025; - if (event.deltaMode == 1) // lines - amount -= event.deltaY * 0.01; - var mouseX, mouseY; - if (e.offsetX) { - mouseX = e.offsetX; - mouseY = e.offsetY; - } else if (e.layerX) { - mouseX = e.layerX; - mouseY = e.layerY; - } - amount *= 10; - var factor = Math.pow(10, amount) - var buffer = new Uint8Array(4); - var height = this.renderer.domElement.clientHeight; - if (!this.last_zoom_coordinate) { - this.renderer.readRenderTargetPixels(this.coordinate_texture, mouseX, - height - mouseY, 1, 1, buffer) - - if (buffer[3] > 1) { - // at least something got drawn - var center = new THREE.Vector3(buffer[0], buffer[1], buffer[2]) - center.multiplyScalar(1. / 255.); // normalize - this.last_zoom_coordinate = center; - } - } - - if (this.last_zoom_coordinate) { // at least something got drawn - // clear it so that we don't use it again - this.renderer.setRenderTarget(this.coordinate_texture); - this.rrenderer.clear(true, true, true); - - var center = this.last_zoom_coordinate; - - // work in normalized coordinates - var np1 = center.clone().sub(center.clone().multiplyScalar(factor)) - var np2 = center.clone().add(center.clone().negate().addScalar(1).multiplyScalar(factor)) - - // and rescale to x/y/z lim - var xlim = this.model.get('xlim') - var ylim = this.model.get('ylim') - var zlim = this.model.get('zlim') - var p1 = new THREE.Vector3(xlim[0], ylim[0], zlim[0]); - var p2 = new THREE.Vector3(xlim[1], ylim[1], zlim[1]); - var scale = p2.clone().sub(p1); - var new_p1 = np1.clone().multiply(scale).add(p1); - var new_p2 = np2.clone().multiply(scale).add(p1); - this.model.set('xlim', [new_p1.x, new_p2.x]) - this.model.set('ylim', [new_p1.y, new_p2.y]) - this.model.set('zlim', [new_p1.z, new_p2.z]) - - this.touch() - } - return false; - }, - _mouse_down: function(e) { - //console.log('mouse down', e) - window.last_event = e - if (e.offsetX) { - mouseX = e.offsetX; - mouseY = e.offsetY; - } else if (e.layerX) { - mouseX = e.layerX; - mouseY = e.layerY; - } - this.mouse_down_position = { - x: mouseX, - y: mouseY - }; - this.mouse_down_limits = { - x: this.model.get('xlim'), - y: this.model.get('ylim'), - z: this.model.get('zlim') - } - var height = this.renderer.domElement.clientHeight; - var buffer = new Uint8Array(4); - this.renderer.readRenderTargetPixels(this.coordinate_texture, mouseX, height - mouseY, 1, 1, buffer) - if (buffer[3] > 1) { // at least something got drawn - var center = new THREE.Vector3(buffer[0], buffer[1], buffer[2]) - center.multiplyScalar(1 / 255.); // normalize - this.last_pan_coordinate = center; - } - - if (this.model.get('mouse_mode') == 'select') { - var cls = selectors[this.model.get('selector')]; - this.selector = new cls(this.canvas_overlay) - e.preventDefault(); - e.stopPropagation(); - } - }, - - _mouse_move: function(e) { - if (!e) { - var e = event; - } - - if (e.offsetX) { - var mouseX = e.offsetX, - mouseY = e.offsetY; - } else if (e.layerX) { - var mouseX = e.layerX, - mouseY = e.layerY; - } - mouse_position = { - x: mouseX, - y: mouseY - }; - - this.last_zoom_coordinate = null; - if (this.selector) { - this.mouse_trail.push([mouseX, mouseY]) - this.selector.mouseMove(mouseX, mouseY) - this.selector.draw() - } - - if (this.model.get('mouse_mode') == 'zoom' && this.last_pan_coordinate) { - if (e.buttons == 1) { - var canvas = this.renderer.domElement; - var pixels_right = mouse_position.x - this.mouse_down_position.x; - var pixels_up = -(mouse_position.y - this.mouse_down_position.y); - // normalized GL screen coordinates - var right = (pixels_right / canvas.clientWidth) * 2; - var up = (pixels_up / canvas.clientHeight) * 2; - var P = this.camera.projectionMatrix; - var W = this._get_view_matrix(); - // M goes from world to screen - var M = M = P.clone().multiply(W); - var Mi = M.clone().getInverse(M); - - var xlim = this.mouse_down_limits.x; - var ylim = this.mouse_down_limits.y; - var zlim = this.mouse_down_limits.z; - var l1 = new THREE.Vector3(xlim[0], ylim[0], zlim[0]); - var l2 = new THREE.Vector3(xlim[1], ylim[1], zlim[1]); - var scale = l2.clone().sub(l1); - - // start pos in world cooordinates - var p1 = this.last_pan_coordinate.clone().multiply(scale).add(l1); - // project to screen coordinates - var sp1 = p1.clone().applyMatrix4(M); - // move p2 in screen coordinates - var sp2 = sp1.clone(); - sp2.x += right; - sp2.y += up; - - // move them back to world coordinates - var np1 = sp1.applyMatrix4(Mi); - var np2 = sp2.applyMatrix4(Mi); - var delta = np2.clone().sub(np1); - - l1.sub(delta); - l2.sub(delta); - this.model.set('xlim', [l1.x, l2.x]); - this.model.set('ylim', [l1.y, l2.y]); - this.model.set('zlim', [l1.z, l2.z]); - } - } - }, - _mouse_dbl_click: function(e) { - if (this.model.get('mouse_mode') == 'zoom' && this.last_pan_coordinate) { - var xlim = this.mouse_down_limits.x - var ylim = this.mouse_down_limits.y - var zlim = this.mouse_down_limits.z - var l1 = new THREE.Vector3(xlim[0], ylim[0], zlim[0]); - var l2 = new THREE.Vector3(xlim[1], ylim[1], zlim[1]); - var scale = l2.clone().sub(l1); - - var center = this.last_pan_coordinate.clone().multiply(scale).add(l1) - var half_scale = scale.clone().multiplyScalar(0.5); - l1 = center.clone().sub(half_scale); - l2 = center.clone().add(half_scale); - this.model.set('xlim', [l1.x, l2.x]); - this.model.set('ylim', [l1.y, l2.y]); - this.model.set('zlim', [l1.z, l2.z]); - } - }, - _mouse_up: function(e) { - if (this.selector) { - var canvas = this.renderer.domElement; - this.send({ - event: 'selection', - data: this.selector.getData(canvas.clientWidth, canvas.clientHeight) - }) - // send event.. - this.mouse_trail = [] - this.selector.close() - this.selector = null; - e.preventDefault(); - e.stopPropagation(); - } - }, - _special_keys_down: function(e) { - if (!this.hover) return; - var evtobj = window.event ? event : e - if (evtobj.altKey) { - //console.log('pressed alt', this.hover) - } - var handled = false; - if (evtobj.key == '=') { // '=' - this.model.set('selection_mode', 'replace'); - handled = true; - } - if (evtobj.key == '|') { // '=' - this.model.set('selection_mode', 'or'); - handled = true; - } - if (evtobj.key == '&') { // '=' - this.model.set('selection_mode', 'and'); - handled = true; - } - if (evtobj.key == '-') { // '=' - this.model.set('selection_mode', 'subtract'); - handled = true; - } - if (evtobj.keyCode == 76) { // 'l' - this.model.set('selector', 'lasso'); - handled = true; - } - if (evtobj.keyCode == 67) { // 'c' - this.model.set('selector', 'circle'); - handled = true; - } - if (evtobj.keyCode == 82) { // 'r' - this.model.set('selector', 'rectangle'); - handled = true; - } - if (evtobj.keyCode == 18) { // shift - // avoid ctrl and shift - if (!this.quick_mouse_mode_change) { - this.quick_mouse_mode_change = true; - this.quick_mouse_previous_mode = this.model.get('mouse_mode') - this.model.set('mouse_mode', 'zoom') - handled = true; - } - } - if (evtobj.keyCode == 17) { // ctrl - if (!this.quick_mouse_mode_change) { - this.quick_mouse_mode_change = true; - this.quick_mouse_previous_mode = this.model.get('mouse_mode') - this.model.set('mouse_mode', 'select') - handled = true; - } - } - if (handled) { - this.touch() - e.preventDefault(); - e.stopPropagation(); - return false; - } - }, - _special_keys_up: function(e) { - var evtobj = window.event ? event : e; - if (evtobj.altKey) { - //console.log('released alt', this.hover) - } - if ((evtobj.keyCode == 17) || (evtobj.keyCode == 18)) { // ctrl or shift - if (this.quick_mouse_mode_change) { - this.quick_mouse_mode_change = false; - this.model.set('mouse_mode', this.quick_mouse_previous_mode); - this.touch(); - } - } - }, - custom_msg: function(content) { - if (content.msg == 'screenshot') { - var data = this.screenshot(undefined, content.width, content.height) - this.send({ - event: 'screenshot', - data: data - }); - } - }, - screenshot: function(mime_type, width, height) { - var resize = width && height - try { - if (resize) - this._update_size(true, width, height) - this._real_update() - var data = this.renderer.domElement.toDataURL(mime_type || 'image/png'); - console.info("captured screenshot") - return data - } finally { - if (resize) - this._update_size(false) - } - }, - _d3_add_axis: function(node, d, i) { - var axis = new THREE.Object3D(); - - axis.translateX(d.translate[0]); - axis.translateY(d.translate[1]); - axis.translateZ(d.translate[2]); - - d3.select(node).attr("translate-x", d.translate[0]); - d3.select(node).attr("translate-y", d.translate[1]); - d3.select(node).attr("translate-z", d.translate[2]); - - axis.rotation.reorder(d.rotation_order); - axis.rotation.x = d.rotate[0]; - axis.rotation.y = d.rotate[1]; - axis.rotation.z = d.rotate[2]; - this.axes.add(axis); - - // TODO: puzzled by the align not working as expected.. - var aligns = { - x: THREEtext2d.textAlign.topRight, - y: THREEtext2d.textAlign.topRight, - z: THREEtext2d.textAlign.center - }; - var label = new THREEtext2d.SpriteText2D(d.label, { - align: aligns[d.name], - font: '100px Arial', - fillStyle: '#00FF00', - antialias: true - }); - label.material.transparent = true; - label.material.alphaTest = 0.3; - - var s = 0.01 * 0.4 / 3; - label.scale.set(s, s, s); - axis.add(label); - d.object_label = label; - d.object = axis; - d.scale = d3.scaleLinear().domain(this.model.get(d.name + "lim")).range([-0.5, 0.5]); - d.ticks = null; - this._d3_update_axis(node, d, i) - }, - _d3_update_axis: function(node, d, i) { - d.object_label.text = d.label; - d.object_label.fillStyle = d.fillStyle; - var n = d.name // x, y or z - d.object_label.fillStyle = this.get_style('axes.' + n + '.label.color axes.' + n + '.color axes.label.color axes.color') - d.object_label.visible = this.get_style('axes.' + n + '.label.visible axes.' + n + '.visible axes.label.visible axes.visible') - }, - _d3_add_axis_tick: function(node, d, i) { - //console.log("add tick", d, node, d3.select(d3.select(node).node().parentNode)) - var parent_data = d3.select(d3.select(node).node().parentNode).datum(); // TODO: find the proper way to do so - var scale = parent_data.scale; - - var tick_format = scale.tickFormat(this.ticks, ".1f"); - var tick_text = tick_format(d.value); - - // TODO: puzzled by the align not working as expected.. - var aligns = { - x: THREEtext2d.textAlign.topRight, - y: THREEtext2d.textAlign.topRight, - z: THREEtext2d.textAlign.center - }; - var sprite = new THREEtext2d.SpriteText2D(tick_text, { - align: aligns[parent_data.name], - font: '100px Arial', - fillStyle: '#00FF00', - antialias: true - }); - sprite.material.transparent = true - sprite.material.alphaTest = 0.3 - sprite.blending = THREE.CustomBlending - sprite.blendSrc = THREE.SrcAlphaFactor - sprite.blendDst = THREE.OneMinusSrcAlphaFactor - sprite.blendEquation = THREE.AddEquation - - var s = 0.01 * 0.4 * 0.5 * 0.5 / 3; - sprite.scale.multiplyScalar(s) - var n = parent_data.name // x, y or z - - sprite.fillStyle = this.get_style('axes.' + n + '.ticklabel.color axes.ticklabel.color axes.' + n + '.color axes.color') - parent_data.object.add(sprite) - d.object_ticklabel = sprite; - this._d3_update_axis_tick(node, d, i) - return sprite - }, - _d3_update_axis_tick: function(node, d, i) { - // TODO: find the proper way to do so - var parent_data = d3.select(d3.select(node).node().parentNode).datum(); - var scale = parent_data.scale; - var tick_format = scale.tickFormat(this.ticks, ".1f"); - var tick_text = tick_format(d.value); - d.object_ticklabel.text = tick_text - d.object_ticklabel.position.x = scale(d.value) - var n = parent_data.name // x, y or z - d.object_ticklabel.fillStyle = this.get_style('axes.' + n + '.ticklabel.color axes.ticklabel.color axes.' + n + '.color axes.color') - d.object_ticklabel.visible = this.get_style('axes.' + n + '.ticklabel.visible axes.' + n + '.visible axes.visible') - }, - _d3_remove_axis_tick: function(node, d, i) { - d.object_ticklabel.parent.remove(d.object_ticklabel) - }, - update_scatters: function() { - var scatters = this.model.get('scatters'); // This is always a list? - if (scatters.length != 0) { // So now check if list has length 0 - var current_sct_cids = [] - // Add new scatter if not already as scatter view in figure - _.each(scatters, scatter_model => { - current_sct_cids.push(scatter_model.cid); - if (!(scatter_model.cid in this.scatter_views)) { - var options = { - parent: this - } - var scatter_view = new scatter.ScatterView({ - options: options, - model: scatter_model - }) - scatter_view.render() - this.scatter_views[scatter_model.cid] = scatter_view - } - }, this) - - // Remove old scatters not contained in scatters - _.each(this.scatter_views, (sct, cid) => { - if (current_sct_cids.indexOf(cid) == -1) { - sct.remove_from_scene(); - delete this.scatter_views[cid]; - } - }, this) - } else { - this.scatter_views = {} - } - }, - update_meshes: function() { - var meshes = this.model.get('meshes'); // This is always a list? - if (meshes.length != 0) { // So now check if list has length 0 - var current_msh_cids = [] - // Add new meshes if not already as mesh view in figure - _.each(meshes, mesh_model => { - current_msh_cids.push(mesh_model.cid); - if (!(mesh_model.cid in this.mesh_views)) { - var options = { - parent: this - } - var mesh_view = new mesh.MeshView({ - options: options, - model: mesh_model - }) - mesh_view.render() - this.mesh_views[mesh_model.cid] = mesh_view - } - }, this) - - // Remove old meshes not contained in meshes - _.each(this.mesh_views, (mv, cid) => { - if (current_msh_cids.indexOf(cid) == -1) { - mv.remove_from_scene(); - delete this.mesh_views[cid]; - } - }, this) - } else { - this.mesh_views = {} - } - }, - update_volumes: function() { - var volumes = this.model.get('volumes'); // This is always a list? - if (volumes.length != 0) { // So now check if list has length 0 - var current_vol_cids = [] - // Add new volumes if not already as volume view in figure - _.each(volumes, vol_model => { - current_vol_cids.push(vol_model.cid); - if (!(vol_model.cid in this.volume_views)) { - var options = { - parent: this - } - var volume_view = new volume.VolumeView({ - options: options, - model: vol_model - }) - this.volume_views[vol_model.cid] = volume_view - volume_view.render() - } - }, this) - - // Remove old meshes not contained in meshes - _.each(this.volume_views, (vol, cid) => { - if (current_vol_cids.indexOf(cid) == -1) { - vol.remove_from_scene(); - delete this.volume_views[cid]; - } - }, this) - } else { - this.volume_views = {} - } - }, - transition: function(f, on_done, context) { - var that = this; - var Transition = function() { - //this.objects = [] - this.time_start = (new Date()).getTime(); - this.duration = that.model.get("animation"); - this.cancelled = false; - this.called_on_done = false - this.set = function(obj) { - this.objects.push(obj) - } - this.is_done = function() { - var dt = (new Date()).getTime() - this.time_start; - return (dt >= this.duration) || this.cancelled - } - this.cancel = function() { - this.cancelled = true; - }, - this.update = function() { - if (this.cancelled) - return - var dt = ((new Date()).getTime() - this.time_start) / this.duration; - - var u = Math.min(1, dt); - u = Math.pow(u, that.model.get("animation_exponent")) - f.apply(context, [u]); - if (dt >= 1 && !this.called_on_done) { - this.called_on_done = true - on_done.apply(context) - } - } - that.transitions.push(this) - } - return new Transition() - }, - on_orientationchange: function(e) { - _.each([this.scene_volume, this.scene_opaque, this.scene_scatter], scene => { - scene.rotation.reorder("XYZ"); - scene.rotation.x = (e.gamma * Math.PI / 180 + Math.PI * 2); - scene.rotation.y = -(e.beta * Math.PI / 180 + Math.PI * 2); - scene.rotation.z = -((e.alpha) * Math.PI / 180); - }, this) - this.update() - - }, - on_canvas_resize: function(event) {}, - keypress: function(event) { - var code = event.keyCode || event.which; - if (event.keyCode == 27) {} - if (event.key == 'f') {} - }, - update_angles: function() { - if (this.camera.ipymodel) - this.camera.ipymodel.syncToModel(true) - this.update() - }, - _get_scale_matrix: function() { - // go from [0, 1] to [-0.5, 0.5] - var matrix = new THREE.Matrix4() - matrix.makeTranslation(-0.5, -0.5, -0.5) - - var matrix_scale = new THREE.Matrix4() - var x = this.model.get('xlim') - var y = this.model.get('ylim') - var z = this.model.get('zlim') - var sx = 1 / (x[1] - x[0]) - var sy = 1 / (y[1] - y[0]) - var sz = 1 / (z[1] - z[0]) - matrix_scale.makeScale(sx, sy, sz) - var translation = new THREE.Matrix4() - translation.makeTranslation(-x[0], -y[0], -z[0]) - matrix.multiply(matrix_scale) - matrix.multiply(translation) - return matrix; - }, - _get_view_matrix() { - // make sure the camera's inverse is up to date, normally the renderer would do this - // but this also gets called before the first render - this.camera.updateMatrixWorld() - this.camera.matrixWorldInverse.getInverse(this.camera.matrixWorld) - // we don't really properly use the worldmatrix, rendering threejs's frustum culling - // useless, we maybe should change this - // https://github.com/mrdoob/three.js/issues/78#issuecomment-846917 - var view_matrix = this.camera.matrixWorldInverse.clone() - view_matrix.multiply(this._get_scale_matrix().clone()) - return view_matrix; - }, - update_current_control: function() { - if (this.camera.ipymodel) - this.camera.ipymodel.syncToModel(true) - this.control_trackball.position0 = this.camera.position.clone() - this.control_trackball.up0 = this.camera.up.clone() - }, - update_panorama: function() { - var material = this.screen_material_cube - if (this.model.get('panorama_mode') == '360') - material.defines = { - PANORAMA_360: true - } - if (this.model.get('panorama_mode') == '180') - material.defines = { - PANORAMA_180: true - } - material.needsUpdate = true - this.update() - }, - update: function() { - // requestAnimationFrame stacks, so make sure multiple update calls only lead to 1 _real_update call - if (!this._update_requested) { - this._update_requested = true - requestAnimationFrame(_.bind(this._real_update, this)) - } - }, - _real_update: function() { - this.control_trackball.handleResize() - this._update_requested = false - // since the threejs animation system can update the camera, - // make sure we keep looking at the center - this.camera.lookAt(0, 0, 0) - - this.renderer.setClearColor(this.get_style_color('background-color')) - this.x_axis.visible = this.get_style('axes.x.visible axes.visible') - this.y_axis.visible = this.get_style('axes.y.visible axes.visible') - this.z_axis.visible = this.get_style('axes.z.visible axes.visible') - this.axes_material.color = this.get_style_color('axes.color') - this.xaxes_material.color = this.get_style_color('axes.x.color axes.color') - this.yaxes_material.color = this.get_style_color('axes.y.color axes.color') - this.zaxes_material.color = this.get_style_color('axes.z.color axes.color') - - this.axes_data[0].fillStyle = this.get_style('axes.x.color axes.color') - this.axes_data[1].fillStyle = this.get_style('axes.y.color axes.color') - this.axes_data[2].fillStyle = this.get_style('axes.z.color axes.color') - - this.axes_data[0].label = this.model.get("xlabel") - this.axes_data[1].label = this.model.get("ylabel") - this.axes_data[2].label = this.model.get("zlabel") - - this.wire_box.visible = this.get_style('box.visible') - this.wire_box_x_line.visible = !this.x_axis.visible && this.wire_box.visible - this.wire_box_y_line.visible = !this.y_axis.visible && this.wire_box.visible - this.wire_box_z_line.visible = !this.z_axis.visible && this.wire_box.visible - - d3.select(this.el_axes).selectAll(".ipyvol-axis") - .data(this.axes_data) - .each(bind_d3(this._d3_update_axis, this)) - .enter() - .append("div") - .attr("class", "ipyvol-axis") - .each(bind_d3(this._d3_add_axis, this)); - - var that = this; - this.ticks = 5 - - function last_tick_selection_data(d, i, node) { - var child_data = d.ticks - if (child_data) { - child_data = d.ticks = child_data.slice() - var ticks = d.scale.ticks(that.ticks) - - // ticks may return a larger array, so grow child data - while (child_data.length < ticks.length) - child_data.push({}) - // ticks may return a smaller array, so pop child data - while (child_data.length > ticks.length) - child_data.pop() - - _.each(ticks, (tick, i) => { - child_data[i].value = tick; - }); - return child_data - } else { - var scale = d.scale; - var ticks = scale.ticks(that.ticks) - var child_data = _.map(ticks, function(value) { - return { - value: value - } - }); - d.ticks = child_data; - return child_data; - } - }; - - this.last_tick_selection = d3.select(this.el_axes) - .selectAll(".ipyvol-axis") - .data(this.axes_data) - .selectAll(".ipyvol-tick") - .data(last_tick_selection_data); - - this.last_tick_selection - .each(bind_d3(this._d3_update_axis_tick, this)) - .enter() - .append("div") - .attr("class", "ipyvol-tick") - .each(bind_d3(this._d3_add_axis_tick, this)); - - this.last_tick_selection - .exit() - .remove() - .each(bind_d3(this._d3_remove_axis_tick, this)) - - var transitions_todo = [] - for (var i = 0; i < this.transitions.length; i++) { - var t = this.transitions[i]; - if (!t.is_done()) - transitions_todo.push(t) - t.update() - } - - this.renderer.clear() - if (!this.model.get("stereo")) { - this._render_eye(this.camera); - } else { - var size = this.renderer.getSize(); - if (this.camera.parent === null) this.camera.updateMatrixWorld(); - this.camera_stereo.eyeSep = this.model.get('eye_separation') / 100.; - this.camera.focus = this.camera.focus - this.camera_stereo.update(this.camera) - - // the 360 rendering uses the position and quaternion, not the matrices - this.camera_stereo.cameraL.position.copy(this.camera.position) - this.camera_stereo.cameraR.position.copy(this.camera.position) - this.camera_stereo.cameraL.quaternion.copy(this.camera.quaternion) - this.camera_stereo.cameraR.quaternion.copy(this.camera.quaternion) - // and up is used for lookAt - this.camera_stereo.cameraL.up.copy(this.camera.up) - this.camera_stereo.cameraR.up.copy(this.camera.up) - - // default is to render left left, and right right - // in 360 mode, left is rendered top, right bottom - var panorama = this.model.get('panorama_mode') != 'no'; - // left eye - this.renderer.setScissorTest(true); - if (panorama) { - this.renderer.setScissor(0, 0, size.width, size.height / 2); - this.renderer.setViewport(0, 0, size.width, size.height / 2); - } else { - this.renderer.setScissor(0, 0, size.width / 2, size.height); - this.renderer.setViewport(0, 0, size.width / 2, size.height); - } - - this._render_eye(this.camera_stereo.cameraL); - - // right eye - if (panorama) { - this.renderer.setScissor(0, size.height / 2, size.width, size.height / 2); - this.renderer.setViewport(0, size.height / 2, size.width, size.height / 2); - } else { - this.renderer.setScissor(size.width / 2, 0, size.width / 2, size.height); - this.renderer.setViewport(size.width / 2, 0, size.width / 2, size.height); - } - - this._render_eye(this.camera_stereo.cameraR); - - this.renderer.setScissorTest(false); - this.renderer.setViewport(0, 0, size.width, size.height); - } - if (this.selector) - this.selector.draw() // TODO: what to do with stereo rendering? - this.transitions = transitions_todo; - if (this.transitions.length > 0) { - this.update() - } - if (this.model.get('render_continuous')) { - this.update() - } - if (this.model.get('scene')) { - this.model.get('scene').trigger('afterRender', this.scene_volume, this.renderer, this.camera) - } - }, - get_style_color: function(name) { - style = this.get_style(name) - if (style) { - return new THREE.Color(style) - } else { - console.error("could not find color for", name) - } - }, - get_style: function(name) { - var value = [null] - _.each(name.split(" "), property => { - var value_found = _.reduce(property.split("."), function(object, property) { - if (object != null && object[property] != undefined) - return object[property] - else - return null - }, this.model.get("style"), this) - if (value_found != null && value[0] == null) - value[0] = value_found - }, this) - - return value[0] - }, - _render_eye: function(camera) { - this.camera.updateMatrixWorld(); - var has_volumes = this.model.get("volumes").length != 0; - var panorama = this.model.get('panorama_mode') != 'no'; - - // set material to rgb - _.each(this.scatter_views, scatter => { - scatter.set_limits(_.pick(this.model.attributes, 'xlim', 'ylim', 'zlim')) - }, this) - _.each(this.mesh_views, mesh_view => { - mesh_view.set_limits(_.pick(this.model.attributes, 'xlim', 'ylim', 'zlim')) - }, this) - - if (panorama) { - this.cube_camera.clear(this.renderer, true, true, true) - this.renderer.autoClear = false; - this.cube_camera.position.copy(camera.position) - this.cube_camera.rotation.copy(camera.rotation) - this.cube_camera.quaternion.copy(this.camera.quaternion) - - if (this.model.get('stereo')) { - // we do 'toe in' http://paulbourke.net/papers/vsmm2006/vsmm2006.pdf - // which should be fine with spherical screens or projections right? - // as opposed to what is described here http://paulbourke.net/stereographics/stereorender/ - var displacement = new THREE.Vector3(0.0, 0, 0); - if (camera == this.camera_stereo.cameraR) - displacement.x += 0.032 - if (camera == this.camera_stereo.cameraL) - displacement.x -= 0.032 - displacement.applyQuaternion(camera.quaternion); - this.cube_camera.position.add(displacement) - var focal_point = new THREE.Vector3(0, 0, 1 * this.camera.focus); // neg z points in screen - focal_point.applyQuaternion(camera.quaternion); - this.cube_camera.lookAt(focal_point) - } - - this.cube_camera.update(this.renderer, this.scene_scatter) - this.cube_camera.update(this.renderer, this.scene_opaque) - this.screen_texture = this.cube_camera.renderTarget; - this.renderer.render(this.screen_scene_cube, this.screen_camera); - return - } - - // render the back coordinates of the box - if (has_volumes) { - // to render the back sides of the boxes, we need to invert the z buffer value - // and invert the test - this.renderer.state.buffers.depth.setClear(0); - _.each(this.volume_views, volume_view => { - volume_view.box_material.side = THREE.BackSide; - volume_view.box_material.depthFunc = THREE.GreaterDepth - volume_view.vol_box_mesh.material = volume_view.box_material; - volume_view.set_limits(_.pick(this.model.attributes, 'xlim', 'ylim', 'zlim')) - }, this) - this.renderer.setRenderTarget(this.volume_back_target) - this.renderer.clear(true, true, true) - this.renderer.render(this.scene_volume, camera, this.volume_back_target); - this.renderer.state.buffers.depth.setClear(1); - - // Color and depth render pass for volume rendering - this.renderer.autoClear = false; - this.renderer.setRenderTarget(this.geometry_depth_target); - this.renderer.clear(true, true, true) - this.renderer.render(this.scene_scatter, camera, this.geometry_depth_target); - this.renderer.render(this.scene_opaque, camera, this.geometry_depth_target); - this.renderer.autoClear = true; - - } - - // Normal color pass of geometry for final screen pass - this.renderer.autoClear = false; - this.renderer.setRenderTarget(this.color_pass_target); - this.renderer.clear(true, true, true) - this.renderer.render(this.scene_scatter, camera, this.color_pass_target); - this.renderer.render(this.scene_opaque, camera, this.color_pass_target); - this.renderer.autoClear = true; - - if (has_volumes) { - // render the box front once, without writing the colors - // so that once we render the box again, each fragment will be processed - // once. - this.renderer.context.colorMask(0, 0, 0, 0) - _.each(this.volume_views, volume_view => { - volume_view.box_material.side = THREE.FrontSide; - volume_view.box_material.depthFunc = THREE.LessEqualDepth - }, this) - this.renderer.autoClear = false; - this.renderer.setRenderTarget(this.color_pass_target); - this.renderer.clear(false, true, false) - this.renderer.render(this.scene_volume, camera, this.color_pass_target); - this.renderer.autoClear = true; - this.renderer.context.colorMask(true, true, true, true) - - // TODO: if volume perfectly overlap, we render it twice, use polygonoffset and LESS z test? - _.each(this.volume_views, volume_view => { - volume_view.vol_box_mesh.material = this.material_multivolume; - // volume_view.set_geometry_depth_tex(this.geometry_depth_target.depthTexture) - }, this) - this.renderer.autoClear = false; - // we want to keep the colors and z-buffer as they are - this.renderer.setRenderTarget(this.color_pass_target); - this.renderer.clear(false, false, false) - this.renderer.render(this.scene_volume, camera, this.color_pass_target); - this.renderer.autoClear = true; - } - - // set RGB material for coordinate texture render - _.each(this.scatter_views, scatter => { - scatter.mesh.material = scatter.mesh.material_rgb - }, this) - _.each(this.mesh_views, mesh_view => { - _.each(mesh_view.meshes, mesh => { - mesh.material = mesh.material_rgb - }, this); - }, this) - - // we also render this for the zoom coordinate - this.renderer.autoClear = false; - this.renderer.setClearAlpha(0) - this.renderer.setRenderTarget(this.coordinate_texture); - this.renderer.clear(true, true, true) - this.renderer.render(this.scene_scatter, camera, this.coordinate_texture); - this.renderer.autoClear = true; - - // now we render the weighted coordinate for the volumetric data - // make sure where we don't render, alpha = 0 - if (has_volumes) { - // render again, but now with depth material - // TODO: this render pass is only needed when the coordinate is required - // we slow down by a factor of 2 by always doing this - this.renderer.context.colorMask(0, 0, 0, 0) - _.each(this.volume_views, volume_view => { - volume_view.box_material.side = THREE.FrontSide; - volume_view.box_material.depthFunc = THREE.LessEqualDepth - }, this) - this.renderer.autoClear = false; - this.renderer.setRenderTarget(this.color_pass_target); - this.renderer.clear(false, true, false) - this.renderer.render(this.scene_volume, camera, this.color_pass_target); - this.renderer.autoClear = true; - this.renderer.context.colorMask(true, true, true, true) - - // TODO: if volume perfectly overlap, we render it twice, use polygonoffset and LESS z test? - _.each(this.volume_views, volume_view => { - volume_view.vol_box_mesh.material = this.material_multivolume_depth; - // volume_view.set_geometry_depth_tex(this.geometry_depth_target.depthTexture) - }, this) - this.renderer.autoClear = false; - // we want to keep the colors and z-buffer as they are - this.renderer.setRenderTarget(this.color_pass_target); - this.renderer.clear(false, false, false) - this.renderer.render(this.scene_volume, camera, this.coordinate_texture); - this.renderer.autoClear = true; - - } - - // restore materials - _.each(this.scatter_views, scatter => { - scatter.mesh.material = scatter.mesh.material_normal - }, this) - _.each(this.mesh_views, mesh_view => { - _.each(mesh_view.meshes, mesh => { - mesh.material = mesh.material_normal - }, this); - }, this) - - // render to screen - this.screen_texture = { - Volume: this.color_pass_target, - Back: this.volume_back_target, - Geometry_back: this.geometry_depth_target, - Coordinate: this.coordinate_texture - }[this.model.get("show")]; - this.screen_material.uniforms.tex.value = this.screen_texture.texture - - this.renderer.clear(true, true, true) - this.renderer.render(this.screen_scene, this.screen_camera); - }, - rebuild_multivolume_rendering_material: function() { - var volumes = this.model.get('volumes'); // This is always a list? - if (volumes.length == 0) - return; - - var material = this.material_multivolume; - var material_depth = this.material_multivolume_depth; - var count_normal = 0; - var count_max_int = 0; - material.uniforms.volumes.value = [] - material.uniforms.volumes_max_int.value = [] - material.uniforms.data.value = [] - material.uniforms.data_max_int.value = [] - material.uniforms.transfer_function.value = [] - material.uniforms.transfer_function_max_int.value = [] - material.uniforms.steps.value = _.max(volumes.map(volume => { - let volume_view = this.volume_views[volume.cid]; - return volume_view ? volume_view.get_ray_steps() : 0; - })); - - _.each(volumes, vol_model => { - let volume_view = this.volume_views[vol_model.cid]; - // could be that the view was not yet created - if (volume_view) { - var volume = volume_view.model; - if (volume_view.is_normal()) { - count_normal++; - material.uniforms.volumes.value.push(volume_view.uniform_volumes_values) - material.uniforms.data.value.push(volume_view.uniform_data.value[0]) - material.uniforms.transfer_function.value.push(volume_view.uniform_transfer_function.value[0]) - } else { - count_max_int++; - material.uniforms.volumes_max_int.value.push(volume_view.uniform_volumes_values) - material.uniforms.data_max_int.value.push(volume_view.uniform_data.value[0]) - material.uniforms.transfer_function_max_int.value.push(volume_view.uniform_transfer_function.value[0]) - } - } - }) - material.defines.VOLUME_COUNT = count_normal; - material.defines.VOLUME_COUNT_MAX_INT = count_max_int; - material_depth.defines.VOLUME_COUNT = count_normal; - material_depth.defines.VOLUME_COUNT_MAX_INT = count_max_int; - - let mustache_render = (template_shader) => { - var view = { - volumes: _.range(count_normal), - volumes_max_int: _.range(count_max_int) - }; - return Mustache.render(template_shader, view) - } - material_depth.fragmentShader = material.fragmentShader = mustache_render(shaders["volr_fragment"]) - material_depth.vertexShader = material.vertexShader = shaders["volr_vertex"] - material_depth.needsUpdate = material.needsUpdate = true; - }, - update_light: function() { - this.material_multivolume.uniforms.ambient_coefficient.value = this.model.get("ambient_coefficient") - this.material_multivolume.uniforms.diffuse_coefficient.value = this.model.get("diffuse_coefficient") - this.material_multivolume.uniforms.specular_coefficient.value = this.model.get("specular_coefficient") - this.material_multivolume.uniforms.specular_exponent.value = this.model.get("specular_exponent") - this.update() - }, - update_size: function() { - this._update_size() - }, - _update_size: function(skip_update, custom_width, custom_height) { - var width, height; - var el = this.renderer.domElement - if (this.is_fullscreen()) { - width = custom_width || el.clientWidth - height = custom_height || el.clientHeight; - } else { - width = custom_width || this.model.get("width"); - height = custom_height || this.model.get("height"); - } - - // the offscreen rendering can be of lower resolution - var render_width = width * this.renderer.getPixelRatio(); - var render_height = height * this.renderer.getPixelRatio(); - var display_width = width * this.model.get('displayscale') - var display_height = height * this.model.get('displayscale') - if (this.is_fullscreen() && this.model.get("volumes") != 0) { - // fullscreen volume rendering is slow, respect width and height - render_width = custom_width || this.model.get("width"); - render_height = custom_height || this.model.get("height"); - } - this.renderer.setSize(width, height, false); - var buffer_width = this.renderer.context.drawingBufferWidth; - var buffer_height = this.renderer.context.drawingBufferHeight; - if ((buffer_width < width) || (buffer_height < height)) { - console.info('could not set resolution to', width, height, ', resolution is', buffer_width, buffer_height) - } - - this.renderer.domElement.style.width = display_width + "px" - this.renderer.domElement.style.height = display_height + "px" - this.canvas_container.style.width = display_width + "px" - this.canvas_container.style.height = display_height + "px" - this.canvas_overlay.style.width = display_width + "px" - this.canvas_overlay.style.height = display_height + "px" - this.canvas_overlay.width = width - this.canvas_overlay.height = height - - if (this.model.get("stereo")) { - render_width /= 2; - } - var aspect = render_width / render_height; - this.camera.aspect = aspect - // TODO: should we now update the camera object? - // this.camera.width = render_width - // this.camera.height = render_height - this.camera.updateProjectionMatrix(); - - this.material_multivolume.uniforms.render_size.value = [render_width, render_height] - - this.volume_back_target.setSize(render_width, render_height); - this.geometry_depth_target.setSize(render_width, render_height); - this.color_pass_target.setSize(render_width, render_height); - this.screen_pass_target.setSize(render_width, render_height); - this.coordinate_texture.setSize(render_width, render_height); - - this.screen_texture = this.color_pass_target.texture; - if (!skip_update) - this.update() - }, - getRenderSize: function() { - var render_size = this.renderer.getSize() - return [render_size.width, render_size.width]; - }, - fullscreen: function() { - screenfull.request(this.el) - }, - is_fullscreen: function() { - return screenfull.element === this.renderer.domElement - } -}); - -var FigureModel = widgets.DOMWidgetModel.extend({ - defaults: function() { - return _.extend(widgets.DOMWidgetModel.prototype.defaults(), { - _model_name: 'FigureModel', - _view_name: 'FigureView', - _model_module: 'ipyvolume', - _view_module: 'ipyvolume', - _model_module_version: semver_range, - _view_module_version: semver_range, - eye_separation: 6.4, - stereo: false, - camera_control: 'trackball', - camera_fov: 45, - camera_center: [0., 0., 0.], - ambient_coefficient: 0.5, - diffuse_coefficient: 0.8, - specular_coefficient: 0.5, - specular_exponent: 5, - width: 500, - height: 400, - pixel_ratio: null, - displayscale: 1, - scatters: null, - meshes: null, - volumes: null, - show: 'Volume', - xlim: [0., 1.], - ylim: [0., 1.], - zlim: [0., 1.], - xlabel: 'x', - ylabel: 'y', - zlabel: 'z', - animation: 1000, - animation_exponent: 1.0, - style: styles['light'], - render_continuous: false, - selector: 'lasso', - selection_mode: 'replace', - mouse_mode: 'normal', - panorama_mode: 'no', - capture_fps: undefined, - cube_resolution: 512, - }) - } -}, { - serializers: _.extend({ - scatters: { deserialize: widgets.unpack_models }, - meshes: { deserialize: widgets.unpack_models }, - volumes: { deserialize: widgets.unpack_models }, - camera: { deserialize: widgets.unpack_models }, - scene: { deserialize: widgets.unpack_models }, - }, widgets.DOMWidgetModel.serializers) -}); - -var WidgetManagerHackModel = widgets.WidgetModel.extend({ - defaults: function() { - return _.extend(widgets.WidgetModel.prototype.defaults(), { - _model_name: 'WidgetManagerHackModel', - _model_module: 'ipyvolume', - _model_module_version: semver_range, - }) - }, - initialize: function(attributes, options) { - console.log(this) - WidgetManagerHackModel.__super__.initialize.apply(this, arguments); - console.info("get reference to widget manager") - window.jupyter_widget_manager = this.widget_manager; - window.jupyter_widgets = widgets - } -}); - -module.exports = { - WidgetManagerHackModel: WidgetManagerHackModel, - FigureModel: FigureModel, - FigureView: FigureView, -}; - -////////////////// -// WEBPACK FOOTER -// ./src/volume.js -// module id = 1 -// module chunks = 0 \ No newline at end of file diff --git a/js/src/figure.ts b/js/src/figure.ts new file mode 100644 index 00000000..329fce01 --- /dev/null +++ b/js/src/figure.ts @@ -0,0 +1,2766 @@ +import * as widgets from "@jupyter-widgets/base"; +import * as d3 from "d3"; +import * as glm from "gl-matrix"; +import * as Mustache from "mustache"; +import * as screenfull from "screenfull"; +import * as THREE from "three"; +import * as THREEtext2d from "three-text2d"; +import { MeshModel, MeshView} from "./mesh"; +import { ScatterModel, ScatterView} from "./scatter"; +import { copy_image_to_clipboard, download_image, select_text} from "./utils"; +import { semver_range} from "./utils"; +import { VolumeModel, VolumeView } from "./volume.js"; + +import { mapValues, range } from "lodash"; +import { selectors } from "./selectors"; +import { Transition } from "./transition"; + +// tslint:disable-next-line: no-var-requires +require("../css/style.css"); +// tslint:disable-next-line: no-var-requires +const styles = require("../data/style.json"); + +const axis_names = ["x", "y", "z"]; + +(window as any).THREE = THREE; + +import { RenderTarget, ShaderMaterial } from "three"; +import { createD3Scale, patchShader } from "./scales"; +import "./three/CombinedCamera.js"; +import "./three/DeviceOrientationControls.js"; +import "./three/OrbitControls.js"; +import "./three/StereoEffect.js"; +import "./three/THREEx.FullScreen.js"; +import "./three/TrackballControls.js"; + +const shaders = { + "screen-fragment": (require("raw-loader!../glsl/screen-fragment.glsl") as any).default, + "screen-vertex": (require("raw-loader!../glsl/screen-vertex.glsl") as any).default, + "volr-fragment": (require("raw-loader!../glsl/volr-fragment.glsl") as any).default, + "volr-vertex": (require("raw-loader!../glsl/volr-vertex.glsl") as any).default, + "shadow-fragment": (require("raw-loader!../glsl/shadow-fragment.glsl") as any).default, + "shadow-vertex": (require("raw-loader!../glsl/shadow-vertex.glsl") as any).default, + "box-fragment": (require("raw-loader!../glsl/box-fragment.glsl") as any).default, + "box-vertex": (require("raw-loader!../glsl/box-vertex.glsl") as any).default, +}; + +// similar to _.bind, except it +// puts this as first argument to f, followed be other arguments, and make context f's this +function bind_d3(f, context) { + return function() { + const args = [this].concat([].slice.call(arguments)); // convert argument to array + f.apply(context, args); + }; +} + +class ToolIcon { + a: HTMLAnchorElement; + li: HTMLLIElement; + sub: HTMLDivElement; + constructor(className, parent) { + this.a = document.createElement("a"); + this.a.className = "ipyvolume-toolicon"; + this.a.setAttribute("href", "javascript:void(0)"); + this.li = document.createElement("li"); + this.li.className = "fa " + className; + this.sub = document.createElement("div"); + this.sub.className = "ipyvolume-toolicon-dropdown-container"; + this.a.appendChild(this.li); + this.a.appendChild(this.sub); + parent.appendChild(this.a); + } + active(state) { + if (state) { + this.li.classList.remove("fa-inactive"); + } else { + this.li.classList.add("fa-inactive"); + } + } +} + +class ToolIconDropdown { + a: HTMLAnchorElement; + li: HTMLLIElement; + span_text: HTMLSpanElement; + constructor(className, parent, text) { + this.a = document.createElement("a"); + this.a.className = "ipyvolume-toolicon-dropdown"; + this.a.setAttribute("href", "javascript:void(0)"); + this.li = document.createElement("li"); + this.li.className = "fa " + className; + this.span_text = document.createElement("span"); + this.span_text.innerText = text; + this.a.appendChild(this.li); + this.li.appendChild(this.span_text); + parent.appendChild(this.a); + } + active(state) { + if (state) { + this.a.classList.remove("ipyvolume-toolicon-inactive"); + } else { + this.a.classList.add("ipyvolume-toolicon-inactive"); + } + } +} + +export +class FigureModel extends widgets.DOMWidgetModel { + + static serializers = {...widgets.DOMWidgetModel.serializers, + scatters: { deserialize: widgets.unpack_models }, + meshes: { deserialize: widgets.unpack_models }, + lights: { deserialize: widgets.unpack_models }, + volumes: { deserialize: widgets.unpack_models }, + camera: { deserialize: widgets.unpack_models }, + scene: { deserialize: widgets.unpack_models }, + controls: { deserialize: widgets.unpack_models }, + scales: { deserialize: widgets.unpack_models }, + }; + defaults() { + return {...super.defaults(), + _model_name: "FigureModel", + _view_name: "FigureView", + _model_module: "ipyvolume", + _view_module: "ipyvolume", + _model_module_version: semver_range, + _view_module_version: semver_range, + eye_separation: 6.4, + stereo: false, + camera_control: "trackball", + camera_fov: 45, + camera_center: [0., 0., 0.], + ambient_coefficient: 0.5, + diffuse_coefficient: 0.8, + specular_coefficient: 0.5, + specular_exponent: 5, + width: 500, + height: 400, + pixel_ratio: null, + displayscale: 1, + scatters: null, + meshes: null, + lights: [], + volumes: null, + show: "render", + scales: {}, + xlabel: "x", + ylabel: "y", + zlabel: "z", + animation: 1000, + animation_exponent: 1.0, + style: styles.light, + render_continuous: false, + selector: "lasso", + selection_mode: "replace", + mouse_mode: "normal", + panorama_mode: "no", + capture_fps: null, + cube_resolution: 512, + box_center: [0.5, 0.5, 0.5], + box_size: [1, 1, 1], + popup_debouce: 100, + slice_x: 0, + slice_y: 0, + slice_z: 0, + _shaders: {}, // override shaders / hot reload + }; + } +} + +export +class FigureView extends widgets.DOMWidgetView { + renderer: any; + transitions: any[]; + _update_requested: boolean; + update_counter: number; + toolbar_div: HTMLDivElement; + fullscreen_icon: any; + stereo_icon: any; + screenshot_icon: any; + camera_control_icon: any; + select_icon: any; + select_icon_lasso: any; + select_icon_circle: any; + select_icon_rectangle: any; + zoom_icon: any; + quick_mouse_mode_change: boolean; + quick_mouse_previous_mode: any; + reset_icon: any; + camera: any; + setting_icon: any; + setting_icon_180: any; + setting_icon_360: any; + popup_container: HTMLDivElement; + canvas_container: HTMLDivElement; + canvas_overlay_container: HTMLDivElement; + canvas_overlay: HTMLCanvasElement; + canvas_renderer_container: HTMLDivElement; + el_mirror: HTMLDivElement; + el_axes: HTMLDivElement; + control_trackball: any; + cube_camera: THREE.CubeCamera; + camera_stereo: THREE.StereoCamera; + renderer_stereo: any; + renderer_selected: any; + axes_material: THREE.LineBasicMaterial; + xaxes_material: THREE.LineBasicMaterial; + yaxes_material: THREE.LineBasicMaterial; + zaxes_material: THREE.LineBasicMaterial; + x_axis: THREE.Line; + y_axis: THREE.Line; + z_axis: THREE.Line; + axes: THREE.Object3D; + wire_box: THREE.Object3D; + wire_box_x_line: THREE.Line; + wire_box_y_line: THREE.Line; + wire_box_z_line: THREE.Line; + axes_data: Array<{ name: string; label: string; object: any; object_label: any; translate: number[]; + rotate: number[]; rotation_order: string; fillStyle: string; }>; + ticks: number; + scene: THREE.Scene; + scene_opaque: THREE.Scene; + mesh_views: { [key: string]: MeshView }; + scatter_views: { [key: string]: ScatterView }; + volume_views: { [key: string]: VolumeView }; + lights: { [key: string]: THREE.Light }; + volume_back_target: THREE.WebGLRenderTarget; + volume_front_target: THREE.WebGLRenderTarget; + geometry_depth_target: THREE.WebGLRenderTarget; + color_pass_target: THREE.WebGLRenderTarget; + screen_pass_target: THREE.WebGLRenderTarget; + coordinate_target: THREE.WebGLRenderTarget; + screen_scene: THREE.Scene; + screen_scene_cube: THREE.Scene; + screen_plane: THREE.PlaneBufferGeometry; + screen_material: THREE.ShaderMaterial; + screen_material_cube: THREE.ShaderMaterial; + screen_mesh: THREE.Mesh; + screen_mesh_cube: THREE.Mesh; + screen_texture: THREE.Texture; + screen_camera: THREE.OrthographicCamera; + mouse_inside: boolean; + mouse_trail: any[]; + select_overlay: any; + control_orbit: any; + material_multivolume: THREE.ShaderMaterial; + material_multivolume_depth: THREE.ShaderMaterial; + hover: boolean; + last_zoom_coordinate: any; + rrenderer: any; + mouse_down_position: { x: any; y: any; }; + mouse_down_domain: { x: any; y: any; z: any; }; + last_pan_coordinate: THREE.Vector3; + selector: any; + last_tick_selection: d3.Selection; + model: FigureModel; + control_external: any = null; + // all plot objects are children of this object, such that we can transform the matrix + // without affecting the scene (and thus the camera controls) + rootObject: THREE.Object3D = null; + id_pass_target: THREE.WebGLRenderTarget; + lastId: number; + _wantsPopup: boolean; + + // rendered to get the front coordinate + front_box_mesh: THREE.Mesh; + front_box_geo: THREE.BoxBufferGeometry; + front_box_material: THREE.ShaderMaterial; + slice_icon: ToolIcon; + + readPixel(x, y) { + return this.readPixelFrom(this.screen_texture, x, y); + } + + readId(x, y) { + const [red, green, blue, alpha] = this.readPixelFrom(this.id_pass_target, x, y) + return red + green*256 + blue*256*256; + } + + readPixelFrom(target: RenderTarget, x, y) { + const buffer = new Uint8Array(4); + const height = this.renderer.domElement.clientHeight; + const pixel_ratio = this.model.get("pixel_ratio") || window.devicePixelRatio; + this.renderer.readRenderTargetPixels(target, x * pixel_ratio, (height - y) * pixel_ratio, 1, 1, buffer); + return buffer; + } + + render() { + this.transitions = []; + this._update_requested = false; + this.update_counter = 0; + const width = this.model.get("width"); + const height = this.model.get("height"); + + this.toolbar_div = document.createElement("div"); + this.el.appendChild(this.toolbar_div); + + const keydown = this._special_keys_down.bind(this); + const keyup = this._special_keys_up.bind(this); + document.addEventListener("keydown", keydown); + document.addEventListener("keyup", keyup); + this.once("remove", () => { + // console.log('remove key listeners') + document.removeEventListener("keydown", keydown); + document.removeEventListener("keyup", keyup); + }); + // set up fullscreen button + // this is per view, so it's not exposed on the python side + // which is ok, since it can only be triggered from a UI action + this.fullscreen_icon = new ToolIcon("fa-arrows-alt", this.toolbar_div); + this.fullscreen_icon.a.title = "Fullscreen"; + this.fullscreen_icon.a.onclick = () => { + const el = this.renderer.domElement; + const old_width = el.style.width; + const old_height = el.style.height; + const restore = () => { + if (!screenfull.isFullscreen) { + el.style.width = old_width; + el.style.height = old_height; + screenfull.off("change", restore); + } else { + el.style.width = "100vw"; + el.style.height = "100vh"; + } + this.update_size(); + }; + screenfull.onchange(restore); + screenfull.request(el); + }; + + this.stereo_icon = new ToolIcon("fa-eye", this.toolbar_div); + this.stereo_icon.a.title = "Stereoscopic view"; + this.stereo_icon.a.onclick = () => { + this.model.set("stereo", !this.model.get("stereo")); + this.model.save_changes(); + }; + this.stereo_icon.active(this.model.get("stereo")); + this.model.on("change:stereo", () => { + this.stereo_icon.active(this.model.get("stereo")); + }); + + this.screenshot_icon = new ToolIcon("fa-picture-o", this.toolbar_div); + this.screenshot_icon.a.title = "Take a screenshot (hold shift to copy to clipboard)"; + this.screenshot_icon.a.onclick = (event) => { + try { + const data = this.screenshot(); + if (event.shiftKey) { + copy_image_to_clipboard(data); + } else { + download_image(data); + } + } finally { // make sure we don't open a new window when we hold shift + event.preventDefault(); + } + return false; + }; + // for headless support + (window as any).ipvss = () => { + const data = this.screenshot(); + return data; + }; + + this.camera_control_icon = new ToolIcon("fa-arrow-up", this.toolbar_div); + this.camera_control_icon.a.title = "Camera locked to 'up' axis (orbit), instead of trackball mode"; + this.camera_control_icon.a.onclick = () => { + const mode = this.model.get("camera_control"); + if (mode === "trackball") { + this.model.set("camera_control", "orbit"); + this.camera_control_icon.active(true); + } else { + this.model.set("camera_control", "trackball"); + this.camera_control_icon.active(false); + } + this.touch(); + }; + this.camera_control_icon.active(false); + + this.select_icon = new ToolIcon("fa-pencil-square-o", this.toolbar_div); + this.select_icon.a.title = "Select mode (auto when control key is pressed)"; + this.select_icon.a.onclick = () => { + if (this.model.get("mouse_mode") === "select") { + this.model.set("mouse_mode", "normal"); + } else { + this.model.set("mouse_mode", "select"); + } + this.update_icons(); + this.touch(); + }; + this.select_icon.active(false); + + this.select_icon_lasso = new ToolIconDropdown("fa-vine", this.select_icon.sub, "Lasso selector"); + this.select_icon_circle = new ToolIconDropdown("fa-circle", this.select_icon.sub, "Circle selector"); + this.select_icon_rectangle = new ToolIconDropdown("fa-square", this.select_icon.sub, "Rectangle selector"); + this.select_icon_lasso.a.onclick = (event) => { + event.stopPropagation(); + this.model.set("mouse_mode", "select"); + this.model.set("selector", "lasso"); + this.touch(); + }; + this.select_icon_circle.a.onclick = (event) => { + event.stopPropagation(); + this.model.set("mouse_mode", "select"); + this.model.set("selector", "circle"); + this.touch(); + }; + this.select_icon_rectangle.a.onclick = (event) => { + event.stopPropagation(); + this.model.set("mouse_mode", "select"); + this.model.set("selector", "rectangle"); + this.touch(); + }; + + this.zoom_icon = new ToolIcon("fa-search-plus", this.toolbar_div); + this.zoom_icon.a.title = "Zoom mode (auto when control key is pressed, use scrolling)"; + this.zoom_icon.a.onclick = () => { + if (this.model.get("mouse_mode") === "zoom") { + this.model.set("mouse_mode", "normal"); + } else { + this.model.set("mouse_mode", "zoom"); + } + this.touch(); + }; + + this.slice_icon = new ToolIcon("fa-cut", this.toolbar_div); + this.slice_icon.a.title = "Set slice coordinate by hovering or clicking the edges of the bounding box"; + this.slice_icon.a.onclick = () => { + if (this.model.get("mouse_mode") === "slice") { + this.model.set("mouse_mode", "normal"); + } else { + this.model.set("mouse_mode", "slice"); + } + this.touch(); + }; + + // this.zoom_icon.active(false) + // using ctrl and shift, you can quickly change mode + // remember the previous mode so we can restore it + this.quick_mouse_mode_change = false; + this.quick_mouse_previous_mode = this.model.get("mouse_mode"); + + this.update_icons(); + this.model.on("change:mouse_mode change:selector", this.update_icons, this); + this.model.on("change:mouse_mode change:selector", this.update_mouse_mode, this); + + this.reset_icon = new ToolIcon("fa-home", this.toolbar_div); + this.reset_icon.a.title = "Reset view"; + const initial_fov = this.model.get("camera_fov"); + this.reset_icon.a.onclick = () => { + this.camera.copy(this.camera_initial); + if (this.camera.ipymodel) { + this.camera.ipymodel.syncToModel(true); + } + }; + + this.setting_icon = new ToolIcon("fa-cog", this.toolbar_div); + this.setting_icon_180 = new ToolIconDropdown("fa-circle", this.setting_icon.sub, "180 degrees"); + this.setting_icon_360 = new ToolIconDropdown("fa-circle", this.setting_icon.sub, "360 degrees"); + const add_resolution = (name, x, y) => { + const tool = new ToolIconDropdown("fa-cogs", this.setting_icon.sub, name + " (" + x + "x" + y + ")"); + tool.a.onclick = (event) => { + this.model.set("width", x); + this.model.set("height", y); + this.touch(); + }; + }; + add_resolution("default", this.model.get("width"), this.model.get("height")); + add_resolution("small", 500, 400); + add_resolution("medium", 640, 480); + add_resolution("large", 800, 600); + add_resolution("HD 720", 1280, 720); + add_resolution("HD", 1920, 1080); + add_resolution("2k", 2048, 1080); + add_resolution("2k x 2k", 2048, 2048); + add_resolution("4k UHD ", 3840, 2160); + add_resolution("4k", 4096, 2160); + add_resolution("4k x 4k", 4096, 4096); + // add_resolution('8k UHD', 7680, 4320) + const add_scaling = (x) => { + const tool = new ToolIconDropdown("fa-compress", this.setting_icon.sub, "Scale canvas (down) by " + x); + tool.a.onclick = (event) => { + this.model.set("displayscale", 1 / x); + this.touch(); + }; + }; + add_scaling(1); + add_scaling(2); + add_scaling(4); + add_scaling(8); + this.setting_icon_180.a.onclick = (event) => { + event.stopPropagation(); + if (this.model.get("panorama_mode") === "180") { + this.model.set("panorama_mode", "no"); + } else { + this.model.set("panorama_mode", "180"); + } + this.touch(); + }; + this.setting_icon_360.a.onclick = (event) => { + event.stopPropagation(); + if (this.model.get("panorama_mode") === "360") { + this.model.set("panorama_mode", "no"); + } else { + this.model.set("panorama_mode", "360"); + } + this.touch(); + }; + this.setting_icon_360.active(this.model.get("panorama_mode") === "360"); + this.setting_icon_180.active(this.model.get("panorama_mode") === "180"); + this.model.on("change:panorama_mode", () => { + this.setting_icon_360.active(this.model.get("panorama_mode") === "360"); + this.setting_icon_180.active(this.model.get("panorama_mode") === "180"); + this.update_panorama(); + }); + + this.el.classList.add("jupyter-widgets"); + // set up WebGL using threejs, with an overlay canvas for 2d drawing + this.canvas_container = document.createElement("div"); + this.canvas_overlay_container = document.createElement("div"); + this.canvas_overlay = document.createElement("canvas"); + this.canvas_overlay_container.appendChild(this.canvas_overlay); + this.canvas_container.appendChild(this.canvas_overlay_container); + + this.renderer = new THREE.WebGLRenderer({alpha: true, antialias: true}); + const update_pixel_ratio = () => { + this.renderer.setPixelRatio(this.model.get("pixel_ratio") || window.devicePixelRatio); + this._update_size(); + }; + this.renderer.setPixelRatio(this.model.get("pixel_ratio") || window.devicePixelRatio); + this.listenTo(this.model, "change:pixel_ratio", update_pixel_ratio); + + this.canvas_renderer_container = document.createElement("div"); + this.canvas_renderer_container.appendChild(this.renderer.domElement); + + this.popup_container = document.createElement("div"); + this.popup_container.classList.add('ipyvolume-popup-container') + + this.canvas_container.appendChild(this.canvas_renderer_container); + this.canvas_container.appendChild(this.canvas_overlay_container); + this.canvas_container.appendChild(this.popup_container); + + this.canvas_overlay_container.style.position = "absolute"; + this.canvas_overlay_container.style.zIndex = "2"; + this.canvas_overlay_container.style.pointerEvents = "none"; + this.canvas_renderer_container.style.position = "absolute"; + this.canvas_renderer_container.style.zIndex = "1"; + this.canvas_container.classList.add("ipyvolume-canvas-container") + this.el.appendChild(this.canvas_container); + this.el.setAttribute("tabindex", "1"); // make sure we can have focus + + // el_mirror is a 'mirror' dom tree that d3 needs + // we use it to attach axes and tickmarks to the dom + // which reflect the objects in the scene + this.el_mirror = document.createElement("div"); + this.el.appendChild(this.el_mirror); + this.el_axes = document.createElement("div"); + this.el_mirror.appendChild(this.el_axes); + + this.renderer.domElement.addEventListener("wheel", this.mousewheel.bind(this), false); + + // const VIEW_ANGLE = this.model.get("camera_fov"); + // const aspect = width / height; + const NEAR = 0.01; + const FAR = 10000; + const orthoNEAR = -500; + const orthoFAR = 1000; + + if (this.model.get("camera")) { + this.camera = this.model.get("camera").obj; + this.model.get("camera").on("change", () => { + // the threejs' lookAt ignore the quaternion, and uses the up vector + // we manually set it ourselve + if (!this.control_external) { + const up = new THREE.Vector3(0, 1, 0); + up.applyQuaternion(this.camera.quaternion); + this.camera.up = up; + this.camera.lookAt(0, 0, 0); + // TODO: shouldn't we do the same with the orbit control? + this.control_trackball.position0 = this.camera.position.clone(); + this.control_trackball.up0 = this.camera.up.clone(); + // TODO: if we implement figure.look_at, we should update control's target as well + this.update(); + } + }); + } else { + this.camera = new THREE.PerspectiveCamera(46, 1, NEAR, FAR); + // same default as the Python version + const z = 2 * Math.tan(45. / 2. * Math.PI / 180.) / Math.tan(this.model.get("camera_fov") / 2. * Math.PI / 180.); + this.camera.position.z = z; + } + + this.camera_initial = this.camera.clone(); + this.cube_camera = new THREE.CubeCamera(this.camera.near, this.camera.far, this.model.get("cube_resolution")); + + this.camera_stereo = new THREE.StereoCamera(); + this.renderer.setSize(width, height); + + this.renderer_stereo = new THREE.StereoEffect(this.renderer); + this.renderer_selected = this.renderer_stereo; + + const make_line = (x1, y1, z1, x2, y2, z2, material) => { + const geometry = new THREE.Geometry(); + geometry.vertices.push(new THREE.Vector3(x1, y1, z1), new THREE.Vector3(x2, y2, z2)); + return new THREE.Line(geometry, material); + }; + + const make_axis = (x, y, z, material) => { + return make_line(-0.5, -0.5, -0.5, -0.5 + x, -0.5 + y, -0.5 + z, material); + }; + + const linewidth = 1; + this.axes_material = new THREE.LineBasicMaterial({ + color: "cyan", + linewidth, + }); + this.xaxes_material = new THREE.LineBasicMaterial({ + color: "red", + linewidth, + }); + this.yaxes_material = new THREE.LineBasicMaterial({ + color: "green", + linewidth, + }); + this.zaxes_material = new THREE.LineBasicMaterial({ + color: "blue", + linewidth, + }); + + this.x_axis = make_axis(1, 0, 0, this.xaxes_material); + this.y_axis = make_axis(0, 1, 0, this.yaxes_material); + this.z_axis = make_axis(0, 0, 1, this.zaxes_material); + + this.axes = new THREE.Object3D(); + this.axes.add(this.x_axis); + this.axes.add(this.y_axis); + this.axes.add(this.z_axis); + + this.wire_box = new THREE.Object3D(); + this.wire_box_x_line = make_line(-0.5, -0.5, -0.5, -0.5 + 1, -0.5, -0.5, this.axes_material); + this.wire_box.add(this.wire_box_x_line); + this.wire_box.add(make_line(-0.5, -0.5 + 1, -0.5, -0.5 + 1, -0.5 + 1, -0.5, this.axes_material)); + this.wire_box.add(make_line(-0.5, -0.5, -0.5 + 1, -0.5 + 1, -0.5, -0.5 + 1, this.axes_material)); + this.wire_box.add(make_line(-0.5, -0.5 + 1, -0.5 + 1, -0.5 + 1, -0.5 + 1, -0.5 + 1, this.axes_material)); + + this.wire_box_y_line = make_line(-0.5, -0.5, -0.5, -0.5, -0.5 + 1, -0.5, this.axes_material); + this.wire_box.add(this.wire_box_y_line); + this.wire_box.add(make_line(-0.5 + 1, -0.5, -0.5, -0.5 + 1, -0.5 + 1, -0.5, this.axes_material)); + this.wire_box.add(make_line(-0.5, -0.5, -0.5 + 1, -0.5, -0.5 + 1, -0.5 + 1, this.axes_material)); + this.wire_box.add(make_line(-0.5 + 1, -0.5, -0.5 + 1, -0.5 + 1, -0.5 + 1, -0.5 + 1, this.axes_material)); + + this.wire_box_z_line = make_line(-0.5, -0.5, -0.5, -0.5, -0.5, -0.5 + 1, this.axes_material); + this.wire_box.add(this.wire_box_z_line); + this.wire_box.add(make_line(-0.5 + 1, -0.5, -0.5, -0.5 + 1, -0.5, -0.5 + 1, this.axes_material)); + this.wire_box.add(make_line(-0.5, -0.5 + 1, -0.5, -0.5, -0.5 + 1, -0.5 + 1, this.axes_material)); + this.wire_box.add(make_line(-0.5 + 1, -0.5 + 1, -0.5, -0.5 + 1, -0.5 + 1, -0.5 + 1, this.axes_material)); + + // d3 data + this.axes_data = [{ + name: "x", + label: "x", + object: null, + object_label: null, + translate: [0.0, -0.5, -0.5], + rotate: [Math.PI / 4., 0, 0], + rotation_order: "XYZ", + fillStyle: "#00FF00", + }, { + name: "y", + label: "y", + object: null, + object_label: null, + translate: [-0.5, 0.0, -0.5], + rotate: [Math.PI * 3. / 4., 0, Math.PI / 2.], + rotation_order: "ZXY", + fillStyle: "#00FF00", + }, { + name: "z", + label: "z", + object: null, + object_label: null, + translate: [-0.5, -0.5, 0.0], + rotate: [-Math.PI / 8., -Math.PI / 2., 0], + rotation_order: "YZX", + fillStyle: "#00FF00", + }]; + + this.ticks = 5; // hardcoded for now + + if(this.model.get("scene")) // null in testing + this.scene = this.model.get("scene").obj; + else + this.scene = new THREE.Scene(); + // // we have our 'private' scene, if we use the real scene, it gives buggy + // // results in the volume rendering when we have two views + // this.scene_volume = new THREE.Scene(); + // could be removed when https://github.com/jovyan/pythreejs/issues/176 is solved + // the default for pythreejs is white, which leads the volume rendering pass to make everything white + this.scene.background = null; + if(this.model.get("scene")) + this.model.get("scene").on("rerender", () => this.update()); + this.rootObject = new THREE.Object3D(); + this.rootObject.name = "rootObject" + this.scene.add(this.rootObject); + + // if (this.model.get("scene")) { + // this.shared_scene = this.model.get("scene").obj; + // this.model.get("scene").on("rerender", () => this.update()); + // } else { + // this.shared_scene = new THREE.Scene(); + // } + + this.scene.add(this.camera); + // the threejs animation system looks at the parent of the camera and sends rerender msg'es + // this.shared_scene.add(this.camera); + + // this.scene_scatter = new THREE.Scene(); + this.scene_opaque = new THREE.Scene(); + + this.scene_opaque.add(this.wire_box); + this.scene_opaque.add(this.axes); + + const update_box = () => { + const box_position = new THREE.Vector3(); + box_position.fromArray(this.model.get('box_center')); + box_position.sub(new THREE.Vector3(0.5, 0.5, 0.5)); + + const box_scale = new THREE.Vector3(); + box_scale.fromArray(this.model.get('box_size')); + + this.scene_opaque.scale.copy(box_scale); + this.scene_opaque.position.copy(box_position); + + this.rootObject.scale.copy(box_scale); + this.rootObject.position.copy(box_position); + this.update(); + } + this.model.on("change:box_center change:box_size", update_box); + update_box(); + + this.front_box_material = new THREE.ShaderMaterial({ + uniforms: { + offset: { type: "3f", value: [0, 0, 0] }, + scale : { type: "3f", value: [1, 1, 1] }, + }, + fragmentShader: shaders["box-fragment"], + vertexShader: shaders["box-vertex"], + side: THREE.BackSide, + }); + this.front_box_geo = new THREE.BoxBufferGeometry(1, 1, 1); + this.front_box_mesh = new THREE.Mesh(this.front_box_geo, this.front_box_material); + this.front_box_mesh.name = "Front object" + this.rootObject.add(this.front_box_mesh); + + this.mesh_views = {}; + this.scatter_views = {}; + this.volume_views = {}; + + let render_width = width; + const render_height = height; + + if (this.model.get("stereo")) { + render_width /= 2; + } + + // Render pass targets + // float texture for better depth data, prev name back_texture + this.volume_back_target = new THREE.WebGLRenderTarget(render_width, render_height, { + minFilter: THREE.LinearFilter, + magFilter: THREE.LinearFilter, + type: THREE.FloatType, + format: THREE.RGBAFormat, + generateMipmaps: false, + }); + + this.volume_front_target = new THREE.WebGLRenderTarget(render_width, render_height, { + minFilter: THREE.LinearFilter, + magFilter: THREE.NearestFilter, + }); + + this.geometry_depth_target = new THREE.WebGLRenderTarget(render_width, render_height, { + minFilter: THREE.LinearFilter, + magFilter: THREE.LinearFilter, + format: THREE.RGBAFormat, + generateMipmaps: false, + }); + this.geometry_depth_target.depthTexture = new THREE.DepthTexture(1, 1); + this.geometry_depth_target.depthTexture.type = THREE.UnsignedShortType; + + this.id_pass_target = new THREE.WebGLRenderTarget(render_width, render_height, { + minFilter: THREE.LinearFilter, + magFilter: THREE.NearestFilter, + }); + + this.color_pass_target = new THREE.WebGLRenderTarget(render_width, render_height, { + minFilter: THREE.LinearFilter, + magFilter: THREE.LinearFilter, + }); + + this.screen_pass_target = new THREE.WebGLRenderTarget(render_width, render_height, { + minFilter: THREE.LinearFilter, + magFilter: THREE.LinearFilter, + }); + + this.coordinate_target = new THREE.WebGLRenderTarget(render_width, render_height, { + minFilter: THREE.LinearFilter, + magFilter: THREE.NearestFilter, + }); + + this.screen_texture = this.color_pass_target.texture; + this.screen_scene = new THREE.Scene(); + this.screen_scene_cube = new THREE.Scene(); + this.screen_plane = new THREE.PlaneBufferGeometry(1.0, 1.0); + + this.screen_material = new THREE.ShaderMaterial({ + uniforms: { + tex: { + type: "t", + value: this.screen_pass_target.texture, + }, + }, + vertexShader: shaders["screen-vertex"], + fragmentShader: shaders["screen-fragment"], + depthWrite: false, + }); + + this.screen_material_cube = new THREE.ShaderMaterial({ + uniforms: { + tex: { + type: "t", + value: this.cube_camera.renderTarget.texture, + }, + }, + vertexShader: shaders["screen-vertex"], + fragmentShader: shaders["screen-fragment"], + defines: {}, + depthWrite: false, + }); + + this.screen_mesh = new THREE.Mesh(this.screen_plane, this.screen_material); + this.screen_mesh_cube = new THREE.Mesh(this.screen_plane, this.screen_material_cube); + this.screen_scene.add(this.screen_mesh); + this.screen_scene_cube.add(this.screen_mesh_cube); + this.screen_camera = new THREE.OrthographicCamera(-0.5, 0.5, 0.5, -0.5, -10000., 10000.); + this.screen_camera.position.z = 10; + this.update_panorama(); + this.on("change:panorama_mode", this.update_panorama, this); + + // we rely here on these events listeners to be executed before those of the controls + // since we disable the controls, seems to work on chrome + this.renderer.domElement.addEventListener("touchstart", this._touch_start.bind(this), false); + this.renderer.domElement.addEventListener("touchmove", this._touch_move.bind(this), false); + this.renderer.domElement.addEventListener("touchcancel", this._touch_cancel.bind(this), false); + this.renderer.domElement.addEventListener("mousedown", this._mouse_down.bind(this), false); + this.renderer.domElement.addEventListener("mousemove", this._mouse_move.bind(this), false); + this.renderer.domElement.addEventListener("dblclick", this._mouse_dbl_click.bind(this), false); + this.renderer.domElement.addEventListener("contextmenu", (event) => { + event.preventDefault(); + event.stopPropagation(); + }, false); + + window.addEventListener("mouseup", this._mouse_up.bind(this), false); + this.mouse_inside = false; + this.mouse_trail = []; // list of x, y positions + this.select_overlay = null; // lasso or sth else? + + // setup controls, 2 builtin custom controls, or an external + // pythreejs control + + this.control_trackball = new THREE.TrackballControls(this.camera, this.renderer.domElement); + this.control_orbit = new THREE.OrbitControls(this.camera, this.renderer.domElement); + this.control_trackball.dynamicDampingFactor = 1.; + this.control_trackball.noPan = true; + this.control_orbit.enablePan = false; + this.control_orbit.dampingFactor = 1.; + this.update_mouse_mode(); + + this.control_orbit.rotateSpeed = 0.5; + this.control_trackball.rotateSpeed = 0.5; + this.control_trackball.zoomSpeed = 3.; + + const update_angles_bound = this.update_angles.bind(this); + const update_bound = this.update.bind(this); + + this.control_trackball.addEventListener("end", update_angles_bound); + this.control_orbit.addEventListener("end", update_angles_bound); + this.control_trackball.addEventListener("change", update_bound); + this.control_orbit.addEventListener("change", update_bound); + + const sync_controls_external = () => { + const controls = this.model.get("controls"); + const controls_previous = (this.model.previousAttributes as any).controls; + // first remove previous event handlers + if (controls_previous) { + const control_external = controls_previous.obj; + control_external.removeEventListener("end", update_angles_bound); + control_external.removeEventListener("change", update_bound); + control_external.dispose(); + } + // and add new event handlers + if (controls) { + // get the threejs object + this.control_external = controls.obj; + this.control_external.addEventListener("end", update_angles_bound); + this.control_external.addEventListener("change", update_bound); + this.control_external.connectEvents(this.el); // custom pythreejs method + } else { + this.control_external = null; + } + this.update_mouse_mode(); + }; + + sync_controls_external(); + this.model.on("change:controls", () => { + sync_controls_external(); + }); + + window.addEventListener("deviceorientation", this.on_orientationchange.bind(this), false); + + const render_size = this.getRenderSize(); + + this.material_multivolume = new THREE.ShaderMaterial({ + uniforms: { + back_tex: { + type: "t", + value: this.volume_back_target.texture, + }, + geometry_depth_tex: { + type: "t", + value: this.geometry_depth_target.depthTexture, + }, + + volumes: { + type: "tv", + value: [{}], + }, + data: { + type: "tv", + value: [], + }, + transfer_function: { + type: "tv", + value: [], + }, + + volumes_max_int: { + type: "tv", + value: [{}], + }, + data_max_int: { + type: "tv", + value: [], + }, + transfer_function_max_int: { + type: "tv", + value: [], + }, + + ambient_coefficient: { + type: "f", + value: this.model.get("ambient_coefficient"), + }, + diffuse_coefficient: { + type: "f", + value: this.model.get("diffuse_coefficient"), + }, + specular_coefficient: { + type: "f", + value: this.model.get("specular_coefficient"), + }, + specular_exponent: { + type: "f", + value: this.model.get("specular_exponent"), + }, + + brightness: { + type: "f", + value: 2., + }, + render_size: { + type: "2f", + value: render_size, + }, + + steps: { + type: "f", + value: 10, + }, + }, + blending: THREE.CustomBlending, + blendSrc: THREE.OneFactor, + blendDst: THREE.OneMinusSrcAlphaFactor, + blendEquation: THREE.AddEquation, + transparent: true, + defines: {}, + side: THREE.FrontSide, + }); + + // make the material behave as phong + this.material_multivolume.uniforms = {...THREE.UniformsUtils.merge( [ + THREE.UniformsLib.common, + THREE.UniformsLib.specularmap, + THREE.UniformsLib.envmap, + THREE.UniformsLib.aomap, + THREE.UniformsLib.lightmap, + THREE.UniformsLib.emissivemap, + THREE.UniformsLib.bumpmap, + THREE.UniformsLib.normalmap, + THREE.UniformsLib.displacementmap, + THREE.UniformsLib.gradientmap, + THREE.UniformsLib.fog, + THREE.UniformsLib.lights, + { + // there are not used, since they are defined per volume in volr-fragment Volume struct + emissive: { value: new THREE.Color( 0x000000 ) }, + specular: { value: new THREE.Color( 0x111111 ) }, + shininess: { value: 30 } + }, + ]), ...this.material_multivolume.uniforms} + // make sure we don't pass our uniforms to THREE, we don't want a deep clone + + // a clone of the box_material_volr, with a different define (faster to render) + this.material_multivolume_depth = new THREE.ShaderMaterial({ + uniforms: this.material_multivolume.uniforms, + blending: THREE.NoBlending, + defines: { + COORDINATE: true, + }, + side: THREE.FrontSide, + }); + + this.model.on("change:scatters", this.update_scatters, this); + this.update_scatters(); + this.model.on("change:meshes", this.update_meshes, this); + this.update_meshes(); + this.model.on("change:volumes", this.update_volumes, this); + this.update_volumes(); + this.model.on("change:lights", this.update_lights, this); + this.update_lights(); + + this.update_size(); + + const that = this; + + this.el.addEventListener("change", this.update.bind(this)); // remove when using animation loop + + // TODO: remove this when we fully depend on the camera worldMatrix + const update_matrix_world_scale = () => { + this.model.set("matrix_world", this._get_view_matrix().elements.slice()); + this.touch(); + }; + + this.model.on("change:xlim change:ylim change:zlim", () => { + update_matrix_world_scale(); + }); + + if (this.model.get("camera")) { + this.model.get("camera").on("change:matrixWorld", () => { + update_matrix_world_scale(); + }); + update_matrix_world_scale(); + + const update_matrix_projection = () => { + this.model.set("matrix_projection", this.camera.projectionMatrix.elements.slice()); + }; + update_matrix_projection(); + this.model.get("camera").on("change:projectionMatrix", () => { + update_matrix_projection(); + }); + update_matrix_projection(); + } + + this.model.on("change:camera_control", this.update_mouse_mode, this); + this.model.on("change:xlabel change:ylabel change:zlabel", this.update, this); + this.model.on("change:render_continuous", this.update, this); + this.model.on("change:style", this.update, this); + const scales = this.model.get("scales"); + for (const coordinate of ["x", "y", "z"]) { + scales[coordinate].on("change", this.update, this); + } + this.model.on("change:xlim change:ylim change:zlim ", this.update, this); + this.model.on("change:stereo", this.update_size, this); + + this.model.on("change:eye_separation", this.update, this); + + this.model.on("change:camera_fov", this.update_current_control, this); + + this.model.on("change:width", this.update_size, this); + this.model.on("change:height", this.update_size, this); + this.model.on("change:displayscale", this.update_size, this); + + this.model.on("change:ambient_coefficient", this.update_light, this); + this.model.on("change:diffuse_coefficient", this.update_light, this); + this.model.on("change:specular_coefficient", this.update_light, this); + this.model.on("change:specular_exponent", this.update_light, this); + + const hot_reload_shaders = () => { + this.rebuild_multivolume_rendering_material(); + this.update(); + } + this.model.on("change:_shaders", hot_reload_shaders, this); + + const update_center = () => { + // WARNING: we cheat a little by setting the scene positions (hence the minus) since it is + // easier, might get us in trouble later? + for (const scene of [this.scene, this.scene_opaque]) { + const pos = this.model.get("camera_center"); + scene.position.set(-pos[0], -pos[1], -pos[2]); + } + this.update(); + }; + + this.model.on("change:camera_center", update_center); + update_center(); + + this.model.on("change:tf", this.tf_set, this); + this.listenTo(this.model, "msg:custom", this.custom_msg.bind(this)); + + + this.renderer.domElement.addEventListener("resize", this.on_canvas_resize.bind(this), false); + this.update(); + + // ensure initial sync of view with figure model + this.update_current_control(); + this.update_light(); + + let stream; + if (this.model.get("capture_fps")) { + stream = this.renderer.domElement.captureStream(this.model.get("capture_fps")); + } else { + stream = this.renderer.domElement.captureStream(); + } + + (this.model as any).stream = Promise.resolve(stream); + (window as any).last_figure_stream = (stream); + (window as any).last_figure = this; + + // keep track over hover status manually + this.renderer.domElement.onmouseover = () => { + this.hover = true; + }; + + this.renderer.domElement.onmouseleave = () => { + this.hover = false; + }; + } + camera_initial(camera_initial: any) { + throw new Error("Method not implemented."); + } + _save_matrices(arg0: string, _save_matrices: any, arg2: this) { + throw new Error("Method not implemented."); + } + tf_set(arg0: string, tf_set: any, arg2: this) { + throw new Error("Method not implemented."); + } + + setStyle() { + // ignore original style setting, our style !== a style widget + } + + update_icons() { + const select_mode = this.model.get("mouse_mode") === "select"; + this.select_icon_lasso.active(this.model.get("selector") === "lasso" && select_mode); + this.select_icon_circle.active(this.model.get("selector") === "circle" && select_mode); + this.select_icon_rectangle.active(this.model.get("selector") === "rectangle" && select_mode); + this.select_icon.active(select_mode); + const zoom_mode = this.model.get("mouse_mode") === "zoom"; + this.zoom_icon.active(zoom_mode); + const slice_mode = this.model.get("mouse_mode") === "slice"; + this.slice_icon.active(slice_mode); + } + + update_mouse_mode() { + const normal_mode = this.model.get("mouse_mode") === "normal"; + if (this.model.get("controls")) { + this.control_trackball.enabled = false; + this.control_orbit.enabled = false; + } else { + this.control_trackball.enabled = this.model.get("camera_control") === "trackball" && normal_mode; + this.control_orbit.enabled = this.model.get("camera_control") === "orbit" && normal_mode; + } + } + + mousewheel(e) { + if (this.model.get("mouse_mode") !== "zoom") { return; } + e.preventDefault(); + e.stopPropagation(); + let amount = e.deltaY * 0.00025; + if (e.deltaMode === 2) { // pages + amount = e.deltaY * 0.025; + } + if (e.deltaMode === 1) { // lines + amount -= e.deltaY * 0.01; + } + let mouseX; + let mouseY; + if (e.offsetX) { + mouseX = e.offsetX; + mouseY = e.offsetY; + } else if (e.layerX) { + mouseX = e.layerX; + mouseY = e.layerY; + } + amount *= 10; + const factor = Math.pow(10, amount); + const height = this.renderer.domElement.clientHeight; + if (!this.last_zoom_coordinate) { + const [red, green, blue, alpha] = this.readPixelFrom(this.coordinate_target, mouseX, mouseY); + + if (alpha > 1) { + // at least something got drawn + const center = new THREE.Vector3(red, green, blue); + center.multiplyScalar(1. / 255.); // normalize + this.last_zoom_coordinate = center; + } + } + + if (this.last_zoom_coordinate) { // at least something got drawn + // clear it so that we don't use it again + this.renderer.setRenderTarget(this.coordinate_target); + this.renderer.clear(true, true, true); + + const center = this.last_zoom_coordinate; + + // work in normalized coordinates + const np1 = center.clone().sub(center.clone().multiplyScalar(factor)); + const np2 = center.clone().add(center.clone().negate().addScalar(1).multiplyScalar(factor)); + + // and rescale to x/y/z lim + const scales = this.model.get("scales"); + const scales_d3 = mapValues(scales, createD3Scale); + scales_d3.x.range([0, 1]); + scales_d3.y.range([0, 1]); + scales_d3.z.range([0, 1]); + + scales.x.set("min", scales_d3.x.invert(np1.x)); + scales.x.set("max", scales_d3.x.invert(np2.x)); + scales.y.set("min", scales_d3.y.invert(np1.y)); + scales.y.set("max", scales_d3.y.invert(np2.y)); + scales.z.set("min", scales_d3.z.invert(np1.z)); + scales.z.set("max", scales_d3.z.invert(np2.z)); + + scales.x.save_changes(); + scales.y.save_changes(); + scales.z.save_changes(); + } + return false; + } + + _mouse_down(e) { + // console.log('mouse down', e) + (window as any).last_event = e; + let mouseX; + let mouseY; + if (e.offsetX) { + mouseX = e.offsetX; + mouseY = e.offsetY; + } else if (e.layerX) { + mouseX = e.layerX; + mouseY = e.layerY; + } + this.mouseDown(mouseX, mouseY); + } + + mouseDown(mouseX, mouseY, e?) { + this.mouse_down_position = { + x: mouseX, + y: mouseY, + }; + const scales = this.model.get("scales"); + this.mouse_down_domain = { + x: scales.x.domain.slice(), + y: scales.y.domain.slice(), + z: scales.z.domain.slice(), + }; + const height = this.renderer.domElement.clientHeight; + const [red, green, blue, alpha] = this.readPixelFrom(this.coordinate_target, mouseX, mouseY); + if (alpha > 1) { // at least something got drawn + const center = new THREE.Vector3(red, green, blue); + center.multiplyScalar(1 / 255.); // normalize + this.last_pan_coordinate = center; + } + + if (this.model.get("mouse_mode") === "select") { + const cls = selectors[this.model.get("selector")]; + this.selector = new cls(this.canvas_overlay); + if (e) { + e.preventDefault(); + e.stopPropagation(); + } + } + if (this.model.get("mouse_mode") === "slice") { + let [xn, yn, zn, alpha] = this.readPixelFrom(this.volume_front_target, mouseX, mouseY); + if(alpha > 0) { + xn /= 255.; + yn /= 255.; + zn /= 255.; + this._set_slice(xn, yn, zn); + } + } + const id = this.readId(mouseX, mouseY); + this.on_id_click(id, mouseX, mouseY); + } + + _mouse_move(e) { + let mouseX; + let mouseY; + if (!e) { + e = event; + } + + if (e.offsetX) { + mouseX = e.offsetX; + mouseY = e.offsetY; + } else if (e.layerX) { + mouseX = e.layerX; + mouseY = e.layerY; + } + const mouse_position = { + x: mouseX, + y: mouseY, + }; + + // console.log(this.readPixelFrom(this.volume_front_target, mouseX, mouseY), mouseX, mouseY) + // normalized xyz coordinate of the mouse + + const id = this.readId(mouseX, mouseY); + this.on_id_hover(id, mouseX, mouseY); + + this.last_zoom_coordinate = null; + if (this.selector) { + this.mouse_trail.push([mouseX, mouseY]); + this.selector.mouseMove(mouseX, mouseY); + this.selector.draw(); + } + + if (this.model.get("mouse_mode") === "zoom" && this.last_pan_coordinate) { + if (e.buttons === 1) { + const pixels_right = mouse_position.x - this.mouse_down_position.x; + const pixels_up = -(mouse_position.y - this.mouse_down_position.y); + this.mouseDrag(pixels_right, pixels_up); + } + } + if (this.model.get("mouse_mode") === "slice") { + let [xn, yn, zn, alpha] = this.readPixelFrom(this.volume_front_target, mouseX, mouseY); + if(alpha > 0) { + xn /= 255.; + yn /= 255.; + zn /= 255.; + this._set_slice(xn, yn, zn); + } + } + } + + _touch_start(event : TouchEvent) { + } + + _touch_cancel(event : TouchEvent) { + } + + _touch_move(event : TouchEvent) { + const touchX = event.targetTouches[0].clientX; + const touchY = event.targetTouches[0].clientY; + console.log("move", touchX, touchY) + if (this.model.get("mouse_mode") === "slice") { + let [xn, yn, zn, alpha] = this.readPixelFrom(this.volume_front_target, touchX, touchY); + if(alpha > 0) { + xn /= 255.; + yn /= 255.; + zn /= 255.; + this._set_slice(xn, yn, zn); + } + return false; + } + } + + _set_slice(xn, yn, zn) { + const scales = this.model.get("scales"); + const scales_d3 = mapValues(scales, createD3Scale); + const x = scales_d3.x.range([0, 1]).invert(xn); + const y = scales_d3.y.range([0, 1]).invert(yn); + const z = scales_d3.z.range([0, 1]).invert(zn); + // console.log(x, y, z); + const [xmin, xmax] = scales_d3.x.domain(); + const [ymin, ymax] = scales_d3.y.domain(); + const [zmin, zmax] = scales_d3.z.domain(); + const dx = Math.abs(xmin - xmax); + const dy = Math.abs(ymin - ymax); + const dz = Math.abs(zmin - zmax); + const on_x = (Math.abs(x - xmin)/dx < 1e-3) || (Math.abs(x - xmax)/dx < 1e-3); + const on_y = (Math.abs(y - ymin)/dy < 1e-3) || (Math.abs(y - ymax)/dy < 1e-3); + const on_z = (Math.abs(z - zmin)/dz < 1e-3) || (Math.abs(z - zmax)/dz < 1e-3); + if(on_x || on_y) { + this.model.set("slice_z", z); + } + if(on_x || on_z) { + this.model.set("slice_y", y); + } + if(on_y || on_z) { + this.model.set("slice_x", x); + } + if(on_x || on_y || on_z) { + this.model.save_changes(); + } + + } + + on_id_click(id, mouseX, mouseY) { + Object.values(this.scatter_views).forEach((scatter_view) => { + scatter_view.onClick(id); + scatter_view.popup(id, mouseX, mouseY, this.popup_container); + }) + Object.values(this.mesh_views).forEach((mesh_view) => { + mesh_view.onClick(id); + mesh_view.popup(id, mouseX, mouseY, this.popup_container); + }) + } + + on_id_hover(id, mouseX, mouseY) { + this._wantsPopup = true; + const check_popup = () => { + if(this._wantsPopup) { + if(id == this.lastId) { + this._wantsPopup = false; + this._on_id_hover(id, mouseX, mouseY); + + } + } + }; + this.lastId = id; // this will avoid 'old' timeouts to show up + setTimeout(check_popup, this.model.get('popup_debouce')) + } + + _on_id_hover(id, mouseX, mouseY) { + Object.values(this.scatter_views).forEach((scatter_view) => { + scatter_view.onHover(id); + this.popup_container.style.left = `${mouseX}px` + const height = this.renderer.domElement.clientHeight; + this.popup_container.style.bottom = `${height-mouseY}px` + scatter_view.popup(id, mouseX, mouseY, this.popup_container); + }) + Object.values(this.mesh_views).forEach((mesh_view) => { + mesh_view.onHover(id); + this.popup_container.style.left = `${mouseX}px` + const height = this.renderer.domElement.clientHeight; + this.popup_container.style.bottom = `${height-mouseY}px` + mesh_view.popup(id, mouseX, mouseY, this.popup_container); + }) + } + + mouseDrag(pixels_right, pixels_up) { + const canvas = this.renderer.domElement; + // normalized GL screen coordinates + const right = (pixels_right / canvas.clientWidth) * 2; + const up = (pixels_up / canvas.clientHeight) * 2; + const P = this.camera.projectionMatrix; + const W = this.camera.matrixWorldInverse; + // M goes from world to screen + const M = P.clone().multiply(W); + + // correct for the aspect of the bounding box + const A = new THREE.Matrix4(); + const box_size = this.model.get('box_size'); + A.makeScale(box_size[0], box_size[1], box_size[2]); + // console.log(A.toArray()) + M.multiply(A); + + const Mi = M.clone().getInverse(M); + + + const scales = this.model.get("scales"); + + const scales_d3 = mapValues(scales, createD3Scale); + scales_d3.x.domain(this.mouse_down_domain.x).range([0, 1]); + scales_d3.y.domain(this.mouse_down_domain.y).range([0, 1]); + scales_d3.z.domain(this.mouse_down_domain.z).range([0, 1]); + + // start with normalized coordinate + let n1 = this.last_pan_coordinate.clone(); + // project to screen coordinates + const sn1 = n1.clone().applyMatrix4(M); + const sn2 = sn1.clone(); + sn2.x += right; + sn2.y += up; + + // move them back to world coordinates + n1 = sn1.clone().applyMatrix4(Mi); + const n2 = sn2.clone().applyMatrix4(Mi); + const delta = n2.clone().sub(n1); + + const l1 = new THREE.Vector3(0, 0, 0); + const l2 = new THREE.Vector3(1, 1, 1); + + l1.sub(delta); + l2.sub(delta); + scales.x.set("min", scales_d3.x.invert(l1.x)); + scales.x.set("max", scales_d3.x.invert(l2.x)); + scales.y.set("min", scales_d3.y.invert(l1.y)); + scales.y.set("max", scales_d3.y.invert(l2.y)); + scales.z.set("min", scales_d3.z.invert(l1.z)); + scales.z.set("max", scales_d3.z.invert(l2.z)); + scales.x.save_changes(); + scales.y.save_changes(); + scales.z.save_changes(); + } + + _mouse_dbl_click(e) { + if (this.model.get("mouse_mode") === "zoom" && this.last_pan_coordinate) { + const xlim = this.mouse_down_domain.x; + const ylim = this.mouse_down_domain.y; + const zlim = this.mouse_down_domain.z; + let l1 = new THREE.Vector3(xlim[0], ylim[0], zlim[0]); + let l2 = new THREE.Vector3(xlim[1], ylim[1], zlim[1]); + const scale = l2.clone().sub(l1); + + const center = this.last_pan_coordinate.clone().multiply(scale).add(l1); + const half_scale = scale.clone().multiplyScalar(0.5); + l1 = center.clone().sub(half_scale); + l2 = center.clone().add(half_scale); + const scales = this.model.get("scales"); + scales.x.set("min", l1.x); + scales.x.set("max", l2.x); + scales.y.set("min", l1.y); + scales.y.set("max", l2.y); + scales.z.set("min", l1.z); + scales.z.set("max", l2.z); + scales.x.save_changes(); + scales.y.save_changes(); + scales.z.save_changes(); + } + } + + _mouse_up(e) { + if (this.selector) { + const canvas = this.renderer.domElement; + this.send({ + event: "selection", + data: this.selector.getData(canvas.clientWidth, canvas.clientHeight), + }); + // send event.. + this.mouse_trail = []; + this.selector.close(); + this.selector = null; + e.preventDefault(); + e.stopPropagation(); + } + } + + _special_keys_down(e) { + if (!this.hover) { return; } + const evtobj = window.event ? event : e; + if (evtobj.altKey) { + // console.log('pressed alt', this.hover) + } + let handled = false; + if (evtobj.key === "=") { // '=' + this.model.set("selection_mode", "replace"); + handled = true; + } + if (evtobj.key === "|") { // '=' + this.model.set("selection_mode", "or"); + handled = true; + } + if (evtobj.key === "&") { // '=' + this.model.set("selection_mode", "and"); + handled = true; + } + if (evtobj.key === "-") { // '=' + this.model.set("selection_mode", "subtract"); + handled = true; + } + if (evtobj.keyCode === 76) { // 'l' + this.model.set("selector", "lasso"); + handled = true; + } + if (evtobj.keyCode === 67) { // 'c' + this.model.set("selector", "circle"); + handled = true; + } + if (evtobj.keyCode === 82) { // 'r' + this.model.set("selector", "rectangle"); + handled = true; + } + if (evtobj.keyCode === 16) { // shift + // avoid ctrl and shift + if (!this.quick_mouse_mode_change) { + this.quick_mouse_mode_change = true; + this.quick_mouse_previous_mode = this.model.get("mouse_mode"); + this.model.set("mouse_mode", "slice"); + handled = true; + } + } + if (evtobj.keyCode === 18) { // alt + // avoid ctrl and shift + if (!this.quick_mouse_mode_change) { + this.quick_mouse_mode_change = true; + this.quick_mouse_previous_mode = this.model.get("mouse_mode"); + this.model.set("mouse_mode", "zoom"); + handled = true; + } + } + if (evtobj.keyCode === 17) { // ctrl + if (!this.quick_mouse_mode_change) { + this.quick_mouse_mode_change = true; + this.quick_mouse_previous_mode = this.model.get("mouse_mode"); + this.model.set("mouse_mode", "select"); + handled = true; + } + } + if (handled) { + this.touch(); + e.preventDefault(); + e.stopPropagation(); + return false; + } + } + + _special_keys_up(e) { + const evtobj = window.event ? event : e; + if (evtobj.altKey) { + // console.log('released alt', this.hover) + } + if ((evtobj.keyCode === 16) || (evtobj.keyCode === 17) || (evtobj.keyCode === 18)) { // ctrl or shift + if (this.quick_mouse_mode_change) { + this.quick_mouse_mode_change = false; + this.model.set("mouse_mode", this.quick_mouse_previous_mode); + this.touch(); + } + } + } + + custom_msg(content) { + if (content.msg === "screenshot") { + const data = this.screenshot(undefined, content.width, content.height); + this.send({ + event: "screenshot", + data, + }); + } + } + + screenshot(mime_type = "image/png", width?, height?) { + const resize = width && height; + try { + if (resize) { + this._update_size(true, width, height); + } + this._real_update(); + const data = this.renderer.domElement.toDataURL(mime_type); + console.info("captured screenshot"); + return data; + } finally { + if (resize) { + this._update_size(false); + } + } + } + + _d3_add_axis(node, d, i) { + const axis = new THREE.Object3D(); + + axis.matrixAutoUpdate = false; + const matrixTrans = new THREE.Matrix4(); + matrixTrans.makeTranslation(d.translate[0], d.translate[1], d.translate[2]); + + d3.select(node).attr("translate-x", d.translate[0]); + d3.select(node).attr("translate-y", d.translate[1]); + d3.select(node).attr("translate-z", d.translate[2]); + + const matrixRot = new THREE.Matrix4(); + matrixRot.makeRotationFromEuler(new THREE.Euler(d.rotate[0], d.rotate[1], d.rotate[2], d.rotation_order)); + + // TODO: puzzled by the align not working as expected.. + const aligns = { + x: THREEtext2d.textAlign.topRight, + y: THREEtext2d.textAlign.topRight, + z: THREEtext2d.textAlign.center, + }; + const label = new THREEtext2d.SpriteText2D(d.label, { + align: aligns[d.name], + font: "100px Arial", + fillStyle: "#00FF00", + antialias: true, + }); + label.material.transparent = true; + label.material.alphaTest = 0.3; + + axis.matrix.multiply(matrixTrans); + axis.matrix.multiply(matrixRot); + + this.axes.add(axis); + axis.add(label); + d.object_label = label; + d.object = axis; + const scale = this.model.get("scales")[d.name]; + d.scale = createD3Scale(scale).range([-0.5, 0.5]); + d.ticks = null; + this._d3_update_axis(node, d, i); + } + + _d3_update_axis(node, d, i) { + d.object_label.text = d.label; + d.object_label.fillStyle = d.fillStyle; + const n = d.name; // x, y or z + const scale = this.model.get("scales")[d.name]; + d.scale = createD3Scale(scale).range([-0.5, 0.5]); + d.object_label.fillStyle = this.get_style("axes." + n + ".label.color axes." + n + ".color axes.label.color axes.color"); + d.object_label.visible = this.get_style("axes." + n + ".label.visible axes." + n + ".visible axes.label.visible axes.visible"); + + // since the axes/box are scales, we need to do a correction in the unrotated frame for the label to show in aspect=1 + const matrixRot = new THREE.Matrix4(); + matrixRot.makeRotationFromEuler(new THREE.Euler(d.rotate[0], d.rotate[1], d.rotate[2], d.rotation_order)); + + const matrixRotInv = new THREE.Matrix4(); + matrixRotInv.getInverse(matrixRot); + + const box_scale = new THREE.Vector3(); + box_scale.fromArray(this.model.get('box_size')); + const vectorScale = new THREE.Vector3(1, 1, 1); + vectorScale.divide(box_scale); + + const matrixScale = new THREE.Matrix4(); + matrixScale.makeScale(vectorScale.x, vectorScale.y, vectorScale.z); + + const s = 0.01 * 0.4 / 3; + const matrixScaleSize = new THREE.Matrix4(); + matrixScaleSize.makeScale(s, s, s); + matrixScale.multiply(matrixScaleSize); + + const label = d.object_label; + label.matrixAutoUpdate = false; + label.matrix.identity(); + label.matrix.multiply(matrixRotInv); + label.matrix.multiply(matrixScale); + label.matrix.multiply(matrixRot); + } + + _d3_add_axis_tick(node, d, i) { + // console.log("add tick", d, node, d3.select(d3.select(node).node().parentNode)) + const parent_data : any = d3.select(d3.select(node).node().parentNode).datum(); // TODO: find the proper way to do so + const scale = (parent_data as any).scale; + + const tick_format = scale.tickFormat(this.ticks, ".1f"); + const tick_text = tick_format(d.value); + + // TODO: puzzled by the align not working as expected.. + const aligns = { + x: THREEtext2d.textAlign.topRight, + y: THREEtext2d.textAlign.topRight, + z: THREEtext2d.textAlign.center, + }; + const sprite = new THREEtext2d.SpriteText2D(tick_text, { + align: aligns[(parent_data as any).name], + font: "100px Arial", + fillStyle: "#00FF00", + antialias: true, + }); + sprite.material.transparent = true; + sprite.material.alphaTest = 0.3; + // there were assigned to sprite, instead of material + // sprite.material.blending = THREE.CustomBlending; + // sprite.material.blendSrc = THREE.SrcAlphaFactor; + // sprite.material.blendDst = THREE.OneMinusSrcAlphaFactor; + // sprite.material.blendEquation = THREE.AddEquation; + + const n = (parent_data as any).name; // x, y or z + + sprite.fillStyle = this.get_style("axes." + n + ".ticklabel.color axes.ticklabel.color axes." + n + ".color axes.color"); + if (tick_text) { + (parent_data as any).object.add(sprite); + } + d.object_ticklabel = sprite; + this._d3_update_axis_tick(node, d, i); + return sprite; + } + + _d3_update_axis_tick(node, d, i) { + // TODO: find the proper way to do so + const parent_data : any = d3.select(d3.select(node).node().parentNode).datum(); + const scale = (parent_data as any).scale; + const tick_format = scale.tickFormat(this.ticks, ".1f"); + const tick_text = tick_format(d.value); + // if we have text, but didn't have it before + if (tick_text && !d.object_ticklabel.text) { + (parent_data as any).object.add(d.object_ticklabel); + } + // if we don't have text, but had it before + if (!tick_text && d.object_ticklabel.text) { + (parent_data as any).object.remove(d.object_ticklabel); + } + d.object_ticklabel.text = tick_text; + const n = (parent_data as any).name; // x, y or z + d.object_ticklabel.fillStyle = this.get_style("axes." + n + ".ticklabel.color axes.ticklabel.color axes." + n + ".color axes.color"); + d.object_ticklabel.visible = this.get_style("axes." + n + ".ticklabel.visible axes." + n + ".visible axes.visible"); + + const matrixRot = new THREE.Matrix4(); + matrixRot.makeRotationFromEuler(new THREE.Euler(parent_data.rotate[0], parent_data.rotate[1], parent_data.rotate[2], parent_data.rotation_order)); + + const matrixRotInv = new THREE.Matrix4(); + matrixRotInv.getInverse(matrixRot); + + const box_scale = new THREE.Vector3(); + box_scale.fromArray(this.model.get('box_size')); + const vectorScale = new THREE.Vector3(1, 1, 1); + vectorScale.divide(box_scale); + + const matrixScale = new THREE.Matrix4(); + matrixScale.makeScale(vectorScale.x, vectorScale.y, vectorScale.z); + + const s = 0.01 * 0.4 * 0.5 * 0.5 / 3; + const matrixScaleSize = new THREE.Matrix4(); + matrixScaleSize.makeScale(s, s, s); + matrixScale.multiply(matrixScaleSize); + + const matrixTranslate = new THREE.Matrix4(); + matrixTranslate.makeTranslation(scale(d.value), 0, 0) + + const label = d.object_ticklabel; + label.matrixAutoUpdate = false; + label.matrix.identity(); + label.matrix.multiply(matrixTranslate); + label.matrix.multiply(matrixRotInv); + label.matrix.multiply(matrixScale); + label.matrix.multiply(matrixRot); + } + + _d3_remove_axis_tick(node, d, i) { + if (d.object_ticklabel.text) { + d.object_ticklabel.parent.remove(d.object_ticklabel); + } + } + + update_scatters() { + const scatters = this.model.get("scatters") as ScatterModel[]; + if (scatters.length !== 0) { // So now check if list has length 0 + const current_scatter_cids = []; + // Add new scatter if not already as scatter view in figure + // _.each(scatters, (scatter_model) => { + scatters.forEach((scatter_model: ScatterModel) => { + current_scatter_cids.push(scatter_model.cid); + if (!(scatter_model.cid in this.scatter_views)) { + const options = { + parent: this, + }; + const scatter_view = new ScatterView({ + options, + model: scatter_model, + }); + scatter_view.render(); + this.scatter_views[scatter_model.cid] = scatter_view; + } + + }); + + // Remove old scatters not contained in scatters + for (const cid of Object.keys(this.scatter_views)) { + const scatter_view = this.scatter_views[cid]; + if (current_scatter_cids.indexOf(cid) === -1) { + scatter_view.remove_from_scene(); + delete this.scatter_views[cid]; + } + } + } else { + this.scatter_views = {}; + } + this._update_id_offsets() + } + + update_meshes() { + const meshes = this.model.get("meshes") as MeshModel[]; + if (meshes.length !== 0) { // So now check if list has length 0 + const current_meshes_cids = []; + // Add new meshes if not already as mesh view in figure + // _.each(meshes, (mesh_model) => { + meshes.forEach((mesh_model) => { + current_meshes_cids.push(mesh_model.cid); + if (!(mesh_model.cid in this.mesh_views)) { + const options = { + parent: this, + }; + const mesh_view = new MeshView({ + options, + model: mesh_model, + }); + mesh_view.render(); + this.mesh_views[mesh_model.cid] = mesh_view; + } + }); + + // Remove old meshes not contained in meshes + for (const cid of Object.keys(this.mesh_views)) { + const mesh_view = this.mesh_views[cid]; + if (current_meshes_cids.indexOf(cid) === -1) { + mesh_view.remove_from_scene(); + delete this.mesh_views[cid]; + } + } + } else { + this.mesh_views = {}; + } + this._update_id_offsets() + } + + update_volumes() { + const volumes = this.model.get("volumes") as VolumeModel[]; // This is always a list? + const previous = this.model.previous("volumes") as VolumeModel[]; // This is always a list? + if (volumes.length !== 0) { // So now check if list has length 0 + const current_volume_cids = []; + // Add new volumes if not already as volume view in figure + // _.each(volumes, (vol_model) => { + volumes.forEach((volume_model) => { + current_volume_cids.push(volume_model.cid); + if (!(volume_model.cid in this.volume_views)) { + const options = { + parent: this, + }; + const volume_view = new VolumeView({ + options, + model: volume_model, + }); + volume_model.add_to_scene(this.rootObject); + this.volume_views[volume_model.cid] = volume_view; + volume_view.render(); + } + }); + + // Remove old volumes + for (const cid of Object.keys(this.volume_views)) { + const volume_view = this.volume_views[cid]; + if (current_volume_cids.indexOf(cid) === -1) { + // volume_view.remove_from_scene(); + delete this.volume_views[cid]; + } + } + } else { + this.volume_views = {}; + } + if(previous) { + for(let prev of previous) { + if(!volumes.includes(prev)) { + prev.remove_from_scene(this.rootObject); + } + } + } + this._update_id_offsets(); + } + + _update_id_offsets() { + let offset = 1; // start at 1, 0 is reserved for nothing selected + for (const scatterView of Object.values(this.scatter_views)) { + scatterView.uniforms.id_offset['value'] = offset; + offset += scatterView.length; + } + for (const meshView of Object.values(this.mesh_views)) { + meshView.uniforms.id_offset['value'] = offset; + offset += meshView.length; + } + } + + async update_lights() { + if(this.model.previous('lights')) { + // Remove previous lights + this.model.previous('lights').forEach(light_model => { + const light = light_model.obj; + this.scene.remove(light); + }); + } + + const lights = this.model.get("lights"); + lights.forEach(light_model => { + const light = light_model.obj; + if (light.castShadow) { + this.update_shadows(); + } + + const on_light_change = () => { + if (light.castShadow) { + this.update_shadows(); + } + this.update(); + } + if(light.target) { + this.scene.add(light.target) + } + light_model.on("change", on_light_change); + light_model.on("childchange", on_light_change); + this.scene.add(light); + }); + // if we update the lights, we need to force all materials to update/ + // see https://stackoverflow.com/questions/16879378/adding-and-removing-three-js-lights-at-run-time + const children = [ + ...Object.values(this.mesh_views), + ...Object.values(this.scatter_views), + ] + for(const child of children) { + child._update_materials(); + } + this.update(); + } + + + + update_shadows() { + // Activate shadow mapping + this.renderer.shadowMap.enabled = true + this.renderer.shadowMap.type = THREE.PCFSoftShadowMap; + // TODO: when do we disable shadow mapping? + } + + transition(f, on_done, context) { + const that = this; + const exp = that.model.get("animation_exponent"); + that.transitions.push(new Transition(f, on_done, that.model.get("animation"), exp)); + } + + on_orientationchange(e) { + if(!this.model.get("orientation_control")) + return; + for (const scene of [this.scene, this.scene_opaque]) { + scene.rotation.reorder("XYZ"); + scene.rotation.x = (e.gamma * Math.PI / 180 + Math.PI * 2); + scene.rotation.y = -(e.beta * Math.PI / 180 + Math.PI * 2); + scene.rotation.z = -((e.alpha) * Math.PI / 180); + } + this.update(); + + } + + // tslint:disable-next-line: no-empty + on_canvas_resize(event) { + } + + keypress(event) { + // const code = event.keyCode || event.which; + // if (event.keyCode === 27) {} + // if (event.key === "f") {} + } + + update_angles() { + if (this.camera.ipymodel) { + this.camera.ipymodel.syncToModel(true); + } + this.update(); + } + + _get_scale_matrix() { + // go from [0, 1] to [-0.5, 0.5] + const matrix = new THREE.Matrix4(); + matrix.makeTranslation(-0.5, -0.5, -0.5); + + const matrix_scale = new THREE.Matrix4(); + const scales = this.model.get("scales"); + const x = scales.x.domain; + const y = scales.y.domain; + const z = scales.z.domain; + const sx = 1 / (x[1] - x[0]); + const sy = 1 / (y[1] - y[0]); + const sz = 1 / (z[1] - z[0]); + matrix_scale.makeScale(sx, sy, sz); + const translation = new THREE.Matrix4(); + translation.makeTranslation(-x[0], -y[0], -z[0]); + matrix.multiply(matrix_scale); + matrix.multiply(translation); + return matrix; + } + + _get_view_matrix() { + // make sure the camera's inverse is up to date, normally the renderer would do this + // but this also gets called before the first render + this.camera.updateMatrixWorld(); + this.camera.matrixWorldInverse.getInverse(this.camera.matrixWorld); + // we don't really properly use the worldmatrix, rendering threejs's frustum culling + // useless, we maybe should change this + // https://github.com/mrdoob/three.js/issues/78#issuecomment-846917 + const view_matrix = this.camera.matrixWorldInverse.clone(); + view_matrix.multiply(this._get_scale_matrix().clone()); + return view_matrix; + } + + update_current_control() { + if (this.camera.ipymodel) { + this.camera.ipymodel.syncToModel(true); + } + this.control_trackball.position0 = this.camera.position.clone(); + this.control_trackball.up0 = this.camera.up.clone(); + } + + update_panorama() { + const material = this.screen_material_cube; + if (this.model.get("panorama_mode") === "360") { + material.defines = { + PANORAMA_360: true, + }; + } + if (this.model.get("panorama_mode") === "180") { + material.defines = { + PANORAMA_180: true, + }; + } + material.needsUpdate = true; + this.update(); + } + + update() { + // requestAnimationFrame stacks, so make sure multiple update calls only lead to 1 _real_update call + if (!this._update_requested) { + this._update_requested = true; + requestAnimationFrame(this._real_update.bind(this)); + } + } + + _real_update() { + this.control_trackball.handleResize(); + if (this.control_external) { + this.control_external.update(); + // it's very likely the controller will update the camera, so we sync it to the kernel + this.camera.ipymodel.syncToModel(true); + } + + this._update_requested = false; + // since the threejs animation system can update the camera, + // make sure we keep looking at the center (only for ipyvolume's own control) + if (!this.control_external) { + this.camera.lookAt(0, 0, 0); + } + for (const scatter_view of Object.values(this.scatter_views)) { + scatter_view.uniforms.aspect.value = this.model.get('box_size'); + } + + this.renderer.setClearColor(this.get_style_color("background-color")); + this.x_axis.visible = this.get_style("axes.x.visible axes.visible"); + this.y_axis.visible = this.get_style("axes.y.visible axes.visible"); + this.z_axis.visible = this.get_style("axes.z.visible axes.visible"); + this.axes_material.color = this.get_style_color("axes.color"); + this.xaxes_material.color = this.get_style_color("axes.x.color axes.color"); + this.yaxes_material.color = this.get_style_color("axes.y.color axes.color"); + this.zaxes_material.color = this.get_style_color("axes.z.color axes.color"); + + this.axes_data[0].fillStyle = this.get_style("axes.x.color axes.color"); + this.axes_data[1].fillStyle = this.get_style("axes.y.color axes.color"); + this.axes_data[2].fillStyle = this.get_style("axes.z.color axes.color"); + + this.axes_data[0].label = this.model.get("xlabel"); + this.axes_data[1].label = this.model.get("ylabel"); + this.axes_data[2].label = this.model.get("zlabel"); + + this.wire_box.visible = this.get_style("box.visible"); + this.wire_box_x_line.visible = !this.x_axis.visible && this.wire_box.visible; + this.wire_box_y_line.visible = !this.y_axis.visible && this.wire_box.visible; + this.wire_box_z_line.visible = !this.z_axis.visible && this.wire_box.visible; + + d3.select(this.el_axes).selectAll(".ipyvol-axis") + .data(this.axes_data) + .each(bind_d3(this._d3_update_axis, this)) + .enter() + .append("div") + .attr("class", "ipyvol-axis") + .each(bind_d3(this._d3_add_axis, this)); + + const that = this; + this.ticks = 5; + + function last_tick_selection_data(d, i, node) { + let child_data = d.ticks; + if (child_data) { + child_data = d.ticks = child_data.slice(); + const ticks = d.scale.ticks(that.ticks); + + // ticks may return a larger array, so grow child data + while (child_data.length < ticks.length) { + child_data.push({}); + } + // ticks may return a smaller array, so pop child data + while (child_data.length > ticks.length) { + child_data.pop(); + } + + // _.each(ticks, (tick, i) => { + for (let j = 0; j < ticks.length; j++) { + child_data[j].value = ticks[j]; + } + return child_data; + } else { + const scale = d.scale; + const ticks = scale.ticks(that.ticks); + child_data = ticks.map((value) => ({value})); + d.ticks = child_data; + return child_data; + } + } + + this.last_tick_selection = d3.select(this.el_axes) + .selectAll(".ipyvol-axis") + .data(this.axes_data) + .selectAll(".ipyvol-tick") + .data(last_tick_selection_data); + + this.last_tick_selection + .each(bind_d3(this._d3_update_axis_tick, this)) + .enter() + .append("div") + .attr("class", "ipyvol-tick") + .each(bind_d3(this._d3_add_axis_tick, this)); + + this.last_tick_selection + .exit() + .remove() + .each(bind_d3(this._d3_remove_axis_tick, this)); + + const transitions_todo = []; + for (const t of this.transitions) { + if (!t.is_done()) { + transitions_todo.push(t); + } + t.update(); + } + + this.renderer.clear(); + if (!this.model.get("stereo")) { + this._render_eye(this.camera); + } else { + const size = this.renderer.getSize(); + if (this.camera.parent === null) { this.camera.updateMatrixWorld(); } + this.camera_stereo.eyeSep = this.model.get("eye_separation") / 100.; + this.camera.focus = this.camera.focus; + this.camera_stereo.update(this.camera); + + // the 360 rendering uses the position and quaternion, not the matrices + this.camera_stereo.cameraL.position.copy(this.camera.position); + this.camera_stereo.cameraR.position.copy(this.camera.position); + this.camera_stereo.cameraL.quaternion.copy(this.camera.quaternion); + this.camera_stereo.cameraR.quaternion.copy(this.camera.quaternion); + // and up is used for lookAt + this.camera_stereo.cameraL.up.copy(this.camera.up); + this.camera_stereo.cameraR.up.copy(this.camera.up); + + // default is to render left left, and right right + // in 360 mode, left is rendered top, right bottom + const panorama = this.model.get("panorama_mode") !== "no"; + // left eye + this.renderer.setScissorTest(true); + if (panorama) { + this.renderer.setScissor(0, 0, size.width, size.height / 2); + this.renderer.setViewport(0, 0, size.width, size.height / 2); + } else { + this.renderer.setScissor(0, 0, size.width / 2, size.height); + this.renderer.setViewport(0, 0, size.width / 2, size.height); + } + + this._render_eye(this.camera_stereo.cameraL); + + // right eye + if (panorama) { + this.renderer.setScissor(0, size.height / 2, size.width, size.height / 2); + this.renderer.setViewport(0, size.height / 2, size.width, size.height / 2); + } else { + this.renderer.setScissor(size.width / 2, 0, size.width / 2, size.height); + this.renderer.setViewport(size.width / 2, 0, size.width / 2, size.height); + } + + this._render_eye(this.camera_stereo.cameraR); + + this.renderer.setScissorTest(false); + this.renderer.setViewport(0, 0, size.width, size.height); + } + if (this.selector) { + this.selector.draw(); + } // TODO: what to do with stereo rendering? + this.transitions = transitions_todo; + if (this.transitions.length > 0) { + this.update(); + } + if (this.model.get("render_continuous")) { + this.update(); + } + if (this.model.get("scene")) { + this.model.get("scene").trigger("afterRender", this.scene, this.renderer, this.camera); + } + } + + get_style_color(name) { + const style = this.get_style(name); + if (style) { + return new THREE.Color(style); + } else { + console.error("could not find color for", name); + } + } + + get_style(name: string) { + const value = [null]; + const sep = " "; + name.split(sep).forEach((property_string) => { + const value_found = property_string.split(".").reduce((object, property) => { + if (object !== null && object[property] !== undefined) { + return object[property]; + } else { + return null; + } + }, this.model.get("style")); + if (value_found !== null && value[0] === null) { + value[0] = value_found; + } + }, this); + + return value[0]; + } + + _render_eye(camera) { + this.camera.updateMatrixWorld(); + let volumes = this.model.get("volumes") as VolumeModel[]; + volumes = volumes.filter((volume) => volume.get("visible")) + const has_volumes = volumes.length !== 0; + const panorama = this.model.get("panorama_mode") !== "no"; + // record who is visible + const wasVisible = this.rootObject.children.reduce((map, o) => { + map[o.id] = o.visible + return map; + }, {}); + const setVisible = ({volumes}) => { + this.rootObject.children.forEach((o) => { + if(volumes) { + //@ts-ignore + o.visible = Boolean(o.isVolume) || Boolean(o.isLight) || Boolean(o.isCamera) + } else { + //@ts-ignore + o.visible = !Boolean(o.isVolume) + } + if(o === this.front_box_mesh) + this.front_box_mesh.visible = false; + }) + }; + const restoreVisible = () => { + this.rootObject.children.forEach((o) => { + o.visible = wasVisible[o.id]; + }); + }; + + // set material to rgb + for (const scatter_view of Object.values(this.scatter_views)) { + scatter_view.set_scales(this.model.get("scales")); + } + for (const mesh_view of Object.values(this.mesh_views)) { + mesh_view.set_scales(this.model.get("scales")); + } + + if (panorama) { + (this.cube_camera as any).clear(this.renderer, true, true, true); + this.renderer.autoClear = false; + this.cube_camera.position.copy(camera.position); + this.cube_camera.rotation.copy(camera.rotation); + this.cube_camera.quaternion.copy(this.camera.quaternion); + + if (this.model.get("stereo")) { + // we do 'toe in' http://paulbourke.net/papers/vsmm2006/vsmm2006.pdf + // which should be fine with spherical screens or projections right? + // as opposed to what is described here http://paulbourke.net/stereographics/stereorender/ + const displacement = new THREE.Vector3(0.0, 0, 0); + if (camera === this.camera_stereo.cameraR) { + displacement.x += 0.032; + } + if (camera === this.camera_stereo.cameraL) { + displacement.x -= 0.032; + } + displacement.applyQuaternion(camera.quaternion); + this.cube_camera.position.add(displacement); + const focal_point = new THREE.Vector3(0, 0, 1 * this.camera.focus); // neg z points in screen + focal_point.applyQuaternion(camera.quaternion); + this.cube_camera.lookAt(focal_point); + } + + this.cube_camera.update(this.renderer, this.scene); // TODO: but do we render volumes? + this.cube_camera.update(this.renderer, this.scene_opaque); + // TODO: typescript seems to disagree with types here + (this.screen_texture as any) = this.cube_camera.renderTarget; + this.renderer.render(this.screen_scene_cube, this.screen_camera); + return; + } + + // we always render the front + this.rootObject.children.forEach((o) => { + o.visible = false; + }) + this.front_box_mesh.visible = true; + (this.front_box_mesh.material as THREE.ShaderMaterial).side = THREE.FrontSide; + this.renderer.setRenderTarget(this.volume_front_target); + this.renderer.clear(true, true, true); + this.renderer.render(this.scene, camera, this.volume_front_target); + this.front_box_mesh.visible = false; + + + // render the back coordinates of the box + if (has_volumes) { + // to render the back sides of the boxes, we need to invert the z buffer value + // and invert the test + this.renderer.state.buffers.depth.setClear(0); + for (const volume_model of volumes) { + volume_model.box_material.side = THREE.BackSide; + volume_model.box_material.depthFunc = THREE.GreaterDepth; + volume_model.vol_box_mesh.material = volume_model.box_material; + volume_model.set_scales(this.model.get("scales")); + } + this.renderer.setRenderTarget(this.volume_back_target); + this.renderer.clear(true, true, true); + setVisible({volumes: true}); + this.renderer.render(this.scene, camera, this.volume_back_target); + this.renderer.state.buffers.depth.setClear(1); + + // Color and depth render pass for volume rendering + this.renderer.autoClear = false; + this.renderer.setRenderTarget(this.geometry_depth_target); + this.renderer.clear(true, true, true); + setVisible({volumes: false}); + this.renderer.render(this.scene, camera, this.geometry_depth_target); + this.renderer.render(this.scene_opaque, camera, this.geometry_depth_target); + this.renderer.autoClear = true; + } + + // Normal color pass of geometry for final screen pass + this.renderer.autoClear = false; + this.renderer.setRenderTarget(this.color_pass_target); + this.renderer.clear(true, true, true); + setVisible({volumes: false}); + this.renderer.render(this.scene, camera, this.color_pass_target); + this.renderer.render(this.scene_opaque, camera, this.color_pass_target); + this.renderer.autoClear = true; + + if (has_volumes) { + // render the box front once, without writing the colors + // so that once we render the box again, each fragment will be processed + // once. + this.renderer.context.colorMask(0, 0, 0, 0); + for (const volume_model of volumes) { + volume_model.box_material.side = THREE.FrontSide; + volume_model.box_material.depthFunc = THREE.LessEqualDepth; + } + this.renderer.autoClear = false; + this.renderer.setRenderTarget(this.color_pass_target); + this.renderer.clear(false, true, false); + setVisible({volumes: true}); + this.renderer.render(this.scene, camera, this.color_pass_target); + this.renderer.autoClear = true; + this.renderer.context.colorMask(true, true, true, true); + + // TODO: if volume perfectly overlap, we render it twice, use polygonoffset and LESS z test? + for (const volume_model of volumes) { + volume_model.vol_box_mesh.material = this.material_multivolume; + // volume_view.set_geometry_depth_tex(this.geometry_depth_target.depthTexture) + } + this.renderer.autoClear = false; + // we want to keep the colors and z-buffer as they are + this.renderer.setRenderTarget(this.color_pass_target); + // threejs does not want to be called with all three false + // this.renderer.clear(false, false, false); + setVisible({volumes: true}); + this.renderer.render(this.scene, camera, this.color_pass_target); + this.renderer.autoClear = true; + } + + // set RGB material for coordinate texture render + for (const scatter_view of Object.values(this.scatter_views)) { + scatter_view.mesh.material = scatter_view.mesh.material_rgb; + } + for (const mesh_view of Object.values(this.mesh_views)) { + mesh_view.meshes.forEach((threejs_mesh) => { + threejs_mesh.material = threejs_mesh.material_rgb; + }); + } + + // we also render this for the zoom coordinate + this.renderer.autoClear = false; + this.renderer.setClearAlpha(0); + this.renderer.setRenderTarget(this.coordinate_target); + this.renderer.clear(true, true, true); + setVisible({volumes: false}); + this.renderer.render(this.scene, camera, this.coordinate_target); + this.renderer.autoClear = true; + + // id pass + // set ID material for coordinate texture render + for (const scatter_view of Object.values(this.scatter_views)) { + scatter_view.mesh.material = scatter_view.mesh.material_id; + } + for (const mesh_view of Object.values(this.mesh_views)) { + mesh_view.meshes.forEach((threejs_mesh) => { + threejs_mesh.material = threejs_mesh.material_id; + }); + } + + // we also render this for the ids + this.renderer.autoClear = false; + this.renderer.setClearAlpha(0); + this.renderer.setRenderTarget(this.id_pass_target); + this.renderer.clear(true, true, true); + setVisible({volumes: false}); + this.renderer.render(this.scene, camera, this.id_pass_target); + this.renderer.autoClear = true; + + // now we render the weighted coordinate for the volumetric data + // make sure where we don't render, alpha = 0 + if (has_volumes) { + // render again, but now with depth material + // TODO: this render pass is only needed when the coordinate is required + // we slow down by a factor of 2 by always doing this + this.renderer.context.colorMask(0, 0, 0, 0); + for (const volume_model of volumes) { + volume_model.box_material.side = THREE.FrontSide; + volume_model.box_material.depthFunc = THREE.LessEqualDepth; + } + this.renderer.autoClear = false; + this.renderer.setRenderTarget(this.color_pass_target); + this.renderer.clear(false, true, false); + setVisible({volumes: true}); + this.renderer.render(this.scene, camera, this.color_pass_target); + this.renderer.autoClear = true; + this.renderer.context.colorMask(true, true, true, true); + + // TODO: if volume perfectly overlap, we render it twice, use polygonoffset and LESS z test? + for (const volume_model of volumes) { + volume_model.vol_box_mesh.material = this.material_multivolume_depth; + // volume_view.set_geometry_depth_tex(this.geometry_depth_target.depthTexture) + } + this.renderer.autoClear = false; + // we want to keep the colors and z-buffer as they are + this.renderer.setRenderTarget(this.color_pass_target); + // threejs does not want to be called with all three false + // this.renderer.clear(false, false, false); + setVisible({volumes: true}); + this.renderer.render(this.scene, camera, this.coordinate_target); + this.renderer.autoClear = true; + + } + + // restore materials + for (const scatter_view of Object.values(this.scatter_views)) { + scatter_view.mesh.material = scatter_view.mesh.material_normal; + } + for (const mesh_view of Object.values(this.mesh_views)) { + mesh_view.meshes.forEach((threejs_mesh) => { + threejs_mesh.material = threejs_mesh.material_normal; + }); + } + + if(this.model.get("show") == "Shadow") { + this._render_shadow(); + } else { + // render to screen + this.screen_texture = { + render: this.color_pass_target, + front: this.volume_front_target, + back: this.volume_back_target, + // Geometry_back: this.geometry_depth_target, + coordinate: this.coordinate_target, + id: this.id_pass_target, + }[this.model.get("show")]; + // TODO: remove any + this.screen_material.uniforms.tex.value = (this.screen_texture as any).texture; + + this.renderer.setRenderTarget(null); + this.renderer.clear(true, true, true); + this.renderer.render(this.screen_scene, this.screen_camera); + } + restoreVisible(); + } + + _render_shadow() { + const lights = this.model.get('lights').map((model) => model.obj).filter((light) => { + return Boolean(light.shadow) && Boolean(light.shadow.map); + }); + if(lights.length == 0) { + throw "No light with a shadow map found." + } + const light = lights[0]; + const target = light.shadow.map.texture; + const textureWidth = target.width; + const textureHeight = target.height; + const quadCamera = new THREE.OrthographicCamera (textureWidth / - 2, textureHeight / 2, textureWidth / 2, textureHeight / - 2, -1000, 1000); + quadCamera.position.z = 100; + var quadScene = new THREE.Scene(); + + const _shaders = this.model.get("_shaders"); + const fragmentShader = _shaders["shadow-fragment"] || shaders["shadow-fragment"]; + const vertexShader = _shaders["shadow-vertex"] || shaders["shadow-vertex"]; + + const quadMaterial = new THREE.ShaderMaterial ({ + uniforms: { + map: { type: "t", value: null }, + }, + vertexShader: vertexShader, + fragmentShader: fragmentShader, + depthTest: false, + depthWrite: false, + }); + + quadScene.add(new THREE.Mesh (new THREE.PlaneGeometry (textureWidth, textureHeight), quadMaterial)); + quadMaterial.uniforms.map.value = target; + this.renderer.render(quadScene, quadCamera); + } + + rebuild_multivolume_rendering_material() { + let volumes = this.model.get("volumes") as VolumeModel[]; + volumes = volumes.filter((volume) => volume.get("visible")) + + const material = this.material_multivolume; + const material_depth = this.material_multivolume_depth; + let count_normal = 0; + let count_max_int = 0; + material.uniforms.volumes.value = []; + material.uniforms.volumes_max_int.value = []; + material.uniforms.data.value = []; + material.uniforms.data_max_int.value = []; + material.uniforms.transfer_function.value = []; + material.uniforms.transfer_function_max_int.value = []; + material.uniforms.steps.value = volumes.map((volume) => { + const volume_view = this.volume_views[volume.cid]; + return volume_view ? volume_view.get_ray_steps() : 0; + }); + + if (volumes.length === 0) { + return; + } + + for (const volume_model of volumes) { + if (volume_model.is_normal()) { + count_normal++; + material.uniforms.volumes.value.push(volume_model.uniform_volumes_values); + material.uniforms.data.value.push(volume_model.uniform_data.value[0]); + material.uniforms.transfer_function.value.push(volume_model.uniform_transfer_function.value[0]); + } else { + count_max_int++; + material.uniforms.volumes_max_int.value.push(volume_model.uniform_volumes_values); + material.uniforms.data_max_int.value.push(volume_model.uniform_data.value[0]); + material.uniforms.transfer_function_max_int.value.push(volume_model.uniform_transfer_function.value[0]); + } + } + material.defines.VOLUME_COUNT = count_normal; + material.defines.VOLUME_COUNT_MAX_INT = count_max_int; + material.lights = true; + material_depth.defines.VOLUME_COUNT = count_normal; + material_depth.defines.VOLUME_COUNT_MAX_INT = count_max_int; + + const mustache_render = (template_shader) => { + const view = { + volumes: range(count_normal), + volumes_max_int: range(count_max_int), + }; + return Mustache.render(template_shader, view); + }; + const _shaders = this.model.get("_shaders"); + material_depth.fragmentShader = material.fragmentShader = patchShader(mustache_render(_shaders["volr-fragment"] || shaders["volr-fragment"])); + material_depth.vertexShader = material.vertexShader = patchShader(_shaders["volr-vertex"] || shaders["volr-vertex"]); + material_depth.needsUpdate = material.needsUpdate = true; + } + + update_light() { + this.material_multivolume.uniforms.ambient_coefficient.value = this.model.get("ambient_coefficient"); + this.material_multivolume.uniforms.diffuse_coefficient.value = this.model.get("diffuse_coefficient"); + this.material_multivolume.uniforms.specular_coefficient.value = this.model.get("specular_coefficient"); + this.material_multivolume.uniforms.specular_exponent.value = this.model.get("specular_exponent"); + this.update(); + } + + update_size() { + this._update_size(); + } + + _update_size(skip_update?, custom_width?, custom_height?) { + let width; + let height; + const el = this.renderer.domElement; + if (this.is_fullscreen()) { + width = custom_width || el.clientWidth; + height = custom_height || el.clientHeight; + } else { + width = custom_width || this.model.get("width"); + height = custom_height || this.model.get("height"); + } + + // the offscreen rendering can be of lower resolution + let render_width = width * this.renderer.getPixelRatio(); + let render_height = height * this.renderer.getPixelRatio(); + const display_width = width * this.model.get("displayscale"); + const display_height = height * this.model.get("displayscale"); + if (this.is_fullscreen() && this.model.get("volumes") !== 0) { + // fullscreen volume rendering is slow, respect width and height + render_width = custom_width || this.model.get("width"); + render_height = custom_height || this.model.get("height"); + } + this.renderer.setSize(width, height, false); + const buffer_width = this.renderer.context.drawingBufferWidth; + const buffer_height = this.renderer.context.drawingBufferHeight; + if ((buffer_width < width) || (buffer_height < height)) { + console.info("could not set resolution to", width, height, ", resolution is", buffer_width, buffer_height); + } + + this.renderer.domElement.style.width = display_width + "px"; + this.renderer.domElement.style.height = display_height + "px"; + this.canvas_container.style.width = display_width + "px"; + this.canvas_container.style.height = display_height + "px"; + this.canvas_overlay.style.width = display_width + "px"; + this.canvas_overlay.style.height = display_height + "px"; + this.canvas_overlay.width = width; + this.canvas_overlay.height = height; + + if (this.model.get("stereo")) { + render_width /= 2; + } + const aspect = render_width / render_height; + this.camera.aspect = aspect; + // TODO: should we now update the camera object? + // this.camera.width = render_width + // this.camera.height = render_height + this.camera.updateProjectionMatrix(); + + this.material_multivolume.uniforms.render_size.value = [render_width, render_height]; + + this.volume_back_target.setSize(render_width, render_height); + this.volume_front_target.setSize(render_width, render_height); + this.geometry_depth_target.setSize(render_width, render_height); + this.color_pass_target.setSize(render_width, render_height); + this.screen_pass_target.setSize(render_width, render_height); + this.coordinate_target.setSize(render_width, render_height); + this.id_pass_target.setSize(render_width, render_height); + + this.screen_texture = this.color_pass_target.texture; + if (!skip_update) { + this.update(); + } + } + + getRenderSize() { + const render_size = this.renderer.getSize(); + return [render_size.width, render_size.width]; + } + + fullscreen() { + screenfull.request(this.el); + } + + is_fullscreen() { + return screenfull.element === this.renderer.domElement; + } +} + +export +class WidgetManagerHackModel extends widgets.WidgetModel { + static __super__: any; + defaults() { + return {...super.defaults(), + _model_name: "WidgetManagerHackModel", + _model_module: "ipyvolume", + _model_module_version: semver_range, + }; + } + + initialize(attributes, options) { + console.log(this); + super.initialize(attributes, options); + console.info("get reference to widget manager"); + (window as any).jupyter_widget_manager = this.widget_manager; + (window as any).jupyter_widgets = widgets; + } +} + +////////////////// +// WEBPACK FOOTER +// ./src/volume.js +// module id = 1 +// module chunks = 0 diff --git a/js/src/index.js b/js/src/index.ts similarity index 61% rename from js/src/index.js rename to js/src/index.ts index 7cc92dc7..811bfc26 100644 --- a/js/src/index.js +++ b/js/src/index.ts @@ -7,8 +7,10 @@ // dynamically. // __webpack_public_path__ = document.querySelector('body').getAttribute('data-base-url') + 'nbextensions/ipyvolume/'; -var _ = require('underscore') // Export widget models and views, and the npm package version number. -module.exports = _.extend({}, require('./figure.js'), require('./tf.js'), require('./scatter.js'), require('./volume.js'), require('./mesh.js'), require('./utils.js')); -module.exports['version'] = require('../package.json').version; -module.exports.mqtt = require('mqtt') + +export * from "./figure"; +export * from "./tf"; +export * from "./scatter"; +export * from "./volume"; +export * from "./mesh"; diff --git a/js/src/labplugin.js b/js/src/labplugin.js deleted file mode 100644 index 6587178a..00000000 --- a/js/src/labplugin.js +++ /dev/null @@ -1,16 +0,0 @@ -var jupyter_volume = require('./index'); -var base = require('@jupyter-widgets/base'); - -module.exports = { - id: 'ipyvolume', - requires: [base.IJupyterWidgetRegistry], - activate: function(app, widgets) { - widgets.registerWidget({ - name: 'ipyvolume', - version: jupyter_volume.version, - exports: jupyter_volume - }); - }, - autoStart: true -}; - diff --git a/js/src/labplugin.ts b/js/src/labplugin.ts new file mode 100644 index 00000000..e4abc792 --- /dev/null +++ b/js/src/labplugin.ts @@ -0,0 +1,18 @@ +import * as base from "@jupyter-widgets/base"; +import * as jupyter_volume from "./index"; +import {semver_range} from "./utils"; + +const plugin = { + id: "ipyvolume", + requires: [base.IJupyterWidgetRegistry as any], + activate(app, widgets) { + widgets.registerWidget({ + name: "ipyvolume", + version: semver_range, + exports: jupyter_volume, + }); + }, + autoStart: true, +}; + +export default plugin; diff --git a/js/src/materials.ts b/js/src/materials.ts new file mode 100644 index 00000000..6a796aee --- /dev/null +++ b/js/src/materials.ts @@ -0,0 +1,48 @@ + +import * as THREE from "three"; +import { patchShader } from "./scales"; + +export +class MeshDepthMaterialCustom extends (THREE as any).MeshDepthMaterial { + constructor(defines, uniforms, vertexShader, fragmentShader, parameters) { + super(parameters); + this.defines = defines; + this.uniforms = uniforms; + this.onBeforeCompile = (shader) => { + // const defines = this.defines(); + const defines = {DEPTH_PACKING:3201, ...this.defines()}; + let define_code = ""; + for (const key of Object.keys(defines)) { + if (defines[key]) { + define_code += `#define ${key} ${defines[key]}\n`; + } + } + shader.vertexShader = patchShader(define_code + vertexShader); + shader.fragmentShader = patchShader(define_code + fragmentShader); + // shallow copy the uniforms, so we share them (e.g. updating time) + shader.uniforms = {...shader.uniforms, ...this.uniforms}; + }; + } +} + +export +class MeshDistanceMaterialCustom extends (THREE as any).MeshDistanceMaterial { + constructor(defines, uniforms, vertexShader, fragmentShader, parameters) { + super(parameters); + this.defines = defines; + this.uniforms = uniforms; + this.onBeforeCompile = (shader) => { + const defines = this.defines(); + let define_code = ""; + for (const key of Object.keys(defines)) { + if (defines[key]) { + define_code += `#define ${key} ${defines[key]}\n`; + } + } + shader.vertexShader = patchShader(define_code + vertexShader); + shader.fragmentShader = patchShader(define_code + fragmentShader); + // shallow copy the uniforms, so we share them (e.g. updating time) + shader.uniforms = {...shader.uniforms, ...this.uniforms}; + }; + } +} diff --git a/js/src/mesh.js b/js/src/mesh.js deleted file mode 100644 index 1912a6fe..00000000 --- a/js/src/mesh.js +++ /dev/null @@ -1,468 +0,0 @@ -var _ = require('underscore'); -var widgets = require('@jupyter-widgets/base'); -var THREE = require('three'); -var serialize = require('./serialize.js'); -var values = require('./values.js'); -var semver_range = require('./utils.js').semver_range; - -var MeshView = widgets.WidgetView.extend( { - render: function() { - //console.log("created mesh view, parent is") - //console.log(this.options.parent) - this.renderer = this.options.parent; - this.previous_values = {} - this.attributes_changed = {} - window.last_mesh = this; - this.meshes = [] - this.texture_loader = new THREE.TextureLoader() - this.textures = null; - if(this.model.get('texture')) { - this._load_textures() - } - - this.uniforms = { - xlim : { type: "2f", value: [0., 1.] }, - ylim : { type: "2f", value: [0., 1.] }, - zlim : { type: "2f", value: [0., 1.] }, - animation_time_x : { type: "f", value: 1. }, - animation_time_y : { type: "f", value: 1. }, - animation_time_z : { type: "f", value: 1. }, - animation_time_u : { type: "f", value: 1. }, - animation_time_v : { type: "f", value: 1. }, - animation_time_color : { type: "f", value: 1. }, - animation_time_texture : { type: "f", value: 1. }, - texture: { type: 't', value: null }, - texture_previous: { type: 't', value: null }, - } - let get_material = (attr_name) => { - if(this.model.get('material')) - return this.model.get('material').obj.clone() - else { - var mat = new THREE.ShaderMaterial(); - mat.side = THREE.DoubleSide; - return mat; - } - - } - this.material = get_material('material'); - this.material_rgb = get_material('material'); - this.line_material = get_material('line_material'); - this.material.polygonOffset = true; - this.material.polygonOffsetFactor = 1; - this.material.polygonOffsetUnits = 0.1; - // this.material.depthFunc = THREE.LessEqualDepth - this.line_material_rgb = get_material('line_material'); - this.materials = [this.material, this.material_rgb, this.line_material, this.line_material_rgb] - this._update_materials() - if(this.model.get('material')) { - this.model.get('material').on('change', () => { - this._update_materials() - this.renderer.update() - }) - } - if(this.model.get('line_material')) { - this.model.get('line_material').on('change', () => { - this._update_materials() - this.renderer.update() - }) - } - - this.create_mesh() - this.add_to_scene() - this.model.on("change:color change:sequence_index change:x change:y change:z change:v change:u change:triangles change:lines", this.on_change, this) - this.model.on("change:geo change:connected", this.update_, this) - this.model.on("change:texture", this._load_textures, this) - this.model.on("change:visible", this.update_visibility, this) - }, - update_visibility: function () { - this._update_materials() - this.renderer.update() - }, - - _load_textures: function() { - var texture = this.model.get('texture'); - if(texture.stream) { // instanceof media.MediaStreamModel) { - this.textures = null - this.texture_video = document.createElement('video') - texture.stream.then(_.bind(function(stream) { - this.texture_video.srcObject = stream; - this.texture_video.play() - var texture = new THREE.VideoTexture(this.texture_video) - //texture.wrapS = THREE.RepeatWrapping; - //texture.wrapT = THREE.RepeatWrapping; - texture.minFilter = THREE.LinearFilter; - //texture.wrapT = THREE.RepeatWrapping; - this.textures = [texture]; - this._update_materials() - this.update_() - }, this)) - } else { - this.textures = _.map(this.model.get('texture'), function(texture_url) { - return this.texture_loader.load(texture_url, _.bind(function(texture) { - texture.wrapS = THREE.RepeatWrapping; - texture.wrapT = THREE.RepeatWrapping; - this._update_materials() - this.update_() - }, this)); - }, this) - } - }, - set_limits: function(limits) { - _.mapObject(limits, function(value, key) { - this.material.uniforms[key].value = value - }, this) - }, - add_to_scene: function() { - _.each(this.meshes, function(mesh) { - this.renderer.scene_scatter.add(mesh) - }, this) - }, - remove_from_scene: function() { - _.each(this.meshes, function(mesh) { - this.renderer.scene_scatter.remove(mesh) - mesh.geometry.dispose() - }, this) - }, - on_change: function(attribute) { - _.mapObject(this.model.changedAttributes(), function(val, key){ - //console.log("changed " +key) - this.previous_values[key] = this.model.previous(key) - // attributes_changed keys will say what needs to be animated, it's values are the properties in - // this.previous_values that need to be removed when the animation is done - // we treat changes in _selected attributes the same - var key_animation = key.replace("_selected", "") - if (key_animation == "sequence_index") { - var animated_by_sequence = ['x', 'y', 'z', 'u', 'v', 'color'] - _.each(animated_by_sequence, function(name) { - if(_.isArray(this.model.get(name)) && this.model.get(name).length > 1) { - this.attributes_changed[name] = [name, 'sequence_index'] - } - }, this) - this.attributes_changed['texture'] = ['texture', 'sequence_index'] - } - else if(key_animation == "triangles") { - // direct change, no animation - } - else if(key_animation == "lines") { - // direct change, no animation - } - else if(key_animation == "selected") { // and no explicit animation on this one - this.attributes_changed["color"] = [key] - } else { - this.attributes_changed[key_animation] = [key] - // animate the size as well on x y z changes - if(["x", "y", "z", "u", "v", 'color'].indexOf(key_animation) != -1) { - //console.log("adding size to list of changed attributes") - //this.attributes_changed["size"] = [] - } - - } - }, this) - this.update_() - }, - update_: function() { - this.remove_from_scene() - this.create_mesh() - this.add_to_scene() - this.renderer.update() - }, - _get_value: function(value, index, default_value) { - var default_value = default_value; - if(!value) - return default_value; - // it is either an array of typed arrays, or a list of numbers coming from the javascript world - if(_.isArray(value) && !_.isNumber(value[0])) { - // check whether alpha component was provided or not - var out_index = index % value.length; - var rows = value.original_data[out_index].shape[0]; - var cols = value.original_data[out_index].shape[1]; - - if ((cols === 3) && _.isNumber(value[out_index][0])) { - // for rbg colors add alphas - var out_length = rows * 4; - var out_value = new Float32Array(out_length); - var temp_value = value[out_index]; - - for (var i = 0; i < rows; i++) { - out_value[i*4] = temp_value[i*3]; - out_value[i*4 + 1] = temp_value[i*3 + 1]; - out_value[i*4 + 2] = temp_value[i*3 + 2]; - out_value[i*4 + 3] = 1.0; - } - - return out_value; - } else { - // either we have color with alpha or a different format, not the rgb - return value[out_index]; - } - } else { - return value; - } - }, - get_current: function(name, index, default_value) { - return this._get_value(this.model.get(name), index, default_value) - }, - get_previous: function(name, index, default_value) { - return this._get_value(this.previous_values[name] || this.model.get(name), index, default_value) - }, - _get_value_vec3: function(value, index, default_value) { - var default_value = default_value; - if(!value) - return default_value - if(_.isArray(value)) - return value[index % value.length] - else - return value - }, - get_current_vec3: function(name, index, default_value) { - return this._get_value_vec3(this.model.get(name), index, default_value) - }, - get_previous_vec3: function(name, index, default_value) { - return this._get_value_vec3(this.previous_values[name] || this.model.get(name), index, default_value) - }, - _update_materials: function() { - if(this.model.get('material')) - this.material.copy(this.model.get('material').obj) - if(this.model.get('material')) - this.material_rgb.copy(this.model.get('material').obj) - if(this.model.get('line_material')) - this.line_material.copy(this.model.get('line_material').obj) - if(this.model.get('line_material')) - this.line_material_rgb.copy(this.model.get('line_material').obj) - this.material_rgb.defines = {USE_RGB: true} - this.line_material.defines = {AS_LINE: true} - this.line_material_rgb.defines = {AS_LINE: true, USE_RGB: true} - this.material.extensions = {derivatives: true} - // locally and the visible with this object's visible trait - this.material.visible = this.material.visible && this.model.get('visible'); - this.material_rgb.visible = this.material.visible && this.model.get('visible'); - this.line_material.visible = this.line_material.visible && this.model.get('visible'); - this.line_material_rgb.visible = this.line_material.visible && this.model.get('visible'); - this.materials.forEach((material) => { - material.vertexShader = require('raw-loader!../glsl/mesh-vertex.glsl'); - material.fragmentShader = require('raw-loader!../glsl/mesh-fragment.glsl'); - material.uniforms = this.uniforms; - material.depthWrite = true; - material.transparant = true; - material.depthTest = true; - }) - var texture = this.model.get('texture'); - if(texture && this.textures) { - this.material.defines['USE_TEXTURE'] = true; - } - this.material.needsUpdate = true; - this.material_rgb.needsUpdate = true; - this.line_material.needsUpdate = true; - this.line_material_rgb.needsUpdate = true; - }, - create_mesh: function() { - /*console.log("previous values: ") - console.log(this.previous_values) - console.log("attributes changed: ") - console.log(this.attributes_changed)*/ - this.meshes = [] - var sequence_index_original, sequence_index_previous_original; - - var sequence_index = sequence_index_original = this.model.get("sequence_index"); - var sequence_index_previous = sequence_index_previous_original = sequence_index; - - if(typeof this.previous_values["sequence_index"] != "undefined") { - sequence_index_previous = sequence_index_previous_original = this.previous_values["sequence_index"] - } - - var time_offset, time_delta; - - if(sequence_index >= sequence_index_previous) { - time_offset = sequence_index_previous - Math.floor(sequence_index_previous) - time_delta = sequence_index - sequence_index_previous - sequence_index = Math.ceil(sequence_index); - sequence_index_previous = Math.floor(sequence_index_previous); - // if we are at integer sequence frame, we can simply interpolate - if((sequence_index_previous != sequence_index_previous_original) || (sequence_index != sequence_index_original)) { - // but when we are not, we should interpolate from the nearest sequence frame to get a proper animation - if((sequence_index - sequence_index_previous) > 1) { - sequence_index_previous = sequence_index - 1; - time_delta = sequence_index_original - sequence_index_previous - time_offset = 0; - } - } - } else { - time_offset = Math.ceil(sequence_index_previous)-sequence_index_previous - time_delta = sequence_index_previous-sequence_index - sequence_index = Math.floor(sequence_index); - sequence_index_previous = Math.ceil(sequence_index_previous); - if((sequence_index_previous != sequence_index_previous_original) || (sequence_index != sequence_index_original)) { - if((sequence_index_previous - sequence_index) > 1) { - sequence_index_previous = sequence_index + 1; - time_offset = 0; - time_delta = sequence_index_previous-sequence_index_original - } - } - } - - if (time_delta > 1) { // we're going over a 'keyframe' border - time_delta = time_delta % 1; - - if(time_delta == 0) { - // special case - time_delta = 1.; - } - } - - if (time_delta == 0) { - // occurs when we don't change keyframes, but just a property - time_delta = 1; - } - //console.log('>>>', sequence_index, sequence_index_previous, time_offset, time_delta) - - var scalar_names = ['x', 'y', 'z', 'u', 'v']; - var vector4_names = ['color']; - - var current = new values.Values(scalar_names, - [], - _.bind(this.get_current, this), - sequence_index, - vector4_names); - var previous = new values.Values(scalar_names, - [], - _.bind(this.get_previous, this), - sequence_index_previous, - vector4_names); - - var length = Math.max(current.length, previous.length) - if(length == 0) { - console.error("no single member is an array, not supported (yet?)") - } - - current.trim(current.length); // make sure all arrays are of equal length - previous.trim(previous.length) - var previous_length = previous.length; - var current_length = current.length; - - if(current.length > previous.length) { // grow.. - previous.pad(current) - } else if(current.length < previous.length) { // shrink.. - current.pad(previous) - } - - - current.merge_to_vec3(['x', 'y', 'z'], 'vertices') - previous.merge_to_vec3(['x', 'y', 'z'], 'vertices') - current.ensure_array(['color']) - previous.ensure_array(['color']) - var triangles = this.model.get('triangles') - if(triangles) { - triangles = triangles[0] - var geometry = new THREE.BufferGeometry(); - geometry.addAttribute('position', new THREE.BufferAttribute(current.array_vec3['vertices'], 3)); - geometry.addAttribute('position_previous', new THREE.BufferAttribute(previous.array_vec3['vertices'], 3)); - geometry.addAttribute('color', new THREE.BufferAttribute(current.array_vec4['color'], 4)); - geometry.addAttribute('color_previous', new THREE.BufferAttribute(previous.array_vec4['color'], 4)); - geometry.setIndex(new THREE.BufferAttribute(triangles, 1)) - var texture = this.model.get('texture'); - var u = current.array['u'] - var v = current.array['v'] - if(texture && u && v && this.textures) { - var sequence_index_texture = sequence_index; - this.material.uniforms['texture'].value = this.textures[sequence_index_texture % this.textures.length]; // TODO/BUG: there could - // be a situation where texture property is modified, but this.textures isn't done yet.. - this.material.uniforms['texture_previous'].value = this.textures[sequence_index_previous % this.textures.length]; - geometry.addAttribute('u', new THREE.BufferAttribute(u, 1)) - geometry.addAttribute('v', new THREE.BufferAttribute(v, 1)) - var u_previous = previous.array['u'] - var v_previous = previous.array['v'] - geometry.addAttribute('u_previous', new THREE.BufferAttribute(u_previous, 1)) - geometry.addAttribute('v_previous', new THREE.BufferAttribute(v_previous, 1)) - } - - this.surface_mesh = new THREE.Mesh(geometry, this.material); - // BUG? because of our custom shader threejs thinks our object if out - // of the frustum - this.surface_mesh.frustumCulled = false; - this.surface_mesh.material_rgb = this.material_rgb; - this.surface_mesh.material_normal = this.material; - this.meshes.push(this.surface_mesh); - } - - var lines = this.model.get('lines'); - if(lines) { - var geometry = new THREE.BufferGeometry(); - - geometry.addAttribute('position', new THREE.BufferAttribute(current.array_vec3['vertices'], 3)) - geometry.addAttribute('position_previous', new THREE.BufferAttribute(previous.array_vec3['vertices'], 3)) - var color = new THREE.BufferAttribute(current.array_vec4['color'], 4); - color.normalized = true; - geometry.addAttribute('color', color) - var color_previous = new THREE.BufferAttribute(previous.array_vec4['color'], 4); - color_previous.normalized = true; - geometry.addAttribute('color_previous', color_previous); - var indices = new Uint32Array(lines[0]); - geometry.setIndex(new THREE.BufferAttribute(indices, 1)); - - this.line_segments = new THREE.LineSegments(geometry, this.line_material); - this.line_segments.frustumCulled = false; - //TODO: check lines with volume rendering, also in scatter - this.line_segments.material_rgb = this.line_material_rgb; - this.line_segments.material_normal = this.line_material; - this.meshes.push(this.line_segments); - } else { - this.line_segments = null; - } - - - _.mapObject(this.attributes_changed, function(changed_properties, key){ - var property = "animation_time_" + key; - //console.log("animating", key) - var done = function done() { - _.each(changed_properties, function clear(prop) { - delete this.previous_values[prop]; // may happen multiple times, that is ok - }, this); - } - // uniforms of material_rgb has a reference to these same object - //this.renderer.transition(this.material.uniforms[property], "value", done, this) - this.renderer.transition(function(value) { - this.material.uniforms[property]['value'] = time_offset + time_delta * value; - }, done, this); - }, this) - this.attributes_changed = {}; - } -}); - -var MeshModel = widgets.WidgetModel.extend({ - defaults: function() { - return _.extend(widgets.WidgetModel.prototype.defaults(), { - _model_name : 'MeshModel', - _view_name : 'MeshView', - _model_module : 'ipyvolume', - _view_module : 'ipyvolume', - _model_module_version: semver_range, - _view_module_version: semver_range, - color: "red", - sequence_index: 0, - connected: false, - visible: true, - visible_lines: true, - visible_faces: true - }) - }}, { - serializers: _.extend({ - x: serialize.array_or_json, - y: serialize.array_or_json, - z: serialize.array_or_json, - u: serialize.array_or_json, - v: serialize.array_or_json, - triangles: serialize.array_or_json, - lines: serialize.array_or_json, - color: serialize.color_or_json, - texture: serialize.texture, - material: { deserialize: widgets.unpack_models }, - line_material: { deserialize: widgets.unpack_models }, - }, widgets.WidgetModel.serializers) -}); - - - -module.exports = { - MeshView:MeshView, - MeshModel:MeshModel -} diff --git a/js/src/mesh.ts b/js/src/mesh.ts new file mode 100644 index 00000000..68c043d3 --- /dev/null +++ b/js/src/mesh.ts @@ -0,0 +1,744 @@ +import * as widgets from "@jupyter-widgets/base"; +import { WidgetModel, WidgetView } from "@jupyter-widgets/base"; +import { isArray, isEqual, isNumber, isString } from "lodash"; +import * as THREE from "three"; +import { FigureView } from "./figure"; +import { MeshDepthMaterialCustom, MeshDistanceMaterialCustom } from "./materials"; +import { createColormap, patchShader, scaleTypeMap } from "./scales"; +import * as serialize from "./serialize.js"; +import { materialToLightingModel, semver_range } from "./utils"; +import * as values from "./values.js"; +import { Object3DView } from "./object3d"; +import { VolumeModel } from "."; + +const shaders = { + "mesh-vertex": (require("raw-loader!../glsl/mesh-vertex.glsl") as any).default, + "mesh-fragment": (require("raw-loader!../glsl/mesh-fragment.glsl") as any).default, +}; + +export +class MeshView extends Object3DView { + figure: FigureView; + previous_values: any; + attributes_changed: any; + meshes: any; + + uniforms: any; + surface_mesh: any; + line_segments: any; + + material: any; + material_rgb: any; + material_id: any; + material_depth: any; + material_distance: any; + line_material: any; + line_material_rgb: any; + line_material_id: any; + materials: any; + scale_defines: {}; + + texture_loader: any; + textures: any; + texture_video: any; + + lighting_model: any; + length = 1; + + render() { + // console.log("created mesh view, parent is") + // console.log(this.options.parent) + + this.figure = this.options.parent; + if(!this.figure) { + throw 'Mesh cannot be displayed, should be added to Figure' + } + this.figure.model.on('change:_shaders', () => { + console.log('updating mesh shader (hot reload)') + this._update_materials(); + }, this); + this.previous_values = {}; + this.attributes_changed = {}; + (window as any).last_mesh_view = this; + this.meshes = []; + this.texture_loader = new THREE.TextureLoader(); + this.textures = null; + if (this.model.get("texture")) { + this._load_textures(); + } + + this.uniforms = { + domain_x: { type: "2f", value: [0., 1.] }, + domain_y: { type: "2f", value: [0., 1.] }, + domain_z: { type: "2f", value: [0., 1.] }, + domain_color: { type: "2f", value: [0., 1.] }, + // tslint:disable-next-line: object-literal-sort-keys + animation_time_x : { type: "f", value: 1. }, + animation_time_y : { type: "f", value: 1. }, + animation_time_z : { type: "f", value: 1. }, + animation_time_u : { type: "f", value: 1. }, + animation_time_v : { type: "f", value: 1. }, + animation_time_color : { type: "f", value: 1. }, + animation_time_texture : { type: "f", value: 1. }, + texture: { type: "t", value: null }, + texture_previous: { type: "t", value: null }, + colormap: {type: "t", value: null}, + id_offset : { type: "f", value: 0 }, + volume_texture: {type: "t", value: null}, + transfer_function: {type: "t", value: null}, + position_offset : { type: "3f", value: [0, 0, 0] }, + volume: {value: null}, + ...THREE.UniformsUtils.merge([THREE.UniformsLib["common"], THREE.UniformsLib["lights"]]) + }; + + const get_material = (name) => { + if (this.model.get(name)) { + return this.model.get(name).obj.clone(); + } else { + const mat = new THREE.ShaderMaterial(); + mat.side = THREE.DoubleSide; + mat.needsUpdate = true; + + return mat; + } + + }; + this.material = get_material("material"); + this.material_rgb = get_material("material"); + this.material_id = get_material("material"); + this.line_material = get_material("line_material"); + this.material.polygonOffset = true; + this.material.polygonOffsetFactor = 1; + this.material.polygonOffsetUnits = 0.1; + // this.material.depthFunc = THREE.LessEqualDepth + this.line_material_rgb = get_material("line_material"); + this.line_material_id = get_material("line_material"); + this.materials = [this.material, this.material_rgb, this.material_id, this.line_material, this.line_material_rgb, this.line_material_id]; + this._update_materials(); + if (this.model.get("material")) { + this.model.get("material").on("change", () => { + this._update_materials(); + }); + } + if (this.model.get("line_material")) { + this.model.get("line_material").on("change", () => { + this._update_materials(); + }); + } + + const update_volume = () => { + this._update_materials(); + } + this.model.on("change:volume", update_volume, this); + + this._update_color_scale(); + this.create_mesh(); + this.add_to_scene(); + + const update_position_offset = () => { + const x = this.model.get("x_offset"); + const y = this.model.get("y_offset"); + const z = this.model.get("z_offset"); + this.uniforms.position_offset.value = [x, y, z]; + this.figure.update(); + } + this.model.on("change:x_offset change:y_offset change:z_offset", update_position_offset); + update_position_offset(); + + this.model.on("change:color change:sequence_index change:x change:y change:z change:v change:u change:triangles change:lines", + this.on_change, this); + this.model.on("change:geo change:connected", this.update_, this); + this.model.on("change:color_scale", this._update_color_scale, this); + this.model.on("change:texture", this._load_textures, this); + this.model.on("change:visible change:lighting_model change:opacity change:material change:cast_shadow change:receive_shadow", this._update_materials, this); + } + + + public _load_textures() { + const texture = this.model.get("texture"); + if (texture.stream) { // instanceof media.MediaStreamModel) { + this.textures = null; + this.texture_video = document.createElement("video"); + texture.stream.then((stream) => { + this.texture_video.srcObject = stream; + this.texture_video.play(); + const threejs_texture = new THREE.VideoTexture(this.texture_video); + // texture.wrapS = THREE.RepeatWrapping; + // texture.wrapT = THREE.RepeatWrapping; + texture.minFilter = THREE.LinearFilter; + // texture.wrapT = THREE.RepeatWrapping; + this.textures = [texture]; + this._update_materials(); + this.update_(); + }); + } else { + this.textures = this.model.get("texture").map((texture_url) => + this.texture_loader.load(texture_url, (threejs_texture) => { + threejs_texture.wrapS = THREE.RepeatWrapping; + threejs_texture.wrapT = THREE.RepeatWrapping; + this._update_materials(); + this.update_(); + }), + ); + } + } + + set_scales(scales) { + const new_scale_defines = {}; + for (const key of Object.keys(scales)) { + this.uniforms[`domain_${key}`].value = scales[key].domain; + new_scale_defines[`SCALE_TYPE_${key}`] = scaleTypeMap[scales[key].type]; + } + if (!isEqual(this.scale_defines, new_scale_defines) ) { + this.scale_defines = new_scale_defines; + this._update_materials(); + } + } + + add_to_scene() { + this.meshes.forEach((mesh) => { + this.figure.rootObject.add(mesh); + }); + } + + update_shadow() { + // TODO: we don't have this yet in scatter (inconsistent) + this.meshes.forEach((mesh) => { + mesh.castShadow = this.model.get("cast_shadow"); + mesh.receiveShadow = this.model.get("receive_shadow"); + }); + } + + remove_from_scene() { + this.meshes.forEach((mesh) => { + this.figure.rootObject.remove(mesh); + mesh.geometry.dispose(); + }); + } + + on_change(attribute) { + for (const key of Object.keys(this.model.changedAttributes())) { + // console.log("changed " +key) + this.previous_values[key] = this.model.previous(key); + // attributes_changed keys will say what needs to be animated, it's values are the properties in + // this.previous_values that need to be removed when the animation is done + // we treat changes in _selected attributes the same + const key_animation = key.replace("_selected", ""); + if (key_animation === "sequence_index") { + const animated_by_sequence = ["x", "y", "z", "u", "v", "color"]; + animated_by_sequence.forEach((name) => { + if (isArray(this.model.get(name)) && this.model.get(name).length > 1) { + this.attributes_changed[name] = [name, "sequence_index"]; + } + }); + this.attributes_changed.texture = ["texture", "sequence_index"]; + } else if (key_animation === "triangles") { + // direct change, no animation + } else if (key_animation === "lines") { + // direct change, no animation + } else if (key_animation === "selected") { // and no explicit animation on this one + this.attributes_changed.color = [key]; + } else { + this.attributes_changed[key_animation] = [key]; + // animate the size as well on x y z changes + if (["x", "y", "z", "u", "v", "color"].indexOf(key_animation) !== -1) { + // console.log("adding size to list of changed attributes") + // this.attributes_changed["size"] = [] + } + } + } + this.update_(); + } + + update_() { + this.remove_from_scene(); + this.create_mesh(); + this.add_to_scene(); + this._update_materials(); + } + + _get_value(value, index, default_value) { + if (!value) { + return default_value; + } + // it is either an array of typed arrays, or a list of numbers coming from the javascript world + if (isArray(value) && !isNumber(value[0])) { + // check whether alpha component was provided or not + const out_index = index % value.length; + const rows = (value as any).original_data[out_index].shape[0]; + const cols = (value as any).original_data[out_index].shape[1]; + + if ((cols === 3) && isNumber(value[out_index][0])) { + // for rbg colors add alphas + const out_length = rows * 4; + const out_value = new Float32Array(out_length); + const temp_value = value[out_index]; + + for (let i = 0; i < rows; i++) { + out_value[i * 4] = temp_value[i * 3]; + out_value[i * 4 + 1] = temp_value[i * 3 + 1]; + out_value[i * 4 + 2] = temp_value[i * 3 + 2]; + out_value[i * 4 + 3] = 1.0; + } + + return out_value; + } else { + // either we have color with alpha or a different format, not the rgb + return value[out_index]; + } + } else { + return value; + } + } + + get_current(name, index, default_value) { + return this._get_value(this.model.get(name), index, default_value); + } + + get_previous(name, index, default_value) { + if (name === "color") { + // special case, if previous color was a string, we don't use the previous + // since we might get NaN values and then the interpolation in the shader will + // always give nan + if (this.previous_values[name] && isString(this.previous_values[name])) { + return this._get_value(this.model.get(name), index, default_value); + } + return this._get_value(this.previous_values[name] || this.model.get(name), index, default_value); + } else { + return this._get_value(this.previous_values[name] || this.model.get(name), index, default_value); + } + } + + _get_value_vec3(value, index, default_value) { + if (!value) { + return default_value; + } + if (isArray(value)) { + return value[index % value.length]; + } else { + return value; + } + } + + get_current_vec3(name, index, default_value) { + return this._get_value_vec3(this.model.get(name), index, default_value); + } + + get_previous_vec3(name, index, default_value) { + return this._get_value_vec3(this.previous_values[name] || this.model.get(name), index, default_value); + } + + _update_color_scale() { + const color_scale_previous = this.model.previous("color_scale"); + const color_scale = this.model.get("color_scale"); + if (color_scale_previous) { + color_scale_previous.off("domain_changed", this._update_color_scale_domain); + color_scale_previous.off("colors_changed", this._update_color_scale_texture); + } + if ((!color_scale_previous && color_scale) || (color_scale_previous && !color_scale_previous)) { + // this will toggle a preprocessor variable + this._update_materials(); + } + if (color_scale) { + color_scale.on("domain_changed", this._update_color_scale_domain, this); + color_scale.on("colors_changed", this._update_color_scale_texture, this); + this._update_color_scale_texture(); + this._update_color_scale_domain(); + this.figure.update(); + } + } + _update_color_scale_texture() { + const color_scale = this.model.get("color_scale"); + this.uniforms.colormap.value = createColormap(color_scale); + this.figure.update(); + } + _update_color_scale_domain() { + const color_scale = this.model.get("color_scale"); + const color = this.model.get("color"); + if (color) { + let min; + let max; + if (color_scale.min !== null) { + min = color_scale.min; + } else { + min = Math.min(...color); + } + if (color_scale.max !== null) { + max = color_scale.max; + } else { + max = Math.max(...color); + } + this.uniforms.domain_color.value = [min, max]; + } else { + if (color_scale.min !== null && color_scale.max !== null) { + this.uniforms.domain_color.value = [color_scale.min, color_scale.max]; + } else { + console.warn("no color set, and color scale does not have a min or max"); + } + + } + this.figure.update(); + } + + _update_materials() { + if (this.model.get("material")) { + this.material.copy(this.model.get("material").obj); + } + if (this.model.get("material")) { + this.material_rgb.copy(this.model.get("material").obj); + } + if (this.model.get("material")) { + this.material_id.copy(this.model.get("material").obj); + } + if (this.model.get("line_material")) { + this.line_material.copy(this.model.get("line_material").obj); + } + if (this.model.get("line_material")) { + this.line_material_rgb.copy(this.model.get("line_material").obj); + } + if (this.model.get("line_material")) { + this.line_material_id.copy(this.model.get("line_material").obj); + } + this.lighting_model = materialToLightingModel(this.material); + // update material defines in order to run correct shader code + this.material.defines = {USE_COLOR: true, USE_COLORMAP: this.model.get("color_scale") !== null, ...this.scale_defines}; + this.material.defines[`AS_${this.lighting_model}`] = true; + this.material.extensions = {derivatives: true}; + this.material_rgb.defines = {AS_COORDINATE: true, USE_COLOR: true, ...this.scale_defines}; + this.material_id.defines = {AS_ID: true, USE_COLOR: true, ...this.scale_defines}; + this.line_material.defines = {IS_LINE: true, ...this.scale_defines}; + this.line_material.defines[`AS_${this.lighting_model}`] = true; + this.line_material_rgb.defines = {IS_LINE: true, AS_COORDINATE: true, USE_COLOR: true, ...this.scale_defines}; + this.line_material_id.defines = {IS_LINE: true, AS_ID: true, USE_COLOR: true, ...this.scale_defines}; + + // locally and the visible with this object's visible trait + this.material.visible = this.material.visible && this.model.get("visible"); + this.material_rgb.visible = this.material.visible && this.model.get("visible"); + this.material_id.visible = this.material.visible && this.model.get("visible"); + this.line_material.visible = this.line_material.visible && this.model.get("visible"); + this.line_material_rgb.visible = this.line_material.visible && this.model.get("visible"); + this.line_material_id.visible = this.line_material.visible && this.model.get("visible"); + + const vertexShader = this.figure.model.get('_shaders')['mesh-vertex'] || shaders['mesh-vertex'] + const fragmentShader = this.figure.model.get('_shaders')['mesh-fragment'] || shaders['mesh-fragment'] + + // + Math.random() * 0.01 to avoid the cache of threejs + // see https://github.com/mrdoob/three.js/pull/17567 + const cache_thrasher = Math.random() * 0.01; + + this.material_depth = new MeshDepthMaterialCustom(() => { + const defines = {...this.material.defines}; + // unset lighting model + delete defines[`AS_${this.lighting_model}`]; + return {AS_DEPTH: true, ...defines}; + }, this.uniforms, vertexShader, fragmentShader, { + depthPacking: THREE.RGBADepthPacking, + alphaTest: 0.5 + cache_thrasher, + }); + + this.material_distance = new MeshDistanceMaterialCustom(() => { + const defines = {...this.material.defines}; + // unset lighting model + delete defines[`AS_${this.lighting_model}`]; + return {AS_DISTANCE: true, ...defines}; + }, this.uniforms, vertexShader, fragmentShader, { + alphaTest: 0.5 + cache_thrasher + }); + + this.materials.forEach((material) => { + material.onBeforeCompile = (shader) => { + shader.vertexShader = patchShader(vertexShader); + shader.fragmentShader = patchShader(fragmentShader); + shader.uniforms = {...shader.uniforms, ...this.uniforms}; + }; + material.alphaTest = 0.5 + cache_thrasher; + material.needsUpdate = true; + material.lights = true; + }); + + this.update_shadow(); + + const texture = this.model.get("texture"); + if (texture && this.textures) { + this.material.defines.USE_TEXTURE = true; + } + const volume = this.model.get("volume") as VolumeModel; + if (volume) { + this.material.defines.USE_VOLUME = true; + this.uniforms.volume_texture.value = volume.texture_volume; + this.uniforms.transfer_function.value = volume.texture_tf; + this.uniforms.volume.value = volume.uniform_volumes_values; + } + this.material.needsUpdate = true; + this.material_rgb.needsUpdate = true; + this.material_id.needsUpdate = true; + this.line_material.needsUpdate = true; + this.line_material_rgb.needsUpdate = true; + this.line_material_id.needsUpdate = true; + if(this.surface_mesh) { + this.surface_mesh.customDepthMaterial = this.material_depth; + this.surface_mesh.customDistanceMaterial = this.material_distance; + } + + this.figure.update(); + } + + create_mesh() { + /*console.log("previous values: ") + console.log(this.previous_values) + console.log("attributes changed: ") + console.log(this.attributes_changed)*/ + this.meshes = []; + let sequence_index_original; + let sequence_index_previous_original; + + let sequence_index = sequence_index_original = this.model.get("sequence_index"); + let sequence_index_previous = sequence_index_previous_original = sequence_index; + + if (typeof this.previous_values.sequence_index !== "undefined") { + sequence_index_previous = sequence_index_previous_original = this.previous_values.sequence_index; + } + + let time_offset; + let time_delta; + + if (sequence_index >= sequence_index_previous) { + time_offset = sequence_index_previous - Math.floor(sequence_index_previous); + time_delta = sequence_index - sequence_index_previous; + sequence_index = Math.ceil(sequence_index); + sequence_index_previous = Math.floor(sequence_index_previous); + // if we are at integer sequence frame, we can simply interpolate + if ((sequence_index_previous !== sequence_index_previous_original) || (sequence_index !== sequence_index_original)) { + // but when we are not, we should interpolate from the nearest sequence frame to get a proper animation + if ((sequence_index - sequence_index_previous) > 1) { + sequence_index_previous = sequence_index - 1; + time_delta = sequence_index_original - sequence_index_previous; + time_offset = 0; + } + } + } else { + time_offset = Math.ceil(sequence_index_previous) - sequence_index_previous; + time_delta = sequence_index_previous - sequence_index; + sequence_index = Math.floor(sequence_index); + sequence_index_previous = Math.ceil(sequence_index_previous); + if ((sequence_index_previous !== sequence_index_previous_original) || (sequence_index !== sequence_index_original)) { + if ((sequence_index_previous - sequence_index) > 1) { + sequence_index_previous = sequence_index + 1; + time_offset = 0; + time_delta = sequence_index_previous - sequence_index_original; + } + } + } + + if (time_delta > 1) { // we're going over a 'keyframe' border + time_delta = time_delta % 1; + + if (time_delta === 0) { + // special case + time_delta = 1.; + } + } + + if (time_delta === 0) { + // occurs when we don't change keyframes, but just a property + time_delta = 1; + } + // console.log('>>>', sequence_index, sequence_index_previous, time_offset, time_delta) + + const scalar_names = ["x", "y", "z", "u", "v"]; + const vector4_names = []; + if (this.model.get("color_scale")) { + scalar_names.push("color"); + } else { + vector4_names.push("color"); + } + + const current = new values.Values(scalar_names, + [], + this.get_current.bind(this), + sequence_index, + vector4_names); + const previous = new values.Values(scalar_names, + [], + this.get_previous.bind(this), + sequence_index_previous, + vector4_names); + + const length = Math.max(current.length, previous.length); + if (length === 0) { + // tslint:disable-next-line: no-console + console.error("no single member is an array, not supported (yet?)"); + } + + current.trim(current.length); // make sure all arrays are of equal length + previous.trim(previous.length); + const previous_length = previous.length; + const current_length = current.length; + + if (current.length > previous.length) { // grow.. + previous.pad(current); + } else if (current.length < previous.length) { // shrink.. + current.pad(previous); + } + + current.merge_to_vec3(["x", "y", "z"], "vertices"); + previous.merge_to_vec3(["x", "y", "z"], "vertices"); + current.ensure_array(["color"]); + previous.ensure_array(["color"]); + let triangles = this.model.get("triangles"); + if (triangles) { + triangles = triangles[0]; + const geometry = new THREE.BufferGeometry(); + geometry.addAttribute("position", new THREE.BufferAttribute(current.array_vec3.vertices, 3)); + geometry.addAttribute("position_previous", new THREE.BufferAttribute(previous.array_vec3.vertices, 3)); + if (this.model.get("color_scale")) { + // TODO: similar as in scatter, we should use previous and next + geometry.addAttribute("color_current", new THREE.BufferAttribute(current.array.color, 1)); + geometry.addAttribute("color_previous", new THREE.BufferAttribute(previous.array.color, 1)); + } else { + geometry.addAttribute("color_current", new THREE.BufferAttribute(current.array_vec4.color, 4)); + geometry.addAttribute("color_previous", new THREE.BufferAttribute(previous.array_vec4.color, 4)); + } + geometry.setIndex(new THREE.BufferAttribute(triangles, 1)); + const texture = this.model.get("texture"); + const u = current.array.u; + const v = current.array.v; + if (texture && u && v && this.textures) { + const sequence_index_texture = sequence_index; + this.uniforms.texture.value = this.textures[sequence_index_texture % this.textures.length]; // TODO/BUG: there could + // be a situation where texture property is modified, but this.textures isn't done yet.. + this.uniforms.texture_previous.value = this.textures[sequence_index_previous % this.textures.length]; + geometry.addAttribute("u", new THREE.BufferAttribute(u, 1)); + geometry.addAttribute("v", new THREE.BufferAttribute(v, 1)); + const u_previous = previous.array.u; + const v_previous = previous.array.v; + geometry.addAttribute("u_previous", new THREE.BufferAttribute(u_previous, 1)); + geometry.addAttribute("v_previous", new THREE.BufferAttribute(v_previous, 1)); + } + geometry.computeVertexNormals(); + + const vertexShader = this.figure.model.get('_shaders')['mesh-vertex'] || shaders['mesh-vertex'] + const fragmentShader = this.figure.model.get('_shaders')['mesh-fragment'] || shaders['mesh-fragment'] + + this.surface_mesh = new THREE.Mesh(geometry, this.material); + this.surface_mesh.name = "Mesh: " + this.model.get("description"); + this.surface_mesh.customDepthMaterial = this.material_depth; + this.surface_mesh.customDistanceMaterial = this.material_distance; + // BUG? because of our custom shader threejs thinks our object if out + // of the frustum + this.surface_mesh.frustumCulled = false; + this.surface_mesh.material_rgb = this.material_rgb; + this.surface_mesh.material_id = this.material_id; + this.surface_mesh.material_normal = this.material; + this.surface_mesh.castShadow = this.model.get("cast_shadow"); + this.surface_mesh.receiveShadow = this.model.get("receive_shadow"); + + this.meshes.push(this.surface_mesh); + } + + const lines = this.model.get("lines"); + if (lines) { + const geometry = new THREE.BufferGeometry(); + + geometry.addAttribute("position", new THREE.BufferAttribute(current.array_vec3.vertices, 3)); + geometry.addAttribute("position_previous", new THREE.BufferAttribute(previous.array_vec3.vertices, 3)); + let color = null; + let color_previous = null; + if (this.model.get("color_scale")) { + color = new THREE.BufferAttribute(current.array.color, 1); + color_previous = new THREE.BufferAttribute(previous.array.color, 1); + } else { + color = new THREE.BufferAttribute(current.array_vec4.color, 4); + color_previous = new THREE.BufferAttribute(previous.array_vec4.color, 4); + } + color.normalized = true; + geometry.addAttribute("color_current", color); + color_previous.normalized = true; + geometry.addAttribute("color_previous", color_previous); + const indices = new Uint32Array(lines[0]); + geometry.setIndex(new THREE.BufferAttribute(indices, 1)); + + this.line_segments = new THREE.LineSegments(geometry, this.line_material); + this.line_segments.name = "Line for Mesh: " + this.model.get("description"); + this.line_segments.frustumCulled = false; + // TODO: check lines with volume rendering, also in scatter + this.line_segments.material_rgb = this.line_material_rgb; + this.line_segments.material_id = this.line_material_id; + this.line_segments.material_normal = this.line_material; + this.meshes.push(this.line_segments); + } else { + this.line_segments = null; + } + this.update_shadow(); + + for (const key of Object.keys(this.attributes_changed)) { + const changed_properties = this.attributes_changed[key]; + const property = "animation_time_" + key; + // console.log("animating", key) + const done = () => { + changed_properties.forEach((prop) => { + delete this.previous_values[prop]; // may happen multiple times, that is ok + }); + }; + // uniforms of material_rgb has a reference to these same object + // this.figure.transition(this.material.uniforms[property], "value", done, this) + this.figure.transition((value) => { + this.uniforms[property].value = time_offset + time_delta * value; + }, done, this); + } + this.attributes_changed = {}; + } +} + +export +class MeshModel extends widgets.WidgetModel { + static serializers = { + ...widgets.WidgetModel.serializers, + x: serialize.array_or_json, + y: serialize.array_or_json, + z: serialize.array_or_json, + u: serialize.array_or_json, + v: serialize.array_or_json, + triangles: serialize.array_or_json, + lines: serialize.array_or_json, + color: serialize.color_or_json, + color_scale: { deserialize: widgets.unpack_models }, + texture: serialize.texture, + volume: { deserialize: widgets.unpack_models }, + material: { deserialize: widgets.unpack_models }, + line_material: { deserialize: widgets.unpack_models }, + popup: { deserialize: widgets.unpack_models }, + }; + defaults() { + return { + ...super.defaults(), + _model_name : "MeshModel", + _view_name : "MeshView", + _model_module : "ipyvolume", + _view_module : "ipyvolume", + _model_module_version: semver_range, + _view_module_version: semver_range, + color: "red", + color_scale: null, + sequence_index: 0, + connected: false, + visible: true, + visible_lines: true, + visible_faces: true, + cast_shadow : true, + receive_shadow : true, + volume: null, + x_offset: 0, + y_offset: 0, + z_offset: 0, + description: 'mesh - noname', + description_color: 'red', + hovered: null, + icon: null, + line_material: null, + material: null, + popup: null, + clicked: null, + }; + } +} diff --git a/js/src/object3d.ts b/js/src/object3d.ts new file mode 100644 index 00000000..1e3d5934 --- /dev/null +++ b/js/src/object3d.ts @@ -0,0 +1,65 @@ +import { WidgetModel, WidgetView } from "@jupyter-widgets/base"; + +export +class Object3DView extends WidgetView { + uniforms: any; + length: number; + popupView: WidgetView; + id_offset: number = 0; + + onHover(id: number) { + const offset = this.uniforms.id_offset.value; + const index = id - offset; + if( (index >= 0) && (index < this.length)) { + this.model.set('hovered_index', index); + this.model.set('hovered', true); + } else { + this.model.set('hovered_index', null); + this.model.set('hovered', false); + } + this.model.save_changes(); + } + + onClick(id: number) { + const offset = this.uniforms.id_offset.value; + const index = id - offset; + if( (index >= 0) && (index < this.length)) { + this.model.set('clicked_index', index); + this.model.set('clicked', true); + } else { + this.model.set('clicked_index', null); + this.model.set('clicked', false); + } + this.model.save_changes(); + } + + async popup(id: number, mouseX, mouseY, el : HTMLDivElement) { + const offset = this.uniforms.id_offset.value; + const index = id - offset; + if( (index >= 0) && (index < this.length)) { + const popupModel = this.model.get('popup') as WidgetModel; + if(popupModel) { + if(!this.popupView) { + this.popupView = await this.options.parent.create_child_view(popupModel); + } + if(!el.contains(this.popupView.el)) { + el.innerHTML = ''; + el.appendChild(this.popupView.el); + } + this.popupView.trigger('displayed'); + popupModel.set('description', this.model.get('description')); + popupModel.set('value', index); + + // TODO: we could get the color for this specific index + popupModel.set('color', this.model.get('description_color')); + popupModel.set('icon', this.model.get('icon')); + popupModel.save_changes(); + } + } else { + // while debugging, comment out the bottom lines so the popup stays + if(this.popupView && el.contains(this.popupView.el)) { + el.innerHTML = ''; + } + } + } +} \ No newline at end of file diff --git a/js/src/scales.ts b/js/src/scales.ts new file mode 100644 index 00000000..3ba14f03 --- /dev/null +++ b/js/src/scales.ts @@ -0,0 +1,70 @@ +import * as d3 from "d3"; +import { range } from "lodash"; +import { Material, ShaderMaterial } from "three"; + +// We also do this in bqplot, does that make sense? +// tslint:disable-next-line: no-var-requires +const shader_scales = (require("raw-loader!../glsl/scales.glsl") as any).default; +const shader_ipyvolume = (require("raw-loader!../glsl/ipyvolume.glsl") as any).default; +const shader_scales_mod = (require("raw-loader!../glsl/scales.glsl") as any); + +export +const scaleTypeMap = { + linear: 1, + log: 2, +}; + +export +function patchMaterial(material: any) { + material.onBeforeCompile = (shader) => { + shader.vertexShader = patchShader(shader.vertexShader); + shader.fragmentShader = patchShader(shader.fragmentShader); + }; +} + +export +function patchShader(shader: string) : string { + return shader.replace( + "#include ", + shader_scales, + ).replace( + "#include ", + shader_ipyvolume, + ); +} + +export +function createD3Scale(scale) { + if (scale.type === "linear") { + return d3.scaleLinear().domain(scale.domain); + } else if (scale.type === "log") { + return d3.scaleLog().domain(scale.domain); + } else { + throw new Error("Scale not supported: " + scale); + } +} + +export +function createColormap(scale) { + // convert the d3 color scale to a texture + const colors = scale ? scale.color_range : ["#ff0000", "#ff0000"]; + const color_scale = d3.scaleLinear() + .range(colors) + .domain(range(colors.length).map((i) => i / (colors.length - 1))); + const colormap_array = []; + const N = 256; + for (let i = 0; i < N; i++) { + const index = i / (N - 1); + const rgb = d3.color(String(color_scale(index))).hex(); + const rgb_str = String(rgb); + const rgb_arr = [parseInt("0x" + rgb_str.substring(1, 3), 16), + parseInt("0x" + rgb_str.substring(3, 5), 16), + parseInt("0x" + rgb_str.substring(5, 7), 16)]; + colormap_array.push(rgb_arr[0], rgb_arr[1], rgb_arr[2]); + } + const colormap_arr = new Uint8Array(colormap_array); + const colormap_texture = new THREE.DataTexture(colormap_arr, N, 1, THREE.RGBFormat, THREE.UnsignedByteType); + colormap_texture.needsUpdate = true; + + return colormap_texture; +} diff --git a/js/src/scatter.js b/js/src/scatter.js deleted file mode 100644 index 252d4e24..00000000 --- a/js/src/scatter.js +++ /dev/null @@ -1,446 +0,0 @@ -var _ = require('underscore'); -var widgets = require('@jupyter-widgets/base'); -var THREE = require('three'); -var serialize = require('./serialize.js'); -var values = require('./values.js'); -var semver_range = require('./utils.js').semver_range; -var cat_data = require("../data/cat.json"); - -var ScatterView = widgets.WidgetView.extend( { - render: function() { - this.renderer = this.options.parent; - this.previous_values = {} - this.attributes_changed = {} - window.last_scatter = this; - - this.texture_loader = new THREE.TextureLoader() - this.textures = null; - if(this.model.get('texture')) { - this._load_textures() - } - - this.geo_diamond = new THREE.SphereGeometry(1, 2, 2) - this.geo_sphere = new THREE.SphereGeometry(0.5, 12, 12) - this.geo_box = new THREE.BoxGeometry(1, 1, 1) - this.geo_cat = new THREE.Geometry() - for(var i = 0; i < cat_data.vertices.length; i++) { - var v = new THREE.Vector3( cat_data.vertices[i][1], cat_data.vertices[i][2], cat_data.vertices[i][0]); - this.geo_cat.vertices.push(v) - } - var i = 0; - while(i < cat_data.indices.length ) { - var indices = [] - var start = i; - var length = 0; - var done = false; - while(!done) { - indices.push(cat_data.indices[i]) - length++; - if(cat_data.indices[i] < 0) - done = true - i++; - } - indices[length-1] = -1-indices[length-1];// indicates end, so swap sign - for(var j = 0; j < indices.length-2; j++) { - //for(var j = 0; j < 1; j++) { - var face = new THREE.Face3( indices[0], indices[1+j], indices[2+j]) - this.geo_cat.faces.push(face) - } - } - this.geo_square_2d = new THREE.PlaneGeometry(2, 2, 1, 1) - this.geo_point_2d = new THREE.PlaneGeometry(0.1, 0.1, 1, 1) - this.geo_triangle_2d = new THREE.CircleGeometry(1, 3, Math.PI/2); - this.geo_circle_2d = new THREE.CircleGeometry(1, 32, Math.PI/2); - - //this.geo = new THREE.ConeGeometry(0.2, 1) - this.geo_arrow = new THREE.CylinderGeometry(0, 0.2, 1) - this.geos = { - diamond: this.geo_diamond, - box: this.geo_box, - arrow: this.geo_arrow, - sphere: this.geo_sphere, - cat: this.geo_cat, - square_2d: this.geo_square_2d, - point_2d: this.geo_point_2d, - circle_2d: this.geo_circle_2d, - triangle_2d: this.geo_triangle_2d - } - - this.uniforms = { - xlim : { type: "2f", value: [0., 1.] }, - ylim : { type: "2f", value: [0., 1.] }, - zlim : { type: "2f", value: [0., 1.] }, - animation_time_x : { type: "f", value: 1. }, - animation_time_y : { type: "f", value: 1. }, - animation_time_z : { type: "f", value: 1. }, - animation_time_vx : { type: "f", value: 1. }, - animation_time_vy : { type: "f", value: 1. }, - animation_time_vz : { type: "f", value: 1. }, - animation_time_size : { type: "f", value: 1. }, - animation_time_color : { type: "f", value: 1. }, - texture: { type: 't', value: null }, - texture_previous: { type: 't', value: null }, - }; - let get_material = (attr_name) => { - if(this.model.get('material')) - return this.model.get('material').obj.clone() - else - return new THREE.ShaderMaterial(); - } - this.material = get_material('material') - this.material_rgb = get_material('material') - this.line_material = get_material('line_material') - this.line_material_rgb = get_material('line_material') - this.materials = [this.material, this.material_rgb, this.line_material, this.line_material_rgb] - this._update_materials() - if(this.model.get('material')) { - this.model.get('material').on('change', () => { - this._update_materials() - this.renderer.update() - }) - } - if(this.model.get('line_material')) { - this.model.get('line_material').on('change', () => { - this._update_materials() - this.renderer.update() - }) - } - - this.create_mesh() - this.add_to_scene() - this.model.on("change:size change:size_selected change:color change:color_selected change:sequence_index change:x change:y change:z change:selected change:vx change:vy change:vz", this.on_change, this) - this.model.on("change:geo change:connected", this.update_, this) - this.model.on("change:texture", this._load_textures, this) - this.model.on("change:visible", this.update_visibility, this) - this.model.on("change:geo", () => { - this._update_materials() - this.renderer.update() - }) - }, - _load_textures: function() { - var texture = this.model.get('texture'); - if(texture.stream) { // instanceof media.MediaStreamModel) { - this.textures = null - this.texture_video = document.createElement('video') - texture.stream.then(_.bind(function(stream) { - this.texture_video.src = window.URL.createObjectURL(stream); - var texture = new THREE.VideoTexture(this.texture_video) - //texture.wrapS = THREE.RepeatWrapping; - //texture.wrapT = THREE.RepeatWrapping; - texture.minFilter = THREE.LinearFilter; - //texture.wrapT = THREE.RepeatWrapping; - this.textures = [texture]; - this.update_() - }, this)) - } else { - this.textures = _.map(this.model.get('texture'), function(texture_url) { - return this.texture_loader.load(texture_url, _.bind(function(texture) { - texture.wrapS = THREE.RepeatWrapping; - texture.wrapT = THREE.RepeatWrapping; - this.update_() - }, this)); - }, this) - } - }, - update_visibility: function () { - this._update_materials() - this.renderer.update() - }, - set_limits: function(limits) { - _.mapObject(limits, function(value, key) { - this.material.uniforms[key].value = value - }, this) - }, - add_to_scene: function() { - this.renderer.scene_scatter.add(this.mesh) - if(this.line_segments) { - this.renderer.scene_scatter.add(this.line_segments) - } - }, - remove_from_scene: function() { - if(this.renderer.scene_scatter.children.indexOf(this.mesh) == -1) { - console.warn('trying to removing scatter mesh from scene that does not include it'); - } - this.renderer.scene_scatter.remove(this.mesh) - this.mesh.geometry.dispose() - if(this.line_segments) { - this.renderer.scene_scatter.remove(this.line_segments) - this.line_segments.geometry.dispose() - } - }, - on_change: function(attribute) { - _.mapObject(this.model.changedAttributes(), function(val, key){ - this.previous_values[key] = this.model.previous(key) - // attributes_changed keys will say what needs to be animated, it's values are the properties in - // this.previous_values that need to be removed when the animation is done - // we treat changes in _selected attributes the same - var key_animation = key.replace("_selected", "") - if (key_animation == "sequence_index") { - var animated_by_sequence = ['x', 'y', 'z', 'vx', 'vy', 'vz', 'size', 'color'] - _.each(animated_by_sequence, function(name) { - if(_.isArray(this.model.get(name))) { - this.attributes_changed[name] = [name, 'sequence_index'] - } - }, this) - } - else if(key_animation == "geo") { - // direct change, no animation - } - else if(key_animation == "selected") { // and no explicit animation on this one - this.attributes_changed["color"] = [key] - this.attributes_changed["size"] = [] - } else { - this.attributes_changed[key_animation] = [key] - // animate the size as well on x y z changes - if(["x", "y", "z", "vx", "vy", "vz", 'color'].indexOf(key_animation) != -1) { - //console.log("adding size to list of changed attributes") - this.attributes_changed["size"] = [] - } - - } - }, this) - this.update_() - }, - update_: function() { - this.remove_from_scene() - this.create_mesh() - this.add_to_scene() - this.renderer.update() - }, - _get_value: function(value, index, default_value) { - var default_value = default_value; - if(!value) - return default_value - // it is either an array of typed arrays, or a list of numbers coming from the javascript world - if(_.isArray(value) && !_.isNumber(value[0])) - return value[index % value.length] - else - return value - }, - get_current: function(name, index, default_value) { - return this._get_value(this.model.get(name), index, default_value) - }, - get_previous: function(name, index, default_value) { - return this._get_value(this.previous_values[name] || this.model.get(name), index, default_value) - }, - _get_value_vec3: function(value, index, default_value) { - var default_value = default_value; - if(!value) - return default_value - if(_.isArray(value)) - return value[index % value.length] - else - return value - }, - get_current_vec3: function(name, index, default_value) { - return this._get_value_vec3(this.model.get(name), index, default_value) - }, - get_previous_vec3: function(name, index, default_value) { - return this._get_value_vec3(this.previous_values[name] || this.model.get(name), index, default_value) - }, - _update_materials: function() { - if(this.model.get('material')) - this.material.copy(this.model.get('material').obj) - if(this.model.get('material')) - this.material_rgb.copy(this.model.get('material').obj) - if(this.model.get('line_material')) - this.line_material.copy(this.model.get('line_material').obj) - if(this.model.get('line_material')) { - this.line_material_rgb.copy(this.model.get('line_material').obj) - // not present on .copy.. bug? - this.line_material_rgb.linewidth = this.line_material.linewidth = this.model.get('line_material').obj.linewidth - } - this.material.extensions = {derivatives: true} - this.material_rgb.defines = {USE_RGB: true} - this.material_rgb.extensions = {derivatives: true} - this.line_material.defines = {AS_LINE: true} - this.line_material_rgb.defines = {USE_RGB: true, AS_LINE: true} - // locally and the visible with this object's visible trait - this.material.visible = this.material.visible && this.model.get('visible'); - this.material_rgb.visible = this.material.visible && this.model.get('visible'); - this.line_material.visible = this.line_material.visible && this.model.get('visible'); - this.line_material_rgb.visible = this.line_material.visible && this.model.get('visible'); - this.materials.forEach((material) => { - material.vertexShader = require('raw-loader!../glsl/scatter-vertex.glsl'); - material.fragmentShader = require('raw-loader!../glsl/scatter-fragment.glsl'); - material.uniforms = _.extend({}, material.uniforms, this.uniforms); - material.depthWrite = true; - material.transparant = true; - material.depthTest = true; - material.needsUpdate = true; - }) - var geo = this.model.get("geo") - var sprite = geo.endsWith('2d'); - if(sprite) { - this.material.defines['USE_SPRITE'] = true; - this.material_rgb.defines['USE_SPRITE'] = true; - } - if (sprite){ - var texture = this.model.get('texture'); - if(texture && this.textures) { - this.material.defines['USE_TEXTURE'] = true; - } - } - this.material.needsUpdate = true; - this.material_rgb.needsUpdate = true; - this.line_material.needsUpdate = true; - this.line_material_rgb.needsUpdate = true; - }, - create_mesh: function() { - var geo = this.model.get("geo") - //console.log(geo) - if(!geo) - geo = "diamond" - var sprite = geo.endsWith('2d'); - var buffer_geo = new THREE.BufferGeometry().fromGeometry(this.geos[geo]); - var instanced_geo = new THREE.InstancedBufferGeometry(); - - var vertices = buffer_geo.attributes.position.clone(); - instanced_geo.addAttribute('position', vertices); - - var sequence_index = this.model.get("sequence_index"); - var sequence_index_previous = this.previous_values["sequence_index"] - if(typeof sequence_index_previous == "undefined") - sequence_index_previous = sequence_index; - - var scalar_names = ['x', 'y', 'z', 'vx', 'vy', 'vz', 'size', 'size_selected']; - var vector4_names = ['color', 'color_selected']; - var current = new values.Values(scalar_names, [], _.bind(this.get_current, this), sequence_index, vector4_names); - var previous = new values.Values(scalar_names, [], _.bind(this.get_previous, this), sequence_index_previous, vector4_names); - - var length = Math.max(current.length, previous.length) - if(length == 0) { - console.error("no single member is an array, not supported (yet?)") - } - - - current.trim(current.length); // make sure all arrays are of equal length - previous.trim(previous.length) - var previous_length = previous.length; - var current_length = current.length; - if(this.model.get("selected") || this.previous_values["selected"]) { - // upgrade size and size_previous to an array if they were not already - current.ensure_array(['size', 'size_selected', 'color', 'color_selected']) - previous.ensure_array(['size', 'size_selected', 'color', 'color_selected']) - var selected = this.get_current('selected', sequence_index, []); - current.select(selected) - var selected = this.get_previous('selected', sequence_index_previous, []); - previous.select(selected) - } - // if we have a change in length, we use size to fade in/out particles, so make sure they are arrays - if(current.length != previous.length) { - current.ensure_array('size') - previous.ensure_array('size') - } - if(current.length > previous.length) { // grow.. - previous.pad(current) - previous.array['size'].fill(0, previous_length); // this will make them smoothly fade in - } else if(current.length < previous.length) { // shrink.. - current.pad(previous) - current.array['size'].fill(0, current_length); // this will make them smoothly fade out - } - // we are only guaranteed to have 16 attributes for the shader, so better merge some into single vectors - current.merge_to_vec3(['vx', 'vy', 'vz'], 'v') - previous.merge_to_vec3(['vx', 'vy', 'vz'], 'v') - - // we don't want to send these to the shader, these are handled at the js side - current.pop(['size_selected', 'color_selected']) - previous.pop(['size_selected', 'color_selected']) - - // add atrributes to the geometry, this makes the available to the shader - current.add_attributes(instanced_geo) - previous.add_attributes(instanced_geo, '_previous') - if (sprite){ - var texture = this.model.get('texture'); - if(texture && this.textures) { - // TODO: this should prolly go into _update_materiuals - this.material.uniforms['texture'].value = this.textures[sequence_index % this.textures.length]; // TODO/BUG: there could - this.material.uniforms['texture_previous'].value = this.textures[sequence_index_previous % this.textures.length]; - } - } - this.mesh = new THREE.Mesh(instanced_geo, this.material); - this.mesh.material_rgb = this.material_rgb - this.mesh.material_normal = this.material - - - if(this.model.get('connected')) { - var geometry = new THREE.BufferGeometry(); - - current.merge_to_vec3(['x', 'y', 'z'], 'vertices') - previous.merge_to_vec3(['x', 'y', 'z'], 'vertices') - geometry.addAttribute('position', new THREE.BufferAttribute(current.array_vec3['vertices'], 3)) - geometry.addAttribute('position_previous', new THREE.BufferAttribute(previous.array_vec3['vertices'], 3)) - - current.ensure_array(['color']) - previous.ensure_array(['color']) - geometry.addAttribute('color', new THREE.BufferAttribute(current.array_vec4['color'], 4)) - geometry.addAttribute('color_previous', new THREE.BufferAttribute(previous.array_vec4['color'], 4)) - - this.line_segments = new THREE.Line(geometry, this.line_material); - this.line_segments.frustumCulled = false; - } else { - this.line_segments = null; - } - - _.mapObject(this.attributes_changed, function(changed_properties, key){ - var property = "animation_time_" + key - //console.log("animating", key) - var done = function done() { - _.each(changed_properties, function clear(prop) { - delete this.previous_values[prop] // may happen multiple times, that is ok - }, this) - } - // uniforms of material_rgb has a reference to these same object - var set = function(value) { - this.material.uniforms[property]['value'] = value - } - this.renderer.transition(set, done, this) - }, this) - this.attributes_changed = {} - } -}); - -var ScatterModel = widgets.WidgetModel.extend({ - defaults: function() { - return _.extend(widgets.WidgetModel.prototype.defaults(), { - _model_name : 'ScatterModel', - _view_name : 'ScatterView', - _model_module : 'ipyvolume', - _view_module : 'ipyvolume', - _model_module_version: semver_range, - _view_module_version: semver_range, - size: 5, - size_selected: 7, - color: "red", - color_selected: "white", - geo: 'diamond', - sequence_index: 0, - connected: false, - visible: true, - selected: null, - }) - }}, { - serializers: _.extend({ - x: serialize.array_or_json, - y: serialize.array_or_json, - z: serialize.array_or_json, - vx: serialize.array_or_json, - vy: serialize.array_or_json, - vz: serialize.array_or_json, - selected: serialize.array_or_json, - size: serialize.array_or_json, - size_selected: serialize.array_or_json, - color: serialize.color_or_json, - color_selected: serialize.color_or_json, - texture: serialize.texture, - material: { deserialize: widgets.unpack_models }, - line_material: { deserialize: widgets.unpack_models }, - }, widgets.WidgetModel.serializers) -}); - - - -module.exports = { - ScatterView:ScatterView, - ScatterModel:ScatterModel -} diff --git a/js/src/scatter.ts b/js/src/scatter.ts new file mode 100644 index 00000000..9ba590fb --- /dev/null +++ b/js/src/scatter.ts @@ -0,0 +1,742 @@ +import * as widgets from "@jupyter-widgets/base"; +import { WidgetModel, WidgetView } from "@jupyter-widgets/base"; +import { isArray, isEqual, isNumber } from "lodash"; +import * as THREE from "three"; +import { MeshDepthMaterialCustom, MeshDistanceMaterialCustom } from "./materials"; +import { Object3DView } from "./object3d"; +import { createColormap, patchShader, scaleTypeMap } from "./scales"; +import * as serialize from "./serialize.js"; +import { materialToLightingModel, semver_range } from "./utils"; +import * as values from "./values.js"; +// tslint:disable-next-line: no-var-requires +const cat_data = require("../data/cat.json"); + +const shaders = { + "scatter-vertex": (require("raw-loader!../glsl/scatter-vertex.glsl") as any).default, + "scatter-fragment": (require("raw-loader!../glsl/scatter-fragment.glsl") as any).default, +}; + +export +class ScatterView extends Object3DView { + figure: any; + previous_values: {color?: any, size?: any, sequence_index?: any, selected?: any}; + attributes_changed: {color?: any, size?: any, sequence_index?: any, selected?: any}; + scale_defines: {}; + texture_loader: THREE.TextureLoader; + textures: any; + geos: { diamond: THREE.BufferGeometry; box: THREE.BufferGeometry; arrow: THREE.BufferGeometry; + cylinder: THREE.BufferGeometry; cylinder_hr: THREE.BufferGeometry; sphere: THREE.SphereBufferGeometry; + cat: THREE.BufferGeometry; square_2d: THREE.BufferGeometry; point_2d: THREE.BufferGeometry; circle_2d: THREE.BufferGeometry; + triangle_2d: THREE.BufferGeometry; }; + material: any; + material_id: any; + material_rgb: any; + material_depth: any; + material_distance: any; + line_material: any; + line_material_rgb: any; + line_material_id: any; + materials: any[]; + texture_video: HTMLVideoElement; + line_segments: any; + mesh: any; + lighting_model : any; + popupView: WidgetView; + + render() { + + this.figure = this.options.parent; + + this.figure = this.options.parent; + if(!this.figure) { + throw 'Scatter cannot be displayed, should be added to Figure' + } + this.figure.model.on('change:_shaders', () => { + console.log('updating scatter shader (hot reload)') + this._update_materials(); + }, this); + + this.previous_values = {}; + this.attributes_changed = {}; + (window as any).last_scatter = this; + + this.texture_loader = new THREE.TextureLoader(); + this.textures = null; + if (this.model.get("texture")) { + this._load_textures(); + } + + const geo_diamond = new THREE.SphereGeometry(1, 2, 2); + const geo_sphere = new THREE.SphereBufferGeometry(0.5, 12, 12); + const geo_box = new THREE.BoxGeometry(1, 1, 1); + const geo_cat = new THREE.Geometry(); + for (const vertex of cat_data.vertices) { + const v = new THREE.Vector3( vertex[1], vertex[2], vertex[0]); + geo_cat.vertices.push(v); + } + let i = 0; + while (i < cat_data.indices.length ) { + const indices = []; + let length = 0; + let done = false; + while (!done) { + indices.push(cat_data.indices[i]); + length++; + if (cat_data.indices[i] < 0) { + done = true; + } + i++; + } + indices[length - 1] = -1 - indices[length - 1]; // indicates end, so swap sign + for (let j = 0; j < indices.length - 2; j++) { + // for(var j = 0; j < 1; j++) { + const face = new THREE.Face3( indices[0], indices[1 + j], indices[2 + j]); + geo_cat.faces.push(face); + } + } + const geo_square_2d = new THREE.PlaneGeometry(2, 2, 1, 1); + const geo_point_2d = new THREE.PlaneGeometry(0.1, 0.1, 1, 1); + const geo_triangle_2d = new THREE.CircleGeometry(1, 3, Math.PI / 2); + const geo_circle_2d = new THREE.CircleGeometry(1, 32, Math.PI / 2); + + // this.geo = new THREE.ConeGeometry(0.2, 1) + const geo_arrow = new THREE.CylinderBufferGeometry(0, 0.2, 1); + const geo_cylinder = new THREE.CylinderGeometry(0.5, 0.5, 1.0); + const geo_cylinder_hr = new THREE.CylinderGeometry(0.5, 0.5, 1.0, 100); + this.geos = { + diamond: new THREE.BufferGeometry().fromGeometry(geo_diamond), + box: new THREE.BufferGeometry().fromGeometry(geo_box), + arrow: geo_arrow, + cylinder: new THREE.BufferGeometry().fromGeometry(geo_cylinder), + cylinder_hr: new THREE.BufferGeometry().fromGeometry(geo_cylinder_hr), + sphere: geo_sphere, + cat: new THREE.BufferGeometry().fromGeometry(geo_cat), + square_2d: new THREE.BufferGeometry().fromGeometry(geo_square_2d), + point_2d: new THREE.BufferGeometry().fromGeometry(geo_point_2d), + circle_2d: new THREE.BufferGeometry().fromGeometry(geo_circle_2d), + triangle_2d: new THREE.BufferGeometry().fromGeometry(geo_triangle_2d), + }; + + this.uniforms = { + domain_x : { type: "2f", value: [0., 1.] }, + domain_y : { type: "2f", value: [0., 1.] }, + domain_z : { type: "2f", value: [0., 1.] }, + domain_size_x : { type: "2f", value: [0., 1.] }, + domain_size_y : { type: "2f", value: [0., 1.] }, + domain_size_z : { type: "2f", value: [0., 1.] }, + domain_aux : { type: "2f", value: [0., 1.] }, + domain_color : { type: "2f", value: [0., 1.] }, + animation_time_x : { type: "f", value: 1. }, + animation_time_y : { type: "f", value: 1. }, + animation_time_z : { type: "f", value: 1. }, + animation_time_aux : { type: "f", value: 1. }, + animation_time_vx : { type: "f", value: 1. }, + animation_time_vy : { type: "f", value: 1. }, + animation_time_vz : { type: "f", value: 1. }, + animation_time_size : { type: "f", value: 1. }, + animation_time_color : { type: "f", value: 1. }, + geo_matrix : { type: "mat4", value: this.model.get('geo_matrix')}, + // if our bounding box has a non unity aspect, we need to correct the scatter glyphs + aspect : { type: "vec3", value: [ 1, 1, 1]}, + texture: { type: "t", value: null }, + texture_previous: { type: "t", value: null }, + colormap: {type: "t", value: null}, + id_offset : { type: "f", value: 0 }, + ...THREE.UniformsUtils.merge([THREE.UniformsLib["common"], THREE.UniformsLib["lights"]]) + }; + const get_material = (name) => { + if (this.model.get(name)) { + return this.model.get(name).obj.clone(); + } else { + return new THREE.ShaderMaterial(); + } + }; + this.material = get_material("material"); + this.material_rgb = get_material("material"); + this.material_id = get_material("material"); + this.line_material = get_material("line_material"); + this.line_material_rgb = get_material("line_material"); + this.line_material_id = get_material("line_material"); + this.materials = [this.material, this.material_id, this.material_rgb, this.line_material, this.line_material_id, this.line_material_rgb]; + + this._update_materials(); + if (this.model.get("material")) { + this.model.get("material").on("change", () => { + this._update_materials(); + }); + } + if (this.model.get("line_material")) { + this.model.get("line_material").on("change", () => { + this._update_materials(); + }); + } + this.model.on("change:geo_matrix", () => { + this.uniforms.geo_matrix.value = this.model.get('geo_matrix'); + this._update_materials(); + this.figure.update(); + }); + this.model.on("change:shader_snippets", () => { + this._update_materials(); + this.figure.update(); + }); + + this._update_color_scale(); + this.create_mesh(); + this.add_to_scene(); + this.model.on("change:size change:size_selected change:color change:color_selected change:sequence_index change:x change:y change:z change:aux change:selected change:vx change:vy change:vz", + this.on_change, this); + this.model.on("change:geo change:connected", this.update_, this); + this.model.on("change:color_scale", this._update_color_scale, this); + this.model.on("change:texture", this._load_textures, this); + this.model.on("change:visible", this._update_materials, this); + this.model.on("change:geo", () => { + this._update_materials(); + }); + const update_scale = (name) => { + const scale_name = name + "_scale"; + const uniform_name = "domain_" + name; + const update_scale_domain = () => { + const scale = this.model.get(scale_name); + let min = 0; + let max = 100; + if (scale) { + if (scale.min !== null) { + min = scale.min; + } + if (scale.max !== null) { + max = scale.max; + } + } + this.uniforms[uniform_name].value = [min, max]; + if(this.mesh) { + this.figure.update(); + } + } + update_scale_domain(); + return () => { + const scale_previous = this.model.previous(scale_name); + const scale = this.model.get(scale_name); + if (scale_previous) { + scale_previous.off("domain_changed", update_scale_domain); + } + const new_scale_defines = {...this.scale_defines}; + // if no scale, default to linear + new_scale_defines[`SCALE_TYPE_${name}`] = scaleTypeMap[scale ? scale.type : 'linear']; + const scale_types_changed = !isEqual(this.scale_defines, new_scale_defines); + this.scale_defines = new_scale_defines; + if ((!scale_previous && scale) || (scale_previous && !scale_previous) || scale_types_changed) { + // this will toggle a preprocessor variable + this._update_materials(); + } + if (scale) { + scale.on("domain_changed", update_scale_domain, this); + update_scale_domain(); + this.figure.update(); + } + // if (this.mesh) { // we don't need to do so on initialization + // this.update_(); + // } + } + } + ["size_x", "size_y", "size_z", "aux"].forEach((name) => { + const updater = update_scale(name); + updater(); + this.model.on(`change:${name}_scale`, updater, this); + }); + + this.model.on("change:material", this._update_materials, this); + this.model.on("change:cast_shadow change:receive_shadow", this.update_, this); + } + + _load_textures() { + const texture = this.model.get("texture"); + if (texture.stream) { // instanceof media.MediaStreamModel) { + this.textures = null; + this.texture_video = document.createElement("video"); + texture.stream.then((stream) => { + this.texture_video.src = window.URL.createObjectURL(stream); + const threejs_texture = new THREE.VideoTexture(this.texture_video); + // texture.wrapS = THREE.RepeatWrapping; + // texture.wrapT = THREE.RepeatWrapping; + threejs_texture.minFilter = THREE.LinearFilter; + // texture.wrapT = THREE.RepeatWrapping; + this.textures = [texture]; + this.update_(); + }); + } else { + this.textures = this.model.get("texture").map((texture_url) => + this.texture_loader.load(texture_url, (threejs_texture) => { + threejs_texture.wrapS = THREE.RepeatWrapping; + threejs_texture.wrapT = THREE.RepeatWrapping; + this.update_(); + }), + ); + } + } + + set_scales(scales) { + const new_scale_defines = {...this.scale_defines}; + for (const key of Object.keys(scales)) { + this.uniforms[`domain_${key}`].value = scales[key].domain; + new_scale_defines[`SCALE_TYPE_${key}`] = scaleTypeMap[scales[key].type]; + } + if (!isEqual(this.scale_defines, new_scale_defines) ) { + this.scale_defines = new_scale_defines; + this._update_materials(); + } + } + add_to_scene() { + this.figure.rootObject.add(this.mesh); + if (this.line_segments) { + this.figure.rootObject.add(this.line_segments); + } + } + remove_from_scene() { + if (this.figure.rootObject.children.indexOf(this.mesh) === -1) { + console.warn("trying to removing scatter mesh from scene that does not include it"); + } + this.figure.rootObject.remove(this.mesh); + this.mesh.geometry.dispose(); + if (this.line_segments) { + this.figure.rootObject.remove(this.line_segments); + this.line_segments.geometry.dispose(); + } + } + on_change() { + for (const key of Object.keys(this.model.changedAttributes())) { + this.previous_values[key] = this.model.previous(key); + // attributes_changed keys will say what needs to be animated, it's values are the properties in + // this.previous_values that need to be removed when the animation is done + // we treat changes in _selected attributes the same + const key_animation = key.replace("_selected", ""); + if (key_animation === "sequence_index") { + const animated_by_sequence = ["x", "y", "z", "aux", "vx", "vy", "vz", "size", "color"]; + animated_by_sequence.forEach((name) => { + if (isArray(this.model.get(name))) { + this.attributes_changed[name] = [name, "sequence_index"]; + } + }); + } else if (key_animation === "geo") { + // direct change, no animation + } else if (key_animation === "selected") { // and no explicit animation on this one + this.attributes_changed.color = [key]; + this.attributes_changed.size = []; + } else { + this.attributes_changed[key_animation] = [key]; + // animate the size as well on x y z changes + if (["x", "y", "z", "aux", "vx", "vy", "vz", "color"].indexOf(key_animation) !== -1) { + // console.log("adding size to list of changed attributes") + this.attributes_changed.size = []; + } + + } + } + this.update_(); + } + update_() { + this.remove_from_scene(); + this.create_mesh(); + this.add_to_scene(); + this.figure.update(); + } + _get_value(value, index, default_value) { + if (!value) { + return default_value; + } + // it is either an array of typed arrays, or a list of numbers coming from the javascript world + if (isArray(value) && !isNumber(value[0])) { + return value[index % value.length]; + } else { + return value; + } + } + get_next(name, index, default_value) { + return this._get_value(this.model.get(name), index, default_value); + } + get_previous(name, index, default_value) { + return this._get_value(this.previous_values[name] || this.model.get(name), index, default_value); + } + _get_value_vec3(value, index, default_value) { + if (!value) { + return default_value; + } + if (isArray(value)) { + return value[index % value.length]; + } else { + return value; + } + } + get_next_vec3(name, index, default_value) { + return this._get_value_vec3(this.model.get(name), index, default_value); + } + get_previous_vec3(name, index, default_value) { + return this._get_value_vec3(this.previous_values[name] || this.model.get(name), index, default_value); + } + _update_color_scale() { + const color_scale_previous = this.model.previous("color_scale"); + const color_scale = this.model.get("color_scale"); + if (color_scale_previous) { + color_scale_previous.off("domain_changed", this._update_color_scale_domain); + color_scale_previous.off("colors_changed", this._update_color_scale_texture); + } + if ((!color_scale_previous && color_scale) || (color_scale_previous && !color_scale_previous)) { + // this will toggle a preprocessor variable + this._update_materials(); + } + if (color_scale) { + color_scale.on("domain_changed", this._update_color_scale_domain, this); + color_scale.on("colors_changed", this._update_color_scale_texture, this); + this._update_color_scale_texture(); + this._update_color_scale_domain(); + this.figure.update(); + } + if (this.mesh) { // we don't need to do so on initialization + this.update_(); + } + } + _update_color_scale_texture() { + const color_scale = this.model.get("color_scale"); + this.uniforms.colormap.value = createColormap(color_scale); + this.figure.update(); + } + _update_color_scale_domain() { + const color_scale = this.model.get("color_scale"); + const color = this.model.get("color"); + if (color) { + let min; + let max; + if (color_scale.min !== null) { + min = color_scale.min; + } else { + min = Math.min(...color); + } + if (color_scale.max !== null) { + max = color_scale.max; + } else { + max = Math.max(...color); + } + this.uniforms.domain_color.value = [min, max]; + } else { + if (color_scale.min !== null && color_scale.max !== null) { + this.uniforms.domain_color.value = [color_scale.min, color_scale.max]; + } else { + console.warn("no color set, and color scale does not have a min or max"); + } + + } + this.figure.update(); + } + _update_materials() { + + if (this.model.get("material")) { + this.material.copy(this.model.get("material").obj); + } + if (this.model.get("material")) { + this.material_rgb.copy(this.model.get("material").obj); + } + if (this.model.get("line_material")) { + this.line_material.copy(this.model.get("line_material").obj); + } + if (this.model.get("line_material")) { + this.line_material_rgb.copy(this.model.get("line_material").obj); + // not present on .copy.. bug? + this.line_material_rgb.linewidth = this.line_material.linewidth = this.model.get("line_material").obj.linewidth; + } + + // TODO: lighting_model for lines could be different + this.lighting_model = materialToLightingModel(this.material) + const shader_snippets = this.model.get('shader_snippets'); + const snippet_defines = {}; + for (const key of Object.keys(shader_snippets)) { + snippet_defines["SHADER_SNIPPET_" + key.toUpperCase()] = shader_snippets[key]; + } + this.material.defines = {USE_COLOR: true, USE_COLORMAP: this.model.get("color_scale") !== null, ...this.scale_defines, ...snippet_defines}; + this.material.defines[`AS_${this.lighting_model}`] = true; + this.material.extensions = {derivatives: true}; + this.material_id.defines = {AS_ID: true, USE_COLOR: true, ...this.scale_defines, ...snippet_defines}; + this.material_id.extensions = {derivatives: true}; + this.material_rgb.defines = {AS_COORDINATE: true, USE_COLOR: true, ...this.scale_defines, ...snippet_defines}; + this.material_rgb.extensions = {derivatives: true}; + this.line_material.defines = {IS_LINE: true, USE_COLOR: true, ...this.scale_defines, ...snippet_defines}; + this.line_material.defines[`AS_${this.lighting_model}`] = true; + this.line_material_rgb.defines = {AS_COORDINATE: true, IS_LINE: true, USE_COLOR: true}; + this.line_material_id.defines = {AS_ID: true, IS_LINE: true, USE_COLOR: true}; + // locally and the visible with this object's visible trait + this.material.visible = this.material.visible && this.model.get("visible"); + this.material_rgb.visible = this.material.visible && this.model.get("visible"); + this.material_id.visible = this.material.visible && this.model.get("visible"); + this.line_material.visible = this.line_material.visible && this.model.get("visible"); + this.line_material_rgb.visible = this.line_material.visible && this.model.get("visible"); + this.line_material_id.visible = this.line_material.visible && this.model.get("visible"); + + const vertexShader = this.figure.model.get('_shaders')['scatter-vertex'] || shaders['scatter-vertex'] + const fragmentShader = this.figure.model.get('_shaders')['scatter-fragment'] || shaders['scatter-fragment'] + + // + Math.random() * 0.01 to avoid the cache of threejs + // see https://github.com/mrdoob/three.js/pull/17567 + const cache_thrasher = Math.random() * 0.01; + + this.material_depth = new MeshDepthMaterialCustom(() => { + const defines = {...this.material.defines}; + delete defines[`AS_${this.lighting_model}`]; + const as_sprite = this.model.get("geo").endsWith("2d"); + if (as_sprite) { + defines.AS_SPRITE = true; + } + return {AS_DEPTH: true, ...defines}; + }, this.uniforms, vertexShader, fragmentShader, { + depthPacking: THREE.RGBADepthPacking, + alphaTest: 0.5 + cache_thrasher, + }); + this.material_distance = new MeshDistanceMaterialCustom(() => { + const defines = {...this.material.defines}; + delete defines[`AS_${this.lighting_model}`]; + const as_sprite = this.model.get("geo").endsWith("2d"); + if (as_sprite) { + defines.AS_SPRITE = true; + } + return {AS_DISTANCE: true, ...defines}; + }, this.uniforms, vertexShader, fragmentShader, { + alphaTest: 0.5 + cache_thrasher + }); + + this.materials.forEach((material) => { + material.onBeforeCompile = (shader) => { + shader.vertexShader = patchShader(vertexShader); + shader.fragmentShader = patchShader(fragmentShader); + shader.uniforms = {...shader.uniforms, ...this.uniforms}; + }; + material.alphaTest = 0.5 + cache_thrasher; + material.needsUpdate = true; + material.lights = true; + if (this.model.get("aux")) { + material.defines.USE_AUX = true; + } + }); + + const geo = this.model.get("geo"); + const sprite = geo.endsWith("2d"); + if (sprite) { + this.material.defines.USE_SPRITE = true; + this.material_rgb.defines.USE_SPRITE = true; + this.material_id.defines.USE_SPRITE = true; + } + if (sprite) { + const texture = this.model.get("texture"); + if (texture && this.textures) { + this.material.defines.USE_TEXTURE = true; + } + } + this.material.needsUpdate = true; + this.material_rgb.needsUpdate = true; + this.material_id.needsUpdate = true; + this.line_material.needsUpdate = true; + this.line_material_rgb.needsUpdate = true; + this.line_material_id.needsUpdate = true; + if(this.mesh) { + this.mesh.customDepthMaterial = this.material_depth; + this.mesh.customDistanceMaterial = this.material_distance; + } + + this.figure.update(); + } + create_mesh() { + let geo = this.model.get("geo"); + // console.log(geo) + if (!geo) { + geo = "diamond"; + } + const sprite = geo.endsWith("2d"); + const buffer_geo = this.geos[geo];//geo); + const instanced_geo = new THREE.InstancedBufferGeometry(); + + const vertices = (buffer_geo.attributes.position as any).clone(); + instanced_geo.addAttribute("position", vertices); + if(buffer_geo.index) { + instanced_geo.index = buffer_geo.index; + } + instanced_geo.computeVertexNormals(); + + const sequence_index = this.model.get("sequence_index"); + let sequence_index_previous = this.previous_values.sequence_index; + if (typeof sequence_index_previous === "undefined") { + sequence_index_previous = sequence_index; + } + const scalar_names = ["x", "y", "z", "aux", "vx", "vy", "vz", "size", "size_selected"]; + const vector4_names = []; + if (this.model.get("color_scale")) { + scalar_names.push("color", "color_selected"); + } else { + vector4_names.push("color", "color_selected"); + } + const next = new values.Values(scalar_names, [], this.get_next.bind(this), sequence_index, vector4_names); + const previous = new values.Values(scalar_names, [], this.get_previous.bind(this), sequence_index_previous, vector4_names); + + const length = Math.max(next.length, previous.length); + if (length === 0) { + console.error("no single member is an array, not supported (yet?)"); + } + + next.trim(next.length); // make sure all arrays are of equal length + previous.trim(previous.length); + const previous_length = previous.length; + const next_length = next.length; + if (this.model.get("selected") || this.previous_values.selected) { + // upgrade size and size_previous to an array if they were not already + next.ensure_array(["size", "size_selected", "color", "color_selected"]); + previous.ensure_array(["size", "size_selected", "color", "color_selected"]); + let selected = this.get_next("selected", sequence_index, []); + next.select(selected); + selected = this.get_previous("selected", sequence_index_previous, []); + previous.select(selected); + } + // if we have a change in length, we use size to fade in/out particles, so make sure they are arrays + if (next.length !== previous.length) { + next.ensure_array("size"); + previous.ensure_array("size"); + } + if (next.length > previous.length) { // grow.. + previous.pad(next); + (previous.array.size as any).fill(0, previous_length); // this will make them smoothly fade in + } else if (next.length < previous.length) { // shrink.. + next.pad(previous); + (next.array.size as any).fill(0, next_length); // this will make them smoothly fade out + } + this.length = next.length; + // we are only guaranteed to have 16 attributes for the shader, so better merge some into single vectors + next.merge_to_vec3(["vx", "vy", "vz"], "v"); + previous.merge_to_vec3(["vx", "vy", "vz"], "v"); + + // we don't want to send these to the shader, these are handled at the js side + next.pop(["size_selected", "color_selected"]); + previous.pop(["size_selected", "color_selected"]); + + // add attributes to the geometry, this makes them available to the shader + next.add_attributes(instanced_geo, "_next"); + previous.add_attributes(instanced_geo, "_previous"); + + const id_array = new Float32Array(next.length); + for(let i = 0; i < next.length; i++) { + id_array[i] = i; + } + const id_attribute = new THREE.InstancedBufferAttribute(id_array, 1, false, 1); + instanced_geo.addAttribute("instance_id", id_attribute); + if (sprite) { + const texture = this.model.get("texture"); + if (texture && this.textures) { + // TODO: this should prolly go into _update_materiuals + this.material.uniforms.texture.value = this.textures[sequence_index % this.textures.length]; // TODO/BUG: there could + this.material.uniforms.texture_previous.value = this.textures[sequence_index_previous % this.textures.length]; + } + } + this.mesh = new THREE.Mesh(instanced_geo, this.material); + this.mesh.castShadow = this.model.get("cast_shadow"); + this.mesh.receiveShadow = this.model.get("receive_shadow"); + // We use the approach used in https://codepen.io/Fyrestar/pen/JqqGZQ + // see also https://discourse.threejs.org/t/shadow-for-instances/7947/7 + // or https://jsfiddle.net/mikatalk/4fn1oqz9/ + + this.mesh.customDepthMaterial = this.material_depth; + this.mesh.customDistanceMaterial = this.material_distance; + this.mesh.material_id = this.material_id; + this.mesh.material_rgb = this.material_rgb; + this.mesh.material_normal = this.material; + + if (this.model.get("connected")) { + const geometry = new THREE.BufferGeometry(); + + next.merge_to_vec3(["x", "y", "z"], "vertices"); + previous.merge_to_vec3(["x", "y", "z"], "vertices"); + geometry.addAttribute("position", new THREE.BufferAttribute(next.array_vec3.vertices, 3)); + geometry.addAttribute("position_previous", new THREE.BufferAttribute(previous.array_vec3.vertices, 3)); + + next.ensure_array(["color"]); + previous.ensure_array(["color"]); + if (this.model.get("color_scale")) { + geometry.addAttribute("color_next", new THREE.BufferAttribute(next.array.color, 1)); + geometry.addAttribute("color_previous", new THREE.BufferAttribute(previous.array.color, 1)); + } else { + geometry.addAttribute("color_next", new THREE.BufferAttribute(next.array_vec4.color, 4)); + geometry.addAttribute("color_previous", new THREE.BufferAttribute(previous.array_vec4.color, 4)); + } + geometry.computeVertexNormals(); + + this.line_segments = new THREE.Line(geometry, this.line_material); + this.line_segments.frustumCulled = false; + this.line_segments.castShadow = this.model.get("cast_shadow"); + this.line_segments.receiveShadow = this.model.get("receive_shadow"); + } else { + this.line_segments = null; + } + + for (const key of Object.keys(this.attributes_changed)) { + const changed_properties = this.attributes_changed[key]; + const property = "animation_time_" + key; + // console.log("animating", key) + const done = () => { + changed_properties.forEach((prop) => { + delete this.previous_values[prop]; // may happen multiple times, that is ok + }); + }; + // all materials share the same uniforms + const set = (value) => { + this.uniforms[property].value = value; + }; + this.figure.transition(set, done, this); + } + this.attributes_changed = {}; + } +} + +export +class ScatterModel extends widgets.WidgetModel { + static serializers = { + ...widgets.WidgetModel.serializers, + x: serialize.array_or_json, + y: serialize.array_or_json, + z: serialize.array_or_json, + aux: serialize.array_or_json, + aux_scale: { deserialize: widgets.unpack_models }, + vx: serialize.array_or_json, + vy: serialize.array_or_json, + vz: serialize.array_or_json, + selected: serialize.array_or_json, + size: serialize.array_or_json, + size_selected: serialize.array_or_json, + size_x_scale: { deserialize: widgets.unpack_models }, + size_y_scale: { deserialize: widgets.unpack_models }, + size_z_scale: { deserialize: widgets.unpack_models }, + color: serialize.color_or_json, + color_scale: { deserialize: widgets.unpack_models }, + color_selected: serialize.color_or_json, + texture: serialize.texture, + material: { deserialize: widgets.unpack_models }, + line_material: { deserialize: widgets.unpack_models }, + popup: { deserialize: widgets.unpack_models }, + }; + + defaults() { + return {...super.defaults(), + _model_name : "ScatterModel", + _view_name : "ScatterView", + _model_module : "ipyvolume", + _view_module : "ipyvolume", + _model_module_version: semver_range, + _view_module_version: semver_range, + size: 5, + size_selected: 7, + color: "red", + color_scale: null, + color_selected: "white", + geo: "diamond", + geo_matrix: [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1], + sequence_index: 0, + connected: false, + visible: true, + selected: null, + shader_snippets: {size: '\n'}, + cast_shadow : true, + receive_shadow : true, + }; + } +} diff --git a/js/src/selectors.js b/js/src/selectors.js deleted file mode 100644 index 011a20c5..00000000 --- a/js/src/selectors.js +++ /dev/null @@ -1,129 +0,0 @@ -var _scale_point = function (xy, width, height) { - // gl's normalized device coordinates, [-1, 1] - return [xy[0] / width * 2 - 1, 1 - xy[1] / height * 2]; -}; - -export -class LassoSelector { - constructor (canvas) { - this.canvas = canvas; - this.points = []; - } - - mouseMove (x, y) { - this.points.push([x, y]); - } - close () { - const context = this.canvas.getContext('2d'); - context.clearRect(0, 0, this.canvas.width, this.canvas.height); - } - draw () { - const context = this.canvas.getContext('2d'); - context.clearRect(0, 0, this.canvas.width, this.canvas.height); - context.lineWidth = 1.5; - context.strokeStyle = 'rgba(255, 0, 0, 1)'; - context.fillStyle = 'rgba(255, 0, 0, 0.5)'; - context.beginPath(); - for (var i = 0; i < this.points.length; i++) { - context.lineTo(this.points[i][0], this.points[i][1]); - } - context.closePath(); - context.fill(); - context.stroke(); - } - getData (width, height) { - var data = { type: 'lasso' }; - data['pixel'] = this.points; - data['device'] = this.points.map((xy) => _scale_point(xy, width, height)); - return data; - } -} - -export -class CircleSelector { - constructor (canvas) { - this.canvas = canvas; - this.points = []; - this.begin = null; - this.end = null; - } - mouseMove (x, y) { - if (!this.begin) { - this.begin = [x, y]; - } else { - this.end = [x, y]; - } - } - close () { - const ctx = this.canvas.getContext('2d'); - ctx.clearRect(0, 0, this.canvas.width, this.canvas.height); - this.begin = null; - this.end = null; - } - draw () { - if (this.begin && this.end) { - const ctx = this.canvas.getContext('2d'); - ctx.clearRect(0, 0, this.canvas.width, this.canvas.height); - ctx.lineWidth = 1.5; - ctx.strokeStyle = 'rgba(255, 0, 0, 1)'; - ctx.fillStyle = 'rgba(255, 0, 0, 0.5)'; - ctx.beginPath(); - var dx = this.begin[0] - this.end[0]; - var dy = this.begin[1] - this.end[1]; - var r = Math.sqrt(dx*dx + dy*dy); - ctx.arc(this.begin[0], this.begin[1], r, 0, 2*Math.PI); - ctx.fill(); - ctx.stroke(); - } - } - getData (width, height) { - var data = { type: 'circle' }; - data['pixel'] = { begin: this.begin, end: this.end }; - data['device'] = { begin: _scale_point(this.begin, width, height), end: _scale_point(this.end, width, height) }; - return data; - } -} - -export -class RectangleSelector { - constructor (canvas) { - this.canvas = canvas; - this.points = []; - this.begin = null; - this.end = null; - } - mouseMove (x, y) { - if (!this.begin) { - this.begin = [x, y]; - } else { - this.end = [x, y]; - } - } - close () { - const ctx = this.canvas.getContext('2d'); - ctx.clearRect(0, 0, this.canvas.width, this.canvas.height); - this.begin = null; - this.end = null; - } - draw () { - if (this.begin && this.end) { - const ctx = this.canvas.getContext('2d'); - ctx.clearRect(0, 0, this.canvas.width, this.canvas.height); - ctx.lineWidth = 1.5; - ctx.strokeStyle = 'rgba(255, 0, 0, 1)'; - ctx.fillStyle = 'rgba(255, 0, 0, 0.5)'; - ctx.beginPath(); - ctx.rect(this.begin[0], this.begin[1], this.end[0] - this.begin[0], this.end[1] - this.begin[1]); - ctx.fill(); - ctx.stroke(); - } - } - getData (width, height) { - var data = { type: 'rectangle' }; - data['pixel'] = { begin: this.begin, end: this.end }; - data['device'] = { begin: _scale_point(this.begin, width, height), end: _scale_point(this.end, width, height) }; - return data; - } -} -export -var selectors = { lasso: LassoSelector, circle: CircleSelector, rectangle: RectangleSelector }; diff --git a/js/src/selectors.ts b/js/src/selectors.ts new file mode 100644 index 00000000..c8345403 --- /dev/null +++ b/js/src/selectors.ts @@ -0,0 +1,145 @@ +function _scale_point(xy, width, height) { + // gl's normalized device coordinates, [-1, 1] + return [xy[0] / width * 2 - 1, 1 - xy[1] / height * 2]; +} + +export +class LassoSelector { + canvas: any; + points: any[]; + constructor(canvas) { + this.canvas = canvas; + this.points = []; + } + + mouseMove(x, y) { + this.points.push([x, y]); + } + + close() { + const context = this.canvas.getContext("2d"); + context.clearRect(0, 0, this.canvas.width, this.canvas.height); + } + draw() { + const context = this.canvas.getContext("2d"); + context.clearRect(0, 0, this.canvas.width, this.canvas.height); + context.lineWidth = 1.5; + context.strokeStyle = "rgba(255, 0, 0, 1)"; + context.fillStyle = "rgba(255, 0, 0, 0.5)"; + context.beginPath(); + for (const point of this.points) { + context.lineTo(point[0], point[1]); + } + context.closePath(); + context.fill(); + context.stroke(); + } + getData(width, height) { + const data = { + type: "lasso", + pixel: this.points, + device: this.points.map((xy) => _scale_point(xy, width, height)), + }; + return data; + } +} + +export +class CircleSelector { + canvas: any; + points: any[]; + begin: any; + end: any; + constructor(canvas) { + this.canvas = canvas; + this.points = []; + this.begin = null; + this.end = null; + } + mouseMove(x, y) { + if (!this.begin) { + this.begin = [x, y]; + } else { + this.end = [x, y]; + } + } + close() { + const ctx = this.canvas.getContext("2d"); + ctx.clearRect(0, 0, this.canvas.width, this.canvas.height); + this.begin = null; + this.end = null; + } + draw() { + if (this.begin && this.end) { + const ctx = this.canvas.getContext("2d"); + ctx.clearRect(0, 0, this.canvas.width, this.canvas.height); + ctx.lineWidth = 1.5; + ctx.strokeStyle = "rgba(255, 0, 0, 1)"; + ctx.fillStyle = "rgba(255, 0, 0, 0.5)"; + ctx.beginPath(); + const dx = this.begin[0] - this.end[0]; + const dy = this.begin[1] - this.end[1]; + const r = Math.sqrt(dx * dx + dy * dy); + ctx.arc(this.begin[0], this.begin[1], r, 0, 2 * Math.PI); + ctx.fill(); + ctx.stroke(); + } + } + getData(width, height) { + const data = { + type: "circle", + pixel: { begin: this.begin, end: this.end }, + device: { begin: _scale_point(this.begin, width, height), end: _scale_point(this.end, width, height) }, + }; + return data; + } +} + +export +class RectangleSelector { + canvas: any; + points: any[]; + begin: any; + end: any; + constructor(canvas) { + this.canvas = canvas; + this.points = []; + this.begin = null; + this.end = null; + } + mouseMove(x, y) { + if (!this.begin) { + this.begin = [x, y]; + } else { + this.end = [x, y]; + } + } + close() { + const ctx = this.canvas.getContext("2d"); + ctx.clearRect(0, 0, this.canvas.width, this.canvas.height); + this.begin = null; + this.end = null; + } + draw() { + if (this.begin && this.end) { + const ctx = this.canvas.getContext("2d"); + ctx.clearRect(0, 0, this.canvas.width, this.canvas.height); + ctx.lineWidth = 1.5; + ctx.strokeStyle = "rgba(255, 0, 0, 1)"; + ctx.fillStyle = "rgba(255, 0, 0, 0.5)"; + ctx.beginPath(); + ctx.rect(this.begin[0], this.begin[1], this.end[0] - this.begin[0], this.end[1] - this.begin[1]); + ctx.fill(); + ctx.stroke(); + } + } + getData(width, height) { + return { + type: "rectangle", + pixel: { begin: this.begin, end: this.end }, + device: { begin: _scale_point(this.begin, width, height), end: _scale_point(this.end, width, height) }, + }; + } +} +export +let selectors = { lasso: LassoSelector, circle: CircleSelector, rectangle: RectangleSelector }; diff --git a/js/src/serialize.js b/js/src/serialize.js deleted file mode 100644 index 57de8b5a..00000000 --- a/js/src/serialize.js +++ /dev/null @@ -1,246 +0,0 @@ -var _ = require('underscore') -var utils = require('./utils.js') -var THREE = require('three') -var widgets = require('@jupyter-widgets/base'); -var ndarray = require('ndarray') - -function ascii_decode(buf) { - return String.fromCharCode.apply(null, new Uint8Array(buf)); -} - -function read_uint16_LE(buffer) { - var view = new DataView(buffer); - var val = view.getUint8(0); - val |= view.getUint8(1) << 8; - return val; -} - -function numpy_buffer_to_ndarray(buf) { - var magic = ascii_decode(buf.slice(0,6)); - if (magic.slice(1,6) != 'NUMPY') { - throw new Error('unknown file type'); - } - - var version = new Uint8Array(buf.slice(6,8)); - var headerLength = read_uint16_LE(buf.slice(8,10)); - var headerStr = ascii_decode(buf.slice(10, 10+headerLength)); - var offsetBytes = 10 + headerLength; - //rest = buf.slice(10+headerLength); XXX -- This makes a copy!!! https://www.khronos.org/registry/typedarray/specs/latest/#5 - - var info = JSON.parse(headerStr.toLowerCase().replace('(','[').replace(',),',']').replace('),',']').replace(/'/g,"\"")); - - // Intepret the bytes according to the specified dtype - var data; - if (info.descr === "|u1") { - data = new Uint8Array(buf, offsetBytes); - } else if (info.descr === "|i1") { - data = new Int8Array(buf, offsetBytes); - } else if (info.descr === " rgb values - // shape is 2 dim, items are float, it should be of shape (len(x), 3) -> rgb values - // shape is 3 dim, items are float, it should be (sequence_length, len(x), 3) -> rgb values - function string_array_to_rgb(string_array) { - var rgbs = new Float32Array(string_array.length * 3); - for(var i = 0; i < string_array.length; i++) { - var color = new THREE.Color(string_array[i]); - rgbs[i*3+0] = color.r; - rgbs[i*3+1] = color.g; - rgbs[i*3+2] = color.b; - } - return rgbs; - } - function rgb_array_to_rgb(rgb_array) { - var rgbs = new Float32Array(rgb_array.length * 3); - for(var i = 0; i < rgb_array.length; i++) { - rgbs[i*3+0] = rgb_array[i][0]; - rgbs[i*3+1] = rgb_array[i][1]; - rgbs[i*3+2] = rgb_array[i][2]; - } - return rgbs; - } - - if (typeof data == "string") { // single color - //var color = new THREE.Color(data) - //arrays = new Float32Array([color.r, color.g, color.b]) // no sequence, scalar - arrays = data; // special case, if we keep it a string, we can control it via colorppicker - } else { - if(typeof data[0].dtype !== "undefined") { // we have a list of ndarrays - arrays = _.map(data, function(data) { return deserialize_typed_array(data, manager)}) - } else { - // must be a plain list of string, or list of list - if(dimension == 1 && typeof data[0] == "string") { - arrays = string_array_to_rgb(data) - } else - if(dimension == 2 && typeof data[0][0] == "string") { - arrays = _.map(data, string_array_to_rgb) - } else { - console.error("don't understand color type") - } - } - } - arrays.original_data = data; - return arrays; -} - - -function serialize_array_or_json(obj, manager) { - if(_.isNumber(obj)) return obj; // return numbers directly - if(obj != null) { - if(typeof obj.original_data == "undefined") // if someone modified the data from javascript land, we don't have this - return obj - else - return obj.original_data; // ftm we just feed back the original data, we don't modify currently - } else { - return null; - } -} -function deserialize_texture(data, manager) { - if(typeof data == "string") { - if(data.startsWith('IPY_MODEL_')) { - return widgets.unpack_models(data, manager) - } - } - return data -} -function deserialize_ndarray(data, manager) { - if(data === null) - return null; - return ndarray(deserialize_typed_array(data, manager), data.shape); -} - -function serialize_ndarray(data, manager) { - if(data === null) - return null; - var ar = data; - if(_.isArray(data) && !data.data) { // plain list of list - var ar = require("ndarray-pack")(data) - } - var data_json = {'data': ar.data.buffer, dtype:arrayToTypes[ar.data.constructor.name], shape:ar.shape} - return data_json; -} - -function serialize_texture(data, manager) { - return data; -} - -window.ndarray = ndarray; - - -module.exports = { - texture: {deserialize:deserialize_texture, serialize: serialize_texture}, - serialize_array_or_json: serialize_array_or_json, - deserialize_array_or_json: deserialize_array_or_json, - deserialize_color_or_json: deserialize_color_or_json, - array_or_json: { deserialize: deserialize_array_or_json, serialize: serialize_array_or_json }, - color_or_json: { deserialize: deserialize_color_or_json, serialize: serialize_array_or_json }, - ndarray: { deserialize: deserialize_ndarray, serialize: serialize_ndarray }, -} diff --git a/js/src/serialize.ts b/js/src/serialize.ts new file mode 100644 index 00000000..969ec127 --- /dev/null +++ b/js/src/serialize.ts @@ -0,0 +1,255 @@ +import * as widgets from "@jupyter-widgets/base"; +import { isArray, isNumber } from "lodash"; +import ndarray from "ndarray"; +import * as THREE from "three"; +import * as utils from "./utils"; + +function ascii_decode(buf) { + return String.fromCharCode.apply(null, new Uint8Array(buf)); +} + +function read_uint16_LE(buffer) { + const view = new DataView(buffer); + let val = view.getUint8(0); + // tslint:disable-next-line: no-bitwise + val |= view.getUint8(1) << 8; + return val; +} + +function numpy_buffer_to_ndarray(buf) { + const magic = ascii_decode(buf.slice(0, 6)); + if (magic.slice(1, 6) !== "NUMPY") { + throw new Error("unknown file type"); + } + + const version = new Uint8Array(buf.slice(6, 8)); + const headerLength = read_uint16_LE(buf.slice(8, 10)); + const headerStr = ascii_decode(buf.slice(10, 10 + headerLength)); + const offsetBytes = 10 + headerLength; + // rest = buf.slice(10+headerLength); XXX -- This makes a copy!!! https://www.khronos.org/registry/typedarray/specs/latest/#5 + + const info = JSON.parse(headerStr.toLowerCase().replace("(", "[").replace(",),", "]").replace("),", "]").replace(/'/g, "\"")); + + // Intepret the bytes according to the specified dtype + let data; + if (info.descr === "|u1") { + data = new Uint8Array(buf, offsetBytes); + } else if (info.descr === "|i1") { + data = new Int8Array(buf, offsetBytes); + } else if (info.descr === " deserialize_typed_array(element, manager)); + } + arrays.original_data = data; + return arrays; + /* + if(_.isArray(data) && !data.buffer) { // plain json, or list of buffers + if(data.length == 0) { + arrays = [] + } else + if(!data[0].buffer) { + // plain json + if(_.isArray(data[0])) { + arrays = _.map(data, function(array1d) { return new Float32Array(array1d)}) + } else { + arrays = [new Float32Array(data)] + } + } else { + arrays = _.map(data, function(data) { return new Float32Array(data.buffer)}); + } + } else { + nd = numpy_buffer_to_ndarray(data.buffer) + if (nd.shape.length == 2) { + arrays = [] + for(var i = 0; i < nd.shape[0]; i++) { + var ar = nd.data.slice(i*nd.stride[0], (i+1)*nd.stride[0]) + arrays.push(ar) + } + } else { // assume 1d... ? + arrays = [nd.data]; + } + } + arrays.original_data = data; + return arrays;*/ +} + +export +function deserialize_color_or_json(data, manager) { + if (data == null) { + return null; + } + let arrays = null; + + // It can deals with these 6 cases: which are threated in the same order + // shape is 0 dim, and it's a string, interpret as color + // shape is 1 dim, items are strings, seperate color for each item + // shape is 2 dim, items are strings, sequence of the above + // shape is 1 dim, items are floats, it should be of length 3 -> rgb values + // shape is 2 dim, items are float, it should be of shape (len(x), 3) -> rgb values + // shape is 3 dim, items are float, it should be (sequence_length, len(x), 3) -> rgb values + function string_array_to_rgb(string_array) { + const rgbs = new Float32Array(string_array.length * 3); + for (let i = 0; i < string_array.length; i++) { + const color = new THREE.Color(string_array[i]); + rgbs[i * 3 + 0] = color.r; + rgbs[i * 3 + 1] = color.g; + rgbs[i * 3 + 2] = color.b; + } + return rgbs; + } + function rgb_array_to_rgb(rgb_array) { + const rgbs = new Float32Array(rgb_array.length * 3); + for (let i = 0; i < rgb_array.length; i++) { + rgbs[i * 3 + 0] = rgb_array[i][0]; + rgbs[i * 3 + 1] = rgb_array[i][1]; + rgbs[i * 3 + 2] = rgb_array[i][2]; + } + return rgbs; + } + + if (typeof data === "string") { // single color + // var color = new THREE.Color(data) + // arrays = new Float32Array([color.r, color.g, color.b]) // no sequence, scalar + return data; // special case, if we keep it a string, we can control it via colorppicker + } else { + if (typeof data.dtype !== "undefined") { // we have a list of ndarrays + arrays = [deserialize_typed_array(data, manager)]; + } else if (typeof data[0].dtype !== "undefined") { // we have a list of ndarrays + arrays = data.map((element) => deserialize_typed_array(element, manager)); + } else { + const dimension = utils.get_array_dimension(data); + // must be a plain list of string, or list of list + if (dimension === 1 && typeof data[0] === "string") { + arrays = string_array_to_rgb(data); + } else + if (dimension === 2 && typeof data[0][0] === "string") { + arrays = data.map(string_array_to_rgb); + } else { + console.error("don't understand color type"); + } + } + } + arrays.original_data = data; + return arrays; +} + +export +function serialize_array_or_json(obj, manager) { + if (isNumber(obj)) { return obj; } // return numbers directly + if (obj != null) { + if (typeof obj.original_data === "undefined") { // if someone modified the data from javascript land, we don't have this + return obj; + } else { + return obj.original_data; + } // ftm we just feed back the original data, we don't modify currently + } else { + return null; + } +} +function deserialize_texture(data, manager) { + if (typeof data === "string") { + if (data.startsWith("IPY_MODEL_")) { + return widgets.unpack_models(data, manager); + } + } + return data; +} +function deserialize_ndarray(data, manager) { + if (data === null) { + return null; + } + return ndarray(deserialize_typed_array(data, manager), data.shape); +} + +function serialize_ndarray(data, manager) { + if (data === null) { + return null; + } + let ar = data; + if (isArray(data) && !(data as any).data) { // plain list of list + ar = require("ndarray-pack")(data); + } + const data_json = { data: ar.data.buffer, dtype: arrayToTypes[ar.data.constructor.name], shape: ar.shape }; + return data_json; +} + +function serialize_texture(data, manager) { + return data; +} + +// (window as any).ndarray = ndarray; + +export const texture = { deserialize: deserialize_texture, serialize: serialize_texture }; +// export const serialize_array_or_json = serialize_array_or_json; +// export const deserialize_array_or_json = deserialize_array_or_json; +// export const deserialize_color_or_json = deserialize_color_or_json; +export const array_or_json = { deserialize: deserialize_array_or_json, serialize: serialize_array_or_json }; +export const color_or_json = { deserialize: deserialize_color_or_json, serialize: serialize_array_or_json }; +const _ndarray = {deserialize: deserialize_ndarray, serialize: serialize_ndarray }; +export {_ndarray as ndarray}; diff --git a/js/src/test.js b/js/src/test.js deleted file mode 100644 index 95b5965b..00000000 --- a/js/src/test.js +++ /dev/null @@ -1,5 +0,0 @@ -describe('ipyvolume', function() { - it('testing', function(){ - assert.equal('1', 1) - }) -}) \ No newline at end of file diff --git a/js/src/test/dummy-manager.ts b/js/src/test/dummy-manager.ts new file mode 100644 index 00000000..14e8e08a --- /dev/null +++ b/js/src/test/dummy-manager.ts @@ -0,0 +1,103 @@ +import * as base from "@jupyter-widgets/base"; +import * as widgets from "@jupyter-widgets/controls"; +import * as services from "@jupyterlab/services"; +import * as Backbone from "backbone"; +import * as sinon from "sinon"; + +let numComms = 0; + +export +class MockComm { + comm_id: string; + target_name: string; + // tslint:disable-next-line: ban-types + _on_msg: Function = null; + // tslint:disable-next-line: ban-types + _on_open: Function = null; + // tslint:disable-next-line: ban-types + _on_close: Function = null; + constructor() { + this.comm_id = `mock-comm-id-${numComms}`; + numComms += 1; + } + on_open(fn) { + this._on_open = fn; + } + on_close(fn) { + this._on_close = fn; + } + on_msg(fn) { + this._on_msg = fn; + } + _process_msg(msg) { + if (this._on_msg) { + return this._on_msg(msg); + } else { + return Promise.resolve(); + } + } + open() { + if (this._on_open) { + this._on_open(); + } + return ""; + } + close() { + if (this._on_close) { + this._on_close(); + } + return ""; + } + send() { + return ""; + } +} + +export +class DummyManager extends base.ManagerBase { + + el: HTMLElement; + library: any; + constructor(library: any) { + super(); + this.el = window.document.createElement("div"); + window.document.body.appendChild(this.el); + this.library = library; + } + + display_view(msg: services.KernelMessage.IMessage, view: base.DOMWidgetView, options: any) { + this.el.appendChild(view.el); + view.on("remove", () => console.log("view removed", view)); + ( window as any).last_view = view; + view.trigger("displayed"); + return Promise.resolve(view.el); + } + + _get_comm_info() { + return Promise.resolve({}); + } + + _create_comm() { + return Promise.resolve(new MockComm()); + } + + protected loadClass(className: string, moduleName: string, moduleVersion: string): Promise { + if (moduleName === "@jupyter-widgets/base") { + if (base[className]) { + return Promise.resolve(base[className]); + } else { + return Promise.reject(`Cannot find class ${className}`); + } + } else if (moduleName === "@jupyter-widgets/controls") { + if (widgets[className]) { + return Promise.resolve(widgets[className]); + } else { + return Promise.reject(`Cannot find class ${className}`); + } + } else if (moduleName in this.library) { + return Promise.resolve(this.library[moduleName][className]); + } else { + return Promise.reject(`Cannot find module ${moduleName}`); + } + } +} diff --git a/js/test/figure.ts b/js/src/test/figure.js similarity index 94% rename from js/test/figure.ts rename to js/src/test/figure.js index 3f88299b..1df877d1 100644 --- a/js/test/figure.ts +++ b/js/src/test/figure.js @@ -1,4 +1,4 @@ -import { FigureModel, FigureView, WidgetManagerHackModel } from "../src/figure.js"; +import { FigureModel, FigureView, WidgetManagerHackModel } from "../"; import { expect } from 'chai'; describe("figure >", () => { diff --git a/js/src/test/index.ts b/js/src/test/index.ts new file mode 100644 index 00000000..1668a5e5 --- /dev/null +++ b/js/src/test/index.ts @@ -0,0 +1,7 @@ +// import all tests here, otherwise if we include them in karma.conf.js it will all be separate bundles +import "./figure"; +import "./mesh"; +import "./scatter"; +import "./selectors"; +import "./values"; +import "./volume"; diff --git a/js/src/test/mesh.ts b/js/src/test/mesh.ts new file mode 100644 index 00000000..dc007331 --- /dev/null +++ b/js/src/test/mesh.ts @@ -0,0 +1,64 @@ +import * as bqplot from "bqplot"; +import { expect } from "chai"; +import * as ipyvolume from "../"; +import {DummyManager} from "./dummy-manager"; +import {create_color_scale, create_figure_mesh_triangles, data_float32, data_uint32} from "./widget-utils"; + +// text pixel coordinate +const test_x = 250; +const test_y = 200; +const pixel_red = [255, 0, 0, 255]; + +describe("mesh >", () => { + beforeEach(async function() { + this.manager = new DummyManager({ipyvolume, bqplot}); + }); + + it("canvas/png render check", async function() { + const x = data_float32([0.0, 0, 1., 1.]); + const y = data_float32([0.1, 1000.0, 0.1, 1000.0]); + const z = data_float32([0.5, 0.5, 0.5, 0.5]); + const { mesh, figure } = await create_figure_mesh_triangles(this.manager, [x], [y], [z], [data_uint32([0, 2, 3, 0, 3, 1])]); + figure._real_update(); + const pixel = await figure.readPixel(test_x, test_y); + const [red, green, blue, alpha] = pixel; + expect(red).to.be.gt(150); + expect(green).to.eq(0); + expect(blue).to.eq(0); + expect(alpha).to.eq(255); + }); + it("with color scale", async function() { + const x = data_float32([0.0, 0, 1., 1.]); + const y = data_float32([0.1, 1000.0, 0.1, 1000.0]); + const z = data_float32([0.5, 0.5, 0.5, 0.5]); + const color = data_float32([0.5, 0.5, 0.5, 0.5]); + const color_scale = create_color_scale(this.manager, "color_scale", 0, 1); + const { mesh, figure } = await create_figure_mesh_triangles(this.manager, [x], [y], [z], [data_uint32([0, 2, 3, 0, 3, 1])], {color_scale: "IPY_MODEL_color_scale", color: [color]}); + figure._real_update(); + const pixel = await figure.readPixel(test_x, test_y); + let [red, green, blue, alpha] = pixel; + expect(red).to.lt(10); + expect(green).to.be.gt(150); + expect(blue).to.lt(10); + expect(alpha).to.eq(255); + + const color2 = [new Float32Array([0.0, 0.25, 0.5, 1.0])]; + // TODO: the deserializers may need some refactoring, this is ugly + (color2 as any).original_data = [{shape: [4]}]; + mesh.model.set("color", color2); + figure._real_update(); + // right upper corner (blue) + [red, green, blue, alpha] = await figure.readPixel(test_x + 100, test_y - 100); + expect(red).to.lt(30); + expect(green).to.lt(30); + expect(blue).to.be.gt(150); + expect(alpha).to.eq(255); + + [red, green, blue, alpha] = await figure.readPixel(test_x + 100, test_y + 100); + expect(red).to.lt(30); + expect(green).to.be.gt(150); + expect(blue).to.lt(30); + expect(alpha).to.eq(255); + + }); +}); diff --git a/js/src/test/scatter.ts b/js/src/test/scatter.ts new file mode 100644 index 00000000..20253caa --- /dev/null +++ b/js/src/test/scatter.ts @@ -0,0 +1,93 @@ +// import {Figure} from '../src/Figure.js'; +// import { ScatterModel, ScatterView, FigureModel, FigureView } from "../../"; +import * as bqplot from "bqplot"; +import { expect } from "chai"; +import * as ipyvolume from "../"; +import {DummyManager} from "./dummy-manager"; +import {create_color_scale, create_figure_scatter, create_model, data_float32} from "./widget-utils"; + +// text pixel coordinate +const test_x = 250; +const test_y = 200; +const pixel_red = [255, 0, 0, 255]; + +describe("scatter >", () => { + beforeEach(async function() { + this.manager = new DummyManager({ipyvolume, bqplot}); + }); + + it("create", async function() { + const x = data_float32([0, 1]); + const y = data_float32([2, 3]); + const z = data_float32([0, 3]); + const { scatter, figure } = await create_figure_scatter(this.manager, [x], [y], [z]); + expect(scatter.model.get("x")[0][0]).to.equal(0); + expect(scatter.model.get("x")[0][1]).to.equal(1); + }); + it("canvas/png render check", async function() { + const x = data_float32([0.5]); + const y = data_float32([10]); + const z = data_float32([0.5]); + const { scatter, figure } = await create_figure_scatter(this.manager, [x], [y], [z]); + scatter.model.set("size", 20); + figure._real_update(); + let pixel = await figure.readPixel(test_x, test_y); + const pixel_original = pixel; + let [red, green, blue, alpha] = pixel; + expect(red).to.be.gt(150); + expect(green).to.eq(0); + expect(blue).to.eq(0); + expect(alpha).to.eq(255); + + figure.mouseDown(test_x, test_y); + figure.mouseDrag(400, 0); + figure._real_update(); + + pixel = await figure.readPixel(test_x, test_y); + [red, green, blue, alpha] = pixel; + expect(red).to.be.eq(255); + expect(green).to.eq(255); + expect(blue).to.eq(255); + expect(alpha).to.eq(255); + + figure.mouseDown(test_x * 1.5, test_y); + figure.mouseDrag(-400, 0); + figure._real_update(); + + pixel = await figure.readPixel(test_x, test_y); + expect(pixel).to.be.deep.equals(pixel_original); + }); + it("with color scale", async function() { + const x = data_float32([0.5]); + const y = data_float32([10]); + const z = data_float32([0.5]); + const color = data_float32([0.5]); + const color_scale = create_color_scale(this.manager, "color_scale", 0, 1); + const { scatter, figure } = await create_figure_scatter(this.manager, [x], [y], [z], {color_scale: "IPY_MODEL_color_scale", color}); + scatter.model.set("size", 20); + figure._real_update(); + const pixel = await figure.readPixel(test_x, test_y); + let [red, green, blue, alpha] = pixel; + expect(red).to.lt(10); + expect(green).to.be.gt(150); + expect(blue).to.lt(10); + expect(alpha).to.eq(255); + + scatter.model.set("color", new Float32Array([0.0])); + figure._real_update(); + [red, green, blue, alpha] = await figure.readPixel(test_x, test_y); + expect(red).to.be.gt(150); + expect(green).to.lt(10); + expect(blue).to.lt(10); + expect(alpha).to.eq(255); + + scatter.model.set("color", new Float32Array([1.0])); + figure._real_update(); + [red, green, blue, alpha] = await figure.readPixel(test_x, test_y); + expect(red).to.lt(10); + expect(green).to.lt(10); + expect(blue).to.be.gt(150); + expect(alpha).to.eq(255); + + }); +}); diff --git a/js/test/selectors.ts b/js/src/test/selectors.js similarity index 99% rename from js/test/selectors.ts rename to js/src/test/selectors.js index c37fb0dd..3d532fa7 100644 --- a/js/test/selectors.ts +++ b/js/src/test/selectors.js @@ -1,4 +1,4 @@ -import { LassoSelector, CircleSelector, RectangleSelector } from "../lib/selectors.js"; +import { LassoSelector, CircleSelector, RectangleSelector } from "../selectors"; import { expect } from 'chai'; const color_inside = [255, 0, 0, 128]; diff --git a/js/src/test/values.ts b/js/src/test/values.ts new file mode 100644 index 00000000..440daa3c --- /dev/null +++ b/js/src/test/values.ts @@ -0,0 +1,19 @@ +import { expect } from "chai"; +import { Values } from "../values"; + +describe("values >", () => { + it("merge float32", () => { + const arrays = {x: new Float32Array([1, 2]), y: new Float32Array([3, 4]), z: new Float32Array([5, 6])}; + const getter = (name) => arrays[name]; + const values = new Values(["x", "y", "z"], [], getter, 0); + values.merge_to_vec3(["x", "y", "z"], "vertices"); + expect(Array.prototype.slice.call(values.array_vec3.vertices)).to.deep.equals([1, 3, 5, 2, 4, 6]); + }); + it("merge float32 and int", () => { + const arrays = {x: new Float32Array([1, 2]), y: new Float32Array([3, 4]), z: new Int32Array([5, 6])}; + const getter = (name) => arrays[name]; + const values = new Values(["x", "y", "z"], [], getter, 0); + values.merge_to_vec3(["x", "y", "z"], "vertices"); + expect(Array.prototype.slice.call(values.array_vec3.vertices)).to.deep.equals([1, 3, 5, 2, 4, 6]); + }); +}); diff --git a/js/src/test/volume.ts b/js/src/test/volume.ts new file mode 100644 index 00000000..d3e8b837 --- /dev/null +++ b/js/src/test/volume.ts @@ -0,0 +1,40 @@ +import * as bqplot from "bqplot"; +import * as threejs from 'jupyter-threejs'; +import { expect } from "chai"; +import * as ipyvolume from "../"; +import {DummyManager} from "./dummy-manager"; +import {create_figure_volume, create_transfer_function, data_float32, data_uint32} from "./widget-utils"; + +// text pixel coordinate +const test_x = 300; +const test_y = 300; +const pixel_red = [255, 0, 0, 255]; + +describe("volume >", () => { + beforeEach(async function() { + this.manager = new DummyManager({ipyvolume, bqplot, 'jupyter-threejs': threejs}); + }); + + it("canvas/png render check", async function() { + const tf = await create_transfer_function(this.manager); + const tiles = new Uint8Array([201, 201, 201, 0, 127, 127, 255, 255, 255, 127, 127, 255, 0, 0, 0, 255, 127, + 255, 127, 255, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 255]); + const data = { + tiles, + image_shape: [4, 2], + slice_shape: [2, 2], + rows: 1, + columns: 2, + slices: 2, + }; + const extent = [[0, 2], [0.1, 1000], [0, 2]]; + const { volume, figure } = await create_figure_volume(this.manager, data, extent, tf); + figure._real_update(); + const pixel = await figure.readPixel(test_x, test_y); + const [red, green, blue, alpha] = pixel; + expect(red).to.be.eq(0); + expect(green).to.gt(120); // this gives different results on travis/headless + expect(blue).to.eq(0); + expect(alpha).to.eq(255); + }); +}); diff --git a/js/src/test/widget-utils.ts b/js/src/test/widget-utils.ts new file mode 100644 index 00000000..5843c717 --- /dev/null +++ b/js/src/test/widget-utils.ts @@ -0,0 +1,147 @@ +import { MeshModel, ScatterModel, VolumeModel } from ".."; + +// some helper functions to quickly create widgets + +export +async function create_model_ipyvolume(manager, name: string, id: string, args: object) { + return create_model(manager, "ipyvolume", `${name}Model`, `${name}View`, id, args); +} + +export +async function create_model_bqplot(manager, name: string, id: string, args: object) { + return create_model(manager, "bqplot", `${name}Model`, name, id, args); +} + +export +async function create_model(manager, module: string, model: string, view: string, id: string, args = {}) { + const model_widget = await manager.new_widget({ + model_module: module, + model_name: model, + model_module_version : "*", + view_module: module, + view_name: view, + view_module_version: "*", + model_id: id, + }, args ); + return model_widget; +} + +export +async function create_linear_scale(manager, scale_name, min, max) { + return await create_model_bqplot(manager, "LinearScale", scale_name, { + min, max, _view_module_version: "*", _view_module: "bqplot"}); +} + +export +async function create_log_scale(manager, scale_name, min, max) { + return await create_model_bqplot(manager, "LogScale", scale_name, { + min, max, _view_module_version: "*", _view_module: "bqplot"}); +} + +export +async function create_color_scale(manager, scale_name, min, max) { + return await create_model_bqplot(manager, "ColorScale", scale_name, { + min, max, colors: ["#f00", "#0f0", "#00f"], _view_module_version: "*", _view_module: "bqplot"}); +} + +export +async function create_view(manager, model, options = {}) { + const view = await manager.create_view(model, options); + return view; +} + +export +async function create_widget(manager, name: string, id: string, args: object) { + const model = await create_model_ipyvolume(manager, name, id, args); + const view = await manager.create_view(model); + await manager.display_view(undefined, view); + return {model, view}; +} + +export +async function create_figure(manager, markModel) { + const layout = await create_model(manager, "@jupyter-widgets/base", "LayoutModel", "LayoutView", "layout_figure1", {_dom_classes: "", width: "400px", height: "500px"}); + + let figureModel; + const scale_x = await create_linear_scale(manager, "scale_x", 0, 1); + const scale_y = await create_log_scale(manager, "scale_y", 0.1, 1000); + // const scale_y = await create_linear_scale(manager, "scale_y", 0, 1); + const scale_z = await create_linear_scale(manager, "scale_z", 0, 1); + const scales = {x: "IPY_MODEL_scale_x", y: "IPY_MODEL_scale_y", z: "IPY_MODEL_scale_z"}; + try { + figureModel = await create_model_ipyvolume(manager, "Figure", "figure1", { + layout: "IPY_MODEL_layout_figure1", + scatters: markModel instanceof ScatterModel ? [`IPY_MODEL_${markModel.model_id}`] : [], + meshes: markModel instanceof MeshModel ? [`IPY_MODEL_${markModel.model_id}`] : [], + volumes: markModel instanceof VolumeModel ? [`IPY_MODEL_${markModel.model_id}`] : [], + animation: 0, + scales, + }); + } catch (e) { + console.error("error", e); + } + const figure = await create_view(manager, figureModel); + await manager.display_view(undefined, figure); + return figure; +} + +export +async function create_figure_scatter(manager, x, y, z, extra = {}) { + const layout = await create_model(manager, "@jupyter-widgets/base", "LayoutModel", "LayoutView", "layout_figure1", {_dom_classes: "", width: "400px", height: "500px"}); + + const scatterModel = await create_model_ipyvolume(manager, "Scatter", "scatter1", { + x, y, z, ...extra, _view_module_version: "*", _view_module: "ipyvolume"}); + const figure = await create_figure(manager, scatterModel); + await manager.display_view(undefined, figure); + return {figure, scatter: await figure.scatter_views[scatterModel.cid]}; +} + +export +async function create_figure_mesh_triangles(manager, x, y, z, triangles, extra = {}) { + const layout = await create_model(manager, "@jupyter-widgets/base", "LayoutModel", "LayoutView", "layout_figure1", {_dom_classes: "", width: "400px", height: "500px"}); + + const meshModel = await create_model_ipyvolume(manager, "Mesh", "mesh1", { + x, y, z, triangles, color: "red", ...extra, _view_module_version: "*", _view_module: "ipyvolume"}); + const figure = await create_figure(manager, meshModel); + await manager.display_view(undefined, figure); + return {figure, mesh: await figure.mesh_views[meshModel.cid]}; +} + +const tf_data = new Uint8Array([0, 0, 128, 63, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 63, 0, 0, 0, 0, 0, 0, 128, 63, 0, 0, 0, 0, 0, 0, 128, 63]); + +export +async function create_transfer_function(manager) { + const layout = await create_model(manager, "@jupyter-widgets/base", "LayoutModel", "LayoutView", "layout_tf_1", {_dom_classes: ""}); + + const tfModel = await create_model_ipyvolume(manager, "TransferFunction", "tf1", { + _dom_classes: [], + layout: "IPY_MODEL_layout_tf_1", + rgba: { + data: tf_data, + dtype: "float32", + shape: [2, 4], + }}, + ); + return tfModel; +} + +export +async function create_figure_volume(manager, data, extent, transfer_function) { + const layout = await create_model(manager, "@jupyter-widgets/base", "LayoutModel", "LayoutView", "layout_figure1", {_dom_classes: "", width: "400px", height: "500px"}); + + const material = await create_model(manager, "jupyter-threejs", `ShaderMaterialModel`, 'ShaderMaterial', 'shader1', {}); + const volumeModel = await create_model_ipyvolume(manager, "Volume", "volume1", { + data, extent, material: "IPY_MODEL_" + String(material.model_id), tf: "IPY_MODEL_" + String(transfer_function.model_id), _view_module_version: "*", _view_module: "ipyvolume"}); + const figure = await create_figure(manager, volumeModel); + await manager.display_view(undefined, figure); + return {figure, volume: await figure.mesh_views[volumeModel.cid]}; +} + +export +function data_float32(ar) { + return { dtype: "float32", data: new Float32Array([...ar]), shape: [ar.length] }; +} +export +function data_uint32(ar) { + return { dtype: "uint32", data: new Uint32Array([...ar]), shape: [ar.length] }; +} diff --git a/js/src/tf.js b/js/src/tf.js deleted file mode 100644 index 09f8c3bf..00000000 --- a/js/src/tf.js +++ /dev/null @@ -1,175 +0,0 @@ -// var exports = module.exports = {}; -var widgets = require('@jupyter-widgets/base'); -var _ = require('underscore') -var serialize = require('./serialize.js') -var semver_range = require('./utils.js').semver_range; -var ndarray_pack = require("ndarray-pack"); - -var TransferFunctionView = widgets.DOMWidgetView.extend( { - render: function() { - this.img = document.createElement('img'); - this.img.setAttribute('src', this.model.get('rgba')); - this.img.setAttribute('style', this.model.get('style')); - this.model.on('change:rgba', function() { - this.img.setAttribute('src', this.model.get('rgba')); - }, this); - this.model.on('change:style', function() { - this.img.setAttribute('style', this.model.get('style')); - }, this); - this.el.appendChild(this.img); - }, -}); - -var TransferFunctionModel = widgets.DOMWidgetModel.extend({ - defaults: function() { - return _.extend(widgets.DOMWidgetModel.prototype.defaults(), { - _model_name : 'TransferFunctionModel', - _view_name : 'TransferFunctionView', - _model_module : 'ipyvolume', - _view_module : 'ipyvolume', - _model_module_version: semver_range, - _view_module_version: semver_range, - rgba: null, - }) - }, - get_data_array: function() { - var flat_array = []; - var rgba = this.get("rgba") - for(var i = 0; i < rgba.shape[0]; i++) { - for(var j = 0; j < 4; j++) { - flat_array.push(rgba.get(i,j)*255) - } - } - var transfer_function_uint8_array = new Uint8Array(flat_array); - // REMOVE: for debugging - //window.transfer_function_uint8_array = transfer_function_uint8_array - //window.flat_array = flat_array - return transfer_function_uint8_array - }, - - },{ - serializers: _.extend({ - rgba: serialize.ndarray, - }, widgets.WidgetModel.serializers) -}); - - -var TransferFunctionJsBumpsModel = TransferFunctionModel.extend({ - defaults: function() { - return _.extend(TransferFunctionModel.prototype.defaults(), { - _model_name : 'TransferFunctionJsBumpsModel', - levels: [0.1, 0.5, 0.8], - opacities: [0.01, 0.05, 0.1], - widths: [0.1, 0.1, 0.1] - }) - }, - constructor : function () { - TransferFunctionModel.prototype.constructor.apply(this, arguments); - this.on("change:levels", this.recalculate_rgba, this); - this.on("change:opacities", this.recalculate_rgba, this); - this.on("change:widths", this.recalculate_rgba, this); - this.recalculate_rgba() - }, - recalculate_rgba: function() { - var rgba = [] - var colors = [[1,0,0], [0,1,0], [0,0,1]] - var levels = this.get("levels") - var widths = this.get("widths") - var opacities = this.get("opacities") - window.rgba = rgba - window.tfjs = this - var N = 256 - for(var i = 0; i < N; i++) { - var x = i/(N-1); - var color = [0, 0, 0, 0]; // red, green, blue and alpha - for(var j = 0; j < levels.length; j++) { - var basecolor = colors[j] - var intensity = Math.exp(-(Math.pow(x-levels[j],2) / Math.pow(widths[j], 2))) - for(var k = 0; k < 3; k++) { - color[k] += (basecolor[k] * intensity * opacities[j]) - } - color[3] += intensity * opacities[j] - } - var max_value = color[0]; - for(var k = 1; k < 3; k++) { - max_value = Math.max(max_value, color[k]) - } - for(var k = 0; k < 3; k++) { - color[k] = Math.min(1, color[k]/max_value); // normalize and clip to 1 - } - color[3] = Math.min(1, color[3]); // clip alpha - rgba.push(color) - } - this.set("rgba", rgba) - this.save_changes() - } -}); - -var TransferFunctionWidgetJs3Model = TransferFunctionModel.extend({ - defaults: function() { - return _.extend(TransferFunctionModel.prototype.defaults(), { - _model_name : 'TransferFunctionWidgetJs3Model', - level1: 0.1, - level2: 0.5, - level3: 0.8, - opacity1: 0.01, - opacity2: 0.05, - opacity3: 0.1, - width1: 0.1, - width2: 0.1, - width3: 0.1 - }) - }, - constructor : function () { - TransferFunctionModel.prototype.constructor.apply(this, arguments); - this.on("change:level1", this.recalculate_rgba, this); - this.on("change:level2", this.recalculate_rgba, this); - this.on("change:level3", this.recalculate_rgba, this); - this.on("change:opacity1", this.recalculate_rgba, this); - this.on("change:opacity2", this.recalculate_rgba, this); - this.on("change:opacity3", this.recalculate_rgba, this); - this.on("change:width1", this.recalculate_rgba, this); - this.on("change:width2", this.recalculate_rgba, this); - this.on("change:width3", this.recalculate_rgba, this); - this.recalculate_rgba() - }, - recalculate_rgba: function() { - var rgba = [] - var colors = [[1,0,0], [0,1,0], [0,0,1]] - var levels = [this.get("level1"), this.get("level2"), this.get("level3")] - var widths = [this.get("width1"), this.get("width2"), this.get("width3")] - var opacities = [this.get("opacity1"), this.get("opacity2"), this.get("opacity3")] - var N = 256 - for(var i = 0; i < N; i++) { - var x = i/(N-1); - var color = [0, 0, 0, 0]; // red, green, blue and alpha - for(var j = 0; j < 3; j++) { - var basecolor = colors[j] - var intensity = Math.exp(-(Math.pow(x-levels[j],2) / Math.pow(widths[j], 2))) - for(var k = 0; k < 3; k++) { - color[k] += (basecolor[k] * intensity * opacities[j]) - } - color[3] += intensity * opacities[j] - } - var max_value = color[0]; - for(var k = 1; k < 3; k++) { - max_value = Math.max(max_value, color[k]) - } - for(var k = 0; k < 3; k++) { - color[k] = Math.min(1, color[k]/max_value); // normalize and clip to 1 - } - color[3] = Math.min(1, color[3]); // clip alpha - rgba.push(color) - } - rgba = ndarray_pack(rgba) - this.set("rgba", rgba) - this.save_changes() - }, -}); - -module.exports = { - TransferFunctionModel: TransferFunctionModel, - TransferFunctionView: TransferFunctionView, - TransferFunctionWidgetJs3Model: TransferFunctionWidgetJs3Model, - TransferFunctionJsBumpsModel: TransferFunctionJsBumpsModel -} diff --git a/js/src/tf.ts b/js/src/tf.ts new file mode 100644 index 00000000..70b6f0f0 --- /dev/null +++ b/js/src/tf.ts @@ -0,0 +1,179 @@ +// var exports = module.exports = {}; +import * as widgets from "@jupyter-widgets/base"; +import {default as ndarray_pack} from "ndarray-pack"; +import * as serialize from "./serialize.js"; +import {semver_range} from "./utils"; + +export +class TransferFunctionView extends widgets.DOMWidgetView { + img: HTMLImageElement; + render() { + this.img = document.createElement("img"); + this.img.setAttribute("src", this.model.get("rgba")); + this.img.setAttribute("style", this.model.get("style")); + this.model.on("change:rgba", function() { + this.img.setAttribute("src", this.model.get("rgba")); + }, this); + this.model.on("change:style", function() { + this.img.setAttribute("style", this.model.get("style")); + }, this); + this.el.appendChild(this.img); + } +} + +export +class TransferFunctionModel extends widgets.DOMWidgetModel { + + static serializers = { + ...widgets.WidgetModel.serializers, + rgba: serialize.ndarray, + }; + defaults() { + return { + ...super.defaults(), + _model_name : "TransferFunctionModel", + _view_name : "TransferFunctionView", + _model_module : "ipyvolume", + _view_module : "ipyvolume", + _model_module_version: semver_range, + _view_module_version: semver_range, + rgba: null, + }; + } + + get_data_array() { + const flat_array = []; + const rgba = this.get("rgba"); + for (let i = 0; i < rgba.shape[0]; i++) { + for (let j = 0; j < 4; j++) { + flat_array.push(rgba.get(i, j) * 255); + } + } + const transfer_function_uint8_array = new Uint8Array(flat_array); + // REMOVE: for debugging + // window.transfer_function_uint8_array = transfer_function_uint8_array + // window.flat_array = flat_array + return transfer_function_uint8_array; + } +} + +export +class TransferFunctionJsBumpsModel extends TransferFunctionModel { + + constructor(...args) { + super(...args); + this.on("change:levels", this.recalculate_rgba, this); + this.on("change:opacities", this.recalculate_rgba, this); + this.on("change:widths", this.recalculate_rgba, this); + this.recalculate_rgba(); + } + defaults() { + return { + ...super.defaults(), + _model_name : "TransferFunctionJsBumpsModel", + levels: [0.1, 0.5, 0.8], + opacities: [0.01, 0.05, 0.1], + widths: [0.1, 0.1, 0.1], + }; + } + + recalculate_rgba() { + const rgba = []; + const colors = [[1, 0, 0], [0, 1, 0], [0, 0, 1]]; + const levels = this.get("levels"); + const widths = this.get("widths"); + const opacities = this.get("opacities"); + (window as any).rgba = rgba; + (window as any).tfjs = this; + const N = 256; + for (let i = 0; i < N; i++) { + const x = i / (N - 1); + const color = [0, 0, 0, 0]; // red, green, blue and alpha + for (let j = 0; j < levels.length; j++) { + const basecolor = colors[j]; + const intensity = Math.exp(-(Math.pow(x - levels[j], 2) / Math.pow(widths[j], 2))); + for (let k = 0; k < 3; k++) { + color[k] += (basecolor[k] * intensity * opacities[j]); + } + color[3] += intensity * opacities[j]; + } + let max_value = color[0]; + for (let k = 1; k < 3; k++) { + max_value = Math.max(max_value, color[k]); + } + for (let k = 0; k < 3; k++) { + color[k] = Math.min(1, color[k] / max_value); // normalize and clip to 1 + } + color[3] = Math.min(1, color[3]); // clip alpha + rgba.push(color); + } + this.set("rgba", rgba); + this.save_changes(); + } +} + +export +class TransferFunctionWidgetJs3Model extends TransferFunctionModel { + + constructor(...args) { + super(...args); + this.on("change:level1", this.recalculate_rgba, this); + this.on("change:level2", this.recalculate_rgba, this); + this.on("change:level3", this.recalculate_rgba, this); + this.on("change:opacity1", this.recalculate_rgba, this); + this.on("change:opacity2", this.recalculate_rgba, this); + this.on("change:opacity3", this.recalculate_rgba, this); + this.on("change:width1", this.recalculate_rgba, this); + this.on("change:width2", this.recalculate_rgba, this); + this.on("change:width3", this.recalculate_rgba, this); + this.recalculate_rgba(); + } + defaults() { + return { + ...super.defaults(), + _model_name : "TransferFunctionWidgetJs3Model", + level1: 0.1, + level2: 0.5, + level3: 0.8, + opacity1: 0.01, + opacity2: 0.05, + opacity3: 0.1, + width1: 0.1, + width2: 0.1, + width3: 0.1, + }; + } + + recalculate_rgba() { + let rgba = []; + const colors = [[1, 0, 0], [0, 1, 0], [0, 0, 1]]; + const levels = [this.get("level1"), this.get("level2"), this.get("level3")]; + const widths = [this.get("width1"), this.get("width2"), this.get("width3")]; + const opacities = [this.get("opacity1"), this.get("opacity2"), this.get("opacity3")]; + const N = 256; + for (let i = 0; i < N; i++) { + const x = i / (N - 1); + const color = [0, 0, 0, 0]; // red, green, blue and alpha + for (let j = 0; j < 3; j++) { + const basecolor = colors[j]; + const intensity = Math.exp(-(Math.pow(x - levels[j], 2) / Math.pow(widths[j], 2))); + for (let k = 0; k < 3; k++) { + color[k] += (basecolor[k] * intensity * opacities[j]); + } + color[3] += intensity * opacities[j]; + } + let max_value = color[0]; + for (let k = 1; k < 3; k++) { + max_value = Math.max(max_value, color[k]); + } + for (let k = 0; k < 3; k++) { + color[k] = Math.min(1, color[k] / max_value); // normalize and clip to 1 + } + color[3] = Math.min(1, color[3]); // clip alpha + rgba.push(color); + } + rgba = ndarray_pack(rgba); + this.set("rgba", rgba); + this.save_changes(); + } +} diff --git a/js/src/transition.ts b/js/src/transition.ts new file mode 100644 index 00000000..b652658d --- /dev/null +++ b/js/src/transition.ts @@ -0,0 +1,48 @@ +export +class Transition { + time_start: number; + duration: any; + cancelled: boolean; + called_on_done: boolean; + on_done: any; + animation_exponent: number; + on_animation: any; + constructor(on_animation, on_done, duration, animation_exponent= 1) { + this.on_done = on_done; + this.on_animation = on_animation; + this.animation_exponent = animation_exponent; + this.duration = duration; + // this.objects = [] + this.time_start = (new Date()).getTime(); + this.cancelled = false; + this.called_on_done = false; + } + + // set(obj) { + // this.objects.push(obj); + // } + + is_done() { + const dt = (new Date()).getTime() - this.time_start; + return (dt >= this.duration) || this.cancelled; + } + + cancel() { + this.cancelled = true; + } + + update() { + if (this.cancelled) { + return; + } + const dt = ((new Date()).getTime() - this.time_start) / this.duration; + + let u = Math.min(1, dt); + u = Math.pow(u, this.animation_exponent); + this.on_animation(u); + if (dt >= 1 && !this.called_on_done) { + this.called_on_done = true; + this.on_done(); + } + } +} diff --git a/js/src/utils.js b/js/src/utils.js deleted file mode 100644 index 7fc18c4b..00000000 --- a/js/src/utils.js +++ /dev/null @@ -1,27 +0,0 @@ -var semver_range = '~' + require('../package.json').version; - -var isTypedArray = require('is-typedarray') - -function is_typedarray(obj) { - return isTypedArray(obj) -} - -function is_arraybuffer(obj) { - return ArrayBuffer.isView(obj) -} - -function get_array_dimension(array) { - var dimension = 0; - while(typeof array[0] != "undefined") { - array = array[0]; - dimension += 1; - } - return dimension -} - -module.exports = { - is_typedarray: is_typedarray, - is_arraybuffer: is_arraybuffer, - get_array_dimension: get_array_dimension, - semver_range: semver_range -} \ No newline at end of file diff --git a/js/src/utils.ts b/js/src/utils.ts new file mode 100644 index 00000000..8aadbcec --- /dev/null +++ b/js/src/utils.ts @@ -0,0 +1,89 @@ +import isTypedArray from "is-typedarray"; + +// same strategy as: ipywidgets/jupyter-js-widgets/src/widget_core.ts, except we use ~ +// so that N.M.x is allowed (we don't care about x, but we assume 0.2.x is not compatible with 0.3.x +export const semver_range = require('../package.json').version; + +export +function is_typedarray(obj) { + return isTypedArray(obj); +} + +export +function is_arraybuffer(obj) { + return ArrayBuffer.isView(obj); +} + +export +function get_array_dimension(array) { + let dimension = 0; + while (typeof array[0] !== "undefined") { + array = array[0]; + dimension += 1; + } + return dimension; +} + +export +function download_image(data) { + const a = document.createElement("a"); + a.download = "ipyvolume.png"; + a.href = data; + // see https://stackoverflow.com/questions/18480474/how-to-save-an-image-from-canvas + if (document.createEvent) { + const e = document.createEvent("MouseEvents"); + e.initMouseEvent("click", true, true, window, + 0, 0, 0, 0, 0, false, false, false, + false, 0, null); + + a.dispatchEvent(e); + } else if ((a as any).fireEvent) { + (a as any).fireEvent("onclick"); + } +} + +export +function select_text(element) { + const doc = document; + if ((doc.body as any).createTextRange) { + const range = (document.body as any).createTextRange(); + range.moveToElementText(element); + range.select(); + } else if (window.getSelection) { + const selection = window.getSelection(); + const range = document.createRange(); + range.selectNodeContents(element); + selection.removeAllRanges(); + selection.addRange(range); + } +} + +export +function copy_image_to_clipboard(data) { + // https://stackoverflow.com/questions/27863617/is-it-possible-to-copy-a-canvas-image-to-the-clipboard + const img = document.createElement("img"); + img.contentEditable = "true"; + img.src = data; + + const div = document.createElement("div"); + div.contentEditable = "true"; + div.appendChild(img); + document.body.appendChild(div); + + // do copy + select_text(img); + document.execCommand("Copy"); + document.body.removeChild(div); +} + +export +function materialToLightingModel(material) { + if (material.type === "MeshPhysicalMaterial") { + return "PHYSICAL"; + } else if (material.type === "MeshLambertMaterial") { + return "LAMBERT"; + } else if (material.type === "MeshPhongMaterial") { + return "PHONG"; + } + return "DEFAULT"; +} diff --git a/js/src/values.js b/js/src/values.js deleted file mode 100644 index a9a9df2e..00000000 --- a/js/src/values.js +++ /dev/null @@ -1,280 +0,0 @@ -var _ = require("underscore"); -var THREE = require("three"); -var utils = require("./utils.js"); -/* Manages a list of scalar and arrays for use with WebGL instanced rendering -*/ -class Values { - constructor(names, names_vec3, getter, sequence_index, names_vec4) { - this.length = Infinity; - this.scalar = {}; - this.scalar_vec3 = {}; - this.scalar_vec4 = {}; - this.array = {}; - this.array_vec3 = {}; - this.array_vec4 = {}; - this.values = {}; - this.trim = (new_length) => { - this.array = _.mapObject(this.array, function (array) { - return array.length === new_length ? array : array.slice(0, new_length); - }); - this.array_vec3 = _.mapObject(this.array_vec3, function (array_vec3) { - return array_vec3.length === new_length * 3 ? array_vec3 : array_vec3.slice(0, new_length * 3); - }); - this.array_vec4 = _.mapObject(this.array_vec4, (array_vec4) => { - return (array_vec4.length === new_length * 4) ? array_vec4 : array_vec4.slice(0, new_length * 4); - }); - this.length = new_length; - }; - this.ensure_array = (name) => { - let names = _.isArray(name) ? name : [name]; - _.each(names, (name) => { - if (typeof this.scalar[name] !== 'undefined') { - let array = this.array[name] = new Float32Array(this.length); - array.fill(this.scalar[name]); - delete this.scalar[name]; - delete this.values[name]; - } - let value_vec3 = this.scalar_vec3[name]; - let value_vec4 = this.scalar_vec4[name]; - if (typeof value_vec3 !== 'undefined') { - let array = this.array_vec3[name] = new Float32Array(this.length * 3); - for (let i = 0; i < this.length; i++) { - array[i * 3 + 0] = value_vec3[0]; - array[i * 3 + 1] = value_vec3[1]; - array[i * 3 + 2] = value_vec3[2]; - } - delete this.scalar_vec3[name]; - delete this.values[name]; - } - if (typeof value_vec4 !== 'undefined') { - this.array_vec4[name] = new Float32Array(this.length * 4); - let array = this.array_vec4[name]; - for (let i = 0; i < this.length; i++) { - array[i * 4 + 0] = value_vec4[0]; - array[i * 4 + 1] = value_vec4[1]; - array[i * 4 + 2] = value_vec4[2]; - array[i * 4 + 3] = value_vec4[3]; - } - delete this.scalar_vec4[name]; - delete this.values[name]; - } - }); - }; - this.grow = (new_length) => { - this.array = _.mapObject(this.array, (array) => { - let new_array = new array.constructor(new_length); - new_array.set(array); - return new_array; - }); - this.array_vec3 = _.mapObject(this.array_vec3, (array_vec3) => { - let new_array = new array_vec3.constructor(new_length * 3); - new_array.set(array_vec3); - return new_array; - }); - this.length = length; - }; - this.pad = (other) => { - this.array = _.mapObject(this.array, (array, name) => { - let new_array = new array.constructor(other.length); - if (typeof other.array[name] === "undefined") { // then other must be a scalar - new_array.fill(other.scalar[name], this.length); - } - else { - new_array.set(other.array[name].slice(this.length), this.length); - } - new_array.set(array); - return new_array; - }); - this.array_vec3 = _.mapObject(this.array_vec3, (array_vec3, name) => { - let new_array = new array_vec3.constructor(other.length * 3); - if (typeof other.array_vec3[name] === "undefined") { // then other must be a scalar - let other_scalar = other.scalar_vec3[name]; - for (let i = this.length; i < other.length; i++) { - new_array[i * 3 + 0] = other_scalar[0]; - new_array[i * 3 + 1] = other_scalar[1]; - new_array[i * 3 + 2] = other_scalar[2]; - } - } - else { - new_array.set(other.array_vec3[name].slice(this.length * 3), this.length * 3); - } - new_array.set(array_vec3); - return new_array; - }); - this.array_vec4 = _.mapObject(this.array_vec4, (array_vec4, name) => { - let new_array = new array_vec4.constructor(other.length * 4); - if (typeof other.array_vec4[name] === "undefined") { - // then other must be a scalar - let other_scalar = other.scalar_vec4[name]; - for (let i = this.length; i < other.length; i++) { - new_array[i * 4 + 0] = other_scalar[0]; - new_array[i * 4 + 1] = other_scalar[1]; - new_array[i * 4 + 2] = other_scalar[2]; - new_array[i * 4 + 3] = other_scalar[3]; - } - } - else { - new_array.set(other.array_vec4[name].slice(this.length * 4), this.length * 4); - } - new_array.set(array_vec4); - return new_array; - }); - this.length = other.length; - }; - this.select = (selected) => { - // copy since we will modify - let sizes = this.array['size'] = this.array['size'].slice(); - let size_selected = this.array['size_selected']; - // copy since we will modify - let color = this.array_vec4['color'] = this.array_vec4['color'].slice(); - let color_selected = this.array_vec4['color_selected']; - // this assumes, and requires that color_selected is an array, maybe a bit inefficient - _.each(selected, (index) => { - if (index < this.length) { - sizes[index] = size_selected[index]; - color[index * 4 + 0] = color_selected[index * 4 + 0]; - color[index * 4 + 1] = color_selected[index * 4 + 1]; - color[index * 4 + 2] = color_selected[index * 4 + 2]; - color[index * 4 + 3] = color_selected[index * 4 + 3]; - } - }); - }; - this.merge_to_vec3 = (names, new_name) => { - let element_length = names.length; - let array = new Float32Array(this.length * element_length); // Float32Array should be replaced by a good common value - _.each(names, (name, index) => { - this.ensure_array(name); - let array1d = this.array[name]; - for (let i = 0; i < this.length; i++) { - array[i * element_length + index] = array1d[i]; - } - delete this.array[name]; - delete this.values[name]; - }); - this.array_vec3[new_name] = array; - }; - this.pop = (name) => { - let names = _.isArray(name) ? name : [name]; - _.each(names, (name) => { - _.each([this.scalar, - this.scalar_vec3, - this.array, - this.array_vec3], (storage) => { - if (typeof storage[name] !== 'undefined') { - delete storage[name]; - } - }); - }); - }; - this.add_attributes = (geometry, postfix) => { - postfix = postfix || ''; - // set all attributes - _.each(this.array, (array, name) => { - if (name.indexOf("selected") === -1) { - // selected attributes should not be send to the shader - let attr = new THREE.InstancedBufferAttribute(array, 1, false, 1); - geometry.addAttribute(name + postfix, attr); - } - }); - _.each(this.array_vec3, (array, name) => { - if (name.indexOf("selected") === -1) { - // selected attributes should not be send to the shader - let attr = new THREE.InstancedBufferAttribute(array, 3, false, 1); - attr.normalized = name.indexOf("color") === -1 ? false : true; // color should be normalized - geometry.addAttribute(name + postfix, attr); - } - }); - _.each(this.array_vec4, (array, name) => { - if (name.indexOf("selected") === -1) { - // selected attributes should not be send to the shader - let attr = new THREE.InstancedBufferAttribute(array, 4, false, 1); - attr.normalized = name.indexOf("color") === -1 ? false : true; // color should be normalized - geometry.addAttribute(name + postfix, attr); - } - }); - _.each(this.scalar, (scalar, name) => { - if (name.indexOf("selected") === -1) { - // selected attributes should not be send to the shader - let attr = new THREE.InstancedBufferAttribute(new Float32Array([scalar]), 1, false, this.length); - geometry.addAttribute(name + postfix, attr); - } - }); - _.each(this.scalar_vec3, (scalar_vec3, name) => { - if (name.indexOf("selected") === -1) { - // selected attributes should not be send to the shader - let attr = new THREE.InstancedBufferAttribute(scalar_vec3, 3, false, this.length); - attr.normalized = name.indexOf("color") == -1 ? false : true; // color should be normalized - geometry.addAttribute(name + postfix, attr); - } - }); - _.each(this.scalar_vec4, (scalar_vec4, name) => { - if (name.indexOf("selected") === -1) { - // selected attributes should not be send to the shader - let attr = new THREE.InstancedBufferAttribute(scalar_vec4, 4, false, this.length); - attr.normalized = name.indexOf("color") == -1 ? false : true; // color should be normalized - geometry.addAttribute(name + postfix, attr); - } - }); - }; - _.each(names, (name) => { - let value = getter(name, sequence_index, Values.defaults[name]); - if (utils.is_typedarray(value)) { - if (name != 'selected') // hardcoded.. hmm bad - this.length = Math.min(this.length, value.length); - this.array[name] = value; - } - else { - this.scalar[name] = value; - } - this.values[name] = value; - }); - _.each(names_vec3, (name) => { - let value = getter(name, sequence_index, Values.defaults[name]); - if (name.indexOf('color') !== -1 && typeof value === "string") { - // special case to support controlling color from a widget - let color = new THREE.Color(value); - // no sequence, scalar - value = new Float32Array([color.r, color.g, color.b]); - } - if (utils.is_typedarray(value) && value.length > 3) { - // single value is interpreted as scalar - this.array_vec3[name] = value; - this.length = Math.min(this.length, value.length / 3); - } - else { - this.scalar_vec3[name] = value; - } - this.values[name] = value; - }); - _.each(names_vec4, (name) => { - let value = getter(name, sequence_index, Values.defaults[name]); - if (name.indexOf('color') !== -1 && typeof value === "string") { - // special case to support controlling color from a widget - let color = new THREE.Color(value); - value = new Float32Array([color.r, color.g, color.b, 1.0]); - } - if (utils.is_typedarray(value) && value.length > 4) { - this.array_vec4[name] = value; - // color vectors have 4 components - this.length = Math.min(this.length, value.length / 4); - } - else { - // single value is interpreted as scalar - this.scalar_vec4[name] = value; - } - this.values[name] = value; - }); - } -} - -Values.defaults = { - vx: 0, - vy: 1, - vz: 0, - x: 0, - y: 0, - z: 0, - size: 0 -}; - -module.exports = { Values: Values }; \ No newline at end of file diff --git a/js/src/values.ts b/js/src/values.ts new file mode 100644 index 00000000..e8932fe0 --- /dev/null +++ b/js/src/values.ts @@ -0,0 +1,310 @@ +// var _ = require("underscore"); +import { forOwn, isArray, isNumber, mapValues } from "lodash"; +import * as THREE from "three"; +import * as utils from "./utils"; + +interface IArrayValues { + vertices?: []; + color?: []; + color_selected?: []; + size?: []; + size_selected?: []; + u?: []; + v?: []; + x?: []; + y?: []; + z?: []; +} + +/* Manages a list of scalar and arrays for use with WebGL instanced rendering +*/ +export +class Values { + static defaults = { + vx: 0, + vy: 1, + vz: 0, + x: 0, + y: 0, + z: 0, + size: 0, + }; + length: number; + scalar: {}; + scalar_vec3: {}; + scalar_vec4: {}; + array: IArrayValues; + array_vec3: IArrayValues; + array_vec4: IArrayValues; + values: {}; + constructor(names, names_vec3, getter, sequence_index, names_vec4= []) { + this.length = Infinity; + this.scalar = {}; + this.scalar_vec3 = {}; + this.scalar_vec4 = {}; + this.array = {}; + this.array_vec3 = {}; + this.array_vec4 = {}; + this.values = {}; + + // _.each(names, (name) => { + for (const name of names) { + const value = getter(name, sequence_index, Values.defaults[name]); + if (utils.is_typedarray(value)) { + if (name !== "selected") { // hardcoded.. hmm bad + this.length = Math.min(this.length, value.length); + } + this.array[name] = value; + } else { + this.scalar[name] = value; + } + this.values[name] = value; + } + for (const name of names_vec3) { + let value = getter(name, sequence_index, Values.defaults[name]); + if (name.indexOf("color") !== -1 && typeof value === "string") { + // special case to support controlling color from a widget + const color = new THREE.Color(value); + // no sequence, scalar + value = new Float32Array([color.r, color.g, color.b]); + } + if (utils.is_typedarray(value) && value.length > 3) { + // single value is interpreted as scalar + this.array_vec3[name] = value; + this.length = Math.min(this.length, value.length / 3); + } else { + this.scalar_vec3[name] = value; + } + this.values[name] = value; + } + for (const name of names_vec4) { + let value = getter(name, sequence_index, Values.defaults[name]); + if (name.indexOf("color") !== -1 && typeof value === "string") { + // special case to support controlling color from a widget + const color = new THREE.Color(value); + value = new Float32Array([color.r, color.g, color.b, 1.0]); + } + if (utils.is_typedarray(value) && value.length > 4) { + this.array_vec4[name] = value; + // color vectors have 4 components + this.length = Math.min(this.length, value.length / 4); + } else { + // single value is interpreted as scalar + this.scalar_vec4[name] = value; + } + this.values[name] = value; + } + if(this.length == Infinity) { + this.length = 1; // no arrays? + } + } + + trim(new_length) { + (this.array as any) = mapValues(this.array, (array: []) => { + return array.length === new_length ? array : array.slice(0, new_length); + }); + (this.array_vec3 as any) = mapValues(this.array_vec3, (array_vec3: []) => { + return array_vec3.length === new_length * 3 ? array_vec3 : array_vec3.slice(0, new_length * 3); + }); + (this.array_vec4 as any) = mapValues(this.array_vec4, (array_vec4: []) => { + return (array_vec4.length === new_length * 4) ? array_vec4 : array_vec4.slice(0, new_length * 4); + }); + this.length = new_length; + } + + ensure_array(name_or_names) { + const names = isArray(name_or_names) ? name_or_names : [name_or_names]; + for (const name of names) { + if (typeof this.scalar[name] !== "undefined") { + const array = this.array[name] = new Float32Array(this.length); + array.fill(this.scalar[name]); + delete this.scalar[name]; + delete this.values[name]; + } + const value_vec3 = this.scalar_vec3[name]; + const value_vec4 = this.scalar_vec4[name]; + if (typeof value_vec3 !== "undefined") { + const array = this.array_vec3[name] = new Float32Array(this.length * 3); + for (let i = 0; i < this.length; i++) { + array[i * 3 + 0] = value_vec3[0]; + array[i * 3 + 1] = value_vec3[1]; + array[i * 3 + 2] = value_vec3[2]; + } + delete this.scalar_vec3[name]; + delete this.values[name]; + } + if (typeof value_vec4 !== "undefined") { + this.array_vec4[name] = new Float32Array(this.length * 4); + const array = this.array_vec4[name]; + for (let i = 0; i < this.length; i++) { + array[i * 4 + 0] = value_vec4[0]; + array[i * 4 + 1] = value_vec4[1]; + array[i * 4 + 2] = value_vec4[2]; + array[i * 4 + 3] = value_vec4[3]; + } + delete this.scalar_vec4[name]; + delete this.values[name]; + } + } + } + + grow(new_length) { + this.array = mapValues(this.array, (array: []) => { + const new_array = new (array.constructor as any)(new_length); + new_array.set(array); + return new_array; + }); + this.array_vec3 = mapValues(this.array_vec3, (array_vec3: []) => { + const new_array = new (array_vec3.constructor as any)(new_length * 3); + new_array.set(array_vec3); + return new_array; + }); + this.length = length; + } + + pad(other) { + this.array = mapValues(this.array, (array: [], name: string) => { + const new_array = new (array.constructor as any)(other.length); + if (typeof other.array[name] === "undefined") { // then other must be a scalar + new_array.fill(other.scalar[name], this.length); + } else { + new_array.set(other.array[name].slice(this.length), this.length); + } + new_array.set(array); + return new_array; + }); + this.array_vec3 = mapValues(this.array_vec3, (array_vec3: [], name: string) => { + const new_array = new (array_vec3.constructor as any)(other.length * 3); + if (typeof other.array_vec3[name] === "undefined") { // then other must be a scalar + const other_scalar = other.scalar_vec3[name]; + for (let i = this.length; i < other.length; i++) { + new_array[i * 3 + 0] = other_scalar[0]; + new_array[i * 3 + 1] = other_scalar[1]; + new_array[i * 3 + 2] = other_scalar[2]; + } + } else { + new_array.set(other.array_vec3[name].slice(this.length * 3), this.length * 3); + } + new_array.set(array_vec3); + return new_array; + }); + this.array_vec4 = mapValues(this.array_vec4, (array_vec4: [], name) => { + const new_array = new (array_vec4.constructor as any)(other.length * 4); + if (typeof other.array_vec4[name] === "undefined") { + // then other must be a scalar + const other_scalar = other.scalar_vec4[name]; + for (let i = this.length; i < other.length; i++) { + new_array[i * 4 + 0] = other_scalar[0]; + new_array[i * 4 + 1] = other_scalar[1]; + new_array[i * 4 + 2] = other_scalar[2]; + new_array[i * 4 + 3] = other_scalar[3]; + } + } else { + new_array.set(other.array_vec4[name].slice(this.length * 4), this.length * 4); + } + new_array.set(array_vec4); + return new_array; + }); + this.length = other.length; + } + + select(selected) { + // copy since we will modify + const sizes = (this.array.size as any) = this.array.size.slice(); + const size_selected = this.array.size_selected; + // copy since we will modify + const color = (this.array_vec4.color as any) = this.array_vec4.color.slice(); + const color_selected = this.array_vec4.color_selected; + // this assumes, and requires that color_selected is an array, maybe a bit inefficient + selected.forEach((element, index) => { + if (index < this.length) { + sizes[index] = size_selected[index]; + color[index * 4 + 0] = color_selected[index * 4 + 0]; + color[index * 4 + 1] = color_selected[index * 4 + 1]; + color[index * 4 + 2] = color_selected[index * 4 + 2]; + color[index * 4 + 3] = color_selected[index * 4 + 3]; + } + }); + } + + merge_to_vec3(names, new_name) { + const element_length = names.length; + const array = new Float32Array(this.length * element_length); // Float32Array should be replaced by a good common value + names.forEach((name, index) => { + this.ensure_array(name); + const array1d = this.array[name]; + for (let i = 0; i < this.length; i++) { + array[i * element_length + index] = array1d[i]; + } + delete this.array[name]; + delete this.values[name]; + }); + this.array_vec3[new_name] = array; + } + + pop(name_or_names) { + const names = isArray(name_or_names) ? name_or_names : [name_or_names]; + // _.each(names, (name) => { + names.forEach((name, index) => { + [this.scalar, + this.scalar_vec3, + this.array, + this.array_vec3].forEach((storage) => { + if (typeof storage[name] !== "undefined") { + delete storage[name]; + } + }); + }); + } + + add_attributes(geometry, postfix = "") { + postfix = postfix; + // set all attributes + forOwn(this.array, (array, name) => { + if (name.indexOf("selected") === -1) { + // selected attributes should not be send to the shader + const attr = new THREE.InstancedBufferAttribute(array, 1, false, 1); + geometry.addAttribute(name + postfix, attr); + } + }); + forOwn(this.array_vec3, (array, name) => { + if (name.indexOf("selected") === -1) { + // selected attributes should not be send to the shader + const attr = new THREE.InstancedBufferAttribute(array, 3, false, 1); + attr.normalized = name.indexOf("color") === -1 ? false : true; // color should be normalized + geometry.addAttribute(name + postfix, attr); + } + }); + forOwn(this.array_vec4, (array, name) => { + if (name.indexOf("selected") === -1) { + // selected attributes should not be send to the shader + const attr = new THREE.InstancedBufferAttribute(array, 4, false, 1); + attr.normalized = name.indexOf("color") === -1 ? false : true; // color should be normalized + geometry.addAttribute(name + postfix, attr); + } + }); + forOwn(this.scalar, (scalar, name) => { + if (name.indexOf("selected") === -1) { + // selected attributes should not be send to the shader + const attr = new THREE.InstancedBufferAttribute(new Float32Array([scalar]), 1, false, this.length); + geometry.addAttribute(name + postfix, attr); + } + }); + forOwn(this.scalar_vec3, (scalar_vec3, name) => { + if (name.indexOf("selected") === -1) { + // selected attributes should not be send to the shader + const attr = new THREE.InstancedBufferAttribute(scalar_vec3, 3, false, this.length); + attr.normalized = name.indexOf("color") === -1 ? false : true; // color should be normalized + geometry.addAttribute(name + postfix, attr); + } + }); + forOwn(this.scalar_vec4, (scalar_vec4, name) => { + if (name.indexOf("selected") === -1) { + // selected attributes should not be send to the shader + const attr = new THREE.InstancedBufferAttribute(scalar_vec4, 4, false, this.length); + attr.normalized = name.indexOf("color") === -1 ? false : true; // color should be normalized + geometry.addAttribute(name + postfix, attr); + } + }); + } +} diff --git a/js/src/volume.js b/js/src/volume.js deleted file mode 100644 index d0153f5d..00000000 --- a/js/src/volume.js +++ /dev/null @@ -1,283 +0,0 @@ -var _ = require('underscore') -var widgets = require('@jupyter-widgets/base'); -var THREE = require('three') -var serialize = require('./serialize.js') -var semver_range = require('./utils.js').semver_range; - -var shaders = {} - -shaders["box_fragment"] = require('raw-loader!../glsl/box-fragment.glsl'); -shaders["box_vertex"] = require('raw-loader!../glsl/box-vertex.glsl'); - -var VolumeView = widgets.WidgetView.extend( { - render: function() { - this.renderer = this.options.parent; - this.attributes_changed = {} - this.data = [] - - window.last_volume_view = this; - - var render_size = this.renderer.getRenderSize() - - this.vol_box_geo = new THREE.BoxBufferGeometry(1, 1, 1); - //this.box_material = new THREE.MeshLambertMaterial({color: 0xCC0000}); - this.box_material = new THREE.ShaderMaterial({ - uniforms: { - offset: { type: '3f', value: [0, 0, 0] }, - scale : { type: '3f', value: [1, 1, 1] }, - }, - fragmentShader: shaders["box_fragment"], - vertexShader: shaders["box_vertex"], - side: THREE.BackSide - }); - this.vol_box_mesh = new THREE.Mesh(this.vol_box_geo, this.box_material) - //this.vol_box_mesh.position.z = -5; - this.vol_box_mesh.updateMatrix() - this.vol_box_mesh.matrixAutoUpdate = true - - this.texture_loader = new THREE.TextureLoader() - - this.texture_tf = null;//new THREE.DataTexture(null, this.model.get("tf").get("rgba").length, 1, THREE.RGBAFormat, THREE.UnsignedByteType) - - this.uniform_volumes_values = {} - this.uniform_data = {type: 'tv', value: []} - this.uniform_transfer_function = {type: 'tv', value: []} - - - // var update_volr_defines = () => { - // if(this.model.get('rendering_method') ) - // this.box_material_volr.defines = {USE_LIGHTING: this.model.get('rendering_lighting')} - // //this.box_material_volr.defines['METHOD_' + this.model.get('rendering_method')] = true; - // //this.box_material_volr.defines['VOLUME_COUNT'] = 1 - // this.box_material_volr.needsUpdate = true - // this.box_material_volr_depth.defines = {COORDINATE: true, USE_LIGHTING: this.model.get('rendering_lighting')} - // //this.box_material_volr_depth.defines['METHOD_' + this.model.get('rendering_method')] = true; - // this.box_material_volr_depth.needsUpdate = true; - // //this.box_material_volr_depth.defines['VOLUME_COUNT'] = 1 - // } - - this.tf_set() - this.data_set() - var update_rendering_method = () => { - this.renderer.rebuild_multivolume_rendering_material() - this.renderer.update() - } - this.model.on('change:rendering_method', update_rendering_method) - //this.model.on('change:rendering_method change:rendering_lighting', update_volr_defines) - update_rendering_method() - - - this.add_to_scene() - - this.model.on('change:data', this.data_set, this); - - var update_minmax = () => { - this.uniform_volumes_values.data_range = [this.model.get('data_min'), this.model.get('data_max')] - this.uniform_volumes_values.show_range = [this.model.get('show_min'), this.model.get('show_max')] - this.renderer.rebuild_multivolume_rendering_material() - this.renderer.update() - } - this.model.on('change:data_min change:data_max change:show_min change:show_max', update_minmax, this); - update_minmax() - - var update_clamp = () => { - this.uniform_volumes_values.clamp_min = this.model.get('clamp_min') - this.uniform_volumes_values.clamp_max = this.model.get('clamp_max') - this.renderer.rebuild_multivolume_rendering_material() - this.renderer.update() - } - this.model.on('change:clamp_min change:clamp_max', update_clamp, this); - update_clamp() - - var update_opacity_scale = () => { - this.uniform_volumes_values.opacity_scale = this.model.get('opacity_scale') - this.renderer.rebuild_multivolume_rendering_material() - this.renderer.update() - } - update_opacity_scale() - this.model.on('change:opacity_scale', update_opacity_scale) - - var update_lighting = () => { - this.uniform_volumes_values.lighting = this.model.get('lighting') - this.renderer.rebuild_multivolume_rendering_material() - this.renderer.update() - } - update_lighting() - this.model.on('change:lighting', update_lighting) - - var update_ray_steps = () => { - this.renderer.rebuild_multivolume_rendering_material() - this.renderer.update() - } - update_ray_steps() - this.model.on('change:ray_steps', update_ray_steps) - - - var update_brightness = () => { - this.uniform_volumes_values.brightness = this.model.get('brightness') - this.renderer.rebuild_multivolume_rendering_material() - this.renderer.update() - } - update_brightness() - this.model.on('change:brightness', update_brightness) - - this.model.on('change:tf', this.tf_set, this) - - this.model.on('change:extent', () => { - this.renderer.rebuild_multivolume_rendering_material() - this.renderer.update() - }) - - window.last_volume = this; // for debugging purposes - - }, - get_ray_steps: function() { - var ray_steps = this.model.get('ray_steps'); - if(ray_steps == null) { - ray_steps = _.max(this.data_shape) - } - return ray_steps; - }, - is_max_intensity() { - return this.model.get('rendering_method') == 'MAX_INTENSITY'; - }, - is_normal() { - return this.model.get('rendering_method') == 'NORMAL'; - }, - data_set: function() { - this.volume = this.model.get("data") - var data = new Uint8Array(this.volume.tiles.buffer) - this.texture_volume = new THREE.DataTexture(data, this.volume.image_shape[0], this.volume.image_shape[1], - THREE.RGBAFormat, THREE.UnsignedByteType) - this.texture_volume.magFilter = THREE.LinearFilter - this.texture_volume.minFilter = THREE.LinearFilter - this.uniform_volumes_values.rows = this.volume.rows - this.uniform_volumes_values.columns = this.volume.columns - this.uniform_volumes_values.slices = this.volume.slices - this.uniform_volumes_values.size = this.volume.image_shape - this.uniform_volumes_values.slice_size = this.volume.slice_shape - this.uniform_data.value = [this.texture_volume] - this.uniform_data.value = [this.texture_volume] - this.uniform_volumes_values.data_range = [this.model.get('data_min'), this.model.get('data_max')] - this.uniform_volumes_values.show_range = [this.model.get('show_min'), this.model.get('show_max')] - this.texture_volume.needsUpdate = true // without this it doesn't seem to work - this.data_shape = [this.volume.slice_shape[0], this.volume.slice_shape[1], this.volume.slices] - this.renderer.rebuild_multivolume_rendering_material() - this.renderer.update() - }, - tf_set: function() { - // TODO: remove listeners from previous - if(this.model.get("tf")) { - this.model.get("tf").on('change:rgba', this.tf_changed, this); - this.tf_changed() - } - }, - tf_changed: function() { - var tf = this.model.get("tf") - if(tf) { - /*if(!this.texture_tf) { - this.texture_tf = new THREE.DataTexture(tf.get_data_array(), tf.get("rgba").length, 1, THREE.RGBAFormat, THREE.UnsignedByteType) - } else { - this.texture_tf.image.data = tf.get_data_array() - this.texture_tf.needsUpdate = true - }*/ - this.texture_tf = new THREE.DataTexture(tf.get_data_array(), tf.get("rgba").shape[0], 1, THREE.RGBAFormat, THREE.UnsignedByteType) - this.texture_tf.needsUpdate = true // without this it doesn't seem to work - // this.box_material_volr.uniforms.transfer_function.value = [this.texture_tf] - this.uniform_transfer_function.value = [this.texture_tf] - } - this.renderer.rebuild_multivolume_rendering_material() - this.renderer.update() - }, - set_limits: function(limits) { - var xlim = limits.xlim; - var ylim = limits.ylim - var zlim = limits.zlim - var dx = (xlim[1] - xlim[0]) - var dy = (ylim[1] - ylim[0]) - var dz = (zlim[1] - zlim[0]) - - var extent = this.model.get('extent') - - // normalized coordinates of the corners of the box - var x0n = (extent[0][0]-xlim[0])/dx - var x1n = (extent[0][1]-xlim[0])/dx - var y0n = (extent[1][0]-ylim[0])/dy - var y1n = (extent[1][1]-ylim[0])/dy - var z0n = (extent[2][0]-zlim[0])/dz - var z1n = (extent[2][1]-zlim[0])/dz - - // clipped coordinates - var cx0 = Math.max(x0n, 0) - var cx1 = Math.min(x1n, 1) - var cy0 = Math.max(y0n, 0) - var cy1 = Math.min(y1n, 1) - var cz0 = Math.max(z0n, 0) - var cz1 = Math.min(z1n, 1) - - // the clipped coordinates back to world space, then normalized to extend - // these are example calculations, the transform goes into scale and offset uniforms below - // var cwx0 = (cx0 * dx + xlim[0] - extent[0][0])/(extent[0][1] - extent[0][0]) - // var cwx1 = (cx1 * dx + xlim[0] - extent[0][0])/(extent[0][1] - extent[0][0]) - - // this.box_geo = new THREE.BoxBufferGeometry(cx1-cx0, cy1-cy0, cz1-cz0) - // this.box_geo.translate((cx1-x0)/2, (cy1-cy0)/2, (cz1-cz0)/2) - // this.box_geo.translate(cx0, cy0, cz0) - // this.box_geo.translate(-0.5, -0.5, -0.5) - this.box_geo = new THREE.BoxBufferGeometry(1, 1, 1) - this.box_geo.translate(0.5, 0.5, 0.5) - this.box_geo.scale((cx1-cx0), (cy1-cy0), (cz1-cz0)) - this.box_geo.translate(cx0, cy0, cz0) - this.box_geo.translate(-0.5, -0.5, -0.5) - this.vol_box_mesh.geometry = this.box_geo - - this.uniform_volumes_values.scale = [1/(x1n-x0n), 1/(y1n-y0n), 1/(z1n-z0n)] - this.uniform_volumes_values.offset = [-x0n, -y0n, -z0n] - }, - add_to_scene: function() { - this.renderer.scene_volume.add(this.vol_box_mesh) - }, - remove_from_scene: function() { - this.renderer.scene_volume.remove(this.vol_box_mesh) - }, -}); - -var VolumeModel = widgets.WidgetModel.extend({ - defaults: function() { - return _.extend(widgets.WidgetModel.prototype.defaults(), { - _model_name : 'VolumeModel', - _view_name : 'VolumeView', - _model_module : 'ipyvolume', - _view_module : 'ipyvolume', - _model_module_version: semver_range, - _view_module_version: semver_range, - sequence_index: 0, - step_size: 0.01, - opacity_scale: 1.0, - brightness: 1.0, - extent: null, - lighting: true, - rendering_method: 'NORMAL', - clamp_min: false, - clamp_max: false, - data_range: null, - show_range: null, - show_min: 0, - show_max: 1, - data_min: 0, - data_max: 1, - ray_steps: null - }) - }}, { - serializers: _.extend({ - tf: { deserialize: widgets.unpack_models }, - data: { serialize: (x) => x} - }, widgets.DOMWidgetModel.serializers) -}); - - - -module.exports = { - VolumeView:VolumeView, - VolumeModel:VolumeModel -} diff --git a/js/src/volume.ts b/js/src/volume.ts new file mode 100644 index 00000000..8f8e0ea7 --- /dev/null +++ b/js/src/volume.ts @@ -0,0 +1,421 @@ +import * as widgets from "@jupyter-widgets/base"; +import * as d3 from "d3"; +import { max } from "lodash"; +import * as THREE from "three"; +import { FigureView } from "./figure.js"; +import { createD3Scale } from "./scales.js"; +import * as serialize from "./serialize.js"; +import {semver_range} from "./utils"; + +const shaders = { + box_fragment: (require("raw-loader!../glsl/box-fragment.glsl") as any).default, + box_vertex: (require("raw-loader!../glsl/box-vertex.glsl") as any).default, +}; + +export +class VolumeView extends widgets.WidgetView { + renderer: FigureView; + attributes_changed: {}; + data: any[]; + data_shape: any[]; + texture_loader: THREE.TextureLoader; + volume: any; + texture_volume: THREE.DataTexture; + render() { + this.renderer = this.options.parent; + this.attributes_changed = {}; + this.data = []; + + // window.last_volume_view = this; + + const render_size = this.renderer.getRenderSize(); + + // this.box_material = new THREE.MeshLambertMaterial({color: 0xCC0000}); + + this.texture_loader = new THREE.TextureLoader(); + + // var update_volr_defines = () => { + // if(this.model.get('rendering_method') ) + // this.box_material_volr.defines = {USE_LIGHTING: this.model.get('rendering_lighting')} + // //this.box_material_volr.defines['METHOD_' + this.model.get('rendering_method')] = true; + // //this.box_material_volr.defines['VOLUME_COUNT'] = 1 + // this.box_material_volr.needsUpdate = true + // this.box_material_volr_depth.defines = {COORDINATE: true, USE_LIGHTING: this.model.get('rendering_lighting')} + // //this.box_material_volr_depth.defines['METHOD_' + this.model.get('rendering_method')] = true; + // this.box_material_volr_depth.needsUpdate = true; + // //this.box_material_volr_depth.defines['VOLUME_COUNT'] = 1 + // } + + this.tf_set(); + this.data_set(); + const update_rendering_method = () => { + this.renderer.rebuild_multivolume_rendering_material(); + this.renderer.update(); + }; + this.model.on("change:rendering_method", update_rendering_method); + // this.model.on('change:rendering_method change:rendering_lighting', update_volr_defines) + update_rendering_method(); + + this.model.on("change:data", this.data_set, this); + + const update_minmax = () => { + this.renderer.rebuild_multivolume_rendering_material(); + this.renderer.update(); + }; + this.model.on("change:data_min change:data_max change:show_min change:show_max", update_minmax, this); + update_minmax(); + + const update_clamp = () => { + this.renderer.rebuild_multivolume_rendering_material(); + this.renderer.update(); + }; + this.model.on("change:clamp_min change:clamp_max", update_clamp, this); + update_clamp(); + + const update_opacity_scale = () => { + this.renderer.rebuild_multivolume_rendering_material(); + this.renderer.update(); + }; + update_opacity_scale(); + this.model.on("change:opacity_scale", update_opacity_scale); + + const update_lighting = () => { + this.renderer.rebuild_multivolume_rendering_material(); + this.renderer.update(); + }; + update_lighting(); + this.model.on("change:lighting", update_lighting); + + const update_ray_steps = () => { + this.renderer.rebuild_multivolume_rendering_material(); + this.renderer.update(); + }; + update_ray_steps(); + this.model.on("change:ray_steps", update_ray_steps); + + const update_brightness = () => { + this.renderer.rebuild_multivolume_rendering_material(); + this.renderer.update(); + }; + update_brightness(); + this.model.on("change:brightness", update_brightness); + + this.model.on("change:tf", this.tf_set, this); + + this.model.on("change:extent", () => { + this.renderer.rebuild_multivolume_rendering_material(); + this.renderer.update(); + }); + + const on_change_material = () => { + this.renderer.rebuild_multivolume_rendering_material(); + this.renderer.update(); + }; + on_change_material(); + this.model.get('material').on("change", on_change_material); + + this.model.on("change:visible", () => { + this.renderer.rebuild_multivolume_rendering_material(); + this.renderer.update(); + }); + this.model.on("change:clip_x_min change:clip_x_max change:clip_y_min change:clip_y_max change:clip_z_min change:clip_z_max", () => { + this.renderer.update(); + }); + + (window as any).last_volume = this; // for debugging purposes + + } + + get_ray_steps() { + let ray_steps = this.model.get("ray_steps"); + if (ray_steps == null) { + ray_steps = max(this.data_shape); + } + return ray_steps; + } + + data_set() { + this.volume = (this.model as VolumeModel).volume; + this.texture_volume = (this.model as VolumeModel).texture_volume; + this.data_shape = [this.volume.slice_shape[0], this.volume.slice_shape[1], this.volume.slices]; + this.renderer.rebuild_multivolume_rendering_material(); + this.renderer.update(); + } + + tf_set() { + // TODO: remove listeners from previous + if (this.model.get("tf")) { + this.model.get("tf").on("change:rgba", this.tf_changed, this); + this.tf_changed(); + } + } + + tf_changed() { + this.renderer.rebuild_multivolume_rendering_material(); + this.renderer.update(); + } + + set_scales(scales) { + (this.model as VolumeModel).set_scales(scales); + } + +} + +export +class VolumeModel extends widgets.WidgetModel { + static serializers = { + ...widgets.WidgetModel.serializers, + tf: { deserialize: widgets.unpack_models }, + data: { serialize: (x) => x}, + material: { deserialize: widgets.unpack_models }, + }; + + volume: any; + scales?: any; + texture_volume: THREE.DataTexture; + uniform_volumes_values: { + data_range?: any, + show_range?: any, + clamp_min?: any, + clamp_max?: any, + opacity_scale?: any, + lighting?: any, + brightness?: any, + rows?: any, + columns?: any, + slices?: any, + size?: any, + slice_size?: any, + scale?: any, + offset?: any, + diffuseColor?: any, + specular?: any, + shininess?: any, + emissive?: any; + }; + uniform_data: { type: string; value: any[]; }; + box_geo: THREE.BoxBufferGeometry; + vol_box_mesh: THREE.Mesh; + vol_box_geo: THREE.BoxBufferGeometry; + box_material: THREE.ShaderMaterial; + texture_tf: any; + uniform_transfer_function: { type: string; value: any[]; }; + + initialize(attributes: any, options: any) { + super.initialize(attributes, options); + const update_texture = () => { + this.volume = this.get("data"); + if(!this.volume) + return; + const data = new Uint8Array(this.volume.tiles.buffer); + this.texture_volume = new THREE.DataTexture(data, this.volume.image_shape[0], this.volume.image_shape[1], + THREE.RGBAFormat, THREE.UnsignedByteType); + this.texture_volume.magFilter = THREE.LinearFilter; + this.texture_volume.minFilter = THREE.LinearFilter; + this.uniform_volumes_values.rows = this.volume.rows; + this.uniform_volumes_values.columns = this.volume.columns; + this.uniform_volumes_values.slices = this.volume.slices; + this.uniform_volumes_values.size = this.volume.image_shape; + this.uniform_volumes_values.slice_size = this.volume.slice_shape; + this.uniform_volumes_values.data_range = [this.get("data_min"), this.get("data_max")]; + this.uniform_volumes_values.show_range = [this.get("show_min"), this.get("show_max")]; + this.texture_volume.needsUpdate = true; // without this it doesn't seem to work + + this.uniform_data.value = [this.texture_volume]; + this.uniform_data.value = [this.texture_volume]; + } + this.on("change:data", () => { + update_texture(); + }) + this.uniform_volumes_values = { + scale: [1, 1, 1], + offset: [0, 0, 0], + }; + this.uniform_data = {type: "tv", value: []}; + update_texture(); + + const update_minmax = () => { + this.uniform_volumes_values.data_range = [this.get("data_min"), this.get("data_max")]; + this.uniform_volumes_values.show_range = [this.get("show_min"), this.get("show_max")]; + }; + this.on("change:data_min change:data_max change:show_min change:show_max", update_minmax, this); + const update_clamp = () => { + this.uniform_volumes_values.clamp_min = this.get("clamp_min"); + this.uniform_volumes_values.clamp_max = this.get("clamp_max"); + }; + this.on("change:clamp_min change:clamp_max", update_clamp, this); + update_clamp(); + const update_opacity_scale = () => { + this.uniform_volumes_values.opacity_scale = this.get("opacity_scale"); + }; + update_opacity_scale(); + this.on("change:opacity_scale", update_opacity_scale); + const update_lighting = () => { + this.uniform_volumes_values.lighting = this.get("lighting"); + }; + update_lighting(); + this.on("change:lighting", update_lighting); + const update_brightness = () => { + this.uniform_volumes_values.brightness = this.get("brightness"); + }; + update_brightness(); + this.on("change:brightness", update_brightness); + const on_change_material = () => { + const material = this.get('material').obj; + const white = new THREE.Color('white'); + this.uniform_volumes_values.diffuseColor = material.color || white; + this.uniform_volumes_values.specular = material.specular || white; + this.uniform_volumes_values.shininess = material.shininess || white; + this.uniform_volumes_values.emissive = material.emissive || white; + }; + on_change_material(); + this.get('material').on("change", on_change_material); + + this.box_material = new THREE.ShaderMaterial({ + uniforms: { + offset: { type: "3f", value: [0, 0, 0] }, + scale : { type: "3f", value: [1, 1, 1] }, + }, + fragmentShader: shaders.box_fragment, + vertexShader: shaders.box_vertex, + side: THREE.BackSide, + }); + this.vol_box_mesh = new THREE.Mesh(this.vol_box_geo, this.box_material); + this.vol_box_mesh.name = "Box for " + this.get("description"); + this.vol_box_geo = new THREE.BoxBufferGeometry(1, 1, 1); + //@ts-ignore + this.vol_box_mesh.isVolume = true; + // this.vol_box_mesh.position.z = -5; + this.vol_box_mesh.updateMatrix(); + this.vol_box_mesh.matrixAutoUpdate = true; + + this.uniform_transfer_function = {type: "tv", value: []}; + this.on("change:tf", this.tf_set, this); + this.tf_set(); + + } + tf_set() { + // TODO: remove listeners from previous + if (this.get("tf")) { + this.get("tf").on("change:rgba", this.tf_changed, this); + this.tf_changed(); + } + } + + tf_changed() { + const tf = this.get("tf"); + if (tf) { + /*if(!this.texture_tf) { + this.texture_tf = new THREE.DataTexture(tf.get_data_array(), tf.get("rgba").length, 1, THREE.RGBAFormat, THREE.UnsignedByteType) + } else { + this.texture_tf.image.data = tf.get_data_array() + this.texture_tf.needsUpdate = true + }*/ + this.texture_tf = new THREE.DataTexture(tf.get_data_array(), tf.get("rgba").shape[0], 1, THREE.RGBAFormat, THREE.UnsignedByteType); + this.texture_tf.needsUpdate = true; // without this it doesn't seem to work + // this.box_material_volr.uniforms.transfer_function.value = [this.texture_tf] + this.uniform_transfer_function.value = [this.texture_tf]; + } + } + is_max_intensity() { + return this.get("rendering_method") === "MAX_INTENSITY"; + } + + is_normal() { + return this.get("rendering_method") === "NORMAL"; + } + set_scales(scales) { + this.scales = scales; + this.update_geometry(); + } + update_geometry() { + const sx = createD3Scale(this.scales.x).range([0, 1]); + const sy = createD3Scale(this.scales.y).range([0, 1]); + const sz = createD3Scale(this.scales.z).range([0, 1]); + + const extent = this.get("extent"); + + // return v, of the clipped value + const or_clip = (v, name) => { + const clip_value = this.get("clip_" + name); + if ((clip_value === undefined) || (clip_value === null)) { + return v; + } + return clip_value; + } + + // normalized coordinates of the corners of the box + const x0n = sx(extent[0][0]); + const x1n = sx(extent[0][1]); + const y0n = sy(extent[1][0]); + const y1n = sy(extent[1][1]); + const z0n = sz(extent[2][0]); + const z1n = sz(extent[2][1]); + + // normalized coordinates of the corners of the box + // including the custom clipping, and viewport clipping + const cx0 = Math.max(sx(or_clip(extent[0][0], "x_min")), 0); + const cx1 = Math.min(sx(or_clip(extent[0][1], "x_max")), 1); + const cy0 = Math.max(sy(or_clip(extent[1][0], "y_min")), 0); + const cy1 = Math.min(sy(or_clip(extent[1][1], "y_max")), 1); + const cz0 = Math.max(sz(or_clip(extent[2][0], "z_min")), 0); + const cz1 = Math.min(sz(or_clip(extent[2][1], "z_max")), 1); + + + // the clipped coordinates back to world space, then normalized to extend + // these are example calculations, the transform goes into scale and offset uniforms below + // var cwx0 = (cx0 * dx + xlim[0] - extent[0][0])/(extent[0][1] - extent[0][0]) + // var cwx1 = (cx1 * dx + xlim[0] - extent[0][0])/(extent[0][1] - extent[0][0]) + + // this.box_geo = new THREE.BoxBufferGeometry(cx1-cx0, cy1-cy0, cz1-cz0) + // this.box_geo.translate((cx1-x0)/2, (cy1-cy0)/2, (cz1-cz0)/2) + // this.box_geo.translate(cx0, cy0, cz0) + // this.box_geo.translate(-0.5, -0.5, -0.5) + this.box_geo = new THREE.BoxBufferGeometry(1, 1, 1); + this.box_geo.translate(0.5, 0.5, 0.5); + this.box_geo.scale((cx1 - cx0), (cy1 - cy0), (cz1 - cz0)); + this.box_geo.translate(cx0, cy0, cz0); + this.box_geo.translate(-0.5, -0.5, -0.5); + this.vol_box_mesh.geometry = this.box_geo; + + this.uniform_volumes_values.scale = [1 / (x1n - x0n), 1 / (y1n - y0n), 1 / (z1n - z0n)]; + this.uniform_volumes_values.offset = [-x0n, -y0n, -z0n]; + + } + add_to_scene(parent) { + parent.add(this.vol_box_mesh); + } + + remove_from_scene(parent) { + parent.remove(this.vol_box_mesh); + } + defaults() { + return { + ...super.defaults(), + _model_name : "VolumeModel", + _view_name : "VolumeView", + _model_module : "ipyvolume", + _view_module : "ipyvolume", + _model_module_version: semver_range, + _view_module_version: semver_range, + sequence_index: 0, + step_size: 0.01, + opacity_scale: 1.0, + brightness: 1.0, + extent: null, + lighting: true, + rendering_method: "NORMAL", + clamp_min: false, + clamp_max: false, + data_range: null, + show_range: null, + show_min: 0, + show_max: 1, + data_min: 0, + data_max: 1, + ray_steps: null, + material: null, // TODO: this default does not match the one from the Python side + visible: true, + }; + } +} diff --git a/js/tsconfig.json b/js/tsconfig.json index 1d6daff2..e50e2ce6 100644 --- a/js/tsconfig.json +++ b/js/tsconfig.json @@ -1,22 +1,25 @@ { -"compilerOptions": { - "noImplicitAny": true, - "lib": ["dom", "es5", "es2015.promise", "es2015.iterable"], - "noEmitOnError": true, - "strictNullChecks": true, + "compilerOptions": { + "esModuleInterop": true, "module": "commonjs", "moduleResolution": "node", - "target": "es2015", + "noEmitOnError": true, + "noUnusedLocals": false, "outDir": "lib", + "preserveWatchOutput": true, + "rootDir": "src", + "inlineSourceMap": true, "skipLibCheck": true, - "sourceMap": true, - "allowJs": true + "strictNullChecks": false, + "target": "es2017", + "types": ["mocha", "node"], + "allowJs": true, }, "include": [ - "./src/**/*" + "./src/**/*" ], "exclude": [ - "node_modules", - "**/*.spec.ts" + "node_modules", + "**/*.spec.ts" ] } diff --git a/js/tslint.json b/js/tslint.json new file mode 100644 index 00000000..4b0d588b --- /dev/null +++ b/js/tslint.json @@ -0,0 +1,17 @@ +{ + "defaultSeverity": "error", + "extends": [ + "tslint:recommended" + ], + "jsRules": {}, + "rules": { + "member-access": false, + "variable-name": false, + "object-literal-sort-keys": false, + "max-line-length": [true, 150], + "no-console": false, + "max-classes-per-file": false + }, + "rulesDirectory": [] + +} \ No newline at end of file diff --git a/js/webpack.config.js b/js/webpack.config.js index ba7fb2e4..5cbfd124 100644 --- a/js/webpack.config.js +++ b/js/webpack.config.js @@ -7,18 +7,11 @@ var pyname = 'ipyvolume' var rules = [ { test: /\.css$/, use: ['style-loader', 'css-loader']}, {test: /\.png$/,use: 'url-loader?limit=10000000'}, - // { test: /\.js$/, loader: 'babel-loader', exclude: /node_modules/}, - { test: /\.(ts|js)?$/, use: [ - { loader: 'cache-loader' }, - { - loader: 'thread-loader', - options: { - // there should be 1 cpu for the fork-ts-checker-webpack-plugin - workers: require('os').cpus().length - 1, - }, - }, - { loader: "ts-loader", options: {transpileOnly: true,happyPackMode: true} } - ]} + { + test: /\.(js|ts)$/, + use: ["source-map-loader"], + enforce: "pre" + } ]; var resolve = { @@ -35,12 +28,13 @@ module.exports = [ // "load_ipython_extension" function which is required for any notebook // extension. // - entry: './src/extension.js', + entry: './lib/extension.js', devtool: 'inline-source-map', output: { filename: 'extension.js', - path: path.resolve(__dirname, `../${pyname}/static`), - libraryTarget: 'amd' + path: path.resolve(__dirname, `../share/jupyter/nbextensions/${pyname}`), + libraryTarget: 'amd', + devtoolModuleFilenameTemplate: `webpack://jupyter-widgets/${pyname}/[resource-path]?[loaders]`, }, resolve: resolve }, @@ -50,18 +44,18 @@ module.exports = [ // custom widget. // It must be an amd module // - entry: './src/index.js', + entry: './lib/index.js', devtool: 'inline-source-map', output: { filename: 'index.js', - path: path.resolve(__dirname, `../${pyname}/static`), - libraryTarget: 'amd' + path: path.resolve(__dirname, `../share/jupyter/nbextensions/${pyname}`), + libraryTarget: 'amd', + devtoolModuleFilenameTemplate: `webpack://jupyter-widgets/${pyname}/[resource-path]?[loaders]`, }, - devtool: 'source-map', module: { rules: rules }, - externals: ['three', 'jupyter-js-widgets', '@jupyter-widgets/base', '@jupyter-widgets/controls'], + externals: ['three', 'jupyter-js-widgets', '@jupyter-widgets/base'], resolve: resolve }, {// Embeddable ipyvolume bundle @@ -78,7 +72,7 @@ module.exports = [ // The target bundle is always `dist/index.js`, which is the path required // by the custom widget embedder. // - entry: './src/embed.js', + entry: './lib/embed.js', devtool: 'inline-source-map', resolve: { extensions: ['.ts', '.js', ''] @@ -87,20 +81,21 @@ module.exports = [ filename: 'index.js', path: path.resolve(__dirname, './dist/'), libraryTarget: 'amd', - publicPath: 'https://unpkg.com/ipyvolume@' + version + '/dist/' + publicPath: 'https://unpkg.com/ipyvolume@' + version + '/dist/', + devtoolModuleFilenameTemplate: `webpack://jupyter-widgets/${pyname}/[resource-path]?[loaders]`, }, devtool: 'source-map', module: { rules: rules }, - externals: ['jupyter-js-widgets', '@jupyter-widgets/base', '@jupyter-widgets/controls'], + externals: ['jupyter-js-widgets', '@jupyter-widgets/base'], resolve: resolve }, { entry: 'three', output: { filename: 'three.js', - path: path.resolve(__dirname, `../${pyname}/static`), + path: path.resolve(__dirname, `../share/jupyter/nbextensions/${pyname}`), libraryTarget: 'amd' }, devtool: 'source-map', diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 00000000..ba04c53f --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,3 @@ +[build-system] +requires = ["jupyter_packaging~=0.7.9", "jupyterlab~=3.0", "setuptools>=40.8.0", "wheel"] +build-backend = "setuptools.build_meta" diff --git a/release.sh b/release.sh new file mode 100755 index 00000000..0f104ed0 --- /dev/null +++ b/release.sh @@ -0,0 +1,6 @@ +#!/bin/bash +set -e -o pipefail +# usage: ./release minor -n +version=$(bump2version --dry-run --list $* | grep new_version | sed -r s,"^.*=",,) +echo Version tag v$version +bumpversion $* --verbose && git push upstream master v$version diff --git a/requirements_rtd.txt b/requirements_rtd.txt index bff50a45..cd9d4ab1 100644 --- a/requirements_rtd.txt +++ b/requirements_rtd.txt @@ -1,13 +1,26 @@ -jupyter_sphinx>=0.1.4 +jupyter_sphinx==0.1.4 #git+https://github.com/maartenbreddels/jupyter-sphinx@ipywidgets7require_d -ipyvolume==0.5.1 +ipyvolume==0.6.0a10 ipywidgets>=7.4.0 traittypes traitlets Pillow scipy -nbsphinx +git+https://github.com/maartenbreddels/nbconvert@fix_closing_script_early#egg=nbconvert +git+https://github.com/maartenbreddels/nbsphinx@fix_closing_script_early#egg=nbsphinx +git+https://github.com/maartenbreddels/nbclient@fix_update_widget_buffers#egg=nbclient recommonmark -matplotlib<2 +matplotlib==3.1.1 ipywebrtc requests +emcee +corner +sphinx_gallery +vaex-core +vaex-hdf5 +vaex-ml +vaex-viz +# see https://github.com/sphinx-doc/sphinx/issues/9727#issuecomment-952289876 +docutils==0.17.1 +bokeh +ipython_genutils diff --git a/setup.cfg b/setup.cfg index 4a067e92..2692c21e 100644 --- a/setup.cfg +++ b/setup.cfg @@ -1,7 +1,7 @@ -[bdist_wheel] -universal=1 - [flake8] -max-line-length = 130 +max-line-length = 230 # once we become more mature, we may want to be more strict -ignore = D100, D101, D102, D103, D104, D105, D107, E203, E722 \ No newline at end of file +ignore = D100, D101, D102, D103, D104, D105, D107, E203, E722 + +[metadata] +license_file = LICENSE diff --git a/setup.py b/setup.py index d307c873..c6ce9533 100644 --- a/setup.py +++ b/setup.py @@ -1,191 +1,117 @@ from __future__ import print_function + from setuptools import setup, find_packages, Command -from setuptools.command.sdist import sdist -from setuptools.command.build_py import build_py -from setuptools.command.egg_info import egg_info -from subprocess import check_call + +from jupyter_packaging import ( + create_cmdclass, + install_npm, + ensure_targets, + combine_commands, + get_version, +) + import os -import sys -import platform +from os.path import join as pjoin +from pathlib import Path from distutils import log here = os.path.dirname(os.path.abspath(__file__)) -node_root = os.path.join(here, 'js') -is_repo = os.path.exists(os.path.join(here, '.git')) -npm_path = os.pathsep.join([os.path.join(node_root, 'node_modules', '.bin'), os.environ.get('PATH', os.defpath)]) +def skip_if_exists(paths, CommandClass): + """Skip a command if list of paths exists.""" + def should_skip(): + return any(not Path(path).exist() for path in paths) + class SkipIfExistCommand(Command): + def initialize_options(self): + if not should_skip: + self.command = CommandClass(self.distribution) + self.command.initialize_options() + else: + self.command = None + + def finalize_options(self): + if self.command is not None: + self.command.finalize_options() + def run(self): + if self.command is not None: + self.command.run() -log.set_verbosity(log.DEBUG) -log.info('setup.py entered') -log.info('$PATH=%s' % os.environ['PATH']) + return SkipIfExistCommand + +# jupyter lab install will fail it we print out info +# log.set_verbosity(log.DEBUG) +# log.info('setup.py entered') +# log.info('$PATH=%s' % os.environ['PATH']) def read(fname): return open(os.path.join(os.path.dirname(__file__), fname)).read() - +name = 'ipyvolume' LONG_DESCRIPTION = read("README.rst") - - -def js_prerelease(command, strict=False): - """Decorator for building minified js/css prior to another command.""" - class DecoratedCommand(command): - def run(self): - jsdeps = self.distribution.get_command_obj('jsdeps') - if not is_repo and all(os.path.exists(t) for t in jsdeps.targets): - # sdist, nothing to do - command.run(self) - return - - try: - self.distribution.run_command('jsdeps') - except Exception as e: - missing = [t for t in jsdeps.targets if not os.path.exists(t)] - if strict or missing: - log.warn('rebuilding js and css failed') - if missing: - log.error('missing files: %s' % missing) - raise e - else: - log.warn('rebuilding js and css failed (not a problem)') - log.warn(str(e)) - command.run(self) - update_package_data(self.distribution) - - return DecoratedCommand - - -def update_package_data(distribution): - """Update package_data to catch changes during setup.""" - build_py = distribution.get_command_obj('build_py') - # distribution.package_data = find_package_data() - # re-init build_py options which load package_data - build_py.finalize_options() - - -class NPM(Command): - description = 'install package.json dependencies using npm' - - user_options = [] - - node_modules = os.path.join(node_root, 'node_modules') - - targets = [ - os.path.join(here, 'ipyvolume', 'static', 'extension.js'), - os.path.join(here, 'ipyvolume', 'static', 'index.js'), - os.path.join(here, 'ipyvolume', 'static', 'three.js'), - ] - - def initialize_options(self): - pass - - def finalize_options(self): - pass - - def get_npm_name(self): - npmName = 'npm' - if platform.system() == 'Windows': - npmName = 'npm.cmd' - return npmName - - def has_npm(self): - npmName = self.get_npm_name() - try: - check_call([npmName, '--version']) - return True - except: - return False - - def should_run_npm_install(self): - return self.has_npm() - - def run(self): - has_npm = self.has_npm() - if not has_npm: - log.error( - "`npm` unavailable. If you're running this command using sudo, make sure `npm` is available to sudo" - ) - - env = os.environ.copy() - env['PATH'] = npm_path - - if self.should_run_npm_install(): - log.info("Installing build dependencies with npm. This may take a while...") - npmName = self.get_npm_name() - check_call([npmName, 'install'], cwd=node_root, stdout=sys.stdout, stderr=sys.stderr) - os.utime(self.node_modules, None) - - for t in self.targets: - if not os.path.exists(t): - msg = 'Missing file: %s' % t - if not has_npm: - msg += '\nnpm is required to build a development version of widgetsnbextension' - raise ValueError(msg) - - # update package data in case this created new files - update_package_data(self.distribution) - - -version_ns = {} -with open(os.path.join(here, 'ipyvolume', '_version.py')) as f: - exec(f.read(), {}, version_ns) - -setup_args = { - 'name': 'ipyvolume', - 'version': version_ns['__version__'], - 'description': 'IPython widget for rendering 3d volumes', - 'long_description': LONG_DESCRIPTION, - 'include_package_data': True, - 'data_files': [ - ( - 'share/jupyter/nbextensions/ipyvolume', - [ - 'ipyvolume/static/extension.js', - 'ipyvolume/static/index.js', - 'ipyvolume/static/three.js', - 'ipyvolume/static/index.js.map', - ], - ), - ('etc/jupyter/nbconfig/notebook.d', ['ipyvolume.json']), - ], - 'install_requires': [ +version = get_version(pjoin(name, '_version.py')) +js_dir = pjoin(here, 'js') +jstargets = [ + pjoin(js_dir, 'lib', 'index.js'), + pjoin('share', 'jupyter', 'nbextensions', 'ipyvolume', 'index.js'), +] +data_files_spec = [ + ('share/jupyter/nbextensions/ipyvolume', 'share/jupyter/nbextensions/ipyvolume', '*.js'), + ('share/jupyter/labextensions/ipyvolume', 'share/jupyter/labextensions/ipyvolume', '*'), + ('share/jupyter/labextensions/ipyvolume/static', 'share/jupyter/labextensions/ipyvolume/static', '*'), + ('etc/jupyter/nbconfig/notebook.d', 'etc/jupyter/nbconfig/notebook.d', 'ipyvolume.json'), +] + +js_command = combine_commands( + install_npm(js_dir, build_cmd='build'), ensure_targets(jstargets), +) + +cmdclass = create_cmdclass('jsdeps', data_files_spec=data_files_spec) +is_repo = os.path.exists(os.path.join(here, '.git')) +if is_repo: + cmdclass['jsdeps'] = js_command +else: + cmdclass['jsdeps'] = skip_if_exists(jstargets, js_command) + +setup( + name="ipyvolume", + version=version, + description='IPython widget for rendering 3d volumes', + long_description=LONG_DESCRIPTION, + include_package_data=True, + cmdclass=cmdclass, + install_requires=[ 'ipywidgets>=7.0.0', + 'bqplot', 'numpy', 'traittypes', 'traitlets', 'Pillow', 'ipywebrtc', 'requests', - 'pythreejs>=2.0.0' + 'ipyvuetify', + 'ipyvue>=1.7.0', + 'pythreejs>=2.4.0', + 'matplotlib' ], - 'license': 'MIT', - 'packages': find_packages(), - 'zip_safe': False, - 'cmdclass': { - 'build_py': js_prerelease(build_py), - 'egg_info': js_prerelease(egg_info), - 'sdist': js_prerelease(sdist, strict=True), - 'jsdeps': NPM, - }, - 'author': 'Maarten A. Breddels', - 'author_email': 'maartenbreddels@gmail.com', - 'url': 'https://github.com/maartenbreddels/ipyvolume', - 'keywords': ['ipython', 'jupyter', 'widgets', 'volume rendering'], - 'classifiers': [ + license='MIT', + packages=find_packages(), + zip_safe=False, + author='Maarten A. Breddels', + author_email='maartenbreddels@gmail.com', + url='https://github.com/maartenbreddels/ipyvolume', + keywords=['ipython', 'jupyter', 'widgets', 'volume rendering'], + classifiers=[ 'Development Status :: 4 - Beta', 'Framework :: IPython', 'Intended Audience :: Developers', 'Intended Audience :: Science/Research', 'Topic :: Multimedia :: Graphics', - 'Programming Language :: Python :: 2', - 'Programming Language :: Python :: 2.7', 'Programming Language :: Python :: 3', - 'Programming Language :: Python :: 3.3', - 'Programming Language :: Python :: 3.4', - 'Programming Language :: Python :: 3.5', 'Programming Language :: Python :: 3.6', + 'Programming Language :: Python :: 3.7', + 'Programming Language :: Python :: 3.8', ], -} - -setup(**setup_args) + package_data={'ipyvolume.vue': ['*.vue']}, +) diff --git a/ui-tests/README.md b/ui-tests/README.md new file mode 100644 index 00000000..01c43c23 --- /dev/null +++ b/ui-tests/README.md @@ -0,0 +1 @@ +Should be run the same as https://github.com/bqplot/bqplot/tree/master/ui-tests \ No newline at end of file diff --git a/ui-tests/galata-config.json b/ui-tests/galata-config.json new file mode 100644 index 00000000..add5f97d --- /dev/null +++ b/ui-tests/galata-config.json @@ -0,0 +1,3 @@ +{ + "testId": "test" +} diff --git a/ui-tests/jupyter_server_config.py b/ui-tests/jupyter_server_config.py new file mode 100644 index 00000000..2c51cf18 --- /dev/null +++ b/ui-tests/jupyter_server_config.py @@ -0,0 +1,8 @@ +c.ServerApp.port = 8999 +c.ServerApp.token = "" +c.ServerApp.password = "" +c.ServerApp.disable_check_xsrf = True +c.ServerApp.open_browser = False +c.LabApp.open_browser = False +c.LabApp.expose_app_in_browser = True +c.ExtensionApp.answer_yes = True diff --git a/ui-tests/package.json b/ui-tests/package.json new file mode 100644 index 00000000..da4175ad --- /dev/null +++ b/ui-tests/package.json @@ -0,0 +1,19 @@ +{ + "name": "ipyvolume-ui-tests", + "version": "1.0.0", + "description": "ipyvolume UI Tests", + "private": true, + "scripts": { + "start-jlab": "jupyter lab --config ./jupyter_server_config.py", + "start-jlab:detached": "yarn run start-jlab&", + "clean": "rimraf tests/notebooks/.ipynb_checkpoints && rimraf test-output", + "test": "yarn run clean && galata --jlab-base-url http://localhost:8999 --image-match-threshold 0.25", + "update-references": "galata --update-references" + }, + "license": "Apache-2.0", + "dependencies": { + "@jupyterlab/galata": "3.0.11-2", + "klaw-sync": "^6.0.0", + "rimraf": "^3.0.2" + } +} diff --git a/ui-tests/reference-output/screenshots/6 b/ui-tests/reference-output/screenshots/6 new file mode 100644 index 00000000..3ea28f3d Binary files /dev/null and b/ui-tests/reference-output/screenshots/6 differ diff --git a/ui-tests/reference-output/screenshots/lighting_ipynb_cell_0.png b/ui-tests/reference-output/screenshots/lighting_ipynb_cell_0.png new file mode 100644 index 00000000..852c456c Binary files /dev/null and b/ui-tests/reference-output/screenshots/lighting_ipynb_cell_0.png differ diff --git a/ui-tests/reference-output/screenshots/lighting_ipynb_cell_1.png b/ui-tests/reference-output/screenshots/lighting_ipynb_cell_1.png new file mode 100644 index 00000000..852c456c Binary files /dev/null and b/ui-tests/reference-output/screenshots/lighting_ipynb_cell_1.png differ diff --git a/ui-tests/reference-output/screenshots/lighting_ipynb_cell_2.png b/ui-tests/reference-output/screenshots/lighting_ipynb_cell_2.png new file mode 100644 index 00000000..98efe8d9 Binary files /dev/null and b/ui-tests/reference-output/screenshots/lighting_ipynb_cell_2.png differ diff --git a/ui-tests/reference-output/screenshots/lighting_ipynb_cell_3.png b/ui-tests/reference-output/screenshots/lighting_ipynb_cell_3.png new file mode 100644 index 00000000..47c2b1c8 Binary files /dev/null and b/ui-tests/reference-output/screenshots/lighting_ipynb_cell_3.png differ diff --git a/ui-tests/reference-output/screenshots/lighting_ipynb_cell_4.png b/ui-tests/reference-output/screenshots/lighting_ipynb_cell_4.png new file mode 100644 index 00000000..c070d9b0 Binary files /dev/null and b/ui-tests/reference-output/screenshots/lighting_ipynb_cell_4.png differ diff --git a/ui-tests/reference-output/screenshots/lighting_ipynb_cell_5.png b/ui-tests/reference-output/screenshots/lighting_ipynb_cell_5.png new file mode 100644 index 00000000..526ad857 Binary files /dev/null and b/ui-tests/reference-output/screenshots/lighting_ipynb_cell_5.png differ diff --git a/ui-tests/reference-output/screenshots/lighting_ipynb_cell_6.png b/ui-tests/reference-output/screenshots/lighting_ipynb_cell_6.png new file mode 100644 index 00000000..acd04d2d Binary files /dev/null and b/ui-tests/reference-output/screenshots/lighting_ipynb_cell_6.png differ diff --git a/ui-tests/reference-output/screenshots/scatter_ipynb_cell_0.png b/ui-tests/reference-output/screenshots/scatter_ipynb_cell_0.png new file mode 100644 index 00000000..62fc8838 Binary files /dev/null and b/ui-tests/reference-output/screenshots/scatter_ipynb_cell_0.png differ diff --git a/ui-tests/tests/ipyvolume.test.ts b/ui-tests/tests/ipyvolume.test.ts new file mode 100644 index 00000000..9342f749 --- /dev/null +++ b/ui-tests/tests/ipyvolume.test.ts @@ -0,0 +1,149 @@ +// Copyright (c) Jupyter Development Team. +// Distributed under the terms of the Modified BSD License. + +import { galata, describe, test } from '@jupyterlab/galata'; +import * as path from 'path'; +const klaw = require('klaw-sync'); + +jest.setTimeout(600000); + +const filterUpdateNotebooks = item => { + const basename = path.basename(item.path); + return basename.includes('_update'); +} + +describe('ipyvolume Visual Regression', () => { + beforeAll(async () => { + await galata.resetUI(); + }); + + afterAll(async () => { + galata.context.capturePrefix = ''; + }); + + test('Upload files to JupyterLab', async () => { + await galata.contents.moveDirectoryToServer( + path.resolve(__dirname, `./notebooks`), + 'uploaded' + ); + expect( + await galata.contents.fileExists('uploaded/scatter.ipynb') + ).toBeTruthy(); + }); + + test('Refresh File Browser', async () => { + await galata.filebrowser.refresh(); + }); + + test('Open directory uploaded', async () => { + await galata.filebrowser.openDirectory('uploaded'); + expect( + await galata.filebrowser.isFileListedInBrowser('scatter.ipynb') + ).toBeTruthy(); + }); + + test('Check ipyvolume first renders', async () => { + const paths = klaw('tests/notebooks', {filter: item => !filterUpdateNotebooks(item), nodir: true}); + const notebooks = paths.map(item => path.basename(item.path)); + + let results = []; + + for (const notebook of notebooks) { + galata.context.capturePrefix = notebook; + + await galata.notebook.open(notebook); + expect(await galata.notebook.isOpen(notebook)).toBeTruthy(); + await galata.notebook.activate(notebook); + expect(await galata.notebook.isActive(notebook)).toBeTruthy(); + + let numCellImages = 0; + + const getCaptureImageName = (id: number): string => { + return `cell-${id}`; + }; + + await galata.notebook.runCellByCell({ + onAfterCellRun: async (cellIndex: number) => { + const cell = await galata.notebook.getCellOutput(cellIndex); + if (cell) { + if ( + await galata.capture.screenshot( + getCaptureImageName(numCellImages), + cell + ) + ) { + numCellImages++; + } + } + } + }); + + for (let c = 0; c < numCellImages; ++c) { + results.push(await galata.capture.compareScreenshot(getCaptureImageName(c))); + } + + await galata.notebook.close(true); + } + + for (const result of results) { + expect(result).toBe('same'); + } + }); + + test('Check ipyvolume update plot properties', async () => { + const paths = klaw('tests/notebooks', {filter: item => filterUpdateNotebooks(item), nodir: true}); + const notebooks = paths.map(item => path.basename(item.path)); + + let results = []; + + for (const notebook of notebooks) { + galata.context.capturePrefix = notebook; + + await galata.notebook.open(notebook); + expect(await galata.notebook.isOpen(notebook)).toBeTruthy(); + await galata.notebook.activate(notebook); + expect(await galata.notebook.isActive(notebook)).toBeTruthy(); + + let numCellImages = 0; + + const getCaptureImageName = (id: number): string => { + return `cell-${id}`; + }; + + await galata.notebook.runCellByCell({ + onAfterCellRun: async (cellIndex: number) => { + // Always get first cell output which must contain the plot + const cell = await galata.notebook.getCellOutput(0); + if (cell) { + if ( + await galata.capture.screenshot( + getCaptureImageName(numCellImages), + cell + ) + ) { + numCellImages++; + } + } + } + }); + + for (let c = 0; c < numCellImages; ++c) { + results.push(await galata.capture.compareScreenshot(getCaptureImageName(c))); + } + + await galata.notebook.close(true); + } + + for (const result of results) { + expect(result).toBe('same'); + } + }); + + test('Open home directory', async () => { + await galata.filebrowser.openHomeDirectory(); + }); + + test('Delete uploaded directory', async () => { + await galata.contents.deleteDirectory('uploaded'); + }); +}); diff --git a/ui-tests/tests/notebooks/lighting.ipynb b/ui-tests/tests/notebooks/lighting.ipynb new file mode 100644 index 00000000..90ab6a2b --- /dev/null +++ b/ui-tests/tests/notebooks/lighting.ipynb @@ -0,0 +1,238 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import ipyvolume as ipv\n", + "import numpy as np\n", + "\n", + "a0 = np.array([0.])\n", + "a1 = np.array([1.])\n", + "\n", + "def scene(flip):\n", + " ipv.xyzlim(-1, 1)\n", + " ipv.light_ambient(intensity=0.4)\n", + " ipv.light_directional(position=[0, 50, 0]);\n", + " if flip:\n", + " s = ipv.quiver(a0, a0, a0, a0, -a1, a0, marker=\"sphere\", size=20);\n", + " else:\n", + " s = ipv.scatter(a0, a0, a0, marker=\"sphere\", size=20);\n", + " m = ipv.plot_plane('bottom')\n", + " ipv.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "da839894b78744e6bbdcf834e89fc301", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox(children=(Figure(camera=PerspectiveCamera(fov=45.0, position=(0.0, 0.0, 2.0), projectionMatrix=(1.0, 0.0,…" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "f = ipv.figure()\n", + "ipv.material_physical(flat_shading=False)\n", + "scene(flip=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "90e1b671d3c84255a8ddae4527001cbc", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox(children=(Figure(camera=PerspectiveCamera(fov=45.0, position=(0.0, 0.0, 2.0), projectionMatrix=(1.0, 0.0,…" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "f = ipv.figure()\n", + "ipv.material_physical(flat_shading=True)\n", + "scene(flip=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "250b7721e554499e89b4c656ca5cb8dd", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox(children=(Figure(camera=PerspectiveCamera(fov=45.0, position=(0.0, 0.0, 2.0), projectionMatrix=(1.0, 0.0,…" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "f = ipv.figure()\n", + "ipv.material_physical()\n", + "scene(flip=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "1641e7cce9cf48e4b550c2cfd1326e69", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox(children=(Figure(camera=PerspectiveCamera(fov=45.0, position=(0.0, 0.0, 2.0), projectionMatrix=(1.0, 0.0,…" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "f = ipv.figure()\n", + "ipv.material_phong()\n", + "scene(flip=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "e3f9c5690ed24667ab3f3e650ef4fddf", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox(children=(Figure(camera=PerspectiveCamera(fov=45.0, position=(0.0, 0.0, 2.0), projectionMatrix=(1.0, 0.0,…" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "f = ipv.figure()\n", + "ipv.material_phong()\n", + "scene(flip=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "72a6e50c55bd438580c43cfd32da5ed3", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox(children=(Figure(camera=PerspectiveCamera(fov=45.0, position=(0.0, 0.0, 2.0), projectionMatrix=(1.0, 0.0,…" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "f = ipv.figure()\n", + "ipv.material_lambert()\n", + "scene(flip=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "e1fc83bb96fe4635a491101d86336c64", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox(children=(Figure(camera=PerspectiveCamera(fov=45.0, position=(0.0, 0.0, 2.0), projectionMatrix=(1.0, 0.0,…" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "f = ipv.figure()\n", + "ipv.material_lambert()\n", + "scene(flip=True)" + ] + }, + { + "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.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/ui-tests/tests/notebooks/scatter.ipynb b/ui-tests/tests/notebooks/scatter.ipynb new file mode 100644 index 00000000..7699c1d2 --- /dev/null +++ b/ui-tests/tests/notebooks/scatter.ipynb @@ -0,0 +1,82 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 5, + "id": "59937d4a", + "metadata": {}, + "outputs": [], + "source": [ + "import ipyvolume as ipv\n", + "import numpy as np" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "87765e2e", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "47f449b06fe544be8db2430c2a37e76a", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox(children=(Figure(camera=PerspectiveCamera(fov=45.0, position=(0.0, 0.0, 2.0), projectionMatrix=(1.0, 0.0,…" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "x_org = x = np.linspace(0, 2, 10)\n", + "y = x**0.5\n", + "z = x**2\n", + "fig = ipv.figure()\n", + "s = ipv.scatter(x, y, z)\n", + "ipv.xyzlim(0, 4)\n", + "ipv.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4681be0c", + "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.7.10" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "state": {}, + "version_major": 2, + "version_minor": 0 + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/ui-tests/yarn.lock b/ui-tests/yarn.lock new file mode 100644 index 00000000..28019b50 --- /dev/null +++ b/ui-tests/yarn.lock @@ -0,0 +1,4469 @@ +# THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY. +# yarn lockfile v1 + + +"@babel/code-frame@^7.0.0", "@babel/code-frame@^7.14.5": + version "7.14.5" + resolved "https://registry.yarnpkg.com/@babel/code-frame/-/code-frame-7.14.5.tgz#23b08d740e83f49c5e59945fbf1b43e80bbf4edb" + integrity sha512-9pzDqyc6OLDaqe+zbACgFkb6fKMNG6CObKpnYXChRsvYGyEdc7CA2BaqeOM+vOtCS5ndmJicPJhKAwYRI6UfFw== + dependencies: + "@babel/highlight" "^7.14.5" + +"@babel/compat-data@^7.14.5": + version "7.14.7" + resolved "https://registry.yarnpkg.com/@babel/compat-data/-/compat-data-7.14.7.tgz#7b047d7a3a89a67d2258dc61f604f098f1bc7e08" + integrity sha512-nS6dZaISCXJ3+518CWiBfEr//gHyMO02uDxBkXTKZDN5POruCnOZ1N4YBRZDCabwF8nZMWBpRxIicmXtBs+fvw== + +"@babel/core@^7.1.0", "@babel/core@^7.7.5": + version "7.14.6" + resolved "https://registry.yarnpkg.com/@babel/core/-/core-7.14.6.tgz#e0814ec1a950032ff16c13a2721de39a8416fcab" + integrity sha512-gJnOEWSqTk96qG5BoIrl5bVtc23DCycmIePPYnamY9RboYdI4nFy5vAQMSl81O5K/W0sLDWfGysnOECC+KUUCA== + dependencies: + "@babel/code-frame" "^7.14.5" + "@babel/generator" "^7.14.5" + "@babel/helper-compilation-targets" "^7.14.5" + "@babel/helper-module-transforms" "^7.14.5" + "@babel/helpers" "^7.14.6" + "@babel/parser" "^7.14.6" + "@babel/template" "^7.14.5" + "@babel/traverse" "^7.14.5" + "@babel/types" "^7.14.5" + convert-source-map "^1.7.0" + debug "^4.1.0" + gensync "^1.0.0-beta.2" + json5 "^2.1.2" + semver "^6.3.0" + source-map "^0.5.0" + +"@babel/generator@^7.14.5": + version "7.14.5" + resolved "https://registry.yarnpkg.com/@babel/generator/-/generator-7.14.5.tgz#848d7b9f031caca9d0cd0af01b063f226f52d785" + integrity sha512-y3rlP+/G25OIX3mYKKIOlQRcqj7YgrvHxOLbVmyLJ9bPmi5ttvUmpydVjcFjZphOktWuA7ovbx91ECloWTfjIA== + dependencies: + "@babel/types" "^7.14.5" + jsesc "^2.5.1" + source-map "^0.5.0" + +"@babel/helper-compilation-targets@^7.14.5": + version "7.14.5" + resolved "https://registry.yarnpkg.com/@babel/helper-compilation-targets/-/helper-compilation-targets-7.14.5.tgz#7a99c5d0967911e972fe2c3411f7d5b498498ecf" + integrity sha512-v+QtZqXEiOnpO6EYvlImB6zCD2Lel06RzOPzmkz/D/XgQiUu3C/Jb1LOqSt/AIA34TYi/Q+KlT8vTQrgdxkbLw== + dependencies: + "@babel/compat-data" "^7.14.5" + "@babel/helper-validator-option" "^7.14.5" + browserslist "^4.16.6" + semver "^6.3.0" + +"@babel/helper-function-name@^7.14.5": + version "7.14.5" + resolved "https://registry.yarnpkg.com/@babel/helper-function-name/-/helper-function-name-7.14.5.tgz#89e2c474972f15d8e233b52ee8c480e2cfcd50c4" + integrity sha512-Gjna0AsXWfFvrAuX+VKcN/aNNWonizBj39yGwUzVDVTlMYJMK2Wp6xdpy72mfArFq5uK+NOuexfzZlzI1z9+AQ== + dependencies: + "@babel/helper-get-function-arity" "^7.14.5" + "@babel/template" "^7.14.5" + "@babel/types" "^7.14.5" + +"@babel/helper-get-function-arity@^7.14.5": + version "7.14.5" + resolved "https://registry.yarnpkg.com/@babel/helper-get-function-arity/-/helper-get-function-arity-7.14.5.tgz#25fbfa579b0937eee1f3b805ece4ce398c431815" + integrity sha512-I1Db4Shst5lewOM4V+ZKJzQ0JGGaZ6VY1jYvMghRjqs6DWgxLCIyFt30GlnKkfUeFLpJt2vzbMVEXVSXlIFYUg== + dependencies: + "@babel/types" "^7.14.5" + +"@babel/helper-hoist-variables@^7.14.5": + version "7.14.5" + resolved "https://registry.yarnpkg.com/@babel/helper-hoist-variables/-/helper-hoist-variables-7.14.5.tgz#e0dd27c33a78e577d7c8884916a3e7ef1f7c7f8d" + integrity sha512-R1PXiz31Uc0Vxy4OEOm07x0oSjKAdPPCh3tPivn/Eo8cvz6gveAeuyUUPB21Hoiif0uoPQSSdhIPS3352nvdyQ== + dependencies: + "@babel/types" "^7.14.5" + +"@babel/helper-member-expression-to-functions@^7.14.5": + version "7.14.7" + resolved "https://registry.yarnpkg.com/@babel/helper-member-expression-to-functions/-/helper-member-expression-to-functions-7.14.7.tgz#97e56244beb94211fe277bd818e3a329c66f7970" + integrity sha512-TMUt4xKxJn6ccjcOW7c4hlwyJArizskAhoSTOCkA0uZ+KghIaci0Qg9R043kUMWI9mtQfgny+NQ5QATnZ+paaA== + dependencies: + "@babel/types" "^7.14.5" + +"@babel/helper-module-imports@^7.14.5": + version "7.14.5" + resolved "https://registry.yarnpkg.com/@babel/helper-module-imports/-/helper-module-imports-7.14.5.tgz#6d1a44df6a38c957aa7c312da076429f11b422f3" + integrity sha512-SwrNHu5QWS84XlHwGYPDtCxcA0hrSlL2yhWYLgeOc0w7ccOl2qv4s/nARI0aYZW+bSwAL5CukeXA47B/1NKcnQ== + dependencies: + "@babel/types" "^7.14.5" + +"@babel/helper-module-transforms@^7.14.5": + version "7.14.5" + resolved "https://registry.yarnpkg.com/@babel/helper-module-transforms/-/helper-module-transforms-7.14.5.tgz#7de42f10d789b423eb902ebd24031ca77cb1e10e" + integrity sha512-iXpX4KW8LVODuAieD7MzhNjmM6dzYY5tfRqT+R9HDXWl0jPn/djKmA+G9s/2C2T9zggw5tK1QNqZ70USfedOwA== + dependencies: + "@babel/helper-module-imports" "^7.14.5" + "@babel/helper-replace-supers" "^7.14.5" + "@babel/helper-simple-access" "^7.14.5" + "@babel/helper-split-export-declaration" "^7.14.5" + "@babel/helper-validator-identifier" "^7.14.5" + "@babel/template" "^7.14.5" + "@babel/traverse" "^7.14.5" + "@babel/types" "^7.14.5" + +"@babel/helper-optimise-call-expression@^7.14.5": + version "7.14.5" + resolved "https://registry.yarnpkg.com/@babel/helper-optimise-call-expression/-/helper-optimise-call-expression-7.14.5.tgz#f27395a8619e0665b3f0364cddb41c25d71b499c" + integrity sha512-IqiLIrODUOdnPU9/F8ib1Fx2ohlgDhxnIDU7OEVi+kAbEZcyiF7BLU8W6PfvPi9LzztjS7kcbzbmL7oG8kD6VA== + dependencies: + "@babel/types" "^7.14.5" + +"@babel/helper-plugin-utils@^7.0.0", "@babel/helper-plugin-utils@^7.10.4", "@babel/helper-plugin-utils@^7.12.13", "@babel/helper-plugin-utils@^7.8.0": + version "7.14.5" + resolved "https://registry.yarnpkg.com/@babel/helper-plugin-utils/-/helper-plugin-utils-7.14.5.tgz#5ac822ce97eec46741ab70a517971e443a70c5a9" + integrity sha512-/37qQCE3K0vvZKwoK4XU/irIJQdIfCJuhU5eKnNxpFDsOkgFaUAwbv+RYw6eYgsC0E4hS7r5KqGULUogqui0fQ== + +"@babel/helper-replace-supers@^7.14.5": + version "7.14.5" + resolved "https://registry.yarnpkg.com/@babel/helper-replace-supers/-/helper-replace-supers-7.14.5.tgz#0ecc0b03c41cd567b4024ea016134c28414abb94" + integrity sha512-3i1Qe9/8x/hCHINujn+iuHy+mMRLoc77b2nI9TB0zjH1hvn9qGlXjWlggdwUcju36PkPCy/lpM7LLUdcTyH4Ow== + dependencies: + "@babel/helper-member-expression-to-functions" "^7.14.5" + "@babel/helper-optimise-call-expression" "^7.14.5" + "@babel/traverse" "^7.14.5" + "@babel/types" "^7.14.5" + +"@babel/helper-simple-access@^7.14.5": + version "7.14.5" + resolved "https://registry.yarnpkg.com/@babel/helper-simple-access/-/helper-simple-access-7.14.5.tgz#66ea85cf53ba0b4e588ba77fc813f53abcaa41c4" + integrity sha512-nfBN9xvmCt6nrMZjfhkl7i0oTV3yxR4/FztsbOASyTvVcoYd0TRHh7eMLdlEcCqobydC0LAF3LtC92Iwxo0wyw== + dependencies: + "@babel/types" "^7.14.5" + +"@babel/helper-split-export-declaration@^7.14.5": + version "7.14.5" + resolved "https://registry.yarnpkg.com/@babel/helper-split-export-declaration/-/helper-split-export-declaration-7.14.5.tgz#22b23a54ef51c2b7605d851930c1976dd0bc693a" + integrity sha512-hprxVPu6e5Kdp2puZUmvOGjaLv9TCe58E/Fl6hRq4YiVQxIcNvuq6uTM2r1mT/oPskuS9CgR+I94sqAYv0NGKA== + dependencies: + "@babel/types" "^7.14.5" + +"@babel/helper-validator-identifier@^7.14.5": + version "7.14.5" + resolved "https://registry.yarnpkg.com/@babel/helper-validator-identifier/-/helper-validator-identifier-7.14.5.tgz#d0f0e277c512e0c938277faa85a3968c9a44c0e8" + integrity sha512-5lsetuxCLilmVGyiLEfoHBRX8UCFD+1m2x3Rj97WrW3V7H3u4RWRXA4evMjImCsin2J2YT0QaVDGf+z8ondbAg== + +"@babel/helper-validator-option@^7.14.5": + version "7.14.5" + resolved "https://registry.yarnpkg.com/@babel/helper-validator-option/-/helper-validator-option-7.14.5.tgz#6e72a1fff18d5dfcb878e1e62f1a021c4b72d5a3" + integrity sha512-OX8D5eeX4XwcroVW45NMvoYaIuFI+GQpA2a8Gi+X/U/cDUIRsV37qQfF905F0htTRCREQIB4KqPeaveRJUl3Ow== + +"@babel/helpers@^7.14.6": + version "7.14.6" + resolved "https://registry.yarnpkg.com/@babel/helpers/-/helpers-7.14.6.tgz#5b58306b95f1b47e2a0199434fa8658fa6c21635" + integrity sha512-yesp1ENQBiLI+iYHSJdoZKUtRpfTlL1grDIX9NRlAVppljLw/4tTyYupIB7uIYmC3stW/imAv8EqaKaS/ibmeA== + dependencies: + "@babel/template" "^7.14.5" + "@babel/traverse" "^7.14.5" + "@babel/types" "^7.14.5" + +"@babel/highlight@^7.14.5": + version "7.14.5" + resolved "https://registry.yarnpkg.com/@babel/highlight/-/highlight-7.14.5.tgz#6861a52f03966405001f6aa534a01a24d99e8cd9" + integrity sha512-qf9u2WFWVV0MppaL877j2dBtQIDgmidgjGk5VIMw3OadXvYaXn66U1BFlH2t4+t3i+8PhedppRv+i40ABzd+gg== + dependencies: + "@babel/helper-validator-identifier" "^7.14.5" + chalk "^2.0.0" + js-tokens "^4.0.0" + +"@babel/parser@^7.1.0", "@babel/parser@^7.14.5", "@babel/parser@^7.14.6", "@babel/parser@^7.14.7": + version "7.14.7" + resolved "https://registry.yarnpkg.com/@babel/parser/-/parser-7.14.7.tgz#6099720c8839ca865a2637e6c85852ead0bdb595" + integrity sha512-X67Z5y+VBJuHB/RjwECp8kSl5uYi0BvRbNeWqkaJCVh+LiTPl19WBUfG627psSgp9rSf6ojuXghQM3ha6qHHdA== + +"@babel/plugin-syntax-async-generators@^7.8.4": + version "7.8.4" + resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-async-generators/-/plugin-syntax-async-generators-7.8.4.tgz#a983fb1aeb2ec3f6ed042a210f640e90e786fe0d" + integrity sha512-tycmZxkGfZaxhMRbXlPXuVFpdWlXpir2W4AMhSJgRKzk/eDlIXOhb2LHWoLpDF7TEHylV5zNhykX6KAgHJmTNw== + dependencies: + "@babel/helper-plugin-utils" "^7.8.0" + +"@babel/plugin-syntax-bigint@^7.8.3": + version "7.8.3" + resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-bigint/-/plugin-syntax-bigint-7.8.3.tgz#4c9a6f669f5d0cdf1b90a1671e9a146be5300cea" + integrity sha512-wnTnFlG+YxQm3vDxpGE57Pj0srRU4sHE/mDkt1qv2YJJSeUAec2ma4WLUnUPeKjyrfntVwe/N6dCXpU+zL3Npg== + dependencies: + "@babel/helper-plugin-utils" "^7.8.0" + +"@babel/plugin-syntax-class-properties@^7.8.3": + version "7.12.13" + resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-class-properties/-/plugin-syntax-class-properties-7.12.13.tgz#b5c987274c4a3a82b89714796931a6b53544ae10" + integrity sha512-fm4idjKla0YahUNgFNLCB0qySdsoPiZP3iQE3rky0mBUtMZ23yDJ9SJdg6dXTSDnulOVqiF3Hgr9nbXvXTQZYA== + dependencies: + "@babel/helper-plugin-utils" "^7.12.13" + +"@babel/plugin-syntax-import-meta@^7.8.3": + version "7.10.4" + resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-import-meta/-/plugin-syntax-import-meta-7.10.4.tgz#ee601348c370fa334d2207be158777496521fd51" + integrity sha512-Yqfm+XDx0+Prh3VSeEQCPU81yC+JWZ2pDPFSS4ZdpfZhp4MkFMaDC1UqseovEKwSUpnIL7+vK+Clp7bfh0iD7g== + dependencies: + "@babel/helper-plugin-utils" "^7.10.4" + +"@babel/plugin-syntax-json-strings@^7.8.3": + version "7.8.3" + resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-json-strings/-/plugin-syntax-json-strings-7.8.3.tgz#01ca21b668cd8218c9e640cb6dd88c5412b2c96a" + integrity sha512-lY6kdGpWHvjoe2vk4WrAapEuBR69EMxZl+RoGRhrFGNYVK8mOPAW8VfbT/ZgrFbXlDNiiaxQnAtgVCZ6jv30EA== + dependencies: + "@babel/helper-plugin-utils" "^7.8.0" + +"@babel/plugin-syntax-logical-assignment-operators@^7.8.3": + version "7.10.4" + resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-logical-assignment-operators/-/plugin-syntax-logical-assignment-operators-7.10.4.tgz#ca91ef46303530448b906652bac2e9fe9941f699" + integrity sha512-d8waShlpFDinQ5MtvGU9xDAOzKH47+FFoney2baFIoMr952hKOLp1HR7VszoZvOsV/4+RRszNY7D17ba0te0ig== + dependencies: + "@babel/helper-plugin-utils" "^7.10.4" + +"@babel/plugin-syntax-nullish-coalescing-operator@^7.8.3": + version "7.8.3" + resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-nullish-coalescing-operator/-/plugin-syntax-nullish-coalescing-operator-7.8.3.tgz#167ed70368886081f74b5c36c65a88c03b66d1a9" + integrity sha512-aSff4zPII1u2QD7y+F8oDsz19ew4IGEJg9SVW+bqwpwtfFleiQDMdzA/R+UlWDzfnHFCxxleFT0PMIrR36XLNQ== + dependencies: + "@babel/helper-plugin-utils" "^7.8.0" + +"@babel/plugin-syntax-numeric-separator@^7.8.3": + version "7.10.4" + resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-numeric-separator/-/plugin-syntax-numeric-separator-7.10.4.tgz#b9b070b3e33570cd9fd07ba7fa91c0dd37b9af97" + integrity sha512-9H6YdfkcK/uOnY/K7/aA2xpzaAgkQn37yzWUMRK7OaPOqOpGS1+n0H5hxT9AUw9EsSjPW8SVyMJwYRtWs3X3ug== + dependencies: + "@babel/helper-plugin-utils" "^7.10.4" + +"@babel/plugin-syntax-object-rest-spread@^7.8.3": + version "7.8.3" + resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-object-rest-spread/-/plugin-syntax-object-rest-spread-7.8.3.tgz#60e225edcbd98a640332a2e72dd3e66f1af55871" + integrity sha512-XoqMijGZb9y3y2XskN+P1wUGiVwWZ5JmoDRwx5+3GmEplNyVM2s2Dg8ILFQm8rWM48orGy5YpI5Bl8U1y7ydlA== + dependencies: + "@babel/helper-plugin-utils" "^7.8.0" + +"@babel/plugin-syntax-optional-catch-binding@^7.8.3": + version "7.8.3" + resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-optional-catch-binding/-/plugin-syntax-optional-catch-binding-7.8.3.tgz#6111a265bcfb020eb9efd0fdfd7d26402b9ed6c1" + integrity sha512-6VPD0Pc1lpTqw0aKoeRTMiB+kWhAoT24PA+ksWSBrFtl5SIRVpZlwN3NNPQjehA2E/91FV3RjLWoVTglWcSV3Q== + dependencies: + "@babel/helper-plugin-utils" "^7.8.0" + +"@babel/plugin-syntax-optional-chaining@^7.8.3": + version "7.8.3" + resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-optional-chaining/-/plugin-syntax-optional-chaining-7.8.3.tgz#4f69c2ab95167e0180cd5336613f8c5788f7d48a" + integrity sha512-KoK9ErH1MBlCPxV0VANkXW2/dw4vlbGDrFgz8bmUsBGYkFRcbRwMh6cIJubdPrkxRwuGdtCk0v/wPTKbQgBjkg== + dependencies: + "@babel/helper-plugin-utils" "^7.8.0" + +"@babel/template@^7.14.5", "@babel/template@^7.3.3": + version "7.14.5" + resolved "https://registry.yarnpkg.com/@babel/template/-/template-7.14.5.tgz#a9bc9d8b33354ff6e55a9c60d1109200a68974f4" + integrity sha512-6Z3Po85sfxRGachLULUhOmvAaOo7xCvqGQtxINai2mEGPFm6pQ4z5QInFnUrRpfoSV60BnjyF5F3c+15fxFV1g== + dependencies: + "@babel/code-frame" "^7.14.5" + "@babel/parser" "^7.14.5" + "@babel/types" "^7.14.5" + +"@babel/traverse@^7.1.0", "@babel/traverse@^7.14.5": + version "7.14.7" + resolved "https://registry.yarnpkg.com/@babel/traverse/-/traverse-7.14.7.tgz#64007c9774cfdc3abd23b0780bc18a3ce3631753" + integrity sha512-9vDr5NzHu27wgwejuKL7kIOm4bwEtaPQ4Z6cpCmjSuaRqpH/7xc4qcGEscwMqlkwgcXl6MvqoAjZkQ24uSdIZQ== + dependencies: + "@babel/code-frame" "^7.14.5" + "@babel/generator" "^7.14.5" + "@babel/helper-function-name" "^7.14.5" + "@babel/helper-hoist-variables" "^7.14.5" + "@babel/helper-split-export-declaration" "^7.14.5" + "@babel/parser" "^7.14.7" + "@babel/types" "^7.14.5" + debug "^4.1.0" + globals "^11.1.0" + +"@babel/types@^7.0.0", "@babel/types@^7.14.5", "@babel/types@^7.3.0", "@babel/types@^7.3.3": + version "7.14.5" + resolved "https://registry.yarnpkg.com/@babel/types/-/types-7.14.5.tgz#3bb997ba829a2104cedb20689c4a5b8121d383ff" + integrity sha512-M/NzBpEL95I5Hh4dwhin5JlE7EzO5PHMAuzjxss3tiOBD46KfQvVedN/3jEPZvdRvtsK2222XfdHogNIttFgcg== + dependencies: + "@babel/helper-validator-identifier" "^7.14.5" + to-fast-properties "^2.0.0" + +"@bcoe/v8-coverage@^0.2.3": + version "0.2.3" + resolved "https://registry.yarnpkg.com/@bcoe/v8-coverage/-/v8-coverage-0.2.3.tgz#75a2e8b51cb758a7553d6804a5932d7aace75c39" + integrity sha512-0hYQ8SB4Db5zvZB4axdMHGwEaQjkZzFjQiN9LVYvIFB2nSUHW9tYpxWriPrWDASIxiaXax83REcLxuSdnGPZtw== + +"@cnakazawa/watch@^1.0.3": + version "1.0.4" + resolved "https://registry.yarnpkg.com/@cnakazawa/watch/-/watch-1.0.4.tgz#f864ae85004d0fcab6f50be9141c4da368d1656a" + integrity sha512-v9kIhKwjeZThiWrLmj0y17CWoyddASLj9O2yvbZkbvw/N3rWOYy9zkV66ursAoVr0mV15bL8g0c4QZUE6cdDoQ== + dependencies: + exec-sh "^0.3.2" + minimist "^1.2.0" + +"@istanbuljs/load-nyc-config@^1.0.0": + version "1.1.0" + resolved "https://registry.yarnpkg.com/@istanbuljs/load-nyc-config/-/load-nyc-config-1.1.0.tgz#fd3db1d59ecf7cf121e80650bb86712f9b55eced" + integrity sha512-VjeHSlIzpv/NyD3N0YuHfXOPDIixcA1q2ZV98wsMqcYlPmv2n3Yb2lYP9XMElnaFVXg5A7YLTeLu6V84uQDjmQ== + dependencies: + camelcase "^5.3.1" + find-up "^4.1.0" + get-package-type "^0.1.0" + js-yaml "^3.13.1" + resolve-from "^5.0.0" + +"@istanbuljs/schema@^0.1.2": + version "0.1.3" + resolved "https://registry.yarnpkg.com/@istanbuljs/schema/-/schema-0.1.3.tgz#e45e384e4b8ec16bce2fd903af78450f6bf7ec98" + integrity sha512-ZXRY4jNvVgSVQ8DL3LTcakaAtXwTVUxE81hslsyD2AtoXW/wVob10HkOJ1X/pAlcI7D+2YoZKg5do8G/w6RYgA== + +"@jest/console@^25.5.0": + version "25.5.0" + resolved "https://registry.yarnpkg.com/@jest/console/-/console-25.5.0.tgz#770800799d510f37329c508a9edd0b7b447d9abb" + integrity sha512-T48kZa6MK1Y6k4b89sexwmSF4YLeZS/Udqg3Jj3jG/cHH+N/sLFCEoXEDMOKugJQ9FxPN1osxIknvKkxt6MKyw== + dependencies: + "@jest/types" "^25.5.0" + chalk "^3.0.0" + jest-message-util "^25.5.0" + jest-util "^25.5.0" + slash "^3.0.0" + +"@jest/core@^25.5.4": + version "25.5.4" + resolved "https://registry.yarnpkg.com/@jest/core/-/core-25.5.4.tgz#3ef7412f7339210f003cdf36646bbca786efe7b4" + integrity sha512-3uSo7laYxF00Dg/DMgbn4xMJKmDdWvZnf89n8Xj/5/AeQ2dOQmn6b6Hkj/MleyzZWXpwv+WSdYWl4cLsy2JsoA== + dependencies: + "@jest/console" "^25.5.0" + "@jest/reporters" "^25.5.1" + "@jest/test-result" "^25.5.0" + "@jest/transform" "^25.5.1" + "@jest/types" "^25.5.0" + ansi-escapes "^4.2.1" + chalk "^3.0.0" + exit "^0.1.2" + graceful-fs "^4.2.4" + jest-changed-files "^25.5.0" + jest-config "^25.5.4" + jest-haste-map "^25.5.1" + jest-message-util "^25.5.0" + jest-regex-util "^25.2.6" + jest-resolve "^25.5.1" + jest-resolve-dependencies "^25.5.4" + jest-runner "^25.5.4" + jest-runtime "^25.5.4" + jest-snapshot "^25.5.1" + jest-util "^25.5.0" + jest-validate "^25.5.0" + jest-watcher "^25.5.0" + micromatch "^4.0.2" + p-each-series "^2.1.0" + realpath-native "^2.0.0" + rimraf "^3.0.0" + slash "^3.0.0" + strip-ansi "^6.0.0" + +"@jest/environment@^25.5.0": + version "25.5.0" + resolved "https://registry.yarnpkg.com/@jest/environment/-/environment-25.5.0.tgz#aa33b0c21a716c65686638e7ef816c0e3a0c7b37" + integrity sha512-U2VXPEqL07E/V7pSZMSQCvV5Ea4lqOlT+0ZFijl/i316cRMHvZ4qC+jBdryd+lmRetjQo0YIQr6cVPNxxK87mA== + dependencies: + "@jest/fake-timers" "^25.5.0" + "@jest/types" "^25.5.0" + jest-mock "^25.5.0" + +"@jest/fake-timers@^25.5.0": + version "25.5.0" + resolved "https://registry.yarnpkg.com/@jest/fake-timers/-/fake-timers-25.5.0.tgz#46352e00533c024c90c2bc2ad9f2959f7f114185" + integrity sha512-9y2+uGnESw/oyOI3eww9yaxdZyHq7XvprfP/eeoCsjqKYts2yRlsHS/SgjPDV8FyMfn2nbMy8YzUk6nyvdLOpQ== + dependencies: + "@jest/types" "^25.5.0" + jest-message-util "^25.5.0" + jest-mock "^25.5.0" + jest-util "^25.5.0" + lolex "^5.0.0" + +"@jest/globals@^25.5.2": + version "25.5.2" + resolved "https://registry.yarnpkg.com/@jest/globals/-/globals-25.5.2.tgz#5e45e9de8d228716af3257eeb3991cc2e162ca88" + integrity sha512-AgAS/Ny7Q2RCIj5kZ+0MuKM1wbF0WMLxbCVl/GOMoCNbODRdJ541IxJ98xnZdVSZXivKpJlNPIWa3QmY0l4CXA== + dependencies: + "@jest/environment" "^25.5.0" + "@jest/types" "^25.5.0" + expect "^25.5.0" + +"@jest/reporters@^25.5.1": + version "25.5.1" + resolved "https://registry.yarnpkg.com/@jest/reporters/-/reporters-25.5.1.tgz#cb686bcc680f664c2dbaf7ed873e93aa6811538b" + integrity sha512-3jbd8pPDTuhYJ7vqiHXbSwTJQNavczPs+f1kRprRDxETeE3u6srJ+f0NPuwvOmk+lmunZzPkYWIFZDLHQPkviw== + dependencies: + "@bcoe/v8-coverage" "^0.2.3" + "@jest/console" "^25.5.0" + "@jest/test-result" "^25.5.0" + "@jest/transform" "^25.5.1" + "@jest/types" "^25.5.0" + chalk "^3.0.0" + collect-v8-coverage "^1.0.0" + exit "^0.1.2" + glob "^7.1.2" + graceful-fs "^4.2.4" + istanbul-lib-coverage "^3.0.0" + istanbul-lib-instrument "^4.0.0" + istanbul-lib-report "^3.0.0" + istanbul-lib-source-maps "^4.0.0" + istanbul-reports "^3.0.2" + jest-haste-map "^25.5.1" + jest-resolve "^25.5.1" + jest-util "^25.5.0" + jest-worker "^25.5.0" + slash "^3.0.0" + source-map "^0.6.0" + string-length "^3.1.0" + terminal-link "^2.0.0" + v8-to-istanbul "^4.1.3" + optionalDependencies: + node-notifier "^6.0.0" + +"@jest/source-map@^25.5.0": + version "25.5.0" + resolved "https://registry.yarnpkg.com/@jest/source-map/-/source-map-25.5.0.tgz#df5c20d6050aa292c2c6d3f0d2c7606af315bd1b" + integrity sha512-eIGx0xN12yVpMcPaVpjXPnn3N30QGJCJQSkEDUt9x1fI1Gdvb07Ml6K5iN2hG7NmMP6FDmtPEssE3z6doOYUwQ== + dependencies: + callsites "^3.0.0" + graceful-fs "^4.2.4" + source-map "^0.6.0" + +"@jest/test-result@^25.5.0": + version "25.5.0" + resolved "https://registry.yarnpkg.com/@jest/test-result/-/test-result-25.5.0.tgz#139a043230cdeffe9ba2d8341b27f2efc77ce87c" + integrity sha512-oV+hPJgXN7IQf/fHWkcS99y0smKLU2czLBJ9WA0jHITLst58HpQMtzSYxzaBvYc6U5U6jfoMthqsUlUlbRXs0A== + dependencies: + "@jest/console" "^25.5.0" + "@jest/types" "^25.5.0" + "@types/istanbul-lib-coverage" "^2.0.0" + collect-v8-coverage "^1.0.0" + +"@jest/test-sequencer@^25.5.4": + version "25.5.4" + resolved "https://registry.yarnpkg.com/@jest/test-sequencer/-/test-sequencer-25.5.4.tgz#9b4e685b36954c38d0f052e596d28161bdc8b737" + integrity sha512-pTJGEkSeg1EkCO2YWq6hbFvKNXk8ejqlxiOg1jBNLnWrgXOkdY6UmqZpwGFXNnRt9B8nO1uWMzLLZ4eCmhkPNA== + dependencies: + "@jest/test-result" "^25.5.0" + graceful-fs "^4.2.4" + jest-haste-map "^25.5.1" + jest-runner "^25.5.4" + jest-runtime "^25.5.4" + +"@jest/transform@^25.5.1": + version "25.5.1" + resolved "https://registry.yarnpkg.com/@jest/transform/-/transform-25.5.1.tgz#0469ddc17699dd2bf985db55fa0fb9309f5c2db3" + integrity sha512-Y8CEoVwXb4QwA6Y/9uDkn0Xfz0finGkieuV0xkdF9UtZGJeLukD5nLkaVrVsODB1ojRWlaoD0AJZpVHCSnJEvg== + dependencies: + "@babel/core" "^7.1.0" + "@jest/types" "^25.5.0" + babel-plugin-istanbul "^6.0.0" + chalk "^3.0.0" + convert-source-map "^1.4.0" + fast-json-stable-stringify "^2.0.0" + graceful-fs "^4.2.4" + jest-haste-map "^25.5.1" + jest-regex-util "^25.2.6" + jest-util "^25.5.0" + micromatch "^4.0.2" + pirates "^4.0.1" + realpath-native "^2.0.0" + slash "^3.0.0" + source-map "^0.6.1" + write-file-atomic "^3.0.0" + +"@jest/types@^25.5.0": + version "25.5.0" + resolved "https://registry.yarnpkg.com/@jest/types/-/types-25.5.0.tgz#4d6a4793f7b9599fc3680877b856a97dbccf2a9d" + integrity sha512-OXD0RgQ86Tu3MazKo8bnrkDRaDXXMGUqd+kTtLtK1Zb7CRzQcaSRPPPV37SvYTdevXEBVxe0HXylEjs8ibkmCw== + dependencies: + "@types/istanbul-lib-coverage" "^2.0.0" + "@types/istanbul-reports" "^1.1.1" + "@types/yargs" "^15.0.0" + chalk "^3.0.0" + +"@jupyterlab/galata@3.0.11-2": + version "3.0.11-2" + resolved "https://registry.yarnpkg.com/@jupyterlab/galata/-/galata-3.0.11-2.tgz#eeaf1a571a744718d664df7a3decc40907405bdc" + integrity sha512-i8jBhL0JUezAZ0Apa56Gy7lH6K0uuYhlkVwY0AYfrMJJw8ILLnd8yunt7QXAPto0m+QC3ud4VZ82KYck4W9+3w== + dependencies: + "@types/dateformat" "^3.0.1" + "@types/jest" "^25.1.2" + "@types/js-beautify" "^1.8.2" + "@types/node" "^13.1.1" + "@types/pixelmatch" "^5.0.0" + "@types/pngjs" "^3.4.1" + "@yarnpkg/lockfile" "^1.1.0" + ansi_up "^5.0.0" + axios "^0.21.1" + chalk "^4.0.0" + cross-spawn "^6.0.5" + dateformat "^3.0.3" + ejs "^3.0.1" + events "^3.0.0" + fs-extra "^8.1.0" + http-server "^0.12.1" + inquirer "^7.1.0" + jest "^25.1.0" + js-beautify "^1.10.3" + meow "^6.0.1" + open "^7.0.4" + pixelmatch "^5.1.0" + playwright "^1.9.1" + pngjs "^3.4.0" + semver "^7.3.2" + ts-jest "^25.2.0" + typescript "^3.7.4" + uuid "^3.4.0" + +"@sinonjs/commons@^1.7.0": + version "1.8.3" + resolved "https://registry.yarnpkg.com/@sinonjs/commons/-/commons-1.8.3.tgz#3802ddd21a50a949b6721ddd72da36e67e7f1b2d" + integrity sha512-xkNcLAn/wZaX14RPlwizcKicDk9G3F8m2nU3L7Ukm5zBgTwiT0wsoFAHx9Jq56fJA1z/7uKGtCRu16sOUCLIHQ== + dependencies: + type-detect "4.0.8" + +"@types/babel__core@^7.1.7": + version "7.1.15" + resolved "https://registry.yarnpkg.com/@types/babel__core/-/babel__core-7.1.15.tgz#2ccfb1ad55a02c83f8e0ad327cbc332f55eb1024" + integrity sha512-bxlMKPDbY8x5h6HBwVzEOk2C8fb6SLfYQ5Jw3uBYuYF1lfWk/kbLd81la82vrIkBb0l+JdmrZaDikPrNxpS/Ew== + dependencies: + "@babel/parser" "^7.1.0" + "@babel/types" "^7.0.0" + "@types/babel__generator" "*" + "@types/babel__template" "*" + "@types/babel__traverse" "*" + +"@types/babel__generator@*": + version "7.6.3" + resolved "https://registry.yarnpkg.com/@types/babel__generator/-/babel__generator-7.6.3.tgz#f456b4b2ce79137f768aa130d2423d2f0ccfaba5" + integrity sha512-/GWCmzJWqV7diQW54smJZzWbSFf4QYtF71WCKhcx6Ru/tFyQIY2eiiITcCAeuPbNSvT9YCGkVMqqvSk2Z0mXiA== + dependencies: + "@babel/types" "^7.0.0" + +"@types/babel__template@*": + version "7.4.1" + resolved "https://registry.yarnpkg.com/@types/babel__template/-/babel__template-7.4.1.tgz#3d1a48fd9d6c0edfd56f2ff578daed48f36c8969" + integrity sha512-azBFKemX6kMg5Io+/rdGT0dkGreboUVR0Cdm3fz9QJWpaQGJRQXl7C+6hOTCZcMll7KFyEQpgbYI2lHdsS4U7g== + dependencies: + "@babel/parser" "^7.1.0" + "@babel/types" "^7.0.0" + +"@types/babel__traverse@*", "@types/babel__traverse@^7.0.6": + version "7.14.2" + resolved "https://registry.yarnpkg.com/@types/babel__traverse/-/babel__traverse-7.14.2.tgz#ffcd470bbb3f8bf30481678fb5502278ca833a43" + integrity sha512-K2waXdXBi2302XUdcHcR1jCeU0LL4TD9HRs/gk0N2Xvrht+G/BfJa4QObBQZfhMdxiCpV3COl5Nfq4uKTeTnJA== + dependencies: + "@babel/types" "^7.3.0" + +"@types/dateformat@^3.0.1": + version "3.0.1" + resolved "https://registry.yarnpkg.com/@types/dateformat/-/dateformat-3.0.1.tgz#98d747a2e5e9a56070c6bf14e27bff56204e34cc" + integrity sha512-KlPPdikagvL6ELjWsljbyDIPzNCeliYkqRpI+zea99vBBbCIA5JNshZAwQKTON139c87y9qvTFVgkFd14rtS4g== + +"@types/graceful-fs@^4.1.2": + version "4.1.5" + resolved "https://registry.yarnpkg.com/@types/graceful-fs/-/graceful-fs-4.1.5.tgz#21ffba0d98da4350db64891f92a9e5db3cdb4e15" + integrity sha512-anKkLmZZ+xm4p8JWBf4hElkM4XR+EZeA2M9BAkkTldmcyDY4mbdIJnRghDJH3Ov5ooY7/UAoENtmdMSkaAd7Cw== + dependencies: + "@types/node" "*" + +"@types/istanbul-lib-coverage@*", "@types/istanbul-lib-coverage@^2.0.0", "@types/istanbul-lib-coverage@^2.0.1": + version "2.0.3" + resolved "https://registry.yarnpkg.com/@types/istanbul-lib-coverage/-/istanbul-lib-coverage-2.0.3.tgz#4ba8ddb720221f432e443bd5f9117fd22cfd4762" + integrity sha512-sz7iLqvVUg1gIedBOvlkxPlc8/uVzyS5OwGz1cKjXzkl3FpL3al0crU8YGU1WoHkxn0Wxbw5tyi6hvzJKNzFsw== + +"@types/istanbul-lib-report@*": + version "3.0.0" + resolved "https://registry.yarnpkg.com/@types/istanbul-lib-report/-/istanbul-lib-report-3.0.0.tgz#c14c24f18ea8190c118ee7562b7ff99a36552686" + integrity sha512-plGgXAPfVKFoYfa9NpYDAkseG+g6Jr294RqeqcqDixSbU34MZVJRi/P+7Y8GDpzkEwLaGZZOpKIEmeVZNtKsrg== + dependencies: + "@types/istanbul-lib-coverage" "*" + +"@types/istanbul-reports@^1.1.1": + version "1.1.2" + resolved "https://registry.yarnpkg.com/@types/istanbul-reports/-/istanbul-reports-1.1.2.tgz#e875cc689e47bce549ec81f3df5e6f6f11cfaeb2" + integrity sha512-P/W9yOX/3oPZSpaYOCQzGqgCQRXn0FFO/V8bWrCQs+wLmvVVxk6CRBXALEvNs9OHIatlnlFokfhuDo2ug01ciw== + dependencies: + "@types/istanbul-lib-coverage" "*" + "@types/istanbul-lib-report" "*" + +"@types/jest@^25.1.2": + version "25.2.3" + resolved "https://registry.yarnpkg.com/@types/jest/-/jest-25.2.3.tgz#33d27e4c4716caae4eced355097a47ad363fdcaf" + integrity sha512-JXc1nK/tXHiDhV55dvfzqtmP4S3sy3T3ouV2tkViZgxY/zeUkcpQcQPGRlgF4KmWzWW5oiWYSZwtCB+2RsE4Fw== + dependencies: + jest-diff "^25.2.1" + pretty-format "^25.2.1" + +"@types/js-beautify@^1.8.2": + version "1.13.2" + resolved "https://registry.yarnpkg.com/@types/js-beautify/-/js-beautify-1.13.2.tgz#49783f6c6c68558738139e612b64b4f1a275383e" + integrity sha512-crV/441NhrynLIclg94i1wV6nX/6rU9ByUyn4muCrsL0HPd3nBzrt6kpQ9MQOB+HeYgLcRARteNJcbnYkp5OwA== + +"@types/minimist@^1.2.0": + version "1.2.2" + resolved "https://registry.yarnpkg.com/@types/minimist/-/minimist-1.2.2.tgz#ee771e2ba4b3dc5b372935d549fd9617bf345b8c" + integrity sha512-jhuKLIRrhvCPLqwPcx6INqmKeiA5EWrsCOPhrlFSrbrmU4ZMPjj5Ul/oLCMDO98XRUIwVm78xICz4EPCektzeQ== + +"@types/node@*": + version "16.3.2" + resolved "https://registry.yarnpkg.com/@types/node/-/node-16.3.2.tgz#655432817f83b51ac869c2d51dd8305fb8342e16" + integrity sha512-jJs9ErFLP403I+hMLGnqDRWT0RYKSvArxuBVh2veudHV7ifEC1WAmjJADacZ7mRbA2nWgHtn8xyECMAot0SkAw== + +"@types/node@^13.1.1": + version "13.13.52" + resolved "https://registry.yarnpkg.com/@types/node/-/node-13.13.52.tgz#03c13be70b9031baaed79481c0c0cfb0045e53f7" + integrity sha512-s3nugnZumCC//n4moGGe6tkNMyYEdaDBitVjwPxXmR5lnMG5dHePinH2EdxkG3Rh1ghFHHixAG4NJhpJW1rthQ== + +"@types/normalize-package-data@^2.4.0": + version "2.4.1" + resolved "https://registry.yarnpkg.com/@types/normalize-package-data/-/normalize-package-data-2.4.1.tgz#d3357479a0fdfdd5907fe67e17e0a85c906e1301" + integrity sha512-Gj7cI7z+98M282Tqmp2K5EIsoouUEzbBJhQQzDE3jSIRk6r9gsz0oUokqIUR4u1R3dMHo0pDHM7sNOHyhulypw== + +"@types/pixelmatch@^5.0.0": + version "5.2.4" + resolved "https://registry.yarnpkg.com/@types/pixelmatch/-/pixelmatch-5.2.4.tgz#ca145cc5ede1388c71c68edf2d1f5190e5ddd0f6" + integrity sha512-HDaSHIAv9kwpMN7zlmwfTv6gax0PiporJOipcrGsVNF3Ba+kryOZc0Pio5pn6NhisgWr7TaajlPEKTbTAypIBQ== + dependencies: + "@types/node" "*" + +"@types/pngjs@^3.4.1": + version "3.4.2" + resolved "https://registry.yarnpkg.com/@types/pngjs/-/pngjs-3.4.2.tgz#8dc49b45fbcf18a5873179e3664f049388e39ecf" + integrity sha512-LJVPDraJ5YFEnMHnzxTN4psdWz1M61MtaAAWPn3qnDk5fvs7BAmmQ9pd3KPlrdrvozMyne4ktanD4pg0L7x1Pw== + dependencies: + "@types/node" "*" + +"@types/prettier@^1.19.0": + version "1.19.1" + resolved "https://registry.yarnpkg.com/@types/prettier/-/prettier-1.19.1.tgz#33509849f8e679e4add158959fdb086440e9553f" + integrity sha512-5qOlnZscTn4xxM5MeGXAMOsIOIKIbh9e85zJWfBRVPlRMEVawzoPhINYbRGkBZCI8LxvBe7tJCdWiarA99OZfQ== + +"@types/stack-utils@^1.0.1": + version "1.0.1" + resolved "https://registry.yarnpkg.com/@types/stack-utils/-/stack-utils-1.0.1.tgz#0a851d3bd96498fa25c33ab7278ed3bd65f06c3e" + integrity sha512-l42BggppR6zLmpfU6fq9HEa2oGPEI8yrSPL3GITjfRInppYFahObbIQOQK3UGxEnyQpltZLaPe75046NOZQikw== + +"@types/yargs-parser@*": + version "20.2.1" + resolved "https://registry.yarnpkg.com/@types/yargs-parser/-/yargs-parser-20.2.1.tgz#3b9ce2489919d9e4fea439b76916abc34b2df129" + integrity sha512-7tFImggNeNBVMsn0vLrpn1H1uPrUBdnARPTpZoitY37ZrdJREzf7I16tMrlK3hen349gr1NYh8CmZQa7CTG6Aw== + +"@types/yargs@^15.0.0": + version "15.0.14" + resolved "https://registry.yarnpkg.com/@types/yargs/-/yargs-15.0.14.tgz#26d821ddb89e70492160b66d10a0eb6df8f6fb06" + integrity sha512-yEJzHoxf6SyQGhBhIYGXQDSCkJjB6HohDShto7m8vaKg9Yp0Yn8+71J9eakh2bnPg6BfsH9PRMhiRTZnd4eXGQ== + dependencies: + "@types/yargs-parser" "*" + +"@types/yauzl@^2.9.1": + version "2.9.2" + resolved "https://registry.yarnpkg.com/@types/yauzl/-/yauzl-2.9.2.tgz#c48e5d56aff1444409e39fa164b0b4d4552a7b7a" + integrity sha512-8uALY5LTvSuHgloDVUvWP3pIauILm+8/0pDMokuDYIoNsOkSwd5AiHBTSEJjKTDcZr5z8UpgOWZkxBF4iJftoA== + dependencies: + "@types/node" "*" + +"@yarnpkg/lockfile@^1.1.0": + version "1.1.0" + resolved "https://registry.yarnpkg.com/@yarnpkg/lockfile/-/lockfile-1.1.0.tgz#e77a97fbd345b76d83245edcd17d393b1b41fb31" + integrity sha512-GpSwvyXOcOOlV70vbnzjj4fW5xW/FdUF6nQEt1ENy7m4ZCczi1+/buVUPAqmGfqznsORNFzUMjctTIp8a9tuCQ== + +abab@^2.0.0: + version "2.0.5" + resolved "https://registry.yarnpkg.com/abab/-/abab-2.0.5.tgz#c0b678fb32d60fc1219c784d6a826fe385aeb79a" + integrity sha512-9IK9EadsbHo6jLWIpxpR6pL0sazTXV6+SQv25ZB+F7Bj9mJNaOc4nCRabwd5M/JwmUa8idz6Eci6eKfJryPs6Q== + +abbrev@1: + version "1.1.1" + resolved "https://registry.yarnpkg.com/abbrev/-/abbrev-1.1.1.tgz#f8f2c887ad10bf67f634f005b6987fed3179aac8" + integrity sha512-nne9/IiQ/hzIhY6pdDnbBtz7DjPTKrY00P/zvPSm5pOFkl6xuGrGnXn/VtTNNfNtAfZ9/1RtehkszU9qcTii0Q== + +acorn-globals@^4.3.2: + version "4.3.4" + resolved "https://registry.yarnpkg.com/acorn-globals/-/acorn-globals-4.3.4.tgz#9fa1926addc11c97308c4e66d7add0d40c3272e7" + integrity sha512-clfQEh21R+D0leSbUdWf3OcfqyaCSAQ8Ryq00bofSekfr9W8u1jyYZo6ir0xu9Gtcf7BjcHJpnbZH7JOCpP60A== + dependencies: + acorn "^6.0.1" + acorn-walk "^6.0.1" + +acorn-walk@^6.0.1: + version "6.2.0" + resolved "https://registry.yarnpkg.com/acorn-walk/-/acorn-walk-6.2.0.tgz#123cb8f3b84c2171f1f7fb252615b1c78a6b1a8c" + integrity sha512-7evsyfH1cLOCdAzZAd43Cic04yKydNx0cF+7tiA19p1XnLLPU4dpCQOqpjqwokFe//vS0QqfqqjCS2JkiIs0cA== + +acorn@^6.0.1: + version "6.4.2" + resolved "https://registry.yarnpkg.com/acorn/-/acorn-6.4.2.tgz#35866fd710528e92de10cf06016498e47e39e1e6" + integrity sha512-XtGIhXwF8YM8bJhGxG5kXgjkEuNGLTkoYqVE+KMR+aspr4KGYmKYg7yUe3KghyQ9yheNwLnjmzh/7+gfDBmHCQ== + +acorn@^7.1.0: + version "7.4.1" + resolved "https://registry.yarnpkg.com/acorn/-/acorn-7.4.1.tgz#feaed255973d2e77555b83dbc08851a6c63520fa" + integrity sha512-nQyp0o1/mNdbTO1PO6kHkwSrmgZ0MT/jCCpNiwbUjGoRN4dlBhqJtoQuCnEOKzgTVwg0ZWiCoQy6SxMebQVh8A== + +agent-base@6: + version "6.0.2" + resolved "https://registry.yarnpkg.com/agent-base/-/agent-base-6.0.2.tgz#49fff58577cfee3f37176feab4c22e00f86d7f77" + integrity sha512-RZNwNclF7+MS/8bDg70amg32dyeZGZxiDuQmZxKLAlQjr3jGyLx+4Kkk58UO7D2QdgFIQCovuSuZESne6RG6XQ== + dependencies: + debug "4" + +ajv@^6.12.3: + version "6.12.6" + resolved "https://registry.yarnpkg.com/ajv/-/ajv-6.12.6.tgz#baf5a62e802b07d977034586f8c3baf5adf26df4" + integrity sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g== + dependencies: + fast-deep-equal "^3.1.1" + fast-json-stable-stringify "^2.0.0" + json-schema-traverse "^0.4.1" + uri-js "^4.2.2" + +ansi-escapes@^4.2.1: + version "4.3.2" + resolved "https://registry.yarnpkg.com/ansi-escapes/-/ansi-escapes-4.3.2.tgz#6b2291d1db7d98b6521d5f1efa42d0f3a9feb65e" + integrity sha512-gKXj5ALrKWQLsYG9jlTRmR/xKluxHV+Z9QEwNIgCfM1/uwPMCuzVVnh5mwTd+OuBZcwSIMbqssNWRm1lE51QaQ== + dependencies: + type-fest "^0.21.3" + +ansi-regex@^4.1.0: + version "4.1.0" + resolved "https://registry.yarnpkg.com/ansi-regex/-/ansi-regex-4.1.0.tgz#8b9f8f08cf1acb843756a839ca8c7e3168c51997" + integrity sha512-1apePfXM1UOSqw0o9IiFAovVz9M5S1Dg+4TrDwfMewQ6p/rmMueb7tWZjQ1rx4Loy1ArBggoqGpfqqdI4rondg== + +ansi-regex@^5.0.0: + version "5.0.0" + resolved "https://registry.yarnpkg.com/ansi-regex/-/ansi-regex-5.0.0.tgz#388539f55179bf39339c81af30a654d69f87cb75" + integrity sha512-bY6fj56OUQ0hU1KjFNDQuJFezqKdrAyFdIevADiqrWHwSlbmBNMHp5ak2f40Pm8JTFyM2mqxkG6ngkHO11f/lg== + +ansi-styles@^3.2.1: + version "3.2.1" + resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-3.2.1.tgz#41fbb20243e50b12be0f04b8dedbf07520ce841d" + integrity sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA== + dependencies: + color-convert "^1.9.0" + +ansi-styles@^4.0.0, ansi-styles@^4.1.0: + version "4.3.0" + resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-4.3.0.tgz#edd803628ae71c04c85ae7a0906edad34b648937" + integrity sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg== + dependencies: + color-convert "^2.0.1" + +ansi_up@^5.0.0: + version "5.0.1" + resolved "https://registry.yarnpkg.com/ansi_up/-/ansi_up-5.0.1.tgz#b66839dba408d3d2f8548904f1ae6fc62d6917ef" + integrity sha512-HGOTjFQECRKZM9fIlGhJfR2pcK8PMUWzFOqcPwqBEnNIa4P2r0Di+g2hxCX0hL0n1NUtAHGRA+fUyA/OajZYFw== + +anymatch@^2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/anymatch/-/anymatch-2.0.0.tgz#bcb24b4f37934d9aa7ac17b4adaf89e7c76ef2eb" + integrity sha512-5teOsQWABXHHBFP9y3skS5P3d/WfWXpv3FUpy+LorMrNYaT9pI4oLMQX7jzQ2KklNpGpWHzdCXTDT2Y3XGlZBw== + dependencies: + micromatch "^3.1.4" + normalize-path "^2.1.1" + +anymatch@^3.0.3: + version "3.1.2" + resolved "https://registry.yarnpkg.com/anymatch/-/anymatch-3.1.2.tgz#c0557c096af32f106198f4f4e2a383537e378716" + integrity sha512-P43ePfOAIupkguHUycrc4qJ9kz8ZiuOUijaETwX7THt0Y/GNK7v0aa8rY816xWjZ7rJdA5XdMcpVFTKMq+RvWg== + dependencies: + normalize-path "^3.0.0" + picomatch "^2.0.4" + +argparse@^1.0.7: + version "1.0.10" + resolved "https://registry.yarnpkg.com/argparse/-/argparse-1.0.10.tgz#bcd6791ea5ae09725e17e5ad988134cd40b3d911" + integrity sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg== + dependencies: + sprintf-js "~1.0.2" + +arr-diff@^4.0.0: + version "4.0.0" + resolved "https://registry.yarnpkg.com/arr-diff/-/arr-diff-4.0.0.tgz#d6461074febfec71e7e15235761a329a5dc7c520" + integrity sha1-1kYQdP6/7HHn4VI1dhoyml3HxSA= + +arr-flatten@^1.1.0: + version "1.1.0" + resolved "https://registry.yarnpkg.com/arr-flatten/-/arr-flatten-1.1.0.tgz#36048bbff4e7b47e136644316c99669ea5ae91f1" + integrity sha512-L3hKV5R/p5o81R7O02IGnwpDmkp6E982XhtbuwSe3O4qOtMMMtodicASA1Cny2U+aCXcNpml+m4dPsvsJ3jatg== + +arr-union@^3.1.0: + version "3.1.0" + resolved "https://registry.yarnpkg.com/arr-union/-/arr-union-3.1.0.tgz#e39b09aea9def866a8f206e288af63919bae39c4" + integrity sha1-45sJrqne+Gao8gbiiK9jkZuuOcQ= + +array-equal@^1.0.0: + version "1.0.0" + resolved "https://registry.yarnpkg.com/array-equal/-/array-equal-1.0.0.tgz#8c2a5ef2472fd9ea742b04c77a75093ba2757c93" + integrity sha1-jCpe8kcv2ep0KwTHenUJO6J1fJM= + +array-unique@^0.3.2: + version "0.3.2" + resolved "https://registry.yarnpkg.com/array-unique/-/array-unique-0.3.2.tgz#a894b75d4bc4f6cd679ef3244a9fd8f46ae2d428" + integrity sha1-qJS3XUvE9s1nnvMkSp/Y9Gri1Cg= + +arrify@^1.0.1: + version "1.0.1" + resolved "https://registry.yarnpkg.com/arrify/-/arrify-1.0.1.tgz#898508da2226f380df904728456849c1501a4b0d" + integrity sha1-iYUI2iIm84DfkEcoRWhJwVAaSw0= + +asn1@~0.2.3: + version "0.2.4" + resolved "https://registry.yarnpkg.com/asn1/-/asn1-0.2.4.tgz#8d2475dfab553bb33e77b54e59e880bb8ce23136" + integrity sha512-jxwzQpLQjSmWXgwaCZE9Nz+glAG01yF1QnWgbhGwHI5A6FRIEY6IVqtHhIepHqI7/kyEyQEagBC5mBEFlIYvdg== + dependencies: + safer-buffer "~2.1.0" + +assert-plus@1.0.0, assert-plus@^1.0.0: + version "1.0.0" + resolved "https://registry.yarnpkg.com/assert-plus/-/assert-plus-1.0.0.tgz#f12e0f3c5d77b0b1cdd9146942e4e96c1e4dd525" + integrity sha1-8S4PPF13sLHN2RRpQuTpbB5N1SU= + +assign-symbols@^1.0.0: + version "1.0.0" + resolved "https://registry.yarnpkg.com/assign-symbols/-/assign-symbols-1.0.0.tgz#59667f41fadd4f20ccbc2bb96b8d4f7f78ec0367" + integrity sha1-WWZ/QfrdTyDMvCu5a41Pf3jsA2c= + +astral-regex@^1.0.0: + version "1.0.0" + resolved "https://registry.yarnpkg.com/astral-regex/-/astral-regex-1.0.0.tgz#6c8c3fb827dd43ee3918f27b82782ab7658a6fd9" + integrity sha512-+Ryf6g3BKoRc7jfp7ad8tM4TtMiaWvbF/1/sQcZPkkS7ag3D5nMBCe2UfOTONtAkaG0tO0ij3C5Lwmf1EiyjHg== + +async@0.9.x: + version "0.9.2" + resolved "https://registry.yarnpkg.com/async/-/async-0.9.2.tgz#aea74d5e61c1f899613bf64bda66d4c78f2fd17d" + integrity sha1-rqdNXmHB+JlhO/ZL2mbUx48v0X0= + +async@^2.6.2: + version "2.6.3" + resolved "https://registry.yarnpkg.com/async/-/async-2.6.3.tgz#d72625e2344a3656e3a3ad4fa749fa83299d82ff" + integrity sha512-zflvls11DCy+dQWzTW2dzuilv8Z5X/pjfmZOWba6TNIVDm+2UDaJmXSOXlasHKfNBs8oo3M0aT50fDEWfKZjXg== + dependencies: + lodash "^4.17.14" + +asynckit@^0.4.0: + version "0.4.0" + resolved "https://registry.yarnpkg.com/asynckit/-/asynckit-0.4.0.tgz#c79ed97f7f34cb8f2ba1bc9790bcc366474b4b79" + integrity sha1-x57Zf380y48robyXkLzDZkdLS3k= + +atob@^2.1.2: + version "2.1.2" + resolved "https://registry.yarnpkg.com/atob/-/atob-2.1.2.tgz#6d9517eb9e030d2436666651e86bd9f6f13533c9" + integrity sha512-Wm6ukoaOGJi/73p/cl2GvLjTI5JM1k/O14isD73YML8StrH/7/lRFgmg8nICZgD3bZZvjwCGxtMOD3wWNAu8cg== + +aws-sign2@~0.7.0: + version "0.7.0" + resolved "https://registry.yarnpkg.com/aws-sign2/-/aws-sign2-0.7.0.tgz#b46e890934a9591f2d2f6f86d7e6a9f1b3fe76a8" + integrity sha1-tG6JCTSpWR8tL2+G1+ap8bP+dqg= + +aws4@^1.8.0: + version "1.11.0" + resolved "https://registry.yarnpkg.com/aws4/-/aws4-1.11.0.tgz#d61f46d83b2519250e2784daf5b09479a8b41c59" + integrity sha512-xh1Rl34h6Fi1DC2WWKfxUTVqRsNnr6LsKz2+hfwDxQJWmrx8+c7ylaqBMcHfl1U1r2dsifOvKX3LQuLNZ+XSvA== + +axios@^0.21.1: + version "0.21.1" + resolved "https://registry.yarnpkg.com/axios/-/axios-0.21.1.tgz#22563481962f4d6bde9a76d516ef0e5d3c09b2b8" + integrity sha512-dKQiRHxGD9PPRIUNIWvZhPTPpl1rf/OxTYKsqKUDjBwYylTvV7SjSHJb9ratfyzM6wCdLCOYLzs73qpg5c4iGA== + dependencies: + follow-redirects "^1.10.0" + +babel-jest@^25.5.1: + version "25.5.1" + resolved "https://registry.yarnpkg.com/babel-jest/-/babel-jest-25.5.1.tgz#bc2e6101f849d6f6aec09720ffc7bc5332e62853" + integrity sha512-9dA9+GmMjIzgPnYtkhBg73gOo/RHqPmLruP3BaGL4KEX3Dwz6pI8auSN8G8+iuEG90+GSswyKvslN+JYSaacaQ== + dependencies: + "@jest/transform" "^25.5.1" + "@jest/types" "^25.5.0" + "@types/babel__core" "^7.1.7" + babel-plugin-istanbul "^6.0.0" + babel-preset-jest "^25.5.0" + chalk "^3.0.0" + graceful-fs "^4.2.4" + slash "^3.0.0" + +babel-plugin-istanbul@^6.0.0: + version "6.0.0" + resolved "https://registry.yarnpkg.com/babel-plugin-istanbul/-/babel-plugin-istanbul-6.0.0.tgz#e159ccdc9af95e0b570c75b4573b7c34d671d765" + integrity sha512-AF55rZXpe7trmEylbaE1Gv54wn6rwU03aptvRoVIGP8YykoSxqdVLV1TfwflBCE/QtHmqtP8SWlTENqbK8GCSQ== + dependencies: + "@babel/helper-plugin-utils" "^7.0.0" + "@istanbuljs/load-nyc-config" "^1.0.0" + "@istanbuljs/schema" "^0.1.2" + istanbul-lib-instrument "^4.0.0" + test-exclude "^6.0.0" + +babel-plugin-jest-hoist@^25.5.0: + version "25.5.0" + resolved "https://registry.yarnpkg.com/babel-plugin-jest-hoist/-/babel-plugin-jest-hoist-25.5.0.tgz#129c80ba5c7fc75baf3a45b93e2e372d57ca2677" + integrity sha512-u+/W+WAjMlvoocYGTwthAiQSxDcJAyHpQ6oWlHdFZaaN+Rlk8Q7iiwDPg2lN/FyJtAYnKjFxbn7xus4HCFkg5g== + dependencies: + "@babel/template" "^7.3.3" + "@babel/types" "^7.3.3" + "@types/babel__traverse" "^7.0.6" + +babel-preset-current-node-syntax@^0.1.2: + version "0.1.4" + resolved "https://registry.yarnpkg.com/babel-preset-current-node-syntax/-/babel-preset-current-node-syntax-0.1.4.tgz#826f1f8e7245ad534714ba001f84f7e906c3b615" + integrity sha512-5/INNCYhUGqw7VbVjT/hb3ucjgkVHKXY7lX3ZjlN4gm565VyFmJUrJ/h+h16ECVB38R/9SF6aACydpKMLZ/c9w== + dependencies: + "@babel/plugin-syntax-async-generators" "^7.8.4" + "@babel/plugin-syntax-bigint" "^7.8.3" + "@babel/plugin-syntax-class-properties" "^7.8.3" + "@babel/plugin-syntax-import-meta" "^7.8.3" + "@babel/plugin-syntax-json-strings" "^7.8.3" + "@babel/plugin-syntax-logical-assignment-operators" "^7.8.3" + "@babel/plugin-syntax-nullish-coalescing-operator" "^7.8.3" + "@babel/plugin-syntax-numeric-separator" "^7.8.3" + "@babel/plugin-syntax-object-rest-spread" "^7.8.3" + "@babel/plugin-syntax-optional-catch-binding" "^7.8.3" + "@babel/plugin-syntax-optional-chaining" "^7.8.3" + +babel-preset-jest@^25.5.0: + version "25.5.0" + resolved "https://registry.yarnpkg.com/babel-preset-jest/-/babel-preset-jest-25.5.0.tgz#c1d7f191829487a907764c65307faa0e66590b49" + integrity sha512-8ZczygctQkBU+63DtSOKGh7tFL0CeCuz+1ieud9lJ1WPQ9O6A1a/r+LGn6Y705PA6whHQ3T1XuB/PmpfNYf8Fw== + dependencies: + babel-plugin-jest-hoist "^25.5.0" + babel-preset-current-node-syntax "^0.1.2" + +balanced-match@^1.0.0: + version "1.0.2" + resolved "https://registry.yarnpkg.com/balanced-match/-/balanced-match-1.0.2.tgz#e83e3a7e3f300b34cb9d87f615fa0cbf357690ee" + integrity sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw== + +base@^0.11.1: + version "0.11.2" + resolved "https://registry.yarnpkg.com/base/-/base-0.11.2.tgz#7bde5ced145b6d551a90db87f83c558b4eb48a8f" + integrity sha512-5T6P4xPgpp0YDFvSWwEZ4NoE3aM4QBQXDzmVbraCkFj8zHM+mba8SyqB5DbZWyR7mYHo6Y7BdQo3MoA4m0TeQg== + dependencies: + cache-base "^1.0.1" + class-utils "^0.3.5" + component-emitter "^1.2.1" + define-property "^1.0.0" + isobject "^3.0.1" + mixin-deep "^1.2.0" + pascalcase "^0.1.1" + +basic-auth@^1.0.3: + version "1.1.0" + resolved "https://registry.yarnpkg.com/basic-auth/-/basic-auth-1.1.0.tgz#45221ee429f7ee1e5035be3f51533f1cdfd29884" + integrity sha1-RSIe5Cn37h5QNb4/UVM/HN/SmIQ= + +bcrypt-pbkdf@^1.0.0: + version "1.0.2" + resolved "https://registry.yarnpkg.com/bcrypt-pbkdf/-/bcrypt-pbkdf-1.0.2.tgz#a4301d389b6a43f9b67ff3ca11a3f6637e360e9e" + integrity sha1-pDAdOJtqQ/m2f/PKEaP2Y342Dp4= + dependencies: + tweetnacl "^0.14.3" + +brace-expansion@^1.1.7: + version "1.1.11" + resolved "https://registry.yarnpkg.com/brace-expansion/-/brace-expansion-1.1.11.tgz#3c7fcbf529d87226f3d2f52b966ff5271eb441dd" + integrity sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA== + dependencies: + balanced-match "^1.0.0" + concat-map "0.0.1" + +braces@^2.3.1: + version "2.3.2" + resolved "https://registry.yarnpkg.com/braces/-/braces-2.3.2.tgz#5979fd3f14cd531565e5fa2df1abfff1dfaee729" + integrity sha512-aNdbnj9P8PjdXU4ybaWLK2IF3jc/EoDYbC7AazW6to3TRsfXxscC9UXOB5iDiEQrkyIbWp2SLQda4+QAa7nc3w== + dependencies: + arr-flatten "^1.1.0" + array-unique "^0.3.2" + extend-shallow "^2.0.1" + fill-range "^4.0.0" + isobject "^3.0.1" + repeat-element "^1.1.2" + snapdragon "^0.8.1" + snapdragon-node "^2.0.1" + split-string "^3.0.2" + to-regex "^3.0.1" + +braces@^3.0.1: + version "3.0.2" + resolved "https://registry.yarnpkg.com/braces/-/braces-3.0.2.tgz#3454e1a462ee8d599e236df336cd9ea4f8afe107" + integrity sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A== + dependencies: + fill-range "^7.0.1" + +browser-process-hrtime@^1.0.0: + version "1.0.0" + resolved "https://registry.yarnpkg.com/browser-process-hrtime/-/browser-process-hrtime-1.0.0.tgz#3c9b4b7d782c8121e56f10106d84c0d0ffc94626" + integrity sha512-9o5UecI3GhkpM6DrXr69PblIuWxPKk9Y0jHBRhdocZ2y7YECBFCsHm79Pr3OyR2AvjhDkabFJaDJMYRazHgsow== + +browser-resolve@^1.11.3: + version "1.11.3" + resolved "https://registry.yarnpkg.com/browser-resolve/-/browser-resolve-1.11.3.tgz#9b7cbb3d0f510e4cb86bdbd796124d28b5890af6" + integrity sha512-exDi1BYWB/6raKHmDTCicQfTkqwN5fioMFV4j8BsfMU4R2DK/QfZfK7kOVkmWCNANf0snkBzqGqAJBao9gZMdQ== + dependencies: + resolve "1.1.7" + +browserslist@^4.16.6: + version "4.16.6" + resolved "https://registry.yarnpkg.com/browserslist/-/browserslist-4.16.6.tgz#d7901277a5a88e554ed305b183ec9b0c08f66fa2" + integrity sha512-Wspk/PqO+4W9qp5iUTJsa1B/QrYn1keNCcEP5OvP7WBwT4KaDly0uONYmC6Xa3Z5IqnUgS0KcgLYu1l74x0ZXQ== + dependencies: + caniuse-lite "^1.0.30001219" + colorette "^1.2.2" + electron-to-chromium "^1.3.723" + escalade "^3.1.1" + node-releases "^1.1.71" + +bs-logger@0.x: + version "0.2.6" + resolved "https://registry.yarnpkg.com/bs-logger/-/bs-logger-0.2.6.tgz#eb7d365307a72cf974cc6cda76b68354ad336bd8" + integrity sha512-pd8DCoxmbgc7hyPKOvxtqNcjYoOsABPQdcCUjGp3d42VR2CX1ORhk2A87oqqu5R1kk+76nsxZupkmyd+MVtCog== + dependencies: + fast-json-stable-stringify "2.x" + +bser@2.1.1: + version "2.1.1" + resolved "https://registry.yarnpkg.com/bser/-/bser-2.1.1.tgz#e6787da20ece9d07998533cfd9de6f5c38f4bc05" + integrity sha512-gQxTNE/GAfIIrmHLUE3oJyp5FO6HRBfhjnw4/wMmA63ZGDJnWBmgY/lyQBpnDUkGmAhbSe39tx2d/iTOAfglwQ== + dependencies: + node-int64 "^0.4.0" + +buffer-crc32@~0.2.3: + version "0.2.13" + resolved "https://registry.yarnpkg.com/buffer-crc32/-/buffer-crc32-0.2.13.tgz#0d333e3f00eac50aa1454abd30ef8c2a5d9a7242" + integrity sha1-DTM+PwDqxQqhRUq9MO+MKl2ackI= + +buffer-from@1.x, buffer-from@^1.0.0: + version "1.1.1" + resolved "https://registry.yarnpkg.com/buffer-from/-/buffer-from-1.1.1.tgz#32713bc028f75c02fdb710d7c7bcec1f2c6070ef" + integrity sha512-MQcXEUbCKtEo7bhqEs6560Hyd4XaovZlO/k9V3hjVUF/zwW7KBVdSK4gIt/bzwS9MbR5qob+F5jusZsb0YQK2A== + +cache-base@^1.0.1: + version "1.0.1" + resolved "https://registry.yarnpkg.com/cache-base/-/cache-base-1.0.1.tgz#0a7f46416831c8b662ee36fe4e7c59d76f666ab2" + integrity sha512-AKcdTnFSWATd5/GCPRxr2ChwIJ85CeyrEyjRHlKxQ56d4XJMGym0uAiKn0xbLOGOl3+yRpOTi484dVCEc5AUzQ== + dependencies: + collection-visit "^1.0.0" + component-emitter "^1.2.1" + get-value "^2.0.6" + has-value "^1.0.0" + isobject "^3.0.1" + set-value "^2.0.0" + to-object-path "^0.3.0" + union-value "^1.0.0" + unset-value "^1.0.0" + +call-bind@^1.0.0: + version "1.0.2" + resolved "https://registry.yarnpkg.com/call-bind/-/call-bind-1.0.2.tgz#b1d4e89e688119c3c9a903ad30abb2f6a919be3c" + integrity sha512-7O+FbCihrB5WGbFYesctwmTKae6rOiIzmz1icreWJ+0aA7LJfuqhEso2T9ncpcFtzMQtzXf2QGGueWJGTYsqrA== + dependencies: + function-bind "^1.1.1" + get-intrinsic "^1.0.2" + +callsites@^3.0.0: + version "3.1.0" + resolved "https://registry.yarnpkg.com/callsites/-/callsites-3.1.0.tgz#b3630abd8943432f54b3f0519238e33cd7df2f73" + integrity sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ== + +camelcase-keys@^6.2.2: + version "6.2.2" + resolved "https://registry.yarnpkg.com/camelcase-keys/-/camelcase-keys-6.2.2.tgz#5e755d6ba51aa223ec7d3d52f25778210f9dc3c0" + integrity sha512-YrwaA0vEKazPBkn0ipTiMpSajYDSe+KjQfrjhcBMxJt/znbvlHd8Pw/Vamaz5EB4Wfhs3SUR3Z9mwRu/P3s3Yg== + dependencies: + camelcase "^5.3.1" + map-obj "^4.0.0" + quick-lru "^4.0.1" + +camelcase@^5.0.0, camelcase@^5.3.1: + version "5.3.1" + resolved "https://registry.yarnpkg.com/camelcase/-/camelcase-5.3.1.tgz#e3c9b31569e106811df242f715725a1f4c494320" + integrity sha512-L28STB170nwWS63UjtlEOE3dldQApaJXZkOI1uMFfzf3rRuPegHaHesyee+YxQ+W6SvRDQV6UrdOdRiR153wJg== + +caniuse-lite@^1.0.30001219: + version "1.0.30001245" + resolved "https://registry.yarnpkg.com/caniuse-lite/-/caniuse-lite-1.0.30001245.tgz#45b941bbd833cb0fa53861ff2bae746b3c6ca5d4" + integrity sha512-768fM9j1PKXpOCKws6eTo3RHmvTUsG9UrpT4WoREFeZgJBTi4/X9g565azS/rVUGtqb8nt7FjLeF5u4kukERnA== + +capture-exit@^2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/capture-exit/-/capture-exit-2.0.0.tgz#fb953bfaebeb781f62898239dabb426d08a509a4" + integrity sha512-PiT/hQmTonHhl/HFGN+Lx3JJUznrVYJ3+AQsnthneZbvW7x+f08Tk7yLJTLEOUvBTbduLeeBkxEaYXUOUrRq6g== + dependencies: + rsvp "^4.8.4" + +caseless@~0.12.0: + version "0.12.0" + resolved "https://registry.yarnpkg.com/caseless/-/caseless-0.12.0.tgz#1b681c21ff84033c826543090689420d187151dc" + integrity sha1-G2gcIf+EAzyCZUMJBolCDRhxUdw= + +chalk@^2.0.0, chalk@^2.4.2: + version "2.4.2" + resolved "https://registry.yarnpkg.com/chalk/-/chalk-2.4.2.tgz#cd42541677a54333cf541a49108c1432b44c9424" + integrity sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ== + dependencies: + ansi-styles "^3.2.1" + escape-string-regexp "^1.0.5" + supports-color "^5.3.0" + +chalk@^3.0.0: + version "3.0.0" + resolved "https://registry.yarnpkg.com/chalk/-/chalk-3.0.0.tgz#3f73c2bf526591f574cc492c51e2456349f844e4" + integrity sha512-4D3B6Wf41KOYRFdszmDqMCGq5VV/uMAB273JILmO+3jAlh8X4qDtdtgCR3fxtbLEMzSx22QdhnDcJvu2u1fVwg== + dependencies: + ansi-styles "^4.1.0" + supports-color "^7.1.0" + +chalk@^4.0.0, chalk@^4.1.0: + version "4.1.1" + resolved "https://registry.yarnpkg.com/chalk/-/chalk-4.1.1.tgz#c80b3fab28bf6371e6863325eee67e618b77e6ad" + integrity sha512-diHzdDKxcU+bAsUboHLPEDQiw0qEe0qd7SYUn3HgcFlWgbDcfLGswOHYeGrHKzG9z6UYf01d9VFMfZxPM1xZSg== + dependencies: + ansi-styles "^4.1.0" + supports-color "^7.1.0" + +chardet@^0.7.0: + version "0.7.0" + resolved "https://registry.yarnpkg.com/chardet/-/chardet-0.7.0.tgz#90094849f0937f2eedc2425d0d28a9e5f0cbad9e" + integrity sha512-mT8iDcrh03qDGRRmoA2hmBJnxpllMR+0/0qlzjqZES6NdiWDcZkCNAk4rPFZ9Q85r27unkiNNg8ZOiwZXBHwcA== + +ci-info@^2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/ci-info/-/ci-info-2.0.0.tgz#67a9e964be31a51e15e5010d58e6f12834002f46" + integrity sha512-5tK7EtrZ0N+OLFMthtqOj4fI2Jeb88C4CAZPu25LDVUgXJ0A3Js4PMGqrn0JU1W0Mh1/Z8wZzYPxqUrXeBboCQ== + +class-utils@^0.3.5: + version "0.3.6" + resolved "https://registry.yarnpkg.com/class-utils/-/class-utils-0.3.6.tgz#f93369ae8b9a7ce02fd41faad0ca83033190c463" + integrity sha512-qOhPa/Fj7s6TY8H8esGu5QNpMMQxz79h+urzrNYN6mn+9BnxlDGf5QZ+XeCDsxSjPqsSR56XOZOJmpeurnLMeg== + dependencies: + arr-union "^3.1.0" + define-property "^0.2.5" + isobject "^3.0.0" + static-extend "^0.1.1" + +cli-cursor@^3.1.0: + version "3.1.0" + resolved "https://registry.yarnpkg.com/cli-cursor/-/cli-cursor-3.1.0.tgz#264305a7ae490d1d03bf0c9ba7c925d1753af307" + integrity sha512-I/zHAwsKf9FqGoXM4WWRACob9+SNukZTd94DWF57E4toouRulbCxcUh6RKUEOQlYTHJnzkPMySvPNaaSLNfLZw== + dependencies: + restore-cursor "^3.1.0" + +cli-width@^3.0.0: + version "3.0.0" + resolved "https://registry.yarnpkg.com/cli-width/-/cli-width-3.0.0.tgz#a2f48437a2caa9a22436e794bf071ec9e61cedf6" + integrity sha512-FxqpkPPwu1HjuN93Omfm4h8uIanXofW0RxVEW3k5RKx+mJJYSthzNhp32Kzxxy3YAEZ/Dc/EWN1vZRY0+kOhbw== + +cliui@^6.0.0: + version "6.0.0" + resolved "https://registry.yarnpkg.com/cliui/-/cliui-6.0.0.tgz#511d702c0c4e41ca156d7d0e96021f23e13225b1" + integrity sha512-t6wbgtoCXvAzst7QgXxJYqPt0usEfbgQdftEPbLL/cvv6HPE5VgvqCuAIDR0NgU52ds6rFwqrgakNLrHEjCbrQ== + dependencies: + string-width "^4.2.0" + strip-ansi "^6.0.0" + wrap-ansi "^6.2.0" + +co@^4.6.0: + version "4.6.0" + resolved "https://registry.yarnpkg.com/co/-/co-4.6.0.tgz#6ea6bdf3d853ae54ccb8e47bfa0bf3f9031fb184" + integrity sha1-bqa989hTrlTMuOR7+gvz+QMfsYQ= + +collect-v8-coverage@^1.0.0: + version "1.0.1" + resolved "https://registry.yarnpkg.com/collect-v8-coverage/-/collect-v8-coverage-1.0.1.tgz#cc2c8e94fc18bbdffe64d6534570c8a673b27f59" + integrity sha512-iBPtljfCNcTKNAto0KEtDfZ3qzjJvqE3aTGZsbhjSBlorqpXJlaWWtPO35D+ZImoC3KWejX64o+yPGxhWSTzfg== + +collection-visit@^1.0.0: + version "1.0.0" + resolved "https://registry.yarnpkg.com/collection-visit/-/collection-visit-1.0.0.tgz#4bc0373c164bc3291b4d368c829cf1a80a59dca0" + integrity sha1-S8A3PBZLwykbTTaMgpzxqApZ3KA= + dependencies: + map-visit "^1.0.0" + object-visit "^1.0.0" + +color-convert@^1.9.0: + version "1.9.3" + resolved "https://registry.yarnpkg.com/color-convert/-/color-convert-1.9.3.tgz#bb71850690e1f136567de629d2d5471deda4c1e8" + integrity sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg== + dependencies: + color-name "1.1.3" + +color-convert@^2.0.1: + version "2.0.1" + resolved "https://registry.yarnpkg.com/color-convert/-/color-convert-2.0.1.tgz#72d3a68d598c9bdb3af2ad1e84f21d896abd4de3" + integrity sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ== + dependencies: + color-name "~1.1.4" + +color-name@1.1.3: + version "1.1.3" + resolved "https://registry.yarnpkg.com/color-name/-/color-name-1.1.3.tgz#a7d0558bd89c42f795dd42328f740831ca53bc25" + integrity sha1-p9BVi9icQveV3UIyj3QIMcpTvCU= + +color-name@~1.1.4: + version "1.1.4" + resolved "https://registry.yarnpkg.com/color-name/-/color-name-1.1.4.tgz#c2a09a87acbde69543de6f63fa3995c826c536a2" + integrity sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA== + +colorette@^1.2.2: + version "1.2.2" + resolved "https://registry.yarnpkg.com/colorette/-/colorette-1.2.2.tgz#cbcc79d5e99caea2dbf10eb3a26fd8b3e6acfa94" + integrity sha512-MKGMzyfeuutC/ZJ1cba9NqcNpfeqMUcYmyF1ZFY6/Cn7CNSAKx6a+s48sqLqyAiZuaP2TcqMhoo+dlwFnVxT9w== + +colors@^1.4.0: + version "1.4.0" + resolved "https://registry.yarnpkg.com/colors/-/colors-1.4.0.tgz#c50491479d4c1bdaed2c9ced32cf7c7dc2360f78" + integrity sha512-a+UqTh4kgZg/SlGvfbzDHpgRu7AAQOmmqRHJnxhRZICKFUT91brVhNNt58CMWU9PsBbv3PDCZUHbVxuDiH2mtA== + +combined-stream@^1.0.6, combined-stream@~1.0.6: + version "1.0.8" + resolved "https://registry.yarnpkg.com/combined-stream/-/combined-stream-1.0.8.tgz#c3d45a8b34fd730631a110a8a2520682b31d5a7f" + integrity sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg== + dependencies: + delayed-stream "~1.0.0" + +commander@^2.19.0: + version "2.20.3" + resolved "https://registry.yarnpkg.com/commander/-/commander-2.20.3.tgz#fd485e84c03eb4881c20722ba48035e8531aeb33" + integrity sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ== + +commander@^6.1.0: + version "6.2.1" + resolved "https://registry.yarnpkg.com/commander/-/commander-6.2.1.tgz#0792eb682dfbc325999bb2b84fddddba110ac73c" + integrity sha512-U7VdrJFnJgo4xjrHpTzu0yrHPGImdsmD95ZlgYSEajAn2JKzDhDTPG9kBTefmObL2w/ngeZnilk+OV9CG3d7UA== + +component-emitter@^1.2.1: + version "1.3.0" + resolved "https://registry.yarnpkg.com/component-emitter/-/component-emitter-1.3.0.tgz#16e4070fba8ae29b679f2215853ee181ab2eabc0" + integrity sha512-Rd3se6QB+sO1TwqZjscQrurpEPIfO0/yYnSin6Q/rD3mOutHvUrCAhJub3r90uNb+SESBuE0QYoB90YdfatsRg== + +concat-map@0.0.1: + version "0.0.1" + resolved "https://registry.yarnpkg.com/concat-map/-/concat-map-0.0.1.tgz#d8a96bd77fd68df7793a73036a3ba0d5405d477b" + integrity sha1-2Klr13/Wjfd5OnMDajug1UBdR3s= + +config-chain@^1.1.12: + version "1.1.13" + resolved "https://registry.yarnpkg.com/config-chain/-/config-chain-1.1.13.tgz#fad0795aa6a6cdaff9ed1b68e9dff94372c232f4" + integrity sha512-qj+f8APARXHrM0hraqXYb2/bOVSV4PvJQlNZ/DVj0QrmNM2q2euizkeuVckQ57J+W0mRH6Hvi+k50M4Jul2VRQ== + dependencies: + ini "^1.3.4" + proto-list "~1.2.1" + +convert-source-map@^1.4.0, convert-source-map@^1.6.0, convert-source-map@^1.7.0: + version "1.8.0" + resolved "https://registry.yarnpkg.com/convert-source-map/-/convert-source-map-1.8.0.tgz#f3373c32d21b4d780dd8004514684fb791ca4369" + integrity sha512-+OQdjP49zViI/6i7nIJpA8rAl4sV/JdPfU9nZs3VqOwGIgizICvuN2ru6fMd+4llL0tar18UYJXfZ/TWtmhUjA== + dependencies: + safe-buffer "~5.1.1" + +copy-descriptor@^0.1.0: + version "0.1.1" + resolved "https://registry.yarnpkg.com/copy-descriptor/-/copy-descriptor-0.1.1.tgz#676f6eb3c39997c2ee1ac3a924fd6124748f578d" + integrity sha1-Z29us8OZl8LuGsOpJP1hJHSPV40= + +core-util-is@1.0.2: + version "1.0.2" + resolved "https://registry.yarnpkg.com/core-util-is/-/core-util-is-1.0.2.tgz#b5fd54220aa2bc5ab57aab7140c940754503c1a7" + integrity sha1-tf1UIgqivFq1eqtxQMlAdUUDwac= + +corser@^2.0.1: + version "2.0.1" + resolved "https://registry.yarnpkg.com/corser/-/corser-2.0.1.tgz#8eda252ecaab5840dcd975ceb90d9370c819ff87" + integrity sha1-jtolLsqrWEDc2XXOuQ2TcMgZ/4c= + +cross-spawn@^6.0.0, cross-spawn@^6.0.5: + version "6.0.5" + resolved "https://registry.yarnpkg.com/cross-spawn/-/cross-spawn-6.0.5.tgz#4a5ec7c64dfae22c3a14124dbacdee846d80cbc4" + integrity sha512-eTVLrBSt7fjbDygz805pMnstIs2VTBNkRm0qxZd+M7A5XDdxVRWO5MxGBXZhjY4cqLYLdtrGqRf8mBPmzwSpWQ== + dependencies: + nice-try "^1.0.4" + path-key "^2.0.1" + semver "^5.5.0" + shebang-command "^1.2.0" + which "^1.2.9" + +cross-spawn@^7.0.0: + version "7.0.3" + resolved "https://registry.yarnpkg.com/cross-spawn/-/cross-spawn-7.0.3.tgz#f73a85b9d5d41d045551c177e2882d4ac85728a6" + integrity sha512-iRDPJKUPVEND7dHPO8rkbOnPpyDygcDFtWjpeWNCgy8WP2rXcxXL8TskReQl6OrB2G7+UJrags1q15Fudc7G6w== + dependencies: + path-key "^3.1.0" + shebang-command "^2.0.0" + which "^2.0.1" + +cssom@^0.4.1: + version "0.4.4" + resolved "https://registry.yarnpkg.com/cssom/-/cssom-0.4.4.tgz#5a66cf93d2d0b661d80bf6a44fb65f5c2e4e0a10" + integrity sha512-p3pvU7r1MyyqbTk+WbNJIgJjG2VmTIaB10rI93LzVPrmDJKkzKYMtxxyAvQXR/NS6otuzveI7+7BBq3SjBS2mw== + +cssom@~0.3.6: + version "0.3.8" + resolved "https://registry.yarnpkg.com/cssom/-/cssom-0.3.8.tgz#9f1276f5b2b463f2114d3f2c75250af8c1a36f4a" + integrity sha512-b0tGHbfegbhPJpxpiBPU2sCkigAqtM9O121le6bbOlgyV+NyGyCmVfJ6QW9eRjz8CpNfWEOYBIMIGRYkLwsIYg== + +cssstyle@^2.0.0: + version "2.3.0" + resolved "https://registry.yarnpkg.com/cssstyle/-/cssstyle-2.3.0.tgz#ff665a0ddbdc31864b09647f34163443d90b0852" + integrity sha512-AZL67abkUzIuvcHqk7c09cezpGNcxUxU4Ioi/05xHk4DQeTkWmGYftIE6ctU6AEt+Gn4n1lDStOtj7FKycP71A== + dependencies: + cssom "~0.3.6" + +dashdash@^1.12.0: + version "1.14.1" + resolved "https://registry.yarnpkg.com/dashdash/-/dashdash-1.14.1.tgz#853cfa0f7cbe2fed5de20326b8dd581035f6e2f0" + integrity sha1-hTz6D3y+L+1d4gMmuN1YEDX24vA= + dependencies: + assert-plus "^1.0.0" + +data-urls@^1.1.0: + version "1.1.0" + resolved "https://registry.yarnpkg.com/data-urls/-/data-urls-1.1.0.tgz#15ee0582baa5e22bb59c77140da8f9c76963bbfe" + integrity sha512-YTWYI9se1P55u58gL5GkQHW4P6VJBJ5iBT+B5a7i2Tjadhv52paJG0qHX4A0OR6/t52odI64KP2YvFpkDOi3eQ== + dependencies: + abab "^2.0.0" + whatwg-mimetype "^2.2.0" + whatwg-url "^7.0.0" + +dateformat@^3.0.3: + version "3.0.3" + resolved "https://registry.yarnpkg.com/dateformat/-/dateformat-3.0.3.tgz#a6e37499a4d9a9cf85ef5872044d62901c9889ae" + integrity sha512-jyCETtSl3VMZMWeRo7iY1FL19ges1t55hMo5yaam4Jrsm5EPL89UQkoQRyiI+Yf4k8r2ZpdngkV8hr1lIdjb3Q== + +debug@4, debug@^4.1.0, debug@^4.1.1: + version "4.3.2" + resolved "https://registry.yarnpkg.com/debug/-/debug-4.3.2.tgz#f0a49c18ac8779e31d4a0c6029dfb76873c7428b" + integrity sha512-mOp8wKcvj7XxC78zLgw/ZA+6TSgkoE2C/ienthhRD298T7UNwAg9diBpLRxC0mOezLl4B0xV7M0cCO6P/O0Xhw== + dependencies: + ms "2.1.2" + +debug@^2.2.0, debug@^2.3.3: + version "2.6.9" + resolved "https://registry.yarnpkg.com/debug/-/debug-2.6.9.tgz#5d128515df134ff327e90a4c93f4e077a536341f" + integrity sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA== + dependencies: + ms "2.0.0" + +debug@^3.1.1: + version "3.2.7" + resolved "https://registry.yarnpkg.com/debug/-/debug-3.2.7.tgz#72580b7e9145fb39b6676f9c5e5fb100b934179a" + integrity sha512-CFjzYYAi4ThfiQvizrFQevTTXHtnCqWfe7x1AhgEscTz6ZbLbfoLRLPugTQyBth6f8ZERVUSyWHFD/7Wu4t1XQ== + dependencies: + ms "^2.1.1" + +decamelize-keys@^1.1.0: + version "1.1.0" + resolved "https://registry.yarnpkg.com/decamelize-keys/-/decamelize-keys-1.1.0.tgz#d171a87933252807eb3cb61dc1c1445d078df2d9" + integrity sha1-0XGoeTMlKAfrPLYdwcFEXQeN8tk= + dependencies: + decamelize "^1.1.0" + map-obj "^1.0.0" + +decamelize@^1.1.0, decamelize@^1.2.0: + version "1.2.0" + resolved "https://registry.yarnpkg.com/decamelize/-/decamelize-1.2.0.tgz#f6534d15148269b20352e7bee26f501f9a191290" + integrity sha1-9lNNFRSCabIDUue+4m9QH5oZEpA= + +decode-uri-component@^0.2.0: + version "0.2.0" + resolved "https://registry.yarnpkg.com/decode-uri-component/-/decode-uri-component-0.2.0.tgz#eb3913333458775cb84cd1a1fae062106bb87545" + integrity sha1-6zkTMzRYd1y4TNGh+uBiEGu4dUU= + +deep-is@~0.1.3: + version "0.1.3" + resolved "https://registry.yarnpkg.com/deep-is/-/deep-is-0.1.3.tgz#b369d6fb5dbc13eecf524f91b070feedc357cf34" + integrity sha1-s2nW+128E+7PUk+RsHD+7cNXzzQ= + +deepmerge@^4.2.2: + version "4.2.2" + resolved "https://registry.yarnpkg.com/deepmerge/-/deepmerge-4.2.2.tgz#44d2ea3679b8f4d4ffba33f03d865fc1e7bf4955" + integrity sha512-FJ3UgI4gIl+PHZm53knsuSFpE+nESMr7M4v9QcgB7S63Kj/6WqMiFQJpBBYz1Pt+66bZpP3Q7Lye0Oo9MPKEdg== + +define-property@^0.2.5: + version "0.2.5" + resolved "https://registry.yarnpkg.com/define-property/-/define-property-0.2.5.tgz#c35b1ef918ec3c990f9a5bc57be04aacec5c8116" + integrity sha1-w1se+RjsPJkPmlvFe+BKrOxcgRY= + dependencies: + is-descriptor "^0.1.0" + +define-property@^1.0.0: + version "1.0.0" + resolved "https://registry.yarnpkg.com/define-property/-/define-property-1.0.0.tgz#769ebaaf3f4a63aad3af9e8d304c9bbe79bfb0e6" + integrity sha1-dp66rz9KY6rTr56NMEybvnm/sOY= + dependencies: + is-descriptor "^1.0.0" + +define-property@^2.0.2: + version "2.0.2" + resolved "https://registry.yarnpkg.com/define-property/-/define-property-2.0.2.tgz#d459689e8d654ba77e02a817f8710d702cb16e9d" + integrity sha512-jwK2UV4cnPpbcG7+VRARKTZPUWowwXA8bzH5NP6ud0oeAxyYPuGZUAC7hMugpCdz4BeSZl2Dl9k66CHJ/46ZYQ== + dependencies: + is-descriptor "^1.0.2" + isobject "^3.0.1" + +delayed-stream@~1.0.0: + version "1.0.0" + resolved "https://registry.yarnpkg.com/delayed-stream/-/delayed-stream-1.0.0.tgz#df3ae199acadfb7d440aaae0b29e2272b24ec619" + integrity sha1-3zrhmayt+31ECqrgsp4icrJOxhk= + +detect-newline@^3.0.0: + version "3.1.0" + resolved "https://registry.yarnpkg.com/detect-newline/-/detect-newline-3.1.0.tgz#576f5dfc63ae1a192ff192d8ad3af6308991b651" + integrity sha512-TLz+x/vEXm/Y7P7wn1EJFNLxYpUD4TgMosxY6fAVJUnJMbupHBOncxyWUG9OpTaH9EBD7uFI5LfEgmMOc54DsA== + +diff-sequences@^25.2.6: + version "25.2.6" + resolved "https://registry.yarnpkg.com/diff-sequences/-/diff-sequences-25.2.6.tgz#5f467c00edd35352b7bca46d7927d60e687a76dd" + integrity sha512-Hq8o7+6GaZeoFjtpgvRBUknSXNeJiCx7V9Fr94ZMljNiCr9n9L8H8aJqgWOQiDDGdyn29fRNcDdRVJ5fdyihfg== + +domexception@^1.0.1: + version "1.0.1" + resolved "https://registry.yarnpkg.com/domexception/-/domexception-1.0.1.tgz#937442644ca6a31261ef36e3ec677fe805582c90" + integrity sha512-raigMkn7CJNNo6Ihro1fzG7wr3fHuYVytzquZKX5n0yizGsTcYgzdIUwj1X9pK0VvjeihV+XiclP+DjwbsSKug== + dependencies: + webidl-conversions "^4.0.2" + +ecc-jsbn@~0.1.1: + version "0.1.2" + resolved "https://registry.yarnpkg.com/ecc-jsbn/-/ecc-jsbn-0.1.2.tgz#3a83a904e54353287874c564b7549386849a98c9" + integrity sha1-OoOpBOVDUyh4dMVkt1SThoSamMk= + dependencies: + jsbn "~0.1.0" + safer-buffer "^2.1.0" + +ecstatic@^3.3.2: + version "3.3.2" + resolved "https://registry.yarnpkg.com/ecstatic/-/ecstatic-3.3.2.tgz#6d1dd49814d00594682c652adb66076a69d46c48" + integrity sha512-fLf9l1hnwrHI2xn9mEDT7KIi22UDqA2jaCwyCbSUJh9a1V+LEUSL/JO/6TIz/QyuBURWUHrFL5Kg2TtO1bkkog== + dependencies: + he "^1.1.1" + mime "^1.6.0" + minimist "^1.1.0" + url-join "^2.0.5" + +editorconfig@^0.15.3: + version "0.15.3" + resolved "https://registry.yarnpkg.com/editorconfig/-/editorconfig-0.15.3.tgz#bef84c4e75fb8dcb0ce5cee8efd51c15999befc5" + integrity sha512-M9wIMFx96vq0R4F+gRpY3o2exzb8hEj/n9S8unZtHSvYjibBp/iMufSzvmOcV/laG0ZtuTVGtiJggPOSW2r93g== + dependencies: + commander "^2.19.0" + lru-cache "^4.1.5" + semver "^5.6.0" + sigmund "^1.0.1" + +ejs@^3.0.1: + version "3.1.6" + resolved "https://registry.yarnpkg.com/ejs/-/ejs-3.1.6.tgz#5bfd0a0689743bb5268b3550cceeebbc1702822a" + integrity sha512-9lt9Zse4hPucPkoP7FHDF0LQAlGyF9JVpnClFLFH3aSSbxmyoqINRpp/9wePWJTUl4KOQwRL72Iw3InHPDkoGw== + dependencies: + jake "^10.6.1" + +electron-to-chromium@^1.3.723: + version "1.3.776" + resolved "https://registry.yarnpkg.com/electron-to-chromium/-/electron-to-chromium-1.3.776.tgz#33f6e2423b61f1bdaa8d2a103aae78a09764a75f" + integrity sha512-V0w7eFSBoFPpdw4xexjVPZ770UDZIevSwkkj4W97XbE3IsCsTRFpa7/yXGZ88EOQAUEA09JMMsWK0xsw0kRAYw== + +emoji-regex@^8.0.0: + version "8.0.0" + resolved "https://registry.yarnpkg.com/emoji-regex/-/emoji-regex-8.0.0.tgz#e818fd69ce5ccfcb404594f842963bf53164cc37" + integrity sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A== + +end-of-stream@^1.1.0: + version "1.4.4" + resolved "https://registry.yarnpkg.com/end-of-stream/-/end-of-stream-1.4.4.tgz#5ae64a5f45057baf3626ec14da0ca5e4b2431eb0" + integrity sha512-+uw1inIHVPQoaVuHzRyXd21icM+cnt4CzD5rW+NC1wjOUSTOs+Te7FOv7AhN7vS9x/oIyhLP5PR1H+phQAHu5Q== + dependencies: + once "^1.4.0" + +error-ex@^1.3.1: + version "1.3.2" + resolved "https://registry.yarnpkg.com/error-ex/-/error-ex-1.3.2.tgz#b4ac40648107fdcdcfae242f428bea8a14d4f1bf" + integrity sha512-7dFHNmqeFSEt2ZBsCriorKnn3Z2pj+fd9kmI6QoWw4//DL+icEBfc0U7qJCisqrTsKTjw4fNFy2pW9OqStD84g== + dependencies: + is-arrayish "^0.2.1" + +escalade@^3.1.1: + version "3.1.1" + resolved "https://registry.yarnpkg.com/escalade/-/escalade-3.1.1.tgz#d8cfdc7000965c5a0174b4a82eaa5c0552742e40" + integrity sha512-k0er2gUkLf8O0zKJiAhmkTnJlTvINGv7ygDNPbeIsX/TJjGJZHuh9B2UxbsaEkmlEo9MfhrSzmhIlhRlI2GXnw== + +escape-string-regexp@^1.0.5: + version "1.0.5" + resolved "https://registry.yarnpkg.com/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz#1b61c0562190a8dff6ae3bb2cf0200ca130b86d4" + integrity sha1-G2HAViGQqN/2rjuyzwIAyhMLhtQ= + +escape-string-regexp@^2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/escape-string-regexp/-/escape-string-regexp-2.0.0.tgz#a30304e99daa32e23b2fd20f51babd07cffca344" + integrity sha512-UpzcLCXolUWcNu5HtVMHYdXJjArjsF9C0aNnquZYY4uW/Vu0miy5YoWvbV345HauVvcAUnpRuhMMcqTcGOY2+w== + +escodegen@^1.11.1: + version "1.14.3" + resolved "https://registry.yarnpkg.com/escodegen/-/escodegen-1.14.3.tgz#4e7b81fba61581dc97582ed78cab7f0e8d63f503" + integrity sha512-qFcX0XJkdg+PB3xjZZG/wKSuT1PnQWx57+TVSjIMmILd2yC/6ByYElPwJnslDsuWuSAp4AwJGumarAAmJch5Kw== + dependencies: + esprima "^4.0.1" + estraverse "^4.2.0" + esutils "^2.0.2" + optionator "^0.8.1" + optionalDependencies: + source-map "~0.6.1" + +esprima@^4.0.0, esprima@^4.0.1: + version "4.0.1" + resolved "https://registry.yarnpkg.com/esprima/-/esprima-4.0.1.tgz#13b04cdb3e6c5d19df91ab6987a8695619b0aa71" + integrity sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A== + +estraverse@^4.2.0: + version "4.3.0" + resolved "https://registry.yarnpkg.com/estraverse/-/estraverse-4.3.0.tgz#398ad3f3c5a24948be7725e83d11a7de28cdbd1d" + integrity sha512-39nnKffWz8xN1BU/2c79n9nB9HDzo0niYUqx6xyqUnyoAnQyyWpOTdZEeiCch8BBu515t4wp9ZmgVfVhn9EBpw== + +esutils@^2.0.2: + version "2.0.3" + resolved "https://registry.yarnpkg.com/esutils/-/esutils-2.0.3.tgz#74d2eb4de0b8da1293711910d50775b9b710ef64" + integrity sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g== + +eventemitter3@^4.0.0: + version "4.0.7" + resolved "https://registry.yarnpkg.com/eventemitter3/-/eventemitter3-4.0.7.tgz#2de9b68f6528d5644ef5c59526a1b4a07306169f" + integrity sha512-8guHBZCwKnFhYdHr2ysuRWErTwhoN2X8XELRlrRwpmfeY2jjuUN4taQMsULKUVo1K4DvZl+0pgfyoysHxvmvEw== + +events@^3.0.0: + version "3.3.0" + resolved "https://registry.yarnpkg.com/events/-/events-3.3.0.tgz#31a95ad0a924e2d2c419a813aeb2c4e878ea7400" + integrity sha512-mQw+2fkQbALzQ7V0MY0IqdnXNOeTtP4r0lN9z7AAawCXgqea7bDii20AYrIBrFd/Hx0M2Ocz6S111CaFkUcb0Q== + +exec-sh@^0.3.2: + version "0.3.6" + resolved "https://registry.yarnpkg.com/exec-sh/-/exec-sh-0.3.6.tgz#ff264f9e325519a60cb5e273692943483cca63bc" + integrity sha512-nQn+hI3yp+oD0huYhKwvYI32+JFeq+XkNcD1GAo3Y/MjxsfVGmrrzrnzjWiNY6f+pUCP440fThsFh5gZrRAU/w== + +execa@^1.0.0: + version "1.0.0" + resolved "https://registry.yarnpkg.com/execa/-/execa-1.0.0.tgz#c6236a5bb4df6d6f15e88e7f017798216749ddd8" + integrity sha512-adbxcyWV46qiHyvSp50TKt05tB4tK3HcmF7/nxfAdhnox83seTDbwnaqKO4sXRy7roHAIFqJP/Rw/AuEbX61LA== + dependencies: + cross-spawn "^6.0.0" + get-stream "^4.0.0" + is-stream "^1.1.0" + npm-run-path "^2.0.0" + p-finally "^1.0.0" + signal-exit "^3.0.0" + strip-eof "^1.0.0" + +execa@^3.2.0: + version "3.4.0" + resolved "https://registry.yarnpkg.com/execa/-/execa-3.4.0.tgz#c08ed4550ef65d858fac269ffc8572446f37eb89" + integrity sha512-r9vdGQk4bmCuK1yKQu1KTwcT2zwfWdbdaXfCtAh+5nU/4fSX+JAb7vZGvI5naJrQlvONrEB20jeruESI69530g== + dependencies: + cross-spawn "^7.0.0" + get-stream "^5.0.0" + human-signals "^1.1.1" + is-stream "^2.0.0" + merge-stream "^2.0.0" + npm-run-path "^4.0.0" + onetime "^5.1.0" + p-finally "^2.0.0" + signal-exit "^3.0.2" + strip-final-newline "^2.0.0" + +exit@^0.1.2: + version "0.1.2" + resolved "https://registry.yarnpkg.com/exit/-/exit-0.1.2.tgz#0632638f8d877cc82107d30a0fff1a17cba1cd0c" + integrity sha1-BjJjj42HfMghB9MKD/8aF8uhzQw= + +expand-brackets@^2.1.4: + version "2.1.4" + resolved "https://registry.yarnpkg.com/expand-brackets/-/expand-brackets-2.1.4.tgz#b77735e315ce30f6b6eff0f83b04151a22449622" + integrity sha1-t3c14xXOMPa27/D4OwQVGiJEliI= + dependencies: + debug "^2.3.3" + define-property "^0.2.5" + extend-shallow "^2.0.1" + posix-character-classes "^0.1.0" + regex-not "^1.0.0" + snapdragon "^0.8.1" + to-regex "^3.0.1" + +expect@^25.5.0: + version "25.5.0" + resolved "https://registry.yarnpkg.com/expect/-/expect-25.5.0.tgz#f07f848712a2813bb59167da3fb828ca21f58bba" + integrity sha512-w7KAXo0+6qqZZhovCaBVPSIqQp7/UTcx4M9uKt2m6pd2VB1voyC8JizLRqeEqud3AAVP02g+hbErDu5gu64tlA== + dependencies: + "@jest/types" "^25.5.0" + ansi-styles "^4.0.0" + jest-get-type "^25.2.6" + jest-matcher-utils "^25.5.0" + jest-message-util "^25.5.0" + jest-regex-util "^25.2.6" + +extend-shallow@^2.0.1: + version "2.0.1" + resolved "https://registry.yarnpkg.com/extend-shallow/-/extend-shallow-2.0.1.tgz#51af7d614ad9a9f610ea1bafbb989d6b1c56890f" + integrity sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8= + dependencies: + is-extendable "^0.1.0" + +extend-shallow@^3.0.0, extend-shallow@^3.0.2: + version "3.0.2" + resolved "https://registry.yarnpkg.com/extend-shallow/-/extend-shallow-3.0.2.tgz#26a71aaf073b39fb2127172746131c2704028db8" + integrity sha1-Jqcarwc7OfshJxcnRhMcJwQCjbg= + dependencies: + assign-symbols "^1.0.0" + is-extendable "^1.0.1" + +extend@~3.0.2: + version "3.0.2" + resolved "https://registry.yarnpkg.com/extend/-/extend-3.0.2.tgz#f8b1136b4071fbd8eb140aff858b1019ec2915fa" + integrity sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g== + +external-editor@^3.0.3: + version "3.1.0" + resolved "https://registry.yarnpkg.com/external-editor/-/external-editor-3.1.0.tgz#cb03f740befae03ea4d283caed2741a83f335495" + integrity sha512-hMQ4CX1p1izmuLYyZqLMO/qGNw10wSv9QDCPfzXfyFrOaCSSoRfqE1Kf1s5an66J5JZC62NewG+mK49jOCtQew== + dependencies: + chardet "^0.7.0" + iconv-lite "^0.4.24" + tmp "^0.0.33" + +extglob@^2.0.4: + version "2.0.4" + resolved "https://registry.yarnpkg.com/extglob/-/extglob-2.0.4.tgz#ad00fe4dc612a9232e8718711dc5cb5ab0285543" + integrity sha512-Nmb6QXkELsuBr24CJSkilo6UHHgbekK5UiZgfE6UHD3Eb27YC6oD+bhcT+tJ6cl8dmsgdQxnWlcry8ksBIBLpw== + dependencies: + array-unique "^0.3.2" + define-property "^1.0.0" + expand-brackets "^2.1.4" + extend-shallow "^2.0.1" + fragment-cache "^0.2.1" + regex-not "^1.0.0" + snapdragon "^0.8.1" + to-regex "^3.0.1" + +extract-zip@^2.0.1: + version "2.0.1" + resolved "https://registry.yarnpkg.com/extract-zip/-/extract-zip-2.0.1.tgz#663dca56fe46df890d5f131ef4a06d22bb8ba13a" + integrity sha512-GDhU9ntwuKyGXdZBUgTIe+vXnWj0fppUEtMDL0+idd5Sta8TGpHssn/eusA9mrPr9qNDym6SxAYZjNvCn/9RBg== + dependencies: + debug "^4.1.1" + get-stream "^5.1.0" + yauzl "^2.10.0" + optionalDependencies: + "@types/yauzl" "^2.9.1" + +extsprintf@1.3.0: + version "1.3.0" + resolved "https://registry.yarnpkg.com/extsprintf/-/extsprintf-1.3.0.tgz#96918440e3041a7a414f8c52e3c574eb3c3e1e05" + integrity sha1-lpGEQOMEGnpBT4xS48V06zw+HgU= + +extsprintf@^1.2.0: + version "1.4.0" + resolved "https://registry.yarnpkg.com/extsprintf/-/extsprintf-1.4.0.tgz#e2689f8f356fad62cca65a3a91c5df5f9551692f" + integrity sha1-4mifjzVvrWLMplo6kcXfX5VRaS8= + +fast-deep-equal@^3.1.1: + version "3.1.3" + resolved "https://registry.yarnpkg.com/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz#3a7d56b559d6cbc3eb512325244e619a65c6c525" + integrity sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q== + +fast-json-stable-stringify@2.x, fast-json-stable-stringify@^2.0.0: + version "2.1.0" + resolved "https://registry.yarnpkg.com/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz#874bf69c6f404c2b5d99c481341399fd55892633" + integrity sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw== + +fast-levenshtein@~2.0.6: + version "2.0.6" + resolved "https://registry.yarnpkg.com/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz#3d8a5c66883a16a30ca8643e851f19baa7797917" + integrity sha1-PYpcZog6FqMMqGQ+hR8Zuqd5eRc= + +fb-watchman@^2.0.0: + version "2.0.1" + resolved "https://registry.yarnpkg.com/fb-watchman/-/fb-watchman-2.0.1.tgz#fc84fb39d2709cf3ff6d743706157bb5708a8a85" + integrity sha512-DkPJKQeY6kKwmuMretBhr7G6Vodr7bFwDYTXIkfG1gjvNpaxBTQV3PbXg6bR1c1UP4jPOX0jHUbbHANL9vRjVg== + dependencies: + bser "2.1.1" + +fd-slicer@~1.1.0: + version "1.1.0" + resolved "https://registry.yarnpkg.com/fd-slicer/-/fd-slicer-1.1.0.tgz#25c7c89cb1f9077f8891bbe61d8f390eae256f1e" + integrity sha1-JcfInLH5B3+IkbvmHY85Dq4lbx4= + dependencies: + pend "~1.2.0" + +figures@^3.0.0: + version "3.2.0" + resolved "https://registry.yarnpkg.com/figures/-/figures-3.2.0.tgz#625c18bd293c604dc4a8ddb2febf0c88341746af" + integrity sha512-yaduQFRKLXYOGgEn6AZau90j3ggSOyiqXU0F9JZfeXYhNa+Jk4X+s45A2zg5jns87GAFa34BBm2kXw4XpNcbdg== + dependencies: + escape-string-regexp "^1.0.5" + +filelist@^1.0.1: + version "1.0.2" + resolved "https://registry.yarnpkg.com/filelist/-/filelist-1.0.2.tgz#80202f21462d4d1c2e214119b1807c1bc0380e5b" + integrity sha512-z7O0IS8Plc39rTCq6i6iHxk43duYOn8uFJiWSewIq0Bww1RNybVHSCjahmcC87ZqAm4OTvFzlzeGu3XAzG1ctQ== + dependencies: + minimatch "^3.0.4" + +fill-range@^4.0.0: + version "4.0.0" + resolved "https://registry.yarnpkg.com/fill-range/-/fill-range-4.0.0.tgz#d544811d428f98eb06a63dc402d2403c328c38f7" + integrity sha1-1USBHUKPmOsGpj3EAtJAPDKMOPc= + dependencies: + extend-shallow "^2.0.1" + is-number "^3.0.0" + repeat-string "^1.6.1" + to-regex-range "^2.1.0" + +fill-range@^7.0.1: + version "7.0.1" + resolved "https://registry.yarnpkg.com/fill-range/-/fill-range-7.0.1.tgz#1919a6a7c75fe38b2c7c77e5198535da9acdda40" + integrity sha512-qOo9F+dMUmC2Lcb4BbVvnKJxTPjCm+RRpe4gDuGrzkL7mEVl/djYSu2OdQ2Pa302N4oqkSg9ir6jaLWJ2USVpQ== + dependencies: + to-regex-range "^5.0.1" + +find-up@^4.0.0, find-up@^4.1.0: + version "4.1.0" + resolved "https://registry.yarnpkg.com/find-up/-/find-up-4.1.0.tgz#97afe7d6cdc0bc5928584b7c8d7b16e8a9aa5d19" + integrity sha512-PpOwAdQ/YlXQ2vj8a3h8IipDuYRi3wceVQQGYWxNINccq40Anw7BlsEXCMbt1Zt+OLA6Fq9suIpIWD0OsnISlw== + dependencies: + locate-path "^5.0.0" + path-exists "^4.0.0" + +follow-redirects@^1.0.0, follow-redirects@^1.10.0: + version "1.14.1" + resolved "https://registry.yarnpkg.com/follow-redirects/-/follow-redirects-1.14.1.tgz#d9114ded0a1cfdd334e164e6662ad02bfd91ff43" + integrity sha512-HWqDgT7ZEkqRzBvc2s64vSZ/hfOceEol3ac/7tKwzuvEyWx3/4UegXh5oBOIotkGsObyk3xznnSRVADBgWSQVg== + +for-in@^1.0.2: + version "1.0.2" + resolved "https://registry.yarnpkg.com/for-in/-/for-in-1.0.2.tgz#81068d295a8142ec0ac726c6e2200c30fb6d5e80" + integrity sha1-gQaNKVqBQuwKxybG4iAMMPttXoA= + +forever-agent@~0.6.1: + version "0.6.1" + resolved "https://registry.yarnpkg.com/forever-agent/-/forever-agent-0.6.1.tgz#fbc71f0c41adeb37f96c577ad1ed42d8fdacca91" + integrity sha1-+8cfDEGt6zf5bFd60e1C2P2sypE= + +form-data@~2.3.2: + version "2.3.3" + resolved "https://registry.yarnpkg.com/form-data/-/form-data-2.3.3.tgz#dcce52c05f644f298c6a7ab936bd724ceffbf3a6" + integrity sha512-1lLKB2Mu3aGP1Q/2eCOx0fNbRMe7XdwktwOruhfqqd0rIJWwN4Dh+E3hrPSlDCXnSR7UtZ1N38rVXm+6+MEhJQ== + dependencies: + asynckit "^0.4.0" + combined-stream "^1.0.6" + mime-types "^2.1.12" + +fragment-cache@^0.2.1: + version "0.2.1" + resolved "https://registry.yarnpkg.com/fragment-cache/-/fragment-cache-0.2.1.tgz#4290fad27f13e89be7f33799c6bc5a0abfff0d19" + integrity sha1-QpD60n8T6Jvn8zeZxrxaCr//DRk= + dependencies: + map-cache "^0.2.2" + +fs-extra@^8.1.0: + version "8.1.0" + resolved "https://registry.yarnpkg.com/fs-extra/-/fs-extra-8.1.0.tgz#49d43c45a88cd9677668cb7be1b46efdb8d2e1c0" + integrity sha512-yhlQgA6mnOJUKOsRUFsgJdQCvkKhcz8tlZG5HBQfReYZy46OwLcY+Zia0mtdHsOo9y/hP+CxMN0TU9QxoOtG4g== + dependencies: + graceful-fs "^4.2.0" + jsonfile "^4.0.0" + universalify "^0.1.0" + +fs.realpath@^1.0.0: + version "1.0.0" + resolved "https://registry.yarnpkg.com/fs.realpath/-/fs.realpath-1.0.0.tgz#1504ad2523158caa40db4a2787cb01411994ea4f" + integrity sha1-FQStJSMVjKpA20onh8sBQRmU6k8= + +fsevents@^2.1.2: + version "2.3.2" + resolved "https://registry.yarnpkg.com/fsevents/-/fsevents-2.3.2.tgz#8a526f78b8fdf4623b709e0b975c52c24c02fd1a" + integrity sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA== + +function-bind@^1.1.1: + version "1.1.1" + resolved "https://registry.yarnpkg.com/function-bind/-/function-bind-1.1.1.tgz#a56899d3ea3c9bab874bb9773b7c5ede92f4895d" + integrity sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A== + +gensync@^1.0.0-beta.2: + version "1.0.0-beta.2" + resolved "https://registry.yarnpkg.com/gensync/-/gensync-1.0.0-beta.2.tgz#32a6ee76c3d7f52d46b2b1ae5d93fea8580a25e0" + integrity sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg== + +get-caller-file@^2.0.1: + version "2.0.5" + resolved "https://registry.yarnpkg.com/get-caller-file/-/get-caller-file-2.0.5.tgz#4f94412a82db32f36e3b0b9741f8a97feb031f7e" + integrity sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg== + +get-intrinsic@^1.0.2: + version "1.1.1" + resolved "https://registry.yarnpkg.com/get-intrinsic/-/get-intrinsic-1.1.1.tgz#15f59f376f855c446963948f0d24cd3637b4abc6" + integrity sha512-kWZrnVM42QCiEA2Ig1bG8zjoIMOgxWwYCEeNdwY6Tv/cOSeGpcoX4pXHfKUxNKVoArnrEr2e9srnAxxGIraS9Q== + dependencies: + function-bind "^1.1.1" + has "^1.0.3" + has-symbols "^1.0.1" + +get-package-type@^0.1.0: + version "0.1.0" + resolved "https://registry.yarnpkg.com/get-package-type/-/get-package-type-0.1.0.tgz#8de2d803cff44df3bc6c456e6668b36c3926e11a" + integrity sha512-pjzuKtY64GYfWizNAJ0fr9VqttZkNiK2iS430LtIHzjBEr6bX8Am2zm4sW4Ro5wjWW5cAlRL1qAMTcXbjNAO2Q== + +get-stream@^4.0.0: + version "4.1.0" + resolved "https://registry.yarnpkg.com/get-stream/-/get-stream-4.1.0.tgz#c1b255575f3dc21d59bfc79cd3d2b46b1c3a54b5" + integrity sha512-GMat4EJ5161kIy2HevLlr4luNjBgvmj413KaQA7jt4V8B4RDsfpHk7WQ9GVqfYyyx8OS/L66Kox+rJRNklLK7w== + dependencies: + pump "^3.0.0" + +get-stream@^5.0.0, get-stream@^5.1.0: + version "5.2.0" + resolved "https://registry.yarnpkg.com/get-stream/-/get-stream-5.2.0.tgz#4966a1795ee5ace65e706c4b7beb71257d6e22d3" + integrity sha512-nBF+F1rAZVCu/p7rjzgA+Yb4lfYXrpl7a6VmJrU8wF9I1CKvP/QwPNZHnOlwbTkY6dvtFIzFMSyQXbLoTQPRpA== + dependencies: + pump "^3.0.0" + +get-value@^2.0.3, get-value@^2.0.6: + version "2.0.6" + resolved "https://registry.yarnpkg.com/get-value/-/get-value-2.0.6.tgz#dc15ca1c672387ca76bd37ac0a395ba2042a2c28" + integrity sha1-3BXKHGcjh8p2vTesCjlbogQqLCg= + +getpass@^0.1.1: + version "0.1.7" + resolved "https://registry.yarnpkg.com/getpass/-/getpass-0.1.7.tgz#5eff8e3e684d569ae4cb2b1282604e8ba62149fa" + integrity sha1-Xv+OPmhNVprkyysSgmBOi6YhSfo= + dependencies: + assert-plus "^1.0.0" + +glob@^7.1.1, glob@^7.1.2, glob@^7.1.3, glob@^7.1.4: + version "7.1.7" + resolved "https://registry.yarnpkg.com/glob/-/glob-7.1.7.tgz#3b193e9233f01d42d0b3f78294bbeeb418f94a90" + integrity sha512-OvD9ENzPLbegENnYP5UUfJIirTg4+XwMWGaQfQTY0JenxNvvIKP3U3/tAQSPIu/lHxXYSZmpXlUHeqAIdKzBLQ== + dependencies: + fs.realpath "^1.0.0" + inflight "^1.0.4" + inherits "2" + minimatch "^3.0.4" + once "^1.3.0" + path-is-absolute "^1.0.0" + +globals@^11.1.0: + version "11.12.0" + resolved "https://registry.yarnpkg.com/globals/-/globals-11.12.0.tgz#ab8795338868a0babd8525758018c2a7eb95c42e" + integrity sha512-WOBp/EEGUiIsJSp7wcv/y6MO+lV9UoncWqxuFfm8eBwzWNgyfBd6Gz+IeKQ9jCmyhoH99g15M3T+QaVHFjizVA== + +graceful-fs@^4.1.11, graceful-fs@^4.1.6, graceful-fs@^4.2.0, graceful-fs@^4.2.4: + version "4.2.6" + resolved "https://registry.yarnpkg.com/graceful-fs/-/graceful-fs-4.2.6.tgz#ff040b2b0853b23c3d31027523706f1885d76bee" + integrity sha512-nTnJ528pbqxYanhpDYsi4Rd8MAeaBA67+RZ10CM1m3bTAVFEDcd5AuA4a6W5YkGZ1iNXHzZz8T6TBKLeBuNriQ== + +growly@^1.3.0: + version "1.3.0" + resolved "https://registry.yarnpkg.com/growly/-/growly-1.3.0.tgz#f10748cbe76af964b7c96c93c6bcc28af120c081" + integrity sha1-8QdIy+dq+WS3yWyTxrzCivEgwIE= + +har-schema@^2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/har-schema/-/har-schema-2.0.0.tgz#a94c2224ebcac04782a0d9035521f24735b7ec92" + integrity sha1-qUwiJOvKwEeCoNkDVSHyRzW37JI= + +har-validator@~5.1.3: + version "5.1.5" + resolved "https://registry.yarnpkg.com/har-validator/-/har-validator-5.1.5.tgz#1f0803b9f8cb20c0fa13822df1ecddb36bde1efd" + integrity sha512-nmT2T0lljbxdQZfspsno9hgrG3Uir6Ks5afism62poxqBM6sDnMEuPmzTq8XN0OEwqKLLdh1jQI3qyE66Nzb3w== + dependencies: + ajv "^6.12.3" + har-schema "^2.0.0" + +hard-rejection@^2.1.0: + version "2.1.0" + resolved "https://registry.yarnpkg.com/hard-rejection/-/hard-rejection-2.1.0.tgz#1c6eda5c1685c63942766d79bb40ae773cecd883" + integrity sha512-VIZB+ibDhx7ObhAe7OVtoEbuP4h/MuOTHJ+J8h/eBXotJYl0fBgR72xDFCKgIh22OJZIOVNxBMWuhAr10r8HdA== + +has-flag@^3.0.0: + version "3.0.0" + resolved "https://registry.yarnpkg.com/has-flag/-/has-flag-3.0.0.tgz#b5d454dc2199ae225699f3467e5a07f3b955bafd" + integrity sha1-tdRU3CGZriJWmfNGfloH87lVuv0= + +has-flag@^4.0.0: + version "4.0.0" + resolved "https://registry.yarnpkg.com/has-flag/-/has-flag-4.0.0.tgz#944771fd9c81c81265c4d6941860da06bb59479b" + integrity sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ== + +has-symbols@^1.0.1: + version "1.0.2" + resolved "https://registry.yarnpkg.com/has-symbols/-/has-symbols-1.0.2.tgz#165d3070c00309752a1236a479331e3ac56f1423" + integrity sha512-chXa79rL/UC2KlX17jo3vRGz0azaWEx5tGqZg5pO3NUyEJVB17dMruQlzCCOfUvElghKcm5194+BCRvi2Rv/Gw== + +has-value@^0.3.1: + version "0.3.1" + resolved "https://registry.yarnpkg.com/has-value/-/has-value-0.3.1.tgz#7b1f58bada62ca827ec0a2078025654845995e1f" + integrity sha1-ex9YutpiyoJ+wKIHgCVlSEWZXh8= + dependencies: + get-value "^2.0.3" + has-values "^0.1.4" + isobject "^2.0.0" + +has-value@^1.0.0: + version "1.0.0" + resolved "https://registry.yarnpkg.com/has-value/-/has-value-1.0.0.tgz#18b281da585b1c5c51def24c930ed29a0be6b177" + integrity sha1-GLKB2lhbHFxR3vJMkw7SmgvmsXc= + dependencies: + get-value "^2.0.6" + has-values "^1.0.0" + isobject "^3.0.0" + +has-values@^0.1.4: + version "0.1.4" + resolved "https://registry.yarnpkg.com/has-values/-/has-values-0.1.4.tgz#6d61de95d91dfca9b9a02089ad384bff8f62b771" + integrity sha1-bWHeldkd/Km5oCCJrThL/49it3E= + +has-values@^1.0.0: + version "1.0.0" + resolved "https://registry.yarnpkg.com/has-values/-/has-values-1.0.0.tgz#95b0b63fec2146619a6fe57fe75628d5a39efe4f" + integrity sha1-lbC2P+whRmGab+V/51Yo1aOe/k8= + dependencies: + is-number "^3.0.0" + kind-of "^4.0.0" + +has@^1.0.3: + version "1.0.3" + resolved "https://registry.yarnpkg.com/has/-/has-1.0.3.tgz#722d7cbfc1f6aa8241f16dd814e011e1f41e8796" + integrity sha512-f2dvO0VU6Oej7RkWJGrehjbzMAjFp5/VKPp5tTpWIV4JHHZK1/BxbFRtf/siA2SWTe09caDmVtYYzWEIbBS4zw== + dependencies: + function-bind "^1.1.1" + +he@^1.1.1: + version "1.2.0" + resolved "https://registry.yarnpkg.com/he/-/he-1.2.0.tgz#84ae65fa7eafb165fddb61566ae14baf05664f0f" + integrity sha512-F/1DnUGPopORZi0ni+CvrCgHQ5FyEAHRLSApuYWMmrbSwoN2Mn/7k+Gl38gJnR7yyDZk6WLXwiGod1JOWNDKGw== + +hosted-git-info@^2.1.4: + version "2.8.9" + resolved "https://registry.yarnpkg.com/hosted-git-info/-/hosted-git-info-2.8.9.tgz#dffc0bf9a21c02209090f2aa69429e1414daf3f9" + integrity sha512-mxIDAb9Lsm6DoOJ7xH+5+X4y1LU/4Hi50L9C5sIswK3JzULS4bwk1FvjdBgvYR4bzT4tuUQiC15FE2f5HbLvYw== + +html-encoding-sniffer@^1.0.2: + version "1.0.2" + resolved "https://registry.yarnpkg.com/html-encoding-sniffer/-/html-encoding-sniffer-1.0.2.tgz#e70d84b94da53aa375e11fe3a351be6642ca46f8" + integrity sha512-71lZziiDnsuabfdYiUeWdCVyKuqwWi23L8YeIgV9jSSZHCtb6wB1BKWooH7L3tn4/FuZJMVWyNaIDr4RGmaSYw== + dependencies: + whatwg-encoding "^1.0.1" + +html-escaper@^2.0.0: + version "2.0.2" + resolved "https://registry.yarnpkg.com/html-escaper/-/html-escaper-2.0.2.tgz#dfd60027da36a36dfcbe236262c00a5822681453" + integrity sha512-H2iMtd0I4Mt5eYiapRdIDjp+XzelXQ0tFE4JS7YFwFevXXMmOp9myNrUvCg0D6ws8iqkRPBfKHgbwig1SmlLfg== + +http-proxy@^1.18.0: + version "1.18.1" + resolved "https://registry.yarnpkg.com/http-proxy/-/http-proxy-1.18.1.tgz#401541f0534884bbf95260334e72f88ee3976549" + integrity sha512-7mz/721AbnJwIVbnaSv1Cz3Am0ZLT/UBwkC92VlxhXv/k/BBQfM2fXElQNC27BVGr0uwUpplYPQM9LnaBMR5NQ== + dependencies: + eventemitter3 "^4.0.0" + follow-redirects "^1.0.0" + requires-port "^1.0.0" + +http-server@^0.12.1: + version "0.12.3" + resolved "https://registry.yarnpkg.com/http-server/-/http-server-0.12.3.tgz#ba0471d0ecc425886616cb35c4faf279140a0d37" + integrity sha512-be0dKG6pni92bRjq0kvExtj/NrrAd28/8fCXkaI/4piTwQMSDSLMhWyW0NI1V+DBI3aa1HMlQu46/HjVLfmugA== + dependencies: + basic-auth "^1.0.3" + colors "^1.4.0" + corser "^2.0.1" + ecstatic "^3.3.2" + http-proxy "^1.18.0" + minimist "^1.2.5" + opener "^1.5.1" + portfinder "^1.0.25" + secure-compare "3.0.1" + union "~0.5.0" + +http-signature@~1.2.0: + version "1.2.0" + resolved "https://registry.yarnpkg.com/http-signature/-/http-signature-1.2.0.tgz#9aecd925114772f3d95b65a60abb8f7c18fbace1" + integrity sha1-muzZJRFHcvPZW2WmCruPfBj7rOE= + dependencies: + assert-plus "^1.0.0" + jsprim "^1.2.2" + sshpk "^1.7.0" + +https-proxy-agent@^5.0.0: + version "5.0.0" + resolved "https://registry.yarnpkg.com/https-proxy-agent/-/https-proxy-agent-5.0.0.tgz#e2a90542abb68a762e0a0850f6c9edadfd8506b2" + integrity sha512-EkYm5BcKUGiduxzSt3Eppko+PiNWNEpa4ySk9vTC6wDsQJW9rHSa+UhGNJoRYp7bz6Ht1eaRIa6QaJqO5rCFbA== + dependencies: + agent-base "6" + debug "4" + +human-signals@^1.1.1: + version "1.1.1" + resolved "https://registry.yarnpkg.com/human-signals/-/human-signals-1.1.1.tgz#c5b1cd14f50aeae09ab6c59fe63ba3395fe4dfa3" + integrity sha512-SEQu7vl8KjNL2eoGBLF3+wAjpsNfA9XMlXAYj/3EdaNfAlxKthD1xjEQfGOUhllCGGJVNY34bRr6lPINhNjyZw== + +iconv-lite@0.4.24, iconv-lite@^0.4.24: + version "0.4.24" + resolved "https://registry.yarnpkg.com/iconv-lite/-/iconv-lite-0.4.24.tgz#2022b4b25fbddc21d2f524974a474aafe733908b" + integrity sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA== + dependencies: + safer-buffer ">= 2.1.2 < 3" + +import-local@^3.0.2: + version "3.0.2" + resolved "https://registry.yarnpkg.com/import-local/-/import-local-3.0.2.tgz#a8cfd0431d1de4a2199703d003e3e62364fa6db6" + integrity sha512-vjL3+w0oulAVZ0hBHnxa/Nm5TAurf9YLQJDhqRZyqb+VKGOB6LU8t9H1Nr5CIo16vh9XfJTOoHwU0B71S557gA== + dependencies: + pkg-dir "^4.2.0" + resolve-cwd "^3.0.0" + +imurmurhash@^0.1.4: + version "0.1.4" + resolved "https://registry.yarnpkg.com/imurmurhash/-/imurmurhash-0.1.4.tgz#9218b9b2b928a238b13dc4fb6b6d576f231453ea" + integrity sha1-khi5srkoojixPcT7a21XbyMUU+o= + +indent-string@^4.0.0: + version "4.0.0" + resolved "https://registry.yarnpkg.com/indent-string/-/indent-string-4.0.0.tgz#624f8f4497d619b2d9768531d58f4122854d7251" + integrity sha512-EdDDZu4A2OyIK7Lr/2zG+w5jmbuk1DVBnEwREQvBzspBJkCEbRa8GxU1lghYcaGJCnRWibjDXlq779X1/y5xwg== + +inflight@^1.0.4: + version "1.0.6" + resolved "https://registry.yarnpkg.com/inflight/-/inflight-1.0.6.tgz#49bd6331d7d02d0c09bc910a1075ba8165b56df9" + integrity sha1-Sb1jMdfQLQwJvJEKEHW6gWW1bfk= + dependencies: + once "^1.3.0" + wrappy "1" + +inherits@2: + version "2.0.4" + resolved "https://registry.yarnpkg.com/inherits/-/inherits-2.0.4.tgz#0fa2c64f932917c3433a0ded55363aae37416b7c" + integrity sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ== + +ini@^1.3.4: + version "1.3.8" + resolved "https://registry.yarnpkg.com/ini/-/ini-1.3.8.tgz#a29da425b48806f34767a4efce397269af28432c" + integrity sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew== + +inquirer@^7.1.0: + version "7.3.3" + resolved "https://registry.yarnpkg.com/inquirer/-/inquirer-7.3.3.tgz#04d176b2af04afc157a83fd7c100e98ee0aad003" + integrity sha512-JG3eIAj5V9CwcGvuOmoo6LB9kbAYT8HXffUl6memuszlwDC/qvFAJw49XJ5NROSFNPxp3iQg1GqkFhaY/CR0IA== + dependencies: + ansi-escapes "^4.2.1" + chalk "^4.1.0" + cli-cursor "^3.1.0" + cli-width "^3.0.0" + external-editor "^3.0.3" + figures "^3.0.0" + lodash "^4.17.19" + mute-stream "0.0.8" + run-async "^2.4.0" + rxjs "^6.6.0" + string-width "^4.1.0" + strip-ansi "^6.0.0" + through "^2.3.6" + +ip-regex@^2.1.0: + version "2.1.0" + resolved "https://registry.yarnpkg.com/ip-regex/-/ip-regex-2.1.0.tgz#fa78bf5d2e6913c911ce9f819ee5146bb6d844e9" + integrity sha1-+ni/XS5pE8kRzp+BnuUUa7bYROk= + +is-accessor-descriptor@^0.1.6: + version "0.1.6" + resolved "https://registry.yarnpkg.com/is-accessor-descriptor/-/is-accessor-descriptor-0.1.6.tgz#a9e12cb3ae8d876727eeef3843f8a0897b5c98d6" + integrity sha1-qeEss66Nh2cn7u84Q/igiXtcmNY= + dependencies: + kind-of "^3.0.2" + +is-accessor-descriptor@^1.0.0: + version "1.0.0" + resolved "https://registry.yarnpkg.com/is-accessor-descriptor/-/is-accessor-descriptor-1.0.0.tgz#169c2f6d3df1f992618072365c9b0ea1f6878656" + integrity sha512-m5hnHTkcVsPfqx3AKlyttIPb7J+XykHvJP2B9bZDjlhLIoEq4XoK64Vg7boZlVWYK6LUY94dYPEE7Lh0ZkZKcQ== + dependencies: + kind-of "^6.0.0" + +is-arrayish@^0.2.1: + version "0.2.1" + resolved "https://registry.yarnpkg.com/is-arrayish/-/is-arrayish-0.2.1.tgz#77c99840527aa8ecb1a8ba697b80645a7a926a9d" + integrity sha1-d8mYQFJ6qOyxqLppe4BkWnqSap0= + +is-buffer@^1.1.5: + version "1.1.6" + resolved "https://registry.yarnpkg.com/is-buffer/-/is-buffer-1.1.6.tgz#efaa2ea9daa0d7ab2ea13a97b2b8ad51fefbe8be" + integrity sha512-NcdALwpXkTm5Zvvbk7owOUSvVvBKDgKP5/ewfXEznmQFfs4ZRmanOeKBTjRVjka3QFoN6XJ+9F3USqfHqTaU5w== + +is-ci@^2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/is-ci/-/is-ci-2.0.0.tgz#6bc6334181810e04b5c22b3d589fdca55026404c" + integrity sha512-YfJT7rkpQB0updsdHLGWrvhBJfcfzNNawYDNIyQXJz0IViGf75O8EBPKSdvw2rF+LGCsX4FZ8tcr3b19LcZq4w== + dependencies: + ci-info "^2.0.0" + +is-core-module@^2.2.0: + version "2.5.0" + resolved "https://registry.yarnpkg.com/is-core-module/-/is-core-module-2.5.0.tgz#f754843617c70bfd29b7bd87327400cda5c18491" + integrity sha512-TXCMSDsEHMEEZ6eCA8rwRDbLu55MRGmrctljsBX/2v1d9/GzqHOxW5c5oPSgrUt2vBFXebu9rGqckXGPWOlYpg== + dependencies: + has "^1.0.3" + +is-data-descriptor@^0.1.4: + version "0.1.4" + resolved "https://registry.yarnpkg.com/is-data-descriptor/-/is-data-descriptor-0.1.4.tgz#0b5ee648388e2c860282e793f1856fec3f301b56" + integrity sha1-C17mSDiOLIYCgueT8YVv7D8wG1Y= + dependencies: + kind-of "^3.0.2" + +is-data-descriptor@^1.0.0: + version "1.0.0" + resolved "https://registry.yarnpkg.com/is-data-descriptor/-/is-data-descriptor-1.0.0.tgz#d84876321d0e7add03990406abbbbd36ba9268c7" + integrity sha512-jbRXy1FmtAoCjQkVmIVYwuuqDFUbaOeDjmed1tOGPrsMhtJA4rD9tkgA0F1qJ3gRFRXcHYVkdeaP50Q5rE/jLQ== + dependencies: + kind-of "^6.0.0" + +is-descriptor@^0.1.0: + version "0.1.6" + resolved "https://registry.yarnpkg.com/is-descriptor/-/is-descriptor-0.1.6.tgz#366d8240dde487ca51823b1ab9f07a10a78251ca" + integrity sha512-avDYr0SB3DwO9zsMov0gKCESFYqCnE4hq/4z3TdUlukEy5t9C0YRq7HLrsN52NAcqXKaepeCD0n+B0arnVG3Hg== + dependencies: + is-accessor-descriptor "^0.1.6" + is-data-descriptor "^0.1.4" + kind-of "^5.0.0" + +is-descriptor@^1.0.0, is-descriptor@^1.0.2: + version "1.0.2" + resolved "https://registry.yarnpkg.com/is-descriptor/-/is-descriptor-1.0.2.tgz#3b159746a66604b04f8c81524ba365c5f14d86ec" + integrity sha512-2eis5WqQGV7peooDyLmNEPUrps9+SXX5c9pL3xEB+4e9HnGuDa7mB7kHxHw4CbqS9k1T2hOH3miL8n8WtiYVtg== + dependencies: + is-accessor-descriptor "^1.0.0" + is-data-descriptor "^1.0.0" + kind-of "^6.0.2" + +is-docker@^2.0.0: + version "2.2.1" + resolved "https://registry.yarnpkg.com/is-docker/-/is-docker-2.2.1.tgz#33eeabe23cfe86f14bde4408a02c0cfb853acdaa" + integrity sha512-F+i2BKsFrH66iaUFc0woD8sLy8getkwTwtOBjvs56Cx4CgJDeKQeqfz8wAYiSb8JOprWhHH5p77PbmYCvvUuXQ== + +is-extendable@^0.1.0, is-extendable@^0.1.1: + version "0.1.1" + resolved "https://registry.yarnpkg.com/is-extendable/-/is-extendable-0.1.1.tgz#62b110e289a471418e3ec36a617d472e301dfc89" + integrity sha1-YrEQ4omkcUGOPsNqYX1HLjAd/Ik= + +is-extendable@^1.0.1: + version "1.0.1" + resolved "https://registry.yarnpkg.com/is-extendable/-/is-extendable-1.0.1.tgz#a7470f9e426733d81bd81e1155264e3a3507cab4" + integrity sha512-arnXMxT1hhoKo9k1LZdmlNyJdDDfy2v0fXjFlmok4+i8ul/6WlbVge9bhM74OpNPQPMGUToDtz+KXa1PneJxOA== + dependencies: + is-plain-object "^2.0.4" + +is-fullwidth-code-point@^3.0.0: + version "3.0.0" + resolved "https://registry.yarnpkg.com/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz#f116f8064fe90b3f7844a38997c0b75051269f1d" + integrity sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg== + +is-generator-fn@^2.0.0: + version "2.1.0" + resolved "https://registry.yarnpkg.com/is-generator-fn/-/is-generator-fn-2.1.0.tgz#7d140adc389aaf3011a8f2a2a4cfa6faadffb118" + integrity sha512-cTIB4yPYL/Grw0EaSzASzg6bBy9gqCofvWN8okThAYIxKJZC+udlRAmGbM0XLeniEJSs8uEgHPGuHSe1XsOLSQ== + +is-number@^3.0.0: + version "3.0.0" + resolved "https://registry.yarnpkg.com/is-number/-/is-number-3.0.0.tgz#24fd6201a4782cf50561c810276afc7d12d71195" + integrity sha1-JP1iAaR4LPUFYcgQJ2r8fRLXEZU= + dependencies: + kind-of "^3.0.2" + +is-number@^7.0.0: + version "7.0.0" + resolved "https://registry.yarnpkg.com/is-number/-/is-number-7.0.0.tgz#7535345b896734d5f80c4d06c50955527a14f12b" + integrity sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng== + +is-plain-obj@^1.1.0: + version "1.1.0" + resolved "https://registry.yarnpkg.com/is-plain-obj/-/is-plain-obj-1.1.0.tgz#71a50c8429dfca773c92a390a4a03b39fcd51d3e" + integrity sha1-caUMhCnfync8kqOQpKA7OfzVHT4= + +is-plain-object@^2.0.3, is-plain-object@^2.0.4: + version "2.0.4" + resolved "https://registry.yarnpkg.com/is-plain-object/-/is-plain-object-2.0.4.tgz#2c163b3fafb1b606d9d17928f05c2a1c38e07677" + integrity sha512-h5PpgXkWitc38BBMYawTYMWJHFZJVnBquFE57xFpjB8pJFiF6gZ+bU+WyI/yqXiFR5mdLsgYNaPe8uao6Uv9Og== + dependencies: + isobject "^3.0.1" + +is-stream@^1.1.0: + version "1.1.0" + resolved "https://registry.yarnpkg.com/is-stream/-/is-stream-1.1.0.tgz#12d4a3dd4e68e0b79ceb8dbc84173ae80d91ca44" + integrity sha1-EtSj3U5o4Lec6428hBc66A2RykQ= + +is-stream@^2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/is-stream/-/is-stream-2.0.0.tgz#bde9c32680d6fae04129d6ac9d921ce7815f78e3" + integrity sha512-XCoy+WlUr7d1+Z8GgSuXmpuUFC9fOhRXglJMx+dwLKTkL44Cjd4W1Z5P+BQZpr+cR93aGP4S/s7Ftw6Nd/kiEw== + +is-typedarray@^1.0.0, is-typedarray@~1.0.0: + version "1.0.0" + resolved "https://registry.yarnpkg.com/is-typedarray/-/is-typedarray-1.0.0.tgz#e479c80858df0c1b11ddda6940f96011fcda4a9a" + integrity sha1-5HnICFjfDBsR3dppQPlgEfzaSpo= + +is-windows@^1.0.2: + version "1.0.2" + resolved "https://registry.yarnpkg.com/is-windows/-/is-windows-1.0.2.tgz#d1850eb9791ecd18e6182ce12a30f396634bb19d" + integrity sha512-eXK1UInq2bPmjyX6e3VHIzMLobc4J94i4AWn+Hpq3OU5KkrRC96OAcR3PRJ/pGu6m8TRnBHP9dkXQVsT/COVIA== + +is-wsl@^2.1.1: + version "2.2.0" + resolved "https://registry.yarnpkg.com/is-wsl/-/is-wsl-2.2.0.tgz#74a4c76e77ca9fd3f932f290c17ea326cd157271" + integrity sha512-fKzAra0rGJUUBwGBgNkHZuToZcn+TtXHpeCgmkMJMMYx1sQDYaCSyjJBSCa2nH1DGm7s3n1oBnohoVTBaN7Lww== + dependencies: + is-docker "^2.0.0" + +isarray@1.0.0: + version "1.0.0" + resolved "https://registry.yarnpkg.com/isarray/-/isarray-1.0.0.tgz#bb935d48582cba168c06834957a54a3e07124f11" + integrity sha1-u5NdSFgsuhaMBoNJV6VKPgcSTxE= + +isexe@^2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/isexe/-/isexe-2.0.0.tgz#e8fbf374dc556ff8947a10dcb0572d633f2cfa10" + integrity sha1-6PvzdNxVb/iUehDcsFctYz8s+hA= + +isobject@^2.0.0: + version "2.1.0" + resolved "https://registry.yarnpkg.com/isobject/-/isobject-2.1.0.tgz#f065561096a3f1da2ef46272f815c840d87e0c89" + integrity sha1-8GVWEJaj8dou9GJy+BXIQNh+DIk= + dependencies: + isarray "1.0.0" + +isobject@^3.0.0, isobject@^3.0.1: + version "3.0.1" + resolved "https://registry.yarnpkg.com/isobject/-/isobject-3.0.1.tgz#4e431e92b11a9731636aa1f9c8d1ccbcfdab78df" + integrity sha1-TkMekrEalzFjaqH5yNHMvP2reN8= + +isstream@~0.1.2: + version "0.1.2" + resolved "https://registry.yarnpkg.com/isstream/-/isstream-0.1.2.tgz#47e63f7af55afa6f92e1500e690eb8b8529c099a" + integrity sha1-R+Y/evVa+m+S4VAOaQ64uFKcCZo= + +istanbul-lib-coverage@^3.0.0: + version "3.0.0" + resolved "https://registry.yarnpkg.com/istanbul-lib-coverage/-/istanbul-lib-coverage-3.0.0.tgz#f5944a37c70b550b02a78a5c3b2055b280cec8ec" + integrity sha512-UiUIqxMgRDET6eR+o5HbfRYP1l0hqkWOs7vNxC/mggutCMUIhWMm8gAHb8tHlyfD3/l6rlgNA5cKdDzEAf6hEg== + +istanbul-lib-instrument@^4.0.0: + version "4.0.3" + resolved "https://registry.yarnpkg.com/istanbul-lib-instrument/-/istanbul-lib-instrument-4.0.3.tgz#873c6fff897450118222774696a3f28902d77c1d" + integrity sha512-BXgQl9kf4WTCPCCpmFGoJkz/+uhvm7h7PFKUYxh7qarQd3ER33vHG//qaE8eN25l07YqZPpHXU9I09l/RD5aGQ== + dependencies: + "@babel/core" "^7.7.5" + "@istanbuljs/schema" "^0.1.2" + istanbul-lib-coverage "^3.0.0" + semver "^6.3.0" + +istanbul-lib-report@^3.0.0: + version "3.0.0" + resolved "https://registry.yarnpkg.com/istanbul-lib-report/-/istanbul-lib-report-3.0.0.tgz#7518fe52ea44de372f460a76b5ecda9ffb73d8a6" + integrity sha512-wcdi+uAKzfiGT2abPpKZ0hSU1rGQjUQnLvtY5MpQ7QCTahD3VODhcu4wcfY1YtkGaDD5yuydOLINXsfbus9ROw== + dependencies: + istanbul-lib-coverage "^3.0.0" + make-dir "^3.0.0" + supports-color "^7.1.0" + +istanbul-lib-source-maps@^4.0.0: + version "4.0.0" + resolved "https://registry.yarnpkg.com/istanbul-lib-source-maps/-/istanbul-lib-source-maps-4.0.0.tgz#75743ce6d96bb86dc7ee4352cf6366a23f0b1ad9" + integrity sha512-c16LpFRkR8vQXyHZ5nLpY35JZtzj1PQY1iZmesUbf1FZHbIupcWfjgOXBY9YHkLEQ6puz1u4Dgj6qmU/DisrZg== + dependencies: + debug "^4.1.1" + istanbul-lib-coverage "^3.0.0" + source-map "^0.6.1" + +istanbul-reports@^3.0.2: + version "3.0.2" + resolved "https://registry.yarnpkg.com/istanbul-reports/-/istanbul-reports-3.0.2.tgz#d593210e5000683750cb09fc0644e4b6e27fd53b" + integrity sha512-9tZvz7AiR3PEDNGiV9vIouQ/EAcqMXFmkcA1CDFTwOB98OZVDL0PH9glHotf5Ugp6GCOTypfzGWI/OqjWNCRUw== + dependencies: + html-escaper "^2.0.0" + istanbul-lib-report "^3.0.0" + +jake@^10.6.1: + version "10.8.2" + resolved "https://registry.yarnpkg.com/jake/-/jake-10.8.2.tgz#ebc9de8558160a66d82d0eadc6a2e58fbc500a7b" + integrity sha512-eLpKyrfG3mzvGE2Du8VoPbeSkRry093+tyNjdYaBbJS9v17knImYGNXQCUV0gLxQtF82m3E8iRb/wdSQZLoq7A== + dependencies: + async "0.9.x" + chalk "^2.4.2" + filelist "^1.0.1" + minimatch "^3.0.4" + +jest-changed-files@^25.5.0: + version "25.5.0" + resolved "https://registry.yarnpkg.com/jest-changed-files/-/jest-changed-files-25.5.0.tgz#141cc23567ceb3f534526f8614ba39421383634c" + integrity sha512-EOw9QEqapsDT7mKF162m8HFzRPbmP8qJQny6ldVOdOVBz3ACgPm/1nAn5fPQ/NDaYhX/AHkrGwwkCncpAVSXcw== + dependencies: + "@jest/types" "^25.5.0" + execa "^3.2.0" + throat "^5.0.0" + +jest-cli@^25.5.4: + version "25.5.4" + resolved "https://registry.yarnpkg.com/jest-cli/-/jest-cli-25.5.4.tgz#b9f1a84d1301a92c5c217684cb79840831db9f0d" + integrity sha512-rG8uJkIiOUpnREh1768/N3n27Cm+xPFkSNFO91tgg+8o2rXeVLStz+vkXkGr4UtzH6t1SNbjwoiswd7p4AhHTw== + dependencies: + "@jest/core" "^25.5.4" + "@jest/test-result" "^25.5.0" + "@jest/types" "^25.5.0" + chalk "^3.0.0" + exit "^0.1.2" + graceful-fs "^4.2.4" + import-local "^3.0.2" + is-ci "^2.0.0" + jest-config "^25.5.4" + jest-util "^25.5.0" + jest-validate "^25.5.0" + prompts "^2.0.1" + realpath-native "^2.0.0" + yargs "^15.3.1" + +jest-config@^25.5.4: + version "25.5.4" + resolved "https://registry.yarnpkg.com/jest-config/-/jest-config-25.5.4.tgz#38e2057b3f976ef7309b2b2c8dcd2a708a67f02c" + integrity sha512-SZwR91SwcdK6bz7Gco8qL7YY2sx8tFJYzvg216DLihTWf+LKY/DoJXpM9nTzYakSyfblbqeU48p/p7Jzy05Atg== + dependencies: + "@babel/core" "^7.1.0" + "@jest/test-sequencer" "^25.5.4" + "@jest/types" "^25.5.0" + babel-jest "^25.5.1" + chalk "^3.0.0" + deepmerge "^4.2.2" + glob "^7.1.1" + graceful-fs "^4.2.4" + jest-environment-jsdom "^25.5.0" + jest-environment-node "^25.5.0" + jest-get-type "^25.2.6" + jest-jasmine2 "^25.5.4" + jest-regex-util "^25.2.6" + jest-resolve "^25.5.1" + jest-util "^25.5.0" + jest-validate "^25.5.0" + micromatch "^4.0.2" + pretty-format "^25.5.0" + realpath-native "^2.0.0" + +jest-diff@^25.2.1, jest-diff@^25.5.0: + version "25.5.0" + resolved "https://registry.yarnpkg.com/jest-diff/-/jest-diff-25.5.0.tgz#1dd26ed64f96667c068cef026b677dfa01afcfa9" + integrity sha512-z1kygetuPiREYdNIumRpAHY6RXiGmp70YHptjdaxTWGmA085W3iCnXNx0DhflK3vwrKmrRWyY1wUpkPMVxMK7A== + dependencies: + chalk "^3.0.0" + diff-sequences "^25.2.6" + jest-get-type "^25.2.6" + pretty-format "^25.5.0" + +jest-docblock@^25.3.0: + version "25.3.0" + resolved "https://registry.yarnpkg.com/jest-docblock/-/jest-docblock-25.3.0.tgz#8b777a27e3477cd77a168c05290c471a575623ef" + integrity sha512-aktF0kCar8+zxRHxQZwxMy70stc9R1mOmrLsT5VO3pIT0uzGRSDAXxSlz4NqQWpuLjPpuMhPRl7H+5FRsvIQAg== + dependencies: + detect-newline "^3.0.0" + +jest-each@^25.5.0: + version "25.5.0" + resolved "https://registry.yarnpkg.com/jest-each/-/jest-each-25.5.0.tgz#0c3c2797e8225cb7bec7e4d249dcd96b934be516" + integrity sha512-QBogUxna3D8vtiItvn54xXde7+vuzqRrEeaw8r1s+1TG9eZLVJE5ZkKoSUlqFwRjnlaA4hyKGiu9OlkFIuKnjA== + dependencies: + "@jest/types" "^25.5.0" + chalk "^3.0.0" + jest-get-type "^25.2.6" + jest-util "^25.5.0" + pretty-format "^25.5.0" + +jest-environment-jsdom@^25.5.0: + version "25.5.0" + resolved "https://registry.yarnpkg.com/jest-environment-jsdom/-/jest-environment-jsdom-25.5.0.tgz#dcbe4da2ea997707997040ecf6e2560aec4e9834" + integrity sha512-7Jr02ydaq4jaWMZLY+Skn8wL5nVIYpWvmeatOHL3tOcV3Zw8sjnPpx+ZdeBfc457p8jCR9J6YCc+Lga0oIy62A== + dependencies: + "@jest/environment" "^25.5.0" + "@jest/fake-timers" "^25.5.0" + "@jest/types" "^25.5.0" + jest-mock "^25.5.0" + jest-util "^25.5.0" + jsdom "^15.2.1" + +jest-environment-node@^25.5.0: + version "25.5.0" + resolved "https://registry.yarnpkg.com/jest-environment-node/-/jest-environment-node-25.5.0.tgz#0f55270d94804902988e64adca37c6ce0f7d07a1" + integrity sha512-iuxK6rQR2En9EID+2k+IBs5fCFd919gVVK5BeND82fYeLWPqvRcFNPKu9+gxTwfB5XwBGBvZ0HFQa+cHtIoslA== + dependencies: + "@jest/environment" "^25.5.0" + "@jest/fake-timers" "^25.5.0" + "@jest/types" "^25.5.0" + jest-mock "^25.5.0" + jest-util "^25.5.0" + semver "^6.3.0" + +jest-get-type@^25.2.6: + version "25.2.6" + resolved "https://registry.yarnpkg.com/jest-get-type/-/jest-get-type-25.2.6.tgz#0b0a32fab8908b44d508be81681487dbabb8d877" + integrity sha512-DxjtyzOHjObRM+sM1knti6or+eOgcGU4xVSb2HNP1TqO4ahsT+rqZg+nyqHWJSvWgKC5cG3QjGFBqxLghiF/Ig== + +jest-haste-map@^25.5.1: + version "25.5.1" + resolved "https://registry.yarnpkg.com/jest-haste-map/-/jest-haste-map-25.5.1.tgz#1df10f716c1d94e60a1ebf7798c9fb3da2620943" + integrity sha512-dddgh9UZjV7SCDQUrQ+5t9yy8iEgKc1AKqZR9YDww8xsVOtzPQSMVLDChc21+g29oTRexb9/B0bIlZL+sWmvAQ== + dependencies: + "@jest/types" "^25.5.0" + "@types/graceful-fs" "^4.1.2" + anymatch "^3.0.3" + fb-watchman "^2.0.0" + graceful-fs "^4.2.4" + jest-serializer "^25.5.0" + jest-util "^25.5.0" + jest-worker "^25.5.0" + micromatch "^4.0.2" + sane "^4.0.3" + walker "^1.0.7" + which "^2.0.2" + optionalDependencies: + fsevents "^2.1.2" + +jest-jasmine2@^25.5.4: + version "25.5.4" + resolved "https://registry.yarnpkg.com/jest-jasmine2/-/jest-jasmine2-25.5.4.tgz#66ca8b328fb1a3c5364816f8958f6970a8526968" + integrity sha512-9acbWEfbmS8UpdcfqnDO+uBUgKa/9hcRh983IHdM+pKmJPL77G0sWAAK0V0kr5LK3a8cSBfkFSoncXwQlRZfkQ== + dependencies: + "@babel/traverse" "^7.1.0" + "@jest/environment" "^25.5.0" + "@jest/source-map" "^25.5.0" + "@jest/test-result" "^25.5.0" + "@jest/types" "^25.5.0" + chalk "^3.0.0" + co "^4.6.0" + expect "^25.5.0" + is-generator-fn "^2.0.0" + jest-each "^25.5.0" + jest-matcher-utils "^25.5.0" + jest-message-util "^25.5.0" + jest-runtime "^25.5.4" + jest-snapshot "^25.5.1" + jest-util "^25.5.0" + pretty-format "^25.5.0" + throat "^5.0.0" + +jest-leak-detector@^25.5.0: + version "25.5.0" + resolved "https://registry.yarnpkg.com/jest-leak-detector/-/jest-leak-detector-25.5.0.tgz#2291c6294b0ce404241bb56fe60e2d0c3e34f0bb" + integrity sha512-rV7JdLsanS8OkdDpZtgBf61L5xZ4NnYLBq72r6ldxahJWWczZjXawRsoHyXzibM5ed7C2QRjpp6ypgwGdKyoVA== + dependencies: + jest-get-type "^25.2.6" + pretty-format "^25.5.0" + +jest-matcher-utils@^25.5.0: + version "25.5.0" + resolved "https://registry.yarnpkg.com/jest-matcher-utils/-/jest-matcher-utils-25.5.0.tgz#fbc98a12d730e5d2453d7f1ed4a4d948e34b7867" + integrity sha512-VWI269+9JS5cpndnpCwm7dy7JtGQT30UHfrnM3mXl22gHGt/b7NkjBqXfbhZ8V4B7ANUsjK18PlSBmG0YH7gjw== + dependencies: + chalk "^3.0.0" + jest-diff "^25.5.0" + jest-get-type "^25.2.6" + pretty-format "^25.5.0" + +jest-message-util@^25.5.0: + version "25.5.0" + resolved "https://registry.yarnpkg.com/jest-message-util/-/jest-message-util-25.5.0.tgz#ea11d93204cc7ae97456e1d8716251185b8880ea" + integrity sha512-ezddz3YCT/LT0SKAmylVyWWIGYoKHOFOFXx3/nA4m794lfVUskMcwhip6vTgdVrOtYdjeQeis2ypzes9mZb4EA== + dependencies: + "@babel/code-frame" "^7.0.0" + "@jest/types" "^25.5.0" + "@types/stack-utils" "^1.0.1" + chalk "^3.0.0" + graceful-fs "^4.2.4" + micromatch "^4.0.2" + slash "^3.0.0" + stack-utils "^1.0.1" + +jest-mock@^25.5.0: + version "25.5.0" + resolved "https://registry.yarnpkg.com/jest-mock/-/jest-mock-25.5.0.tgz#a91a54dabd14e37ecd61665d6b6e06360a55387a" + integrity sha512-eXWuTV8mKzp/ovHc5+3USJMYsTBhyQ+5A1Mak35dey/RG8GlM4YWVylZuGgVXinaW6tpvk/RSecmF37FKUlpXA== + dependencies: + "@jest/types" "^25.5.0" + +jest-pnp-resolver@^1.2.1: + version "1.2.2" + resolved "https://registry.yarnpkg.com/jest-pnp-resolver/-/jest-pnp-resolver-1.2.2.tgz#b704ac0ae028a89108a4d040b3f919dfddc8e33c" + integrity sha512-olV41bKSMm8BdnuMsewT4jqlZ8+3TCARAXjZGT9jcoSnrfUnRCqnMoF9XEeoWjbzObpqF9dRhHQj0Xb9QdF6/w== + +jest-regex-util@^25.2.6: + version "25.2.6" + resolved "https://registry.yarnpkg.com/jest-regex-util/-/jest-regex-util-25.2.6.tgz#d847d38ba15d2118d3b06390056028d0f2fd3964" + integrity sha512-KQqf7a0NrtCkYmZZzodPftn7fL1cq3GQAFVMn5Hg8uKx/fIenLEobNanUxb7abQ1sjADHBseG/2FGpsv/wr+Qw== + +jest-resolve-dependencies@^25.5.4: + version "25.5.4" + resolved "https://registry.yarnpkg.com/jest-resolve-dependencies/-/jest-resolve-dependencies-25.5.4.tgz#85501f53957c8e3be446e863a74777b5a17397a7" + integrity sha512-yFmbPd+DAQjJQg88HveObcGBA32nqNZ02fjYmtL16t1xw9bAttSn5UGRRhzMHIQbsep7znWvAvnD4kDqOFM0Uw== + dependencies: + "@jest/types" "^25.5.0" + jest-regex-util "^25.2.6" + jest-snapshot "^25.5.1" + +jest-resolve@^25.5.1: + version "25.5.1" + resolved "https://registry.yarnpkg.com/jest-resolve/-/jest-resolve-25.5.1.tgz#0e6fbcfa7c26d2a5fe8f456088dc332a79266829" + integrity sha512-Hc09hYch5aWdtejsUZhA+vSzcotf7fajSlPA6EZPE1RmPBAD39XtJhvHWFStid58iit4IPDLI/Da4cwdDmAHiQ== + dependencies: + "@jest/types" "^25.5.0" + browser-resolve "^1.11.3" + chalk "^3.0.0" + graceful-fs "^4.2.4" + jest-pnp-resolver "^1.2.1" + read-pkg-up "^7.0.1" + realpath-native "^2.0.0" + resolve "^1.17.0" + slash "^3.0.0" + +jest-runner@^25.5.4: + version "25.5.4" + resolved "https://registry.yarnpkg.com/jest-runner/-/jest-runner-25.5.4.tgz#ffec5df3875da5f5c878ae6d0a17b8e4ecd7c71d" + integrity sha512-V/2R7fKZo6blP8E9BL9vJ8aTU4TH2beuqGNxHbxi6t14XzTb+x90B3FRgdvuHm41GY8ch4xxvf0ATH4hdpjTqg== + dependencies: + "@jest/console" "^25.5.0" + "@jest/environment" "^25.5.0" + "@jest/test-result" "^25.5.0" + "@jest/types" "^25.5.0" + chalk "^3.0.0" + exit "^0.1.2" + graceful-fs "^4.2.4" + jest-config "^25.5.4" + jest-docblock "^25.3.0" + jest-haste-map "^25.5.1" + jest-jasmine2 "^25.5.4" + jest-leak-detector "^25.5.0" + jest-message-util "^25.5.0" + jest-resolve "^25.5.1" + jest-runtime "^25.5.4" + jest-util "^25.5.0" + jest-worker "^25.5.0" + source-map-support "^0.5.6" + throat "^5.0.0" + +jest-runtime@^25.5.4: + version "25.5.4" + resolved "https://registry.yarnpkg.com/jest-runtime/-/jest-runtime-25.5.4.tgz#dc981fe2cb2137abcd319e74ccae7f7eeffbfaab" + integrity sha512-RWTt8LeWh3GvjYtASH2eezkc8AehVoWKK20udV6n3/gC87wlTbE1kIA+opCvNWyyPeBs6ptYsc6nyHUb1GlUVQ== + dependencies: + "@jest/console" "^25.5.0" + "@jest/environment" "^25.5.0" + "@jest/globals" "^25.5.2" + "@jest/source-map" "^25.5.0" + "@jest/test-result" "^25.5.0" + "@jest/transform" "^25.5.1" + "@jest/types" "^25.5.0" + "@types/yargs" "^15.0.0" + chalk "^3.0.0" + collect-v8-coverage "^1.0.0" + exit "^0.1.2" + glob "^7.1.3" + graceful-fs "^4.2.4" + jest-config "^25.5.4" + jest-haste-map "^25.5.1" + jest-message-util "^25.5.0" + jest-mock "^25.5.0" + jest-regex-util "^25.2.6" + jest-resolve "^25.5.1" + jest-snapshot "^25.5.1" + jest-util "^25.5.0" + jest-validate "^25.5.0" + realpath-native "^2.0.0" + slash "^3.0.0" + strip-bom "^4.0.0" + yargs "^15.3.1" + +jest-serializer@^25.5.0: + version "25.5.0" + resolved "https://registry.yarnpkg.com/jest-serializer/-/jest-serializer-25.5.0.tgz#a993f484e769b4ed54e70e0efdb74007f503072b" + integrity sha512-LxD8fY1lByomEPflwur9o4e2a5twSQ7TaVNLlFUuToIdoJuBt8tzHfCsZ42Ok6LkKXWzFWf3AGmheuLAA7LcCA== + dependencies: + graceful-fs "^4.2.4" + +jest-snapshot@^25.5.1: + version "25.5.1" + resolved "https://registry.yarnpkg.com/jest-snapshot/-/jest-snapshot-25.5.1.tgz#1a2a576491f9961eb8d00c2e5fd479bc28e5ff7f" + integrity sha512-C02JE1TUe64p2v1auUJ2ze5vcuv32tkv9PyhEb318e8XOKF7MOyXdJ7kdjbvrp3ChPLU2usI7Rjxs97Dj5P0uQ== + dependencies: + "@babel/types" "^7.0.0" + "@jest/types" "^25.5.0" + "@types/prettier" "^1.19.0" + chalk "^3.0.0" + expect "^25.5.0" + graceful-fs "^4.2.4" + jest-diff "^25.5.0" + jest-get-type "^25.2.6" + jest-matcher-utils "^25.5.0" + jest-message-util "^25.5.0" + jest-resolve "^25.5.1" + make-dir "^3.0.0" + natural-compare "^1.4.0" + pretty-format "^25.5.0" + semver "^6.3.0" + +jest-util@^25.5.0: + version "25.5.0" + resolved "https://registry.yarnpkg.com/jest-util/-/jest-util-25.5.0.tgz#31c63b5d6e901274d264a4fec849230aa3fa35b0" + integrity sha512-KVlX+WWg1zUTB9ktvhsg2PXZVdkI1NBevOJSkTKYAyXyH4QSvh+Lay/e/v+bmaFfrkfx43xD8QTfgobzlEXdIA== + dependencies: + "@jest/types" "^25.5.0" + chalk "^3.0.0" + graceful-fs "^4.2.4" + is-ci "^2.0.0" + make-dir "^3.0.0" + +jest-validate@^25.5.0: + version "25.5.0" + resolved "https://registry.yarnpkg.com/jest-validate/-/jest-validate-25.5.0.tgz#fb4c93f332c2e4cf70151a628e58a35e459a413a" + integrity sha512-okUFKqhZIpo3jDdtUXUZ2LxGUZJIlfdYBvZb1aczzxrlyMlqdnnws9MOxezoLGhSaFc2XYaHNReNQfj5zPIWyQ== + dependencies: + "@jest/types" "^25.5.0" + camelcase "^5.3.1" + chalk "^3.0.0" + jest-get-type "^25.2.6" + leven "^3.1.0" + pretty-format "^25.5.0" + +jest-watcher@^25.5.0: + version "25.5.0" + resolved "https://registry.yarnpkg.com/jest-watcher/-/jest-watcher-25.5.0.tgz#d6110d101df98badebe435003956fd4a465e8456" + integrity sha512-XrSfJnVASEl+5+bb51V0Q7WQx65dTSk7NL4yDdVjPnRNpM0hG+ncFmDYJo9O8jaSRcAitVbuVawyXCRoxGrT5Q== + dependencies: + "@jest/test-result" "^25.5.0" + "@jest/types" "^25.5.0" + ansi-escapes "^4.2.1" + chalk "^3.0.0" + jest-util "^25.5.0" + string-length "^3.1.0" + +jest-worker@^25.5.0: + version "25.5.0" + resolved "https://registry.yarnpkg.com/jest-worker/-/jest-worker-25.5.0.tgz#2611d071b79cea0f43ee57a3d118593ac1547db1" + integrity sha512-/dsSmUkIy5EBGfv/IjjqmFxrNAUpBERfGs1oHROyD7yxjG/w+t0GOJDX8O1k32ySmd7+a5IhnJU2qQFcJ4n1vw== + dependencies: + merge-stream "^2.0.0" + supports-color "^7.0.0" + +jest@^25.1.0: + version "25.5.4" + resolved "https://registry.yarnpkg.com/jest/-/jest-25.5.4.tgz#f21107b6489cfe32b076ce2adcadee3587acb9db" + integrity sha512-hHFJROBTqZahnO+X+PMtT6G2/ztqAZJveGqz//FnWWHurizkD05PQGzRZOhF3XP6z7SJmL+5tCfW8qV06JypwQ== + dependencies: + "@jest/core" "^25.5.4" + import-local "^3.0.2" + jest-cli "^25.5.4" + +jpeg-js@^0.4.2: + version "0.4.3" + resolved "https://registry.yarnpkg.com/jpeg-js/-/jpeg-js-0.4.3.tgz#6158e09f1983ad773813704be80680550eff977b" + integrity sha512-ru1HWKek8octvUHFHvE5ZzQ1yAsJmIvRdGWvSoKV52XKyuyYA437QWDttXT8eZXDSbuMpHlLzPDZUPd6idIz+Q== + +js-beautify@^1.10.3: + version "1.14.0" + resolved "https://registry.yarnpkg.com/js-beautify/-/js-beautify-1.14.0.tgz#2ce790c555d53ce1e3d7363227acf5dc69024c2d" + integrity sha512-yuck9KirNSCAwyNJbqW+BxJqJ0NLJ4PwBUzQQACl5O3qHMBXVkXb/rD0ilh/Lat/tn88zSZ+CAHOlk0DsY7GuQ== + dependencies: + config-chain "^1.1.12" + editorconfig "^0.15.3" + glob "^7.1.3" + nopt "^5.0.0" + +js-tokens@^4.0.0: + version "4.0.0" + resolved "https://registry.yarnpkg.com/js-tokens/-/js-tokens-4.0.0.tgz#19203fb59991df98e3a287050d4647cdeaf32499" + integrity sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ== + +js-yaml@^3.13.1: + version "3.14.1" + resolved "https://registry.yarnpkg.com/js-yaml/-/js-yaml-3.14.1.tgz#dae812fdb3825fa306609a8717383c50c36a0537" + integrity sha512-okMH7OXXJ7YrN9Ok3/SXrnu4iX9yOk+25nqX4imS2npuvTYDmo/QEZoqwZkYaIDk3jVvBOTOIEgEhaLOynBS9g== + dependencies: + argparse "^1.0.7" + esprima "^4.0.0" + +jsbn@~0.1.0: + version "0.1.1" + resolved "https://registry.yarnpkg.com/jsbn/-/jsbn-0.1.1.tgz#a5e654c2e5a2deb5f201d96cefbca80c0ef2f513" + integrity sha1-peZUwuWi3rXyAdls77yoDA7y9RM= + +jsdom@^15.2.1: + version "15.2.1" + resolved "https://registry.yarnpkg.com/jsdom/-/jsdom-15.2.1.tgz#d2feb1aef7183f86be521b8c6833ff5296d07ec5" + integrity sha512-fAl1W0/7T2G5vURSyxBzrJ1LSdQn6Tr5UX/xD4PXDx/PDgwygedfW6El/KIj3xJ7FU61TTYnc/l/B7P49Eqt6g== + dependencies: + abab "^2.0.0" + acorn "^7.1.0" + acorn-globals "^4.3.2" + array-equal "^1.0.0" + cssom "^0.4.1" + cssstyle "^2.0.0" + data-urls "^1.1.0" + domexception "^1.0.1" + escodegen "^1.11.1" + html-encoding-sniffer "^1.0.2" + nwsapi "^2.2.0" + parse5 "5.1.0" + pn "^1.1.0" + request "^2.88.0" + request-promise-native "^1.0.7" + saxes "^3.1.9" + symbol-tree "^3.2.2" + tough-cookie "^3.0.1" + w3c-hr-time "^1.0.1" + w3c-xmlserializer "^1.1.2" + webidl-conversions "^4.0.2" + whatwg-encoding "^1.0.5" + whatwg-mimetype "^2.3.0" + whatwg-url "^7.0.0" + ws "^7.0.0" + xml-name-validator "^3.0.0" + +jsesc@^2.5.1: + version "2.5.2" + resolved "https://registry.yarnpkg.com/jsesc/-/jsesc-2.5.2.tgz#80564d2e483dacf6e8ef209650a67df3f0c283a4" + integrity sha512-OYu7XEzjkCQ3C5Ps3QIZsQfNpqoJyZZA99wd9aWd05NCtC5pWOkShK2mkL6HXQR6/Cy2lbNdPlZBpuQHXE63gA== + +json-parse-even-better-errors@^2.3.0: + version "2.3.1" + resolved "https://registry.yarnpkg.com/json-parse-even-better-errors/-/json-parse-even-better-errors-2.3.1.tgz#7c47805a94319928e05777405dc12e1f7a4ee02d" + integrity sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w== + +json-schema-traverse@^0.4.1: + version "0.4.1" + resolved "https://registry.yarnpkg.com/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz#69f6a87d9513ab8bb8fe63bdb0979c448e684660" + integrity sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg== + +json-schema@0.2.3: + version "0.2.3" + resolved "https://registry.yarnpkg.com/json-schema/-/json-schema-0.2.3.tgz#b480c892e59a2f05954ce727bd3f2a4e882f9e13" + integrity sha1-tIDIkuWaLwWVTOcnvT8qTogvnhM= + +json-stringify-safe@~5.0.1: + version "5.0.1" + resolved "https://registry.yarnpkg.com/json-stringify-safe/-/json-stringify-safe-5.0.1.tgz#1296a2d58fd45f19a0f6ce01d65701e2c735b6eb" + integrity sha1-Epai1Y/UXxmg9s4B1lcB4sc1tus= + +json5@2.x, json5@^2.1.2: + version "2.2.0" + resolved "https://registry.yarnpkg.com/json5/-/json5-2.2.0.tgz#2dfefe720c6ba525d9ebd909950f0515316c89a3" + integrity sha512-f+8cldu7X/y7RAJurMEJmdoKXGB/X550w2Nr3tTbezL6RwEE/iMcm+tZnXeoZtKuOq6ft8+CqzEkrIgx1fPoQA== + dependencies: + minimist "^1.2.5" + +jsonfile@^4.0.0: + version "4.0.0" + resolved "https://registry.yarnpkg.com/jsonfile/-/jsonfile-4.0.0.tgz#8771aae0799b64076b76640fca058f9c10e33ecb" + integrity sha1-h3Gq4HmbZAdrdmQPygWPnBDjPss= + optionalDependencies: + graceful-fs "^4.1.6" + +jsprim@^1.2.2: + version "1.4.1" + resolved "https://registry.yarnpkg.com/jsprim/-/jsprim-1.4.1.tgz#313e66bc1e5cc06e438bc1b7499c2e5c56acb6a2" + integrity sha1-MT5mvB5cwG5Di8G3SZwuXFastqI= + dependencies: + assert-plus "1.0.0" + extsprintf "1.3.0" + json-schema "0.2.3" + verror "1.10.0" + +kind-of@^3.0.2, kind-of@^3.0.3, kind-of@^3.2.0: + version "3.2.2" + resolved "https://registry.yarnpkg.com/kind-of/-/kind-of-3.2.2.tgz#31ea21a734bab9bbb0f32466d893aea51e4a3c64" + integrity sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ= + dependencies: + is-buffer "^1.1.5" + +kind-of@^4.0.0: + version "4.0.0" + resolved "https://registry.yarnpkg.com/kind-of/-/kind-of-4.0.0.tgz#20813df3d712928b207378691a45066fae72dd57" + integrity sha1-IIE989cSkosgc3hpGkUGb65y3Vc= + dependencies: + is-buffer "^1.1.5" + +kind-of@^5.0.0: + version "5.1.0" + resolved "https://registry.yarnpkg.com/kind-of/-/kind-of-5.1.0.tgz#729c91e2d857b7a419a1f9aa65685c4c33f5845d" + integrity sha512-NGEErnH6F2vUuXDh+OlbcKW7/wOcfdRHaZ7VWtqCztfHri/++YKmP51OdWeGPuqCOba6kk2OTe5d02VmTB80Pw== + +kind-of@^6.0.0, kind-of@^6.0.2, kind-of@^6.0.3: + version "6.0.3" + resolved "https://registry.yarnpkg.com/kind-of/-/kind-of-6.0.3.tgz#07c05034a6c349fa06e24fa35aa76db4580ce4dd" + integrity sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw== + +klaw-sync@^6.0.0: + version "6.0.0" + resolved "https://registry.yarnpkg.com/klaw-sync/-/klaw-sync-6.0.0.tgz#1fd2cfd56ebb6250181114f0a581167099c2b28c" + integrity sha512-nIeuVSzdCCs6TDPTqI8w1Yre34sSq7AkZ4B3sfOBbI2CgVSB4Du4aLQijFU2+lhAFCwt9+42Hel6lQNIv6AntQ== + dependencies: + graceful-fs "^4.1.11" + +kleur@^3.0.3: + version "3.0.3" + resolved "https://registry.yarnpkg.com/kleur/-/kleur-3.0.3.tgz#a79c9ecc86ee1ce3fa6206d1216c501f147fc07e" + integrity sha512-eTIzlVOSUR+JxdDFepEYcBMtZ9Qqdef+rnzWdRZuMbOywu5tO2w2N7rqjoANZ5k9vywhL6Br1VRjUIgTQx4E8w== + +leven@^3.1.0: + version "3.1.0" + resolved "https://registry.yarnpkg.com/leven/-/leven-3.1.0.tgz#77891de834064cccba82ae7842bb6b14a13ed7f2" + integrity sha512-qsda+H8jTaUaN/x5vzW2rzc+8Rw4TAQ/4KjB46IwK5VH+IlVeeeje/EoZRpiXvIqjFgK84QffqPztGI3VBLG1A== + +levn@~0.3.0: + version "0.3.0" + resolved "https://registry.yarnpkg.com/levn/-/levn-0.3.0.tgz#3b09924edf9f083c0490fdd4c0bc4421e04764ee" + integrity sha1-OwmSTt+fCDwEkP3UwLxEIeBHZO4= + dependencies: + prelude-ls "~1.1.2" + type-check "~0.3.2" + +lines-and-columns@^1.1.6: + version "1.1.6" + resolved "https://registry.yarnpkg.com/lines-and-columns/-/lines-and-columns-1.1.6.tgz#1c00c743b433cd0a4e80758f7b64a57440d9ff00" + integrity sha1-HADHQ7QzzQpOgHWPe2SldEDZ/wA= + +locate-path@^5.0.0: + version "5.0.0" + resolved "https://registry.yarnpkg.com/locate-path/-/locate-path-5.0.0.tgz#1afba396afd676a6d42504d0a67a3a7eb9f62aa0" + integrity sha512-t7hw9pI+WvuwNJXwk5zVHpyhIqzg2qTlklJOf0mVxGSbe3Fp2VieZcduNYjaLDoy6p9uGpQEGWG87WpMKlNq8g== + dependencies: + p-locate "^4.1.0" + +lodash.memoize@4.x: + version "4.1.2" + resolved "https://registry.yarnpkg.com/lodash.memoize/-/lodash.memoize-4.1.2.tgz#bcc6c49a42a2840ed997f323eada5ecd182e0bfe" + integrity sha1-vMbEmkKihA7Zl/Mj6tpezRguC/4= + +lodash.sortby@^4.7.0: + version "4.7.0" + resolved "https://registry.yarnpkg.com/lodash.sortby/-/lodash.sortby-4.7.0.tgz#edd14c824e2cc9c1e0b0a1b42bb5210516a42438" + integrity sha1-7dFMgk4sycHgsKG0K7UhBRakJDg= + +lodash@^4.17.14, lodash@^4.17.19: + version "4.17.21" + resolved "https://registry.yarnpkg.com/lodash/-/lodash-4.17.21.tgz#679591c564c3bffaae8454cf0b3df370c3d6911c" + integrity sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg== + +lolex@^5.0.0: + version "5.1.2" + resolved "https://registry.yarnpkg.com/lolex/-/lolex-5.1.2.tgz#953694d098ce7c07bc5ed6d0e42bc6c0c6d5a367" + integrity sha512-h4hmjAvHTmd+25JSwrtTIuwbKdwg5NzZVRMLn9saij4SZaepCrTCxPr35H/3bjwfMJtN+t3CX8672UIkglz28A== + dependencies: + "@sinonjs/commons" "^1.7.0" + +lru-cache@^4.1.5: + version "4.1.5" + resolved "https://registry.yarnpkg.com/lru-cache/-/lru-cache-4.1.5.tgz#8bbe50ea85bed59bc9e33dcab8235ee9bcf443cd" + integrity sha512-sWZlbEP2OsHNkXrMl5GYk/jKk70MBng6UU4YI/qGDYbgf6YbP4EvmqISbXCoJiRKs+1bSpFHVgQxvJ17F2li5g== + dependencies: + pseudomap "^1.0.2" + yallist "^2.1.2" + +lru-cache@^6.0.0: + version "6.0.0" + resolved "https://registry.yarnpkg.com/lru-cache/-/lru-cache-6.0.0.tgz#6d6fe6570ebd96aaf90fcad1dafa3b2566db3a94" + integrity sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA== + dependencies: + yallist "^4.0.0" + +make-dir@^3.0.0: + version "3.1.0" + resolved "https://registry.yarnpkg.com/make-dir/-/make-dir-3.1.0.tgz#415e967046b3a7f1d185277d84aa58203726a13f" + integrity sha512-g3FeP20LNwhALb/6Cz6Dd4F2ngze0jz7tbzrD2wAV+o9FeNHe4rL+yK2md0J/fiSf1sa1ADhXqi5+oVwOM/eGw== + dependencies: + semver "^6.0.0" + +make-error@1.x: + version "1.3.6" + resolved "https://registry.yarnpkg.com/make-error/-/make-error-1.3.6.tgz#2eb2e37ea9b67c4891f684a1394799af484cf7a2" + integrity sha512-s8UhlNe7vPKomQhC1qFelMokr/Sc3AgNbso3n74mVPA5LTZwkB9NlXf4XPamLxJE8h0gh73rM94xvwRT2CVInw== + +makeerror@1.0.x: + version "1.0.11" + resolved "https://registry.yarnpkg.com/makeerror/-/makeerror-1.0.11.tgz#e01a5c9109f2af79660e4e8b9587790184f5a96c" + integrity sha1-4BpckQnyr3lmDk6LlYd5AYT1qWw= + dependencies: + tmpl "1.0.x" + +map-cache@^0.2.2: + version "0.2.2" + resolved "https://registry.yarnpkg.com/map-cache/-/map-cache-0.2.2.tgz#c32abd0bd6525d9b051645bb4f26ac5dc98a0dbf" + integrity sha1-wyq9C9ZSXZsFFkW7TyasXcmKDb8= + +map-obj@^1.0.0: + version "1.0.1" + resolved "https://registry.yarnpkg.com/map-obj/-/map-obj-1.0.1.tgz#d933ceb9205d82bdcf4886f6742bdc2b4dea146d" + integrity sha1-2TPOuSBdgr3PSIb2dCvcK03qFG0= + +map-obj@^4.0.0: + version "4.2.1" + resolved "https://registry.yarnpkg.com/map-obj/-/map-obj-4.2.1.tgz#e4ea399dbc979ae735c83c863dd31bdf364277b7" + integrity sha512-+WA2/1sPmDj1dlvvJmB5G6JKfY9dpn7EVBUL06+y6PoljPkh+6V1QihwxNkbcGxCRjt2b0F9K0taiCuo7MbdFQ== + +map-visit@^1.0.0: + version "1.0.0" + resolved "https://registry.yarnpkg.com/map-visit/-/map-visit-1.0.0.tgz#ecdca8f13144e660f1b5bd41f12f3479d98dfb8f" + integrity sha1-7Nyo8TFE5mDxtb1B8S80edmN+48= + dependencies: + object-visit "^1.0.0" + +meow@^6.0.1: + version "6.1.1" + resolved "https://registry.yarnpkg.com/meow/-/meow-6.1.1.tgz#1ad64c4b76b2a24dfb2f635fddcadf320d251467" + integrity sha512-3YffViIt2QWgTy6Pale5QpopX/IvU3LPL03jOTqp6pGj3VjesdO/U8CuHMKpnQr4shCNCM5fd5XFFvIIl6JBHg== + dependencies: + "@types/minimist" "^1.2.0" + camelcase-keys "^6.2.2" + decamelize-keys "^1.1.0" + hard-rejection "^2.1.0" + minimist-options "^4.0.2" + normalize-package-data "^2.5.0" + read-pkg-up "^7.0.1" + redent "^3.0.0" + trim-newlines "^3.0.0" + type-fest "^0.13.1" + yargs-parser "^18.1.3" + +merge-stream@^2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/merge-stream/-/merge-stream-2.0.0.tgz#52823629a14dd00c9770fb6ad47dc6310f2c1f60" + integrity sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w== + +micromatch@4.x, micromatch@^4.0.2: + version "4.0.4" + resolved "https://registry.yarnpkg.com/micromatch/-/micromatch-4.0.4.tgz#896d519dfe9db25fce94ceb7a500919bf881ebf9" + integrity sha512-pRmzw/XUcwXGpD9aI9q/0XOwLNygjETJ8y0ao0wdqprrzDa4YnxLcz7fQRZr8voh8V10kGhABbNcHVk5wHgWwg== + dependencies: + braces "^3.0.1" + picomatch "^2.2.3" + +micromatch@^3.1.4: + version "3.1.10" + resolved "https://registry.yarnpkg.com/micromatch/-/micromatch-3.1.10.tgz#70859bc95c9840952f359a068a3fc49f9ecfac23" + integrity sha512-MWikgl9n9M3w+bpsY3He8L+w9eF9338xRl8IAO5viDizwSzziFEyUzo2xrrloB64ADbTf8uA8vRqqttDTOmccg== + dependencies: + arr-diff "^4.0.0" + array-unique "^0.3.2" + braces "^2.3.1" + define-property "^2.0.2" + extend-shallow "^3.0.2" + extglob "^2.0.4" + fragment-cache "^0.2.1" + kind-of "^6.0.2" + nanomatch "^1.2.9" + object.pick "^1.3.0" + regex-not "^1.0.0" + snapdragon "^0.8.1" + to-regex "^3.0.2" + +mime-db@1.48.0: + version "1.48.0" + resolved "https://registry.yarnpkg.com/mime-db/-/mime-db-1.48.0.tgz#e35b31045dd7eada3aaad537ed88a33afbef2d1d" + integrity sha512-FM3QwxV+TnZYQ2aRqhlKBMHxk10lTbMt3bBkMAp54ddrNeVSfcQYOOKuGuy3Ddrm38I04If834fOUSq1yzslJQ== + +mime-types@^2.1.12, mime-types@~2.1.19: + version "2.1.31" + resolved "https://registry.yarnpkg.com/mime-types/-/mime-types-2.1.31.tgz#a00d76b74317c61f9c2db2218b8e9f8e9c5c9e6b" + integrity sha512-XGZnNzm3QvgKxa8dpzyhFTHmpP3l5YNusmne07VUOXxou9CqUqYa/HBy124RqtVh/O2pECas/MOcsDgpilPOPg== + dependencies: + mime-db "1.48.0" + +mime@^1.6.0: + version "1.6.0" + resolved "https://registry.yarnpkg.com/mime/-/mime-1.6.0.tgz#32cd9e5c64553bd58d19a568af452acff04981b1" + integrity sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg== + +mime@^2.4.6: + version "2.5.2" + resolved "https://registry.yarnpkg.com/mime/-/mime-2.5.2.tgz#6e3dc6cc2b9510643830e5f19d5cb753da5eeabe" + integrity sha512-tqkh47FzKeCPD2PUiPB6pkbMzsCasjxAfC62/Wap5qrUWcb+sFasXUC5I3gYM5iBM8v/Qpn4UK0x+j0iHyFPDg== + +mimic-fn@^2.1.0: + version "2.1.0" + resolved "https://registry.yarnpkg.com/mimic-fn/-/mimic-fn-2.1.0.tgz#7ed2c2ccccaf84d3ffcb7a69b57711fc2083401b" + integrity sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg== + +min-indent@^1.0.0: + version "1.0.1" + resolved "https://registry.yarnpkg.com/min-indent/-/min-indent-1.0.1.tgz#a63f681673b30571fbe8bc25686ae746eefa9869" + integrity sha512-I9jwMn07Sy/IwOj3zVkVik2JTvgpaykDZEigL6Rx6N9LbMywwUSMtxET+7lVoDLLd3O3IXwJwvuuns8UB/HeAg== + +minimatch@^3.0.4: + version "3.0.4" + resolved "https://registry.yarnpkg.com/minimatch/-/minimatch-3.0.4.tgz#5166e286457f03306064be5497e8dbb0c3d32083" + integrity sha512-yJHVQEhyqPLUTgt9B83PXu6W3rx4MvvHvSUvToogpwoGDOUQ+yDrR0HRot+yOCdCO7u4hX3pWft6kWBBcqh0UA== + dependencies: + brace-expansion "^1.1.7" + +minimist-options@^4.0.2: + version "4.1.0" + resolved "https://registry.yarnpkg.com/minimist-options/-/minimist-options-4.1.0.tgz#c0655713c53a8a2ebd77ffa247d342c40f010619" + integrity sha512-Q4r8ghd80yhO/0j1O3B2BjweX3fiHg9cdOwjJd2J76Q135c+NDxGCqdYKQ1SKBuFfgWbAUzBfvYjPUEeNgqN1A== + dependencies: + arrify "^1.0.1" + is-plain-obj "^1.1.0" + kind-of "^6.0.3" + +minimist@^1.1.0, minimist@^1.1.1, minimist@^1.2.0, minimist@^1.2.5: + version "1.2.5" + resolved "https://registry.yarnpkg.com/minimist/-/minimist-1.2.5.tgz#67d66014b66a6a8aaa0c083c5fd58df4e4e97602" + integrity sha512-FM9nNUYrRBAELZQT3xeZQ7fmMOBg6nWNmJKTcgsJeaLstP/UODVpGsr5OhXhhXg6f+qtJ8uiZ+PUxkDWcgIXLw== + +mixin-deep@^1.2.0: + version "1.3.2" + resolved "https://registry.yarnpkg.com/mixin-deep/-/mixin-deep-1.3.2.tgz#1120b43dc359a785dce65b55b82e257ccf479566" + integrity sha512-WRoDn//mXBiJ1H40rqa3vH0toePwSsGb45iInWlTySa+Uu4k3tYUSxa2v1KqAiLtvlrSzaExqS1gtk96A9zvEA== + dependencies: + for-in "^1.0.2" + is-extendable "^1.0.1" + +mkdirp@0.x, mkdirp@^0.5.5: + version "0.5.5" + resolved "https://registry.yarnpkg.com/mkdirp/-/mkdirp-0.5.5.tgz#d91cefd62d1436ca0f41620e251288d420099def" + integrity sha512-NKmAlESf6jMGym1++R0Ra7wvhV+wFW63FaSOFPwRahvea0gMUcGUhVeAg/0BC0wiv9ih5NYPB1Wn1UEI1/L+xQ== + dependencies: + minimist "^1.2.5" + +ms@2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/ms/-/ms-2.0.0.tgz#5608aeadfc00be6c2901df5f9861788de0d597c8" + integrity sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g= + +ms@2.1.2: + version "2.1.2" + resolved "https://registry.yarnpkg.com/ms/-/ms-2.1.2.tgz#d09d1f357b443f493382a8eb3ccd183872ae6009" + integrity sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w== + +ms@^2.1.1: + version "2.1.3" + resolved "https://registry.yarnpkg.com/ms/-/ms-2.1.3.tgz#574c8138ce1d2b5861f0b44579dbadd60c6615b2" + integrity sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA== + +mute-stream@0.0.8: + version "0.0.8" + resolved "https://registry.yarnpkg.com/mute-stream/-/mute-stream-0.0.8.tgz#1630c42b2251ff81e2a283de96a5497ea92e5e0d" + integrity sha512-nnbWWOkoWyUsTjKrhgD0dcz22mdkSnpYqbEjIm2nhwhuxlSkpywJmBo8h0ZqJdkp73mb90SssHkN4rsRaBAfAA== + +nanomatch@^1.2.9: + version "1.2.13" + resolved "https://registry.yarnpkg.com/nanomatch/-/nanomatch-1.2.13.tgz#b87a8aa4fc0de8fe6be88895b38983ff265bd119" + integrity sha512-fpoe2T0RbHwBTBUOftAfBPaDEi06ufaUai0mE6Yn1kacc3SnTErfb/h+X94VXzI64rKFHYImXSvdwGGCmwOqCA== + dependencies: + arr-diff "^4.0.0" + array-unique "^0.3.2" + define-property "^2.0.2" + extend-shallow "^3.0.2" + fragment-cache "^0.2.1" + is-windows "^1.0.2" + kind-of "^6.0.2" + object.pick "^1.3.0" + regex-not "^1.0.0" + snapdragon "^0.8.1" + to-regex "^3.0.1" + +natural-compare@^1.4.0: + version "1.4.0" + resolved "https://registry.yarnpkg.com/natural-compare/-/natural-compare-1.4.0.tgz#4abebfeed7541f2c27acfb29bdbbd15c8d5ba4f7" + integrity sha1-Sr6/7tdUHywnrPspvbvRXI1bpPc= + +nice-try@^1.0.4: + version "1.0.5" + resolved "https://registry.yarnpkg.com/nice-try/-/nice-try-1.0.5.tgz#a3378a7696ce7d223e88fc9b764bd7ef1089e366" + integrity sha512-1nh45deeb5olNY7eX82BkPO7SSxR5SSYJiPTrTdFUVYwAl8CKMA5N9PjTYkHiRjisVcxcQ1HXdLhx2qxxJzLNQ== + +node-int64@^0.4.0: + version "0.4.0" + resolved "https://registry.yarnpkg.com/node-int64/-/node-int64-0.4.0.tgz#87a9065cdb355d3182d8f94ce11188b825c68a3b" + integrity sha1-h6kGXNs1XTGC2PlM4RGIuCXGijs= + +node-modules-regexp@^1.0.0: + version "1.0.0" + resolved "https://registry.yarnpkg.com/node-modules-regexp/-/node-modules-regexp-1.0.0.tgz#8d9dbe28964a4ac5712e9131642107c71e90ec40" + integrity sha1-jZ2+KJZKSsVxLpExZCEHxx6Q7EA= + +node-notifier@^6.0.0: + version "6.0.0" + resolved "https://registry.yarnpkg.com/node-notifier/-/node-notifier-6.0.0.tgz#cea319e06baa16deec8ce5cd7f133c4a46b68e12" + integrity sha512-SVfQ/wMw+DesunOm5cKqr6yDcvUTDl/yc97ybGHMrteNEY6oekXpNpS3lZwgLlwz0FLgHoiW28ZpmBHUDg37cw== + dependencies: + growly "^1.3.0" + is-wsl "^2.1.1" + semver "^6.3.0" + shellwords "^0.1.1" + which "^1.3.1" + +node-releases@^1.1.71: + version "1.1.73" + resolved "https://registry.yarnpkg.com/node-releases/-/node-releases-1.1.73.tgz#dd4e81ddd5277ff846b80b52bb40c49edf7a7b20" + integrity sha512-uW7fodD6pyW2FZNZnp/Z3hvWKeEW1Y8R1+1CnErE8cXFXzl5blBOoVB41CvMer6P6Q0S5FXDwcHgFd1Wj0U9zg== + +nopt@^5.0.0: + version "5.0.0" + resolved "https://registry.yarnpkg.com/nopt/-/nopt-5.0.0.tgz#530942bb58a512fccafe53fe210f13a25355dc88" + integrity sha512-Tbj67rffqceeLpcRXrT7vKAN8CwfPeIBgM7E6iBkmKLV7bEMwpGgYLGv0jACUsECaa/vuxP0IjEont6umdMgtQ== + dependencies: + abbrev "1" + +normalize-package-data@^2.5.0: + version "2.5.0" + resolved "https://registry.yarnpkg.com/normalize-package-data/-/normalize-package-data-2.5.0.tgz#e66db1838b200c1dfc233225d12cb36520e234a8" + integrity sha512-/5CMN3T0R4XTj4DcGaexo+roZSdSFW/0AOOTROrjxzCG1wrWXEsGbRKevjlIL+ZDE4sZlJr5ED4YW0yqmkK+eA== + dependencies: + hosted-git-info "^2.1.4" + resolve "^1.10.0" + semver "2 || 3 || 4 || 5" + validate-npm-package-license "^3.0.1" + +normalize-path@^2.1.1: + version "2.1.1" + resolved "https://registry.yarnpkg.com/normalize-path/-/normalize-path-2.1.1.tgz#1ab28b556e198363a8c1a6f7e6fa20137fe6aed9" + integrity sha1-GrKLVW4Zg2Oowab35vogE3/mrtk= + dependencies: + remove-trailing-separator "^1.0.1" + +normalize-path@^3.0.0: + version "3.0.0" + resolved "https://registry.yarnpkg.com/normalize-path/-/normalize-path-3.0.0.tgz#0dcd69ff23a1c9b11fd0978316644a0388216a65" + integrity sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA== + +npm-run-path@^2.0.0: + version "2.0.2" + resolved "https://registry.yarnpkg.com/npm-run-path/-/npm-run-path-2.0.2.tgz#35a9232dfa35d7067b4cb2ddf2357b1871536c5f" + integrity sha1-NakjLfo11wZ7TLLd8jV7GHFTbF8= + dependencies: + path-key "^2.0.0" + +npm-run-path@^4.0.0: + version "4.0.1" + resolved "https://registry.yarnpkg.com/npm-run-path/-/npm-run-path-4.0.1.tgz#b7ecd1e5ed53da8e37a55e1c2269e0b97ed748ea" + integrity sha512-S48WzZW777zhNIrn7gxOlISNAqi9ZC/uQFnRdbeIHhZhCA6UqpkOT8T1G7BvfdgP4Er8gF4sUbaS0i7QvIfCWw== + dependencies: + path-key "^3.0.0" + +nwsapi@^2.2.0: + version "2.2.0" + resolved "https://registry.yarnpkg.com/nwsapi/-/nwsapi-2.2.0.tgz#204879a9e3d068ff2a55139c2c772780681a38b7" + integrity sha512-h2AatdwYH+JHiZpv7pt/gSX1XoRGb7L/qSIeuqA6GwYoF9w1vP1cw42TO0aI2pNyshRK5893hNSl+1//vHK7hQ== + +oauth-sign@~0.9.0: + version "0.9.0" + resolved "https://registry.yarnpkg.com/oauth-sign/-/oauth-sign-0.9.0.tgz#47a7b016baa68b5fa0ecf3dee08a85c679ac6455" + integrity sha512-fexhUFFPTGV8ybAtSIGbV6gOkSv8UtRbDBnAyLQw4QPKkgNlsH2ByPGtMUqdWkos6YCRmAqViwgZrJc/mRDzZQ== + +object-copy@^0.1.0: + version "0.1.0" + resolved "https://registry.yarnpkg.com/object-copy/-/object-copy-0.1.0.tgz#7e7d858b781bd7c991a41ba975ed3812754e998c" + integrity sha1-fn2Fi3gb18mRpBupde04EnVOmYw= + dependencies: + copy-descriptor "^0.1.0" + define-property "^0.2.5" + kind-of "^3.0.3" + +object-inspect@^1.9.0: + version "1.11.0" + resolved "https://registry.yarnpkg.com/object-inspect/-/object-inspect-1.11.0.tgz#9dceb146cedd4148a0d9e51ab88d34cf509922b1" + integrity sha512-jp7ikS6Sd3GxQfZJPyH3cjcbJF6GZPClgdV+EFygjFLQ5FmW/dRUnTd9PQ9k0JhoNDabWFbpF1yCdSWCC6gexg== + +object-visit@^1.0.0: + version "1.0.1" + resolved "https://registry.yarnpkg.com/object-visit/-/object-visit-1.0.1.tgz#f79c4493af0c5377b59fe39d395e41042dd045bb" + integrity sha1-95xEk68MU3e1n+OdOV5BBC3QRbs= + dependencies: + isobject "^3.0.0" + +object.pick@^1.3.0: + version "1.3.0" + resolved "https://registry.yarnpkg.com/object.pick/-/object.pick-1.3.0.tgz#87a10ac4c1694bd2e1cbf53591a66141fb5dd747" + integrity sha1-h6EKxMFpS9Lhy/U1kaZhQftd10c= + dependencies: + isobject "^3.0.1" + +once@^1.3.0, once@^1.3.1, once@^1.4.0: + version "1.4.0" + resolved "https://registry.yarnpkg.com/once/-/once-1.4.0.tgz#583b1aa775961d4b113ac17d9c50baef9dd76bd1" + integrity sha1-WDsap3WWHUsROsF9nFC6753Xa9E= + dependencies: + wrappy "1" + +onetime@^5.1.0: + version "5.1.2" + resolved "https://registry.yarnpkg.com/onetime/-/onetime-5.1.2.tgz#d0e96ebb56b07476df1dd9c4806e5237985ca45e" + integrity sha512-kbpaSSGJTWdAY5KPVeMOKXSrPtr8C8C7wodJbcsd51jRnmD+GZu8Y0VoU6Dm5Z4vWr0Ig/1NKuWRKf7j5aaYSg== + dependencies: + mimic-fn "^2.1.0" + +open@^7.0.4: + version "7.4.2" + resolved "https://registry.yarnpkg.com/open/-/open-7.4.2.tgz#b8147e26dcf3e426316c730089fd71edd29c2321" + integrity sha512-MVHddDVweXZF3awtlAS+6pgKLlm/JgxZ90+/NBurBoQctVOOB/zDdVjcyPzQ+0laDGbsWgrRkflI65sQeOgT9Q== + dependencies: + is-docker "^2.0.0" + is-wsl "^2.1.1" + +opener@^1.5.1: + version "1.5.2" + resolved "https://registry.yarnpkg.com/opener/-/opener-1.5.2.tgz#5d37e1f35077b9dcac4301372271afdeb2a13598" + integrity sha512-ur5UIdyw5Y7yEj9wLzhqXiy6GZ3Mwx0yGI+5sMn2r0N0v3cKJvUmFH5yPP+WXh9e0xfyzyJX95D8l088DNFj7A== + +optionator@^0.8.1: + version "0.8.3" + resolved "https://registry.yarnpkg.com/optionator/-/optionator-0.8.3.tgz#84fa1d036fe9d3c7e21d99884b601167ec8fb495" + integrity sha512-+IW9pACdk3XWmmTXG8m3upGUJst5XRGzxMRjXzAuJ1XnIFNvfhjjIuYkDvysnPQ7qzqVzLt78BCruntqRhWQbA== + dependencies: + deep-is "~0.1.3" + fast-levenshtein "~2.0.6" + levn "~0.3.0" + prelude-ls "~1.1.2" + type-check "~0.3.2" + word-wrap "~1.2.3" + +os-tmpdir@~1.0.2: + version "1.0.2" + resolved "https://registry.yarnpkg.com/os-tmpdir/-/os-tmpdir-1.0.2.tgz#bbe67406c79aa85c5cfec766fe5734555dfa1274" + integrity sha1-u+Z0BseaqFxc/sdm/lc0VV36EnQ= + +p-each-series@^2.1.0: + version "2.2.0" + resolved "https://registry.yarnpkg.com/p-each-series/-/p-each-series-2.2.0.tgz#105ab0357ce72b202a8a8b94933672657b5e2a9a" + integrity sha512-ycIL2+1V32th+8scbpTvyHNaHe02z0sjgh91XXjAk+ZeXoPN4Z46DVUnzdso0aX4KckKw0FNNFHdjZ2UsZvxiA== + +p-finally@^1.0.0: + version "1.0.0" + resolved "https://registry.yarnpkg.com/p-finally/-/p-finally-1.0.0.tgz#3fbcfb15b899a44123b34b6dcc18b724336a2cae" + integrity sha1-P7z7FbiZpEEjs0ttzBi3JDNqLK4= + +p-finally@^2.0.0: + version "2.0.1" + resolved "https://registry.yarnpkg.com/p-finally/-/p-finally-2.0.1.tgz#bd6fcaa9c559a096b680806f4d657b3f0f240561" + integrity sha512-vpm09aKwq6H9phqRQzecoDpD8TmVyGw70qmWlyq5onxY7tqyTTFVvxMykxQSQKILBSFlbXpypIw2T1Ml7+DDtw== + +p-limit@^2.2.0: + version "2.3.0" + resolved "https://registry.yarnpkg.com/p-limit/-/p-limit-2.3.0.tgz#3dd33c647a214fdfffd835933eb086da0dc21db1" + integrity sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w== + dependencies: + p-try "^2.0.0" + +p-locate@^4.1.0: + version "4.1.0" + resolved "https://registry.yarnpkg.com/p-locate/-/p-locate-4.1.0.tgz#a3428bb7088b3a60292f66919278b7c297ad4f07" + integrity sha512-R79ZZ/0wAxKGu3oYMlz8jy/kbhsNrS7SKZ7PxEHBgJ5+F2mtFW2fK2cOtBh1cHYkQsbzFV7I+EoRKe6Yt0oK7A== + dependencies: + p-limit "^2.2.0" + +p-try@^2.0.0: + version "2.2.0" + resolved "https://registry.yarnpkg.com/p-try/-/p-try-2.2.0.tgz#cb2868540e313d61de58fafbe35ce9004d5540e6" + integrity sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ== + +parse-json@^5.0.0: + version "5.2.0" + resolved "https://registry.yarnpkg.com/parse-json/-/parse-json-5.2.0.tgz#c76fc66dee54231c962b22bcc8a72cf2f99753cd" + integrity sha512-ayCKvm/phCGxOkYRSCM82iDwct8/EonSEgCSxWxD7ve6jHggsFl4fZVQBPRNgQoKiuV/odhFrGzQXZwbifC8Rg== + dependencies: + "@babel/code-frame" "^7.0.0" + error-ex "^1.3.1" + json-parse-even-better-errors "^2.3.0" + lines-and-columns "^1.1.6" + +parse5@5.1.0: + version "5.1.0" + resolved "https://registry.yarnpkg.com/parse5/-/parse5-5.1.0.tgz#c59341c9723f414c452975564c7c00a68d58acd2" + integrity sha512-fxNG2sQjHvlVAYmzBZS9YlDp6PTSSDwa98vkD4QgVDDCAo84z5X1t5XyJQ62ImdLXx5NdIIfihey6xpum9/gRQ== + +pascalcase@^0.1.1: + version "0.1.1" + resolved "https://registry.yarnpkg.com/pascalcase/-/pascalcase-0.1.1.tgz#b363e55e8006ca6fe21784d2db22bd15d7917f14" + integrity sha1-s2PlXoAGym/iF4TS2yK9FdeRfxQ= + +path-exists@^4.0.0: + version "4.0.0" + resolved "https://registry.yarnpkg.com/path-exists/-/path-exists-4.0.0.tgz#513bdbe2d3b95d7762e8c1137efa195c6c61b5b3" + integrity sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w== + +path-is-absolute@^1.0.0: + version "1.0.1" + resolved "https://registry.yarnpkg.com/path-is-absolute/-/path-is-absolute-1.0.1.tgz#174b9268735534ffbc7ace6bf53a5a9e1b5c5f5f" + integrity sha1-F0uSaHNVNP+8es5r9TpanhtcX18= + +path-key@^2.0.0, path-key@^2.0.1: + version "2.0.1" + resolved "https://registry.yarnpkg.com/path-key/-/path-key-2.0.1.tgz#411cadb574c5a140d3a4b1910d40d80cc9f40b40" + integrity sha1-QRyttXTFoUDTpLGRDUDYDMn0C0A= + +path-key@^3.0.0, path-key@^3.1.0: + version "3.1.1" + resolved "https://registry.yarnpkg.com/path-key/-/path-key-3.1.1.tgz#581f6ade658cbba65a0d3380de7753295054f375" + integrity sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q== + +path-parse@^1.0.6: + version "1.0.7" + resolved "https://registry.yarnpkg.com/path-parse/-/path-parse-1.0.7.tgz#fbc114b60ca42b30d9daf5858e4bd68bbedb6735" + integrity sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw== + +pend@~1.2.0: + version "1.2.0" + resolved "https://registry.yarnpkg.com/pend/-/pend-1.2.0.tgz#7a57eb550a6783f9115331fcf4663d5c8e007a50" + integrity sha1-elfrVQpng/kRUzH89GY9XI4AelA= + +performance-now@^2.1.0: + version "2.1.0" + resolved "https://registry.yarnpkg.com/performance-now/-/performance-now-2.1.0.tgz#6309f4e0e5fa913ec1c69307ae364b4b377c9e7b" + integrity sha1-Ywn04OX6kT7BxpMHrjZLSzd8nns= + +picomatch@^2.0.4, picomatch@^2.2.3: + version "2.3.0" + resolved "https://registry.yarnpkg.com/picomatch/-/picomatch-2.3.0.tgz#f1f061de8f6a4bf022892e2d128234fb98302972" + integrity sha512-lY1Q/PiJGC2zOv/z391WOTD+Z02bCgsFfvxoXXf6h7kv9o+WmsmzYqrAwY63sNgOxE4xEdq0WyUnXfKeBrSvYw== + +pirates@^4.0.1: + version "4.0.1" + resolved "https://registry.yarnpkg.com/pirates/-/pirates-4.0.1.tgz#643a92caf894566f91b2b986d2c66950a8e2fb87" + integrity sha512-WuNqLTbMI3tmfef2TKxlQmAiLHKtFhlsCZnPIpuv2Ow0RDVO8lfy1Opf4NUzlMXLjPl+Men7AuVdX6TA+s+uGA== + dependencies: + node-modules-regexp "^1.0.0" + +pixelmatch@^5.1.0: + version "5.2.1" + resolved "https://registry.yarnpkg.com/pixelmatch/-/pixelmatch-5.2.1.tgz#9e4e4f4aa59648208a31310306a5bed5522b0d65" + integrity sha512-WjcAdYSnKrrdDdqTcVEY7aB7UhhwjYQKYhHiBXdJef0MOaQeYpUdQ+iVyBLa5YBKS8MPVPPMX7rpOByISLpeEQ== + dependencies: + pngjs "^4.0.1" + +pkg-dir@^4.2.0: + version "4.2.0" + resolved "https://registry.yarnpkg.com/pkg-dir/-/pkg-dir-4.2.0.tgz#f099133df7ede422e81d1d8448270eeb3e4261f3" + integrity sha512-HRDzbaKjC+AOWVXxAU/x54COGeIv9eb+6CkDSQoNTt4XyWoIJvuPsXizxu/Fr23EiekbtZwmh1IcIG/l/a10GQ== + dependencies: + find-up "^4.0.0" + +playwright@^1.9.1: + version "1.12.3" + resolved "https://registry.yarnpkg.com/playwright/-/playwright-1.12.3.tgz#113afa2cba10fb56e9a5b307377343e32a155a99" + integrity sha512-eyhHvZV7dMAUltqjQsgJ9CjZM8dznzN1+rcfCI6W6lfQ7IlPvTFGLuKOCcI4ETbjfbxqaS5FKIkb1WDDzq2Nww== + dependencies: + commander "^6.1.0" + debug "^4.1.1" + extract-zip "^2.0.1" + https-proxy-agent "^5.0.0" + jpeg-js "^0.4.2" + mime "^2.4.6" + pngjs "^5.0.0" + progress "^2.0.3" + proper-lockfile "^4.1.1" + proxy-from-env "^1.1.0" + rimraf "^3.0.2" + stack-utils "^2.0.3" + ws "^7.4.6" + yazl "^2.5.1" + +pn@^1.1.0: + version "1.1.0" + resolved "https://registry.yarnpkg.com/pn/-/pn-1.1.0.tgz#e2f4cef0e219f463c179ab37463e4e1ecdccbafb" + integrity sha512-2qHaIQr2VLRFoxe2nASzsV6ef4yOOH+Fi9FBOVH6cqeSgUnoyySPZkxzLuzd+RYOQTRpROA0ztTMqxROKSb/nA== + +pngjs@^3.4.0: + version "3.4.0" + resolved "https://registry.yarnpkg.com/pngjs/-/pngjs-3.4.0.tgz#99ca7d725965fb655814eaf65f38f12bbdbf555f" + integrity sha512-NCrCHhWmnQklfH4MtJMRjZ2a8c80qXeMlQMv2uVp9ISJMTt562SbGd6n2oq0PaPgKm7Z6pL9E2UlLIhC+SHL3w== + +pngjs@^4.0.1: + version "4.0.1" + resolved "https://registry.yarnpkg.com/pngjs/-/pngjs-4.0.1.tgz#f803869bb2fc1bfe1bf99aa4ec21c108117cfdbe" + integrity sha512-rf5+2/ioHeQxR6IxuYNYGFytUyG3lma/WW1nsmjeHlWwtb2aByla6dkVc8pmJ9nplzkTA0q2xx7mMWrOTqT4Gg== + +pngjs@^5.0.0: + version "5.0.0" + resolved "https://registry.yarnpkg.com/pngjs/-/pngjs-5.0.0.tgz#e79dd2b215767fd9c04561c01236df960bce7fbb" + integrity sha512-40QW5YalBNfQo5yRYmiw7Yz6TKKVr3h6970B2YE+3fQpsWcrbj1PzJgxeJ19DRQjhMbKPIuMY8rFaXc8moolVw== + +portfinder@^1.0.25: + version "1.0.28" + resolved "https://registry.yarnpkg.com/portfinder/-/portfinder-1.0.28.tgz#67c4622852bd5374dd1dd900f779f53462fac778" + integrity sha512-Se+2isanIcEqf2XMHjyUKskczxbPH7dQnlMjXX6+dybayyHvAf/TCgyMRlzf/B6QDhAEFOGes0pzRo3by4AbMA== + dependencies: + async "^2.6.2" + debug "^3.1.1" + mkdirp "^0.5.5" + +posix-character-classes@^0.1.0: + version "0.1.1" + resolved "https://registry.yarnpkg.com/posix-character-classes/-/posix-character-classes-0.1.1.tgz#01eac0fe3b5af71a2a6c02feabb8c1fef7e00eab" + integrity sha1-AerA/jta9xoqbAL+q7jB/vfgDqs= + +prelude-ls@~1.1.2: + version "1.1.2" + resolved "https://registry.yarnpkg.com/prelude-ls/-/prelude-ls-1.1.2.tgz#21932a549f5e52ffd9a827f570e04be62a97da54" + integrity sha1-IZMqVJ9eUv/ZqCf1cOBL5iqX2lQ= + +pretty-format@^25.2.1, pretty-format@^25.5.0: + version "25.5.0" + resolved "https://registry.yarnpkg.com/pretty-format/-/pretty-format-25.5.0.tgz#7873c1d774f682c34b8d48b6743a2bf2ac55791a" + integrity sha512-kbo/kq2LQ/A/is0PQwsEHM7Ca6//bGPPvU6UnsdDRSKTWxT/ru/xb88v4BJf6a69H+uTytOEsTusT9ksd/1iWQ== + dependencies: + "@jest/types" "^25.5.0" + ansi-regex "^5.0.0" + ansi-styles "^4.0.0" + react-is "^16.12.0" + +progress@^2.0.3: + version "2.0.3" + resolved "https://registry.yarnpkg.com/progress/-/progress-2.0.3.tgz#7e8cf8d8f5b8f239c1bc68beb4eb78567d572ef8" + integrity sha512-7PiHtLll5LdnKIMw100I+8xJXR5gW2QwWYkT6iJva0bXitZKa/XMrSbdmg3r2Xnaidz9Qumd0VPaMrZlF9V9sA== + +prompts@^2.0.1: + version "2.4.1" + resolved "https://registry.yarnpkg.com/prompts/-/prompts-2.4.1.tgz#befd3b1195ba052f9fd2fde8a486c4e82ee77f61" + integrity sha512-EQyfIuO2hPDsX1L/blblV+H7I0knhgAd82cVneCwcdND9B8AuCDuRcBH6yIcG4dFzlOUqbazQqwGjx5xmsNLuQ== + dependencies: + kleur "^3.0.3" + sisteransi "^1.0.5" + +proper-lockfile@^4.1.1: + version "4.1.2" + resolved "https://registry.yarnpkg.com/proper-lockfile/-/proper-lockfile-4.1.2.tgz#c8b9de2af6b2f1601067f98e01ac66baa223141f" + integrity sha512-TjNPblN4BwAWMXU8s9AEz4JmQxnD1NNL7bNOY/AKUzyamc379FWASUhc/K1pL2noVb+XmZKLL68cjzLsiOAMaA== + dependencies: + graceful-fs "^4.2.4" + retry "^0.12.0" + signal-exit "^3.0.2" + +proto-list@~1.2.1: + version "1.2.4" + resolved "https://registry.yarnpkg.com/proto-list/-/proto-list-1.2.4.tgz#212d5bfe1318306a420f6402b8e26ff39647a849" + integrity sha1-IS1b/hMYMGpCD2QCuOJv85ZHqEk= + +proxy-from-env@^1.1.0: + version "1.1.0" + resolved "https://registry.yarnpkg.com/proxy-from-env/-/proxy-from-env-1.1.0.tgz#e102f16ca355424865755d2c9e8ea4f24d58c3e2" + integrity sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg== + +pseudomap@^1.0.2: + version "1.0.2" + resolved "https://registry.yarnpkg.com/pseudomap/-/pseudomap-1.0.2.tgz#f052a28da70e618917ef0a8ac34c1ae5a68286b3" + integrity sha1-8FKijacOYYkX7wqKw0wa5aaChrM= + +psl@^1.1.28: + version "1.8.0" + resolved "https://registry.yarnpkg.com/psl/-/psl-1.8.0.tgz#9326f8bcfb013adcc005fdff056acce020e51c24" + integrity sha512-RIdOzyoavK+hA18OGGWDqUTsCLhtA7IcZ/6NCs4fFJaHBDab+pDDmDIByWFRQJq2Cd7r1OoQxBGKOaztq+hjIQ== + +pump@^3.0.0: + version "3.0.0" + resolved "https://registry.yarnpkg.com/pump/-/pump-3.0.0.tgz#b4a2116815bde2f4e1ea602354e8c75565107a64" + integrity sha512-LwZy+p3SFs1Pytd/jYct4wpv49HiYCqd9Rlc5ZVdk0V+8Yzv6jR5Blk3TRmPL1ft69TxP0IMZGJ+WPFU2BFhww== + dependencies: + end-of-stream "^1.1.0" + once "^1.3.1" + +punycode@^2.1.0, punycode@^2.1.1: + version "2.1.1" + resolved "https://registry.yarnpkg.com/punycode/-/punycode-2.1.1.tgz#b58b010ac40c22c5657616c8d2c2c02c7bf479ec" + integrity sha512-XRsRjdf+j5ml+y/6GKHPZbrF/8p2Yga0JPtdqTIY2Xe5ohJPD9saDJJLPvp9+NSBprVvevdXZybnj2cv8OEd0A== + +qs@^6.4.0: + version "6.10.1" + resolved "https://registry.yarnpkg.com/qs/-/qs-6.10.1.tgz#4931482fa8d647a5aab799c5271d2133b981fb6a" + integrity sha512-M528Hph6wsSVOBiYUnGf+K/7w0hNshs/duGsNXPUCLH5XAqjEtiPGwNONLV0tBH8NoGb0mvD5JubnUTrujKDTg== + dependencies: + side-channel "^1.0.4" + +qs@~6.5.2: + version "6.5.2" + resolved "https://registry.yarnpkg.com/qs/-/qs-6.5.2.tgz#cb3ae806e8740444584ef154ce8ee98d403f3e36" + integrity sha512-N5ZAX4/LxJmF+7wN74pUD6qAh9/wnvdQcjq9TZjevvXzSUo7bfmw91saqMjzGS2xq91/odN2dW/WOl7qQHNDGA== + +quick-lru@^4.0.1: + version "4.0.1" + resolved "https://registry.yarnpkg.com/quick-lru/-/quick-lru-4.0.1.tgz#5b8878f113a58217848c6482026c73e1ba57727f" + integrity sha512-ARhCpm70fzdcvNQfPoy49IaanKkTlRWF2JMzqhcJbhSFRZv7nPTvZJdcY7301IPmvW+/p0RgIWnQDLJxifsQ7g== + +react-is@^16.12.0: + version "16.13.1" + resolved "https://registry.yarnpkg.com/react-is/-/react-is-16.13.1.tgz#789729a4dc36de2999dc156dd6c1d9c18cea56a4" + integrity sha512-24e6ynE2H+OKt4kqsOvNd8kBpV65zoxbA4BVsEOB3ARVWQki/DHzaUoC5KuON/BiccDaCCTZBuOcfZs70kR8bQ== + +read-pkg-up@^7.0.1: + version "7.0.1" + resolved "https://registry.yarnpkg.com/read-pkg-up/-/read-pkg-up-7.0.1.tgz#f3a6135758459733ae2b95638056e1854e7ef507" + integrity sha512-zK0TB7Xd6JpCLmlLmufqykGE+/TlOePD6qKClNW7hHDKFh/J7/7gCWGR7joEQEW1bKq3a3yUZSObOoWLFQ4ohg== + dependencies: + find-up "^4.1.0" + read-pkg "^5.2.0" + type-fest "^0.8.1" + +read-pkg@^5.2.0: + version "5.2.0" + resolved "https://registry.yarnpkg.com/read-pkg/-/read-pkg-5.2.0.tgz#7bf295438ca5a33e56cd30e053b34ee7250c93cc" + integrity sha512-Ug69mNOpfvKDAc2Q8DRpMjjzdtrnv9HcSMX+4VsZxD1aZ6ZzrIE7rlzXBtWTyhULSMKg076AW6WR5iZpD0JiOg== + dependencies: + "@types/normalize-package-data" "^2.4.0" + normalize-package-data "^2.5.0" + parse-json "^5.0.0" + type-fest "^0.6.0" + +realpath-native@^2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/realpath-native/-/realpath-native-2.0.0.tgz#7377ac429b6e1fd599dc38d08ed942d0d7beb866" + integrity sha512-v1SEYUOXXdbBZK8ZuNgO4TBjamPsiSgcFr0aP+tEKpQZK8vooEUqV6nm6Cv502mX4NF2EfsnVqtNAHG+/6Ur1Q== + +redent@^3.0.0: + version "3.0.0" + resolved "https://registry.yarnpkg.com/redent/-/redent-3.0.0.tgz#e557b7998316bb53c9f1f56fa626352c6963059f" + integrity sha512-6tDA8g98We0zd0GvVeMT9arEOnTw9qM03L9cJXaCjrip1OO764RDBLBfrB4cwzNGDj5OA5ioymC9GkizgWJDUg== + dependencies: + indent-string "^4.0.0" + strip-indent "^3.0.0" + +regex-not@^1.0.0, regex-not@^1.0.2: + version "1.0.2" + resolved "https://registry.yarnpkg.com/regex-not/-/regex-not-1.0.2.tgz#1f4ece27e00b0b65e0247a6810e6a85d83a5752c" + integrity sha512-J6SDjUgDxQj5NusnOtdFxDwN/+HWykR8GELwctJ7mdqhcyy1xEc4SRFHUXvxTp661YaVKAjfRLZ9cCqS6tn32A== + dependencies: + extend-shallow "^3.0.2" + safe-regex "^1.1.0" + +remove-trailing-separator@^1.0.1: + version "1.1.0" + resolved "https://registry.yarnpkg.com/remove-trailing-separator/-/remove-trailing-separator-1.1.0.tgz#c24bce2a283adad5bc3f58e0d48249b92379d8ef" + integrity sha1-wkvOKig62tW8P1jg1IJJuSN52O8= + +repeat-element@^1.1.2: + version "1.1.4" + resolved "https://registry.yarnpkg.com/repeat-element/-/repeat-element-1.1.4.tgz#be681520847ab58c7568ac75fbfad28ed42d39e9" + integrity sha512-LFiNfRcSu7KK3evMyYOuCzv3L10TW7yC1G2/+StMjK8Y6Vqd2MG7r/Qjw4ghtuCOjFvlnms/iMmLqpvW/ES/WQ== + +repeat-string@^1.6.1: + version "1.6.1" + resolved "https://registry.yarnpkg.com/repeat-string/-/repeat-string-1.6.1.tgz#8dcae470e1c88abc2d600fff4a776286da75e637" + integrity sha1-jcrkcOHIirwtYA//Sndihtp15jc= + +request-promise-core@1.1.4: + version "1.1.4" + resolved "https://registry.yarnpkg.com/request-promise-core/-/request-promise-core-1.1.4.tgz#3eedd4223208d419867b78ce815167d10593a22f" + integrity sha512-TTbAfBBRdWD7aNNOoVOBH4pN/KigV6LyapYNNlAPA8JwbovRti1E88m3sYAwsLi5ryhPKsE9APwnjFTgdUjTpw== + dependencies: + lodash "^4.17.19" + +request-promise-native@^1.0.7: + version "1.0.9" + resolved "https://registry.yarnpkg.com/request-promise-native/-/request-promise-native-1.0.9.tgz#e407120526a5efdc9a39b28a5679bf47b9d9dc28" + integrity sha512-wcW+sIUiWnKgNY0dqCpOZkUbF/I+YPi+f09JZIDa39Ec+q82CpSYniDp+ISgTTbKmnpJWASeJBPZmoxH84wt3g== + dependencies: + request-promise-core "1.1.4" + stealthy-require "^1.1.1" + tough-cookie "^2.3.3" + +request@^2.88.0: + version "2.88.2" + resolved "https://registry.yarnpkg.com/request/-/request-2.88.2.tgz#d73c918731cb5a87da047e207234146f664d12b3" + integrity sha512-MsvtOrfG9ZcrOwAW+Qi+F6HbD0CWXEh9ou77uOb7FM2WPhwT7smM833PzanhJLsgXjN89Ir6V2PczXNnMpwKhw== + dependencies: + aws-sign2 "~0.7.0" + aws4 "^1.8.0" + caseless "~0.12.0" + combined-stream "~1.0.6" + extend "~3.0.2" + forever-agent "~0.6.1" + form-data "~2.3.2" + har-validator "~5.1.3" + http-signature "~1.2.0" + is-typedarray "~1.0.0" + isstream "~0.1.2" + json-stringify-safe "~5.0.1" + mime-types "~2.1.19" + oauth-sign "~0.9.0" + performance-now "^2.1.0" + qs "~6.5.2" + safe-buffer "^5.1.2" + tough-cookie "~2.5.0" + tunnel-agent "^0.6.0" + uuid "^3.3.2" + +require-directory@^2.1.1: + version "2.1.1" + resolved "https://registry.yarnpkg.com/require-directory/-/require-directory-2.1.1.tgz#8c64ad5fd30dab1c976e2344ffe7f792a6a6df42" + integrity sha1-jGStX9MNqxyXbiNE/+f3kqam30I= + +require-main-filename@^2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/require-main-filename/-/require-main-filename-2.0.0.tgz#d0b329ecc7cc0f61649f62215be69af54aa8989b" + integrity sha512-NKN5kMDylKuldxYLSUfrbo5Tuzh4hd+2E8NPPX02mZtn1VuREQToYe/ZdlJy+J3uCpfaiGF05e7B8W0iXbQHmg== + +requires-port@^1.0.0: + version "1.0.0" + resolved "https://registry.yarnpkg.com/requires-port/-/requires-port-1.0.0.tgz#925d2601d39ac485e091cf0da5c6e694dc3dcaff" + integrity sha1-kl0mAdOaxIXgkc8NpcbmlNw9yv8= + +resolve-cwd@^3.0.0: + version "3.0.0" + resolved "https://registry.yarnpkg.com/resolve-cwd/-/resolve-cwd-3.0.0.tgz#0f0075f1bb2544766cf73ba6a6e2adfebcb13f2d" + integrity sha512-OrZaX2Mb+rJCpH/6CpSqt9xFVpN++x01XnN2ie9g6P5/3xelLAkXWVADpdz1IHD/KFfEXyE6V0U01OQ3UO2rEg== + dependencies: + resolve-from "^5.0.0" + +resolve-from@^5.0.0: + version "5.0.0" + resolved "https://registry.yarnpkg.com/resolve-from/-/resolve-from-5.0.0.tgz#c35225843df8f776df21c57557bc087e9dfdfc69" + integrity sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw== + +resolve-url@^0.2.1: + version "0.2.1" + resolved "https://registry.yarnpkg.com/resolve-url/-/resolve-url-0.2.1.tgz#2c637fe77c893afd2a663fe21aa9080068e2052a" + integrity sha1-LGN/53yJOv0qZj/iGqkIAGjiBSo= + +resolve@1.1.7: + version "1.1.7" + resolved "https://registry.yarnpkg.com/resolve/-/resolve-1.1.7.tgz#203114d82ad2c5ed9e8e0411b3932875e889e97b" + integrity sha1-IDEU2CrSxe2ejgQRs5ModeiJ6Xs= + +resolve@^1.10.0, resolve@^1.17.0: + version "1.20.0" + resolved "https://registry.yarnpkg.com/resolve/-/resolve-1.20.0.tgz#629a013fb3f70755d6f0b7935cc1c2c5378b1975" + integrity sha512-wENBPt4ySzg4ybFQW2TT1zMQucPK95HSh/nq2CFTZVOGut2+pQvSsgtda4d26YrYcr067wjbmzOG8byDPBX63A== + dependencies: + is-core-module "^2.2.0" + path-parse "^1.0.6" + +restore-cursor@^3.1.0: + version "3.1.0" + resolved "https://registry.yarnpkg.com/restore-cursor/-/restore-cursor-3.1.0.tgz#39f67c54b3a7a58cea5236d95cf0034239631f7e" + integrity sha512-l+sSefzHpj5qimhFSE5a8nufZYAM3sBSVMAPtYkmC+4EH2anSGaEMXSD0izRQbu9nfyQ9y5JrVmp7E8oZrUjvA== + dependencies: + onetime "^5.1.0" + signal-exit "^3.0.2" + +ret@~0.1.10: + version "0.1.15" + resolved "https://registry.yarnpkg.com/ret/-/ret-0.1.15.tgz#b8a4825d5bdb1fc3f6f53c2bc33f81388681c7bc" + integrity sha512-TTlYpa+OL+vMMNG24xSlQGEJ3B/RzEfUlLct7b5G/ytav+wPrplCpVMFuwzXbkecJrb6IYo1iFb0S9v37754mg== + +retry@^0.12.0: + version "0.12.0" + resolved "https://registry.yarnpkg.com/retry/-/retry-0.12.0.tgz#1b42a6266a21f07421d1b0b54b7dc167b01c013b" + integrity sha1-G0KmJmoh8HQh0bC1S33BZ7AcATs= + +rimraf@^3.0.0, rimraf@^3.0.2: + version "3.0.2" + resolved "https://registry.yarnpkg.com/rimraf/-/rimraf-3.0.2.tgz#f1a5402ba6220ad52cc1282bac1ae3aa49fd061a" + integrity sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA== + dependencies: + glob "^7.1.3" + +rsvp@^4.8.4: + version "4.8.5" + resolved "https://registry.yarnpkg.com/rsvp/-/rsvp-4.8.5.tgz#c8f155311d167f68f21e168df71ec5b083113734" + integrity sha512-nfMOlASu9OnRJo1mbEk2cz0D56a1MBNrJ7orjRZQG10XDyuvwksKbuXNp6qa+kbn839HwjwhBzhFmdsaEAfauA== + +run-async@^2.4.0: + version "2.4.1" + resolved "https://registry.yarnpkg.com/run-async/-/run-async-2.4.1.tgz#8440eccf99ea3e70bd409d49aab88e10c189a455" + integrity sha512-tvVnVv01b8c1RrA6Ep7JkStj85Guv/YrMcwqYQnwjsAS2cTmmPGBBjAjpCW7RrSodNSoE2/qg9O4bceNvUuDgQ== + +rxjs@^6.6.0: + version "6.6.7" + resolved "https://registry.yarnpkg.com/rxjs/-/rxjs-6.6.7.tgz#90ac018acabf491bf65044235d5863c4dab804c9" + integrity sha512-hTdwr+7yYNIT5n4AMYp85KA6yw2Va0FLa3Rguvbpa4W3I5xynaBZo41cM3XM+4Q6fRMj3sBYIR1VAmZMXYJvRQ== + dependencies: + tslib "^1.9.0" + +safe-buffer@^5.0.1, safe-buffer@^5.1.2: + version "5.2.1" + resolved "https://registry.yarnpkg.com/safe-buffer/-/safe-buffer-5.2.1.tgz#1eaf9fa9bdb1fdd4ec75f58f9cdb4e6b7827eec6" + integrity sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ== + +safe-buffer@~5.1.1: + version "5.1.2" + resolved "https://registry.yarnpkg.com/safe-buffer/-/safe-buffer-5.1.2.tgz#991ec69d296e0313747d59bdfd2b745c35f8828d" + integrity sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g== + +safe-regex@^1.1.0: + version "1.1.0" + resolved "https://registry.yarnpkg.com/safe-regex/-/safe-regex-1.1.0.tgz#40a3669f3b077d1e943d44629e157dd48023bf2e" + integrity sha1-QKNmnzsHfR6UPURinhV91IAjvy4= + dependencies: + ret "~0.1.10" + +"safer-buffer@>= 2.1.2 < 3", safer-buffer@^2.0.2, safer-buffer@^2.1.0, safer-buffer@~2.1.0: + version "2.1.2" + resolved "https://registry.yarnpkg.com/safer-buffer/-/safer-buffer-2.1.2.tgz#44fa161b0187b9549dd84bb91802f9bd8385cd6a" + integrity sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg== + +sane@^4.0.3: + version "4.1.0" + resolved "https://registry.yarnpkg.com/sane/-/sane-4.1.0.tgz#ed881fd922733a6c461bc189dc2b6c006f3ffded" + integrity sha512-hhbzAgTIX8O7SHfp2c8/kREfEn4qO/9q8C9beyY6+tvZ87EpoZ3i1RIEvp27YBswnNbY9mWd6paKVmKbAgLfZA== + dependencies: + "@cnakazawa/watch" "^1.0.3" + anymatch "^2.0.0" + capture-exit "^2.0.0" + exec-sh "^0.3.2" + execa "^1.0.0" + fb-watchman "^2.0.0" + micromatch "^3.1.4" + minimist "^1.1.1" + walker "~1.0.5" + +saxes@^3.1.9: + version "3.1.11" + resolved "https://registry.yarnpkg.com/saxes/-/saxes-3.1.11.tgz#d59d1fd332ec92ad98a2e0b2ee644702384b1c5b" + integrity sha512-Ydydq3zC+WYDJK1+gRxRapLIED9PWeSuuS41wqyoRmzvhhh9nc+QQrVMKJYzJFULazeGhzSV0QleN2wD3boh2g== + dependencies: + xmlchars "^2.1.1" + +secure-compare@3.0.1: + version "3.0.1" + resolved "https://registry.yarnpkg.com/secure-compare/-/secure-compare-3.0.1.tgz#f1a0329b308b221fae37b9974f3d578d0ca999e3" + integrity sha1-8aAymzCLIh+uN7mXTz1XjQypmeM= + +"semver@2 || 3 || 4 || 5", semver@^5.5.0, semver@^5.6.0: + version "5.7.1" + resolved "https://registry.yarnpkg.com/semver/-/semver-5.7.1.tgz#a954f931aeba508d307bbf069eff0c01c96116f7" + integrity sha512-sauaDf/PZdVgrLTNYHRtpXa1iRiKcaebiKQ1BJdpQlWH2lCvexQdX55snPFyK7QzpudqbCI0qXFfOasHdyNDGQ== + +semver@6.x, semver@^6.0.0, semver@^6.3.0: + version "6.3.0" + resolved "https://registry.yarnpkg.com/semver/-/semver-6.3.0.tgz#ee0a64c8af5e8ceea67687b133761e1becbd1d3d" + integrity sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw== + +semver@^7.3.2: + version "7.3.5" + resolved "https://registry.yarnpkg.com/semver/-/semver-7.3.5.tgz#0b621c879348d8998e4b0e4be94b3f12e6018ef7" + integrity sha512-PoeGJYh8HK4BTO/a9Tf6ZG3veo/A7ZVsYrSA6J8ny9nb3B1VrpkuN+z9OE5wfE5p6H4LchYZsegiQgbJD94ZFQ== + dependencies: + lru-cache "^6.0.0" + +set-blocking@^2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/set-blocking/-/set-blocking-2.0.0.tgz#045f9782d011ae9a6803ddd382b24392b3d890f7" + integrity sha1-BF+XgtARrppoA93TgrJDkrPYkPc= + +set-value@^2.0.0, set-value@^2.0.1: + version "2.0.1" + resolved "https://registry.yarnpkg.com/set-value/-/set-value-2.0.1.tgz#a18d40530e6f07de4228c7defe4227af8cad005b" + integrity sha512-JxHc1weCN68wRY0fhCoXpyK55m/XPHafOmK4UWD7m2CI14GMcFypt4w/0+NV5f/ZMby2F6S2wwA7fgynh9gWSw== + dependencies: + extend-shallow "^2.0.1" + is-extendable "^0.1.1" + is-plain-object "^2.0.3" + split-string "^3.0.1" + +shebang-command@^1.2.0: + version "1.2.0" + resolved "https://registry.yarnpkg.com/shebang-command/-/shebang-command-1.2.0.tgz#44aac65b695b03398968c39f363fee5deafdf1ea" + integrity sha1-RKrGW2lbAzmJaMOfNj/uXer98eo= + dependencies: + shebang-regex "^1.0.0" + +shebang-command@^2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/shebang-command/-/shebang-command-2.0.0.tgz#ccd0af4f8835fbdc265b82461aaf0c36663f34ea" + integrity sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA== + dependencies: + shebang-regex "^3.0.0" + +shebang-regex@^1.0.0: + version "1.0.0" + resolved "https://registry.yarnpkg.com/shebang-regex/-/shebang-regex-1.0.0.tgz#da42f49740c0b42db2ca9728571cb190c98efea3" + integrity sha1-2kL0l0DAtC2yypcoVxyxkMmO/qM= + +shebang-regex@^3.0.0: + version "3.0.0" + resolved "https://registry.yarnpkg.com/shebang-regex/-/shebang-regex-3.0.0.tgz#ae16f1644d873ecad843b0307b143362d4c42172" + integrity sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A== + +shellwords@^0.1.1: + version "0.1.1" + resolved "https://registry.yarnpkg.com/shellwords/-/shellwords-0.1.1.tgz#d6b9181c1a48d397324c84871efbcfc73fc0654b" + integrity sha512-vFwSUfQvqybiICwZY5+DAWIPLKsWO31Q91JSKl3UYv+K5c2QRPzn0qzec6QPu1Qc9eHYItiP3NdJqNVqetYAww== + +side-channel@^1.0.4: + version "1.0.4" + resolved "https://registry.yarnpkg.com/side-channel/-/side-channel-1.0.4.tgz#efce5c8fdc104ee751b25c58d4290011fa5ea2cf" + integrity sha512-q5XPytqFEIKHkGdiMIrY10mvLRvnQh42/+GoBlFW3b2LXLE2xxJpZFdm94we0BaoV3RwJyGqg5wS7epxTv0Zvw== + dependencies: + call-bind "^1.0.0" + get-intrinsic "^1.0.2" + object-inspect "^1.9.0" + +sigmund@^1.0.1: + version "1.0.1" + resolved "https://registry.yarnpkg.com/sigmund/-/sigmund-1.0.1.tgz#3ff21f198cad2175f9f3b781853fd94d0d19b590" + integrity sha1-P/IfGYytIXX587eBhT/ZTQ0ZtZA= + +signal-exit@^3.0.0, signal-exit@^3.0.2: + version "3.0.3" + resolved "https://registry.yarnpkg.com/signal-exit/-/signal-exit-3.0.3.tgz#a1410c2edd8f077b08b4e253c8eacfcaf057461c" + integrity sha512-VUJ49FC8U1OxwZLxIbTTrDvLnf/6TDgxZcK8wxR8zs13xpx7xbG60ndBlhNrFi2EMuFRoeDoJO7wthSLq42EjA== + +sisteransi@^1.0.5: + version "1.0.5" + resolved "https://registry.yarnpkg.com/sisteransi/-/sisteransi-1.0.5.tgz#134d681297756437cc05ca01370d3a7a571075ed" + integrity sha512-bLGGlR1QxBcynn2d5YmDX4MGjlZvy2MRBDRNHLJ8VI6l6+9FUiyTFNJ0IveOSP0bcXgVDPRcfGqA0pjaqUpfVg== + +slash@^3.0.0: + version "3.0.0" + resolved "https://registry.yarnpkg.com/slash/-/slash-3.0.0.tgz#6539be870c165adbd5240220dbe361f1bc4d4634" + integrity sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q== + +snapdragon-node@^2.0.1: + version "2.1.1" + resolved "https://registry.yarnpkg.com/snapdragon-node/-/snapdragon-node-2.1.1.tgz#6c175f86ff14bdb0724563e8f3c1b021a286853b" + integrity sha512-O27l4xaMYt/RSQ5TR3vpWCAB5Kb/czIcqUFOM/C4fYcLnbZUc1PkjTAMjof2pBWaSTwOUd6qUHcFGVGj7aIwnw== + dependencies: + define-property "^1.0.0" + isobject "^3.0.0" + snapdragon-util "^3.0.1" + +snapdragon-util@^3.0.1: + version "3.0.1" + resolved "https://registry.yarnpkg.com/snapdragon-util/-/snapdragon-util-3.0.1.tgz#f956479486f2acd79700693f6f7b805e45ab56e2" + integrity sha512-mbKkMdQKsjX4BAL4bRYTj21edOf8cN7XHdYUJEe+Zn99hVEYcMvKPct1IqNe7+AZPirn8BCDOQBHQZknqmKlZQ== + dependencies: + kind-of "^3.2.0" + +snapdragon@^0.8.1: + version "0.8.2" + resolved "https://registry.yarnpkg.com/snapdragon/-/snapdragon-0.8.2.tgz#64922e7c565b0e14204ba1aa7d6964278d25182d" + integrity sha512-FtyOnWN/wCHTVXOMwvSv26d+ko5vWlIDD6zoUJ7LW8vh+ZBC8QdljveRP+crNrtBwioEUWy/4dMtbBjA4ioNlg== + dependencies: + base "^0.11.1" + debug "^2.2.0" + define-property "^0.2.5" + extend-shallow "^2.0.1" + map-cache "^0.2.2" + source-map "^0.5.6" + source-map-resolve "^0.5.0" + use "^3.1.0" + +source-map-resolve@^0.5.0: + version "0.5.3" + resolved "https://registry.yarnpkg.com/source-map-resolve/-/source-map-resolve-0.5.3.tgz#190866bece7553e1f8f267a2ee82c606b5509a1a" + integrity sha512-Htz+RnsXWk5+P2slx5Jh3Q66vhQj1Cllm0zvnaY98+NFx+Dv2CF/f5O/t8x+KaNdrdIAsruNzoh/KpialbqAnw== + dependencies: + atob "^2.1.2" + decode-uri-component "^0.2.0" + resolve-url "^0.2.1" + source-map-url "^0.4.0" + urix "^0.1.0" + +source-map-support@^0.5.6: + version "0.5.19" + resolved "https://registry.yarnpkg.com/source-map-support/-/source-map-support-0.5.19.tgz#a98b62f86dcaf4f67399648c085291ab9e8fed61" + integrity sha512-Wonm7zOCIJzBGQdB+thsPar0kYuCIzYvxZwlBa87yi/Mdjv7Tip2cyVbLj5o0cFPN4EVkuTwb3GDDyUx2DGnGw== + dependencies: + buffer-from "^1.0.0" + source-map "^0.6.0" + +source-map-url@^0.4.0: + version "0.4.1" + resolved "https://registry.yarnpkg.com/source-map-url/-/source-map-url-0.4.1.tgz#0af66605a745a5a2f91cf1bbf8a7afbc283dec56" + integrity sha512-cPiFOTLUKvJFIg4SKVScy4ilPPW6rFgMgfuZJPNoDuMs3nC1HbMUycBoJw77xFIp6z1UJQJOfx6C9GMH80DiTw== + +source-map@^0.5.0, source-map@^0.5.6: + version "0.5.7" + resolved "https://registry.yarnpkg.com/source-map/-/source-map-0.5.7.tgz#8a039d2d1021d22d1ea14c80d8ea468ba2ef3fcc" + integrity sha1-igOdLRAh0i0eoUyA2OpGi6LvP8w= + +source-map@^0.6.0, source-map@^0.6.1, source-map@~0.6.1: + version "0.6.1" + resolved "https://registry.yarnpkg.com/source-map/-/source-map-0.6.1.tgz#74722af32e9614e9c287a8d0bbde48b5e2f1a263" + integrity sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g== + +source-map@^0.7.3: + version "0.7.3" + resolved "https://registry.yarnpkg.com/source-map/-/source-map-0.7.3.tgz#5302f8169031735226544092e64981f751750383" + integrity sha512-CkCj6giN3S+n9qrYiBTX5gystlENnRW5jZeNLHpe6aue+SrHcG5VYwujhW9s4dY31mEGsxBDrHR6oI69fTXsaQ== + +spdx-correct@^3.0.0: + version "3.1.1" + resolved "https://registry.yarnpkg.com/spdx-correct/-/spdx-correct-3.1.1.tgz#dece81ac9c1e6713e5f7d1b6f17d468fa53d89a9" + integrity sha512-cOYcUWwhCuHCXi49RhFRCyJEK3iPj1Ziz9DpViV3tbZOwXD49QzIN3MpOLJNxh2qwq2lJJZaKMVw9qNi4jTC0w== + dependencies: + spdx-expression-parse "^3.0.0" + spdx-license-ids "^3.0.0" + +spdx-exceptions@^2.1.0: + version "2.3.0" + resolved "https://registry.yarnpkg.com/spdx-exceptions/-/spdx-exceptions-2.3.0.tgz#3f28ce1a77a00372683eade4a433183527a2163d" + integrity sha512-/tTrYOC7PPI1nUAgx34hUpqXuyJG+DTHJTnIULG4rDygi4xu/tfgmq1e1cIRwRzwZgo4NLySi+ricLkZkw4i5A== + +spdx-expression-parse@^3.0.0: + version "3.0.1" + resolved "https://registry.yarnpkg.com/spdx-expression-parse/-/spdx-expression-parse-3.0.1.tgz#cf70f50482eefdc98e3ce0a6833e4a53ceeba679" + integrity sha512-cbqHunsQWnJNE6KhVSMsMeH5H/L9EpymbzqTQ3uLwNCLZ1Q481oWaofqH7nO6V07xlXwY6PhQdQ2IedWx/ZK4Q== + dependencies: + spdx-exceptions "^2.1.0" + spdx-license-ids "^3.0.0" + +spdx-license-ids@^3.0.0: + version "3.0.9" + resolved "https://registry.yarnpkg.com/spdx-license-ids/-/spdx-license-ids-3.0.9.tgz#8a595135def9592bda69709474f1cbeea7c2467f" + integrity sha512-Ki212dKK4ogX+xDo4CtOZBVIwhsKBEfsEEcwmJfLQzirgc2jIWdzg40Unxz/HzEUqM1WFzVlQSMF9kZZ2HboLQ== + +split-string@^3.0.1, split-string@^3.0.2: + version "3.1.0" + resolved "https://registry.yarnpkg.com/split-string/-/split-string-3.1.0.tgz#7cb09dda3a86585705c64b39a6466038682e8fe2" + integrity sha512-NzNVhJDYpwceVVii8/Hu6DKfD2G+NrQHlS/V/qgv763EYudVwEcMQNxd2lh+0VrUByXN/oJkl5grOhYWvQUYiw== + dependencies: + extend-shallow "^3.0.0" + +sprintf-js@~1.0.2: + version "1.0.3" + resolved "https://registry.yarnpkg.com/sprintf-js/-/sprintf-js-1.0.3.tgz#04e6926f662895354f3dd015203633b857297e2c" + integrity sha1-BOaSb2YolTVPPdAVIDYzuFcpfiw= + +sshpk@^1.7.0: + version "1.16.1" + resolved "https://registry.yarnpkg.com/sshpk/-/sshpk-1.16.1.tgz#fb661c0bef29b39db40769ee39fa70093d6f6877" + integrity sha512-HXXqVUq7+pcKeLqqZj6mHFUMvXtOJt1uoUx09pFW6011inTMxqI8BA8PM95myrIyyKwdnzjdFjLiE6KBPVtJIg== + dependencies: + asn1 "~0.2.3" + assert-plus "^1.0.0" + bcrypt-pbkdf "^1.0.0" + dashdash "^1.12.0" + ecc-jsbn "~0.1.1" + getpass "^0.1.1" + jsbn "~0.1.0" + safer-buffer "^2.0.2" + tweetnacl "~0.14.0" + +stack-utils@^1.0.1: + version "1.0.5" + resolved "https://registry.yarnpkg.com/stack-utils/-/stack-utils-1.0.5.tgz#a19b0b01947e0029c8e451d5d61a498f5bb1471b" + integrity sha512-KZiTzuV3CnSnSvgMRrARVCj+Ht7rMbauGDK0LdVFRGyenwdylpajAp4Q0i6SX8rEmbTpMMf6ryq2gb8pPq2WgQ== + dependencies: + escape-string-regexp "^2.0.0" + +stack-utils@^2.0.3: + version "2.0.3" + resolved "https://registry.yarnpkg.com/stack-utils/-/stack-utils-2.0.3.tgz#cd5f030126ff116b78ccb3c027fe302713b61277" + integrity sha512-gL//fkxfWUsIlFL2Tl42Cl6+HFALEaB1FU76I/Fy+oZjRreP7OPMXFlGbxM7NQsI0ZpUfw76sHnv0WNYuTb7Iw== + dependencies: + escape-string-regexp "^2.0.0" + +static-extend@^0.1.1: + version "0.1.2" + resolved "https://registry.yarnpkg.com/static-extend/-/static-extend-0.1.2.tgz#60809c39cbff55337226fd5e0b520f341f1fb5c6" + integrity sha1-YICcOcv/VTNyJv1eC1IPNB8ftcY= + dependencies: + define-property "^0.2.5" + object-copy "^0.1.0" + +stealthy-require@^1.1.1: + version "1.1.1" + resolved "https://registry.yarnpkg.com/stealthy-require/-/stealthy-require-1.1.1.tgz#35b09875b4ff49f26a777e509b3090a3226bf24b" + integrity sha1-NbCYdbT/SfJqd35QmzCQoyJr8ks= + +string-length@^3.1.0: + version "3.1.0" + resolved "https://registry.yarnpkg.com/string-length/-/string-length-3.1.0.tgz#107ef8c23456e187a8abd4a61162ff4ac6e25837" + integrity sha512-Ttp5YvkGm5v9Ijagtaz1BnN+k9ObpvS0eIBblPMp2YWL8FBmi9qblQ9fexc2k/CXFgrTIteU3jAw3payCnwSTA== + dependencies: + astral-regex "^1.0.0" + strip-ansi "^5.2.0" + +string-width@^4.1.0, string-width@^4.2.0: + version "4.2.2" + resolved "https://registry.yarnpkg.com/string-width/-/string-width-4.2.2.tgz#dafd4f9559a7585cfba529c6a0a4f73488ebd4c5" + integrity sha512-XBJbT3N4JhVumXE0eoLU9DCjcaF92KLNqTmFCnG1pf8duUxFGwtP6AD6nkjw9a3IdiRtL3E2w3JDiE/xi3vOeA== + dependencies: + emoji-regex "^8.0.0" + is-fullwidth-code-point "^3.0.0" + strip-ansi "^6.0.0" + +strip-ansi@^5.2.0: + version "5.2.0" + resolved "https://registry.yarnpkg.com/strip-ansi/-/strip-ansi-5.2.0.tgz#8c9a536feb6afc962bdfa5b104a5091c1ad9c0ae" + integrity sha512-DuRs1gKbBqsMKIZlrffwlug8MHkcnpjs5VPmL1PAh+mA30U0DTotfDZ0d2UUsXpPmPmMMJ6W773MaA3J+lbiWA== + dependencies: + ansi-regex "^4.1.0" + +strip-ansi@^6.0.0: + version "6.0.0" + resolved "https://registry.yarnpkg.com/strip-ansi/-/strip-ansi-6.0.0.tgz#0b1571dd7669ccd4f3e06e14ef1eed26225ae532" + integrity sha512-AuvKTrTfQNYNIctbR1K/YGTR1756GycPsg7b9bdV9Duqur4gv6aKqHXah67Z8ImS7WEz5QVcOtlfW2rZEugt6w== + dependencies: + ansi-regex "^5.0.0" + +strip-bom@^4.0.0: + version "4.0.0" + resolved "https://registry.yarnpkg.com/strip-bom/-/strip-bom-4.0.0.tgz#9c3505c1db45bcedca3d9cf7a16f5c5aa3901878" + integrity sha512-3xurFv5tEgii33Zi8Jtp55wEIILR9eh34FAW00PZf+JnSsTmV/ioewSgQl97JHvgjoRGwPShsWm+IdrxB35d0w== + +strip-eof@^1.0.0: + version "1.0.0" + resolved "https://registry.yarnpkg.com/strip-eof/-/strip-eof-1.0.0.tgz#bb43ff5598a6eb05d89b59fcd129c983313606bf" + integrity sha1-u0P/VZim6wXYm1n80SnJgzE2Br8= + +strip-final-newline@^2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/strip-final-newline/-/strip-final-newline-2.0.0.tgz#89b852fb2fcbe936f6f4b3187afb0a12c1ab58ad" + integrity sha512-BrpvfNAE3dcvq7ll3xVumzjKjZQ5tI1sEUIKr3Uoks0XUl45St3FlatVqef9prk4jRDzhW6WZg+3bk93y6pLjA== + +strip-indent@^3.0.0: + version "3.0.0" + resolved "https://registry.yarnpkg.com/strip-indent/-/strip-indent-3.0.0.tgz#c32e1cee940b6b3432c771bc2c54bcce73cd3001" + integrity sha512-laJTa3Jb+VQpaC6DseHhF7dXVqHTfJPCRDaEbid/drOhgitgYku/letMUqOXFoWV0zIIUbjpdH2t+tYj4bQMRQ== + dependencies: + min-indent "^1.0.0" + +supports-color@^5.3.0: + version "5.5.0" + resolved "https://registry.yarnpkg.com/supports-color/-/supports-color-5.5.0.tgz#e2e69a44ac8772f78a1ec0b35b689df6530efc8f" + integrity sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow== + dependencies: + has-flag "^3.0.0" + +supports-color@^7.0.0, supports-color@^7.1.0: + version "7.2.0" + resolved "https://registry.yarnpkg.com/supports-color/-/supports-color-7.2.0.tgz#1b7dcdcb32b8138801b3e478ba6a51caa89648da" + integrity sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw== + dependencies: + has-flag "^4.0.0" + +supports-hyperlinks@^2.0.0: + version "2.2.0" + resolved "https://registry.yarnpkg.com/supports-hyperlinks/-/supports-hyperlinks-2.2.0.tgz#4f77b42488765891774b70c79babd87f9bd594bb" + integrity sha512-6sXEzV5+I5j8Bmq9/vUphGRM/RJNT9SCURJLjwfOg51heRtguGWDzcaBlgAzKhQa0EVNpPEKzQuBwZ8S8WaCeQ== + dependencies: + has-flag "^4.0.0" + supports-color "^7.0.0" + +symbol-tree@^3.2.2: + version "3.2.4" + resolved "https://registry.yarnpkg.com/symbol-tree/-/symbol-tree-3.2.4.tgz#430637d248ba77e078883951fb9aa0eed7c63fa2" + integrity sha512-9QNk5KwDF+Bvz+PyObkmSYjI5ksVUYtjW7AU22r2NKcfLJcXp96hkDWU3+XndOsUb+AQ9QhfzfCT2O+CNWT5Tw== + +terminal-link@^2.0.0: + version "2.1.1" + resolved "https://registry.yarnpkg.com/terminal-link/-/terminal-link-2.1.1.tgz#14a64a27ab3c0df933ea546fba55f2d078edc994" + integrity sha512-un0FmiRUQNr5PJqy9kP7c40F5BOfpGlYTrxonDChEZB7pzZxRNp/bt+ymiy9/npwXya9KH99nJ/GXFIiUkYGFQ== + dependencies: + ansi-escapes "^4.2.1" + supports-hyperlinks "^2.0.0" + +test-exclude@^6.0.0: + version "6.0.0" + resolved "https://registry.yarnpkg.com/test-exclude/-/test-exclude-6.0.0.tgz#04a8698661d805ea6fa293b6cb9e63ac044ef15e" + integrity sha512-cAGWPIyOHU6zlmg88jwm7VRyXnMN7iV68OGAbYDk/Mh/xC/pzVPlQtY6ngoIH/5/tciuhGfvESU8GrHrcxD56w== + dependencies: + "@istanbuljs/schema" "^0.1.2" + glob "^7.1.4" + minimatch "^3.0.4" + +throat@^5.0.0: + version "5.0.0" + resolved "https://registry.yarnpkg.com/throat/-/throat-5.0.0.tgz#c5199235803aad18754a667d659b5e72ce16764b" + integrity sha512-fcwX4mndzpLQKBS1DVYhGAcYaYt7vsHNIvQV+WXMvnow5cgjPphq5CaayLaGsjRdSCKZFNGt7/GYAuXaNOiYCA== + +through@^2.3.6: + version "2.3.8" + resolved "https://registry.yarnpkg.com/through/-/through-2.3.8.tgz#0dd4c9ffaabc357960b1b724115d7e0e86a2e1f5" + integrity sha1-DdTJ/6q8NXlgsbckEV1+Doai4fU= + +tmp@^0.0.33: + version "0.0.33" + resolved "https://registry.yarnpkg.com/tmp/-/tmp-0.0.33.tgz#6d34335889768d21b2bcda0aa277ced3b1bfadf9" + integrity sha512-jRCJlojKnZ3addtTOjdIqoRuPEKBvNXcGYqzO6zWZX8KfKEpnGY5jfggJQ3EjKuu8D4bJRr0y+cYJFmYbImXGw== + dependencies: + os-tmpdir "~1.0.2" + +tmpl@1.0.x: + version "1.0.4" + resolved "https://registry.yarnpkg.com/tmpl/-/tmpl-1.0.4.tgz#23640dd7b42d00433911140820e5cf440e521dd1" + integrity sha1-I2QN17QtAEM5ERQIIOXPRA5SHdE= + +to-fast-properties@^2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/to-fast-properties/-/to-fast-properties-2.0.0.tgz#dc5e698cbd079265bc73e0377681a4e4e83f616e" + integrity sha1-3F5pjL0HkmW8c+A3doGk5Og/YW4= + +to-object-path@^0.3.0: + version "0.3.0" + resolved "https://registry.yarnpkg.com/to-object-path/-/to-object-path-0.3.0.tgz#297588b7b0e7e0ac08e04e672f85c1f4999e17af" + integrity sha1-KXWIt7Dn4KwI4E5nL4XB9JmeF68= + dependencies: + kind-of "^3.0.2" + +to-regex-range@^2.1.0: + version "2.1.1" + resolved "https://registry.yarnpkg.com/to-regex-range/-/to-regex-range-2.1.1.tgz#7c80c17b9dfebe599e27367e0d4dd5590141db38" + integrity sha1-fIDBe53+vlmeJzZ+DU3VWQFB2zg= + dependencies: + is-number "^3.0.0" + repeat-string "^1.6.1" + +to-regex-range@^5.0.1: + version "5.0.1" + resolved "https://registry.yarnpkg.com/to-regex-range/-/to-regex-range-5.0.1.tgz#1648c44aae7c8d988a326018ed72f5b4dd0392e4" + integrity sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ== + dependencies: + is-number "^7.0.0" + +to-regex@^3.0.1, to-regex@^3.0.2: + version "3.0.2" + resolved "https://registry.yarnpkg.com/to-regex/-/to-regex-3.0.2.tgz#13cfdd9b336552f30b51f33a8ae1b42a7a7599ce" + integrity sha512-FWtleNAtZ/Ki2qtqej2CXTOayOH9bHDQF+Q48VpWyDXjbYxA4Yz8iDB31zXOBUlOHHKidDbqGVrTUvQMPmBGBw== + dependencies: + define-property "^2.0.2" + extend-shallow "^3.0.2" + regex-not "^1.0.2" + safe-regex "^1.1.0" + +tough-cookie@^2.3.3, tough-cookie@~2.5.0: + version "2.5.0" + resolved "https://registry.yarnpkg.com/tough-cookie/-/tough-cookie-2.5.0.tgz#cd9fb2a0aa1d5a12b473bd9fb96fa3dcff65ade2" + integrity sha512-nlLsUzgm1kfLXSXfRZMc1KLAugd4hqJHDTvc2hDIwS3mZAfMEuMbc03SujMF+GEcpaX/qboeycw6iO8JwVv2+g== + dependencies: + psl "^1.1.28" + punycode "^2.1.1" + +tough-cookie@^3.0.1: + version "3.0.1" + resolved "https://registry.yarnpkg.com/tough-cookie/-/tough-cookie-3.0.1.tgz#9df4f57e739c26930a018184887f4adb7dca73b2" + integrity sha512-yQyJ0u4pZsv9D4clxO69OEjLWYw+jbgspjTue4lTQZLfV0c5l1VmK2y1JK8E9ahdpltPOaAThPcp5nKPUgSnsg== + dependencies: + ip-regex "^2.1.0" + psl "^1.1.28" + punycode "^2.1.1" + +tr46@^1.0.1: + version "1.0.1" + resolved "https://registry.yarnpkg.com/tr46/-/tr46-1.0.1.tgz#a8b13fd6bfd2489519674ccde55ba3693b706d09" + integrity sha1-qLE/1r/SSJUZZ0zN5VujaTtwbQk= + dependencies: + punycode "^2.1.0" + +trim-newlines@^3.0.0: + version "3.0.1" + resolved "https://registry.yarnpkg.com/trim-newlines/-/trim-newlines-3.0.1.tgz#260a5d962d8b752425b32f3a7db0dcacd176c144" + integrity sha512-c1PTsA3tYrIsLGkJkzHF+w9F2EyxfXGo4UyJc4pFL++FMjnq0HJS69T3M7d//gKrFKwy429bouPescbjecU+Zw== + +ts-jest@^25.2.0: + version "25.5.1" + resolved "https://registry.yarnpkg.com/ts-jest/-/ts-jest-25.5.1.tgz#2913afd08f28385d54f2f4e828be4d261f4337c7" + integrity sha512-kHEUlZMK8fn8vkxDjwbHlxXRB9dHYpyzqKIGDNxbzs+Rz+ssNDSDNusEK8Fk/sDd4xE6iKoQLfFkFVaskmTJyw== + dependencies: + bs-logger "0.x" + buffer-from "1.x" + fast-json-stable-stringify "2.x" + json5 "2.x" + lodash.memoize "4.x" + make-error "1.x" + micromatch "4.x" + mkdirp "0.x" + semver "6.x" + yargs-parser "18.x" + +tslib@^1.9.0: + version "1.14.1" + resolved "https://registry.yarnpkg.com/tslib/-/tslib-1.14.1.tgz#cf2d38bdc34a134bcaf1091c41f6619e2f672d00" + integrity sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg== + +tunnel-agent@^0.6.0: + version "0.6.0" + resolved "https://registry.yarnpkg.com/tunnel-agent/-/tunnel-agent-0.6.0.tgz#27a5dea06b36b04a0a9966774b290868f0fc40fd" + integrity sha1-J6XeoGs2sEoKmWZ3SykIaPD8QP0= + dependencies: + safe-buffer "^5.0.1" + +tweetnacl@^0.14.3, tweetnacl@~0.14.0: + version "0.14.5" + resolved "https://registry.yarnpkg.com/tweetnacl/-/tweetnacl-0.14.5.tgz#5ae68177f192d4456269d108afa93ff8743f4f64" + integrity sha1-WuaBd/GS1EViadEIr6k/+HQ/T2Q= + +type-check@~0.3.2: + version "0.3.2" + resolved "https://registry.yarnpkg.com/type-check/-/type-check-0.3.2.tgz#5884cab512cf1d355e3fb784f30804b2b520db72" + integrity sha1-WITKtRLPHTVeP7eE8wgEsrUg23I= + dependencies: + prelude-ls "~1.1.2" + +type-detect@4.0.8: + version "4.0.8" + resolved "https://registry.yarnpkg.com/type-detect/-/type-detect-4.0.8.tgz#7646fb5f18871cfbb7749e69bd39a6388eb7450c" + integrity sha512-0fr/mIH1dlO+x7TlcMy+bIDqKPsw/70tVyeHW787goQjhmqaZe10uwLujubK9q9Lg6Fiho1KUKDYz0Z7k7g5/g== + +type-fest@^0.13.1: + version "0.13.1" + resolved "https://registry.yarnpkg.com/type-fest/-/type-fest-0.13.1.tgz#0172cb5bce80b0bd542ea348db50c7e21834d934" + integrity sha512-34R7HTnG0XIJcBSn5XhDd7nNFPRcXYRZrBB2O2jdKqYODldSzBAqzsWoZYYvduky73toYS/ESqxPvkDf/F0XMg== + +type-fest@^0.21.3: + version "0.21.3" + resolved "https://registry.yarnpkg.com/type-fest/-/type-fest-0.21.3.tgz#d260a24b0198436e133fa26a524a6d65fa3b2e37" + integrity sha512-t0rzBq87m3fVcduHDUFhKmyyX+9eo6WQjZvf51Ea/M0Q7+T374Jp1aUiyUl0GKxp8M/OETVHSDvmkyPgvX+X2w== + +type-fest@^0.6.0: + version "0.6.0" + resolved "https://registry.yarnpkg.com/type-fest/-/type-fest-0.6.0.tgz#8d2a2370d3df886eb5c90ada1c5bf6188acf838b" + integrity sha512-q+MB8nYR1KDLrgr4G5yemftpMC7/QLqVndBmEEdqzmNj5dcFOO4Oo8qlwZE3ULT3+Zim1F8Kq4cBnikNhlCMlg== + +type-fest@^0.8.1: + version "0.8.1" + resolved "https://registry.yarnpkg.com/type-fest/-/type-fest-0.8.1.tgz#09e249ebde851d3b1e48d27c105444667f17b83d" + integrity sha512-4dbzIzqvjtgiM5rw1k5rEHtBANKmdudhGyBEajN01fEyhaAIhsoKNy6y7+IN93IfpFtwY9iqi7kD+xwKhQsNJA== + +typedarray-to-buffer@^3.1.5: + version "3.1.5" + resolved "https://registry.yarnpkg.com/typedarray-to-buffer/-/typedarray-to-buffer-3.1.5.tgz#a97ee7a9ff42691b9f783ff1bc5112fe3fca9080" + integrity sha512-zdu8XMNEDepKKR+XYOXAVPtWui0ly0NtohUscw+UmaHiAWT8hrV1rr//H6V+0DvJ3OQ19S979M0laLfX8rm82Q== + dependencies: + is-typedarray "^1.0.0" + +typescript@^3.7.4: + version "3.9.10" + resolved "https://registry.yarnpkg.com/typescript/-/typescript-3.9.10.tgz#70f3910ac7a51ed6bef79da7800690b19bf778b8" + integrity sha512-w6fIxVE/H1PkLKcCPsFqKE7Kv7QUwhU8qQY2MueZXWx5cPZdwFupLgKK3vntcK98BtNHZtAF4LA/yl2a7k8R6Q== + +union-value@^1.0.0: + version "1.0.1" + resolved "https://registry.yarnpkg.com/union-value/-/union-value-1.0.1.tgz#0b6fe7b835aecda61c6ea4d4f02c14221e109847" + integrity sha512-tJfXmxMeWYnczCVs7XAEvIV7ieppALdyepWMkHkwciRpZraG/xwT+s2JN8+pr1+8jCRf80FFzvr+MpQeeoF4Xg== + dependencies: + arr-union "^3.1.0" + get-value "^2.0.6" + is-extendable "^0.1.1" + set-value "^2.0.1" + +union@~0.5.0: + version "0.5.0" + resolved "https://registry.yarnpkg.com/union/-/union-0.5.0.tgz#b2c11be84f60538537b846edb9ba266ba0090075" + integrity sha512-N6uOhuW6zO95P3Mel2I2zMsbsanvvtgn6jVqJv4vbVcz/JN0OkL9suomjQGmWtxJQXOCqUJvquc1sMeNz/IwlA== + dependencies: + qs "^6.4.0" + +universalify@^0.1.0: + version "0.1.2" + resolved "https://registry.yarnpkg.com/universalify/-/universalify-0.1.2.tgz#b646f69be3942dabcecc9d6639c80dc105efaa66" + integrity sha512-rBJeI5CXAlmy1pV+617WB9J63U6XcazHHF2f2dbJix4XzpUF0RS3Zbj0FGIOCAva5P/d/GBOYaACQ1w+0azUkg== + +unset-value@^1.0.0: + version "1.0.0" + resolved "https://registry.yarnpkg.com/unset-value/-/unset-value-1.0.0.tgz#8376873f7d2335179ffb1e6fc3a8ed0dfc8ab559" + integrity sha1-g3aHP30jNRef+x5vw6jtDfyKtVk= + dependencies: + has-value "^0.3.1" + isobject "^3.0.0" + +uri-js@^4.2.2: + version "4.4.1" + resolved "https://registry.yarnpkg.com/uri-js/-/uri-js-4.4.1.tgz#9b1a52595225859e55f669d928f88c6c57f2a77e" + integrity sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg== + dependencies: + punycode "^2.1.0" + +urix@^0.1.0: + version "0.1.0" + resolved "https://registry.yarnpkg.com/urix/-/urix-0.1.0.tgz#da937f7a62e21fec1fd18d49b35c2935067a6c72" + integrity sha1-2pN/emLiH+wf0Y1Js1wpNQZ6bHI= + +url-join@^2.0.5: + version "2.0.5" + resolved "https://registry.yarnpkg.com/url-join/-/url-join-2.0.5.tgz#5af22f18c052a000a48d7b82c5e9c2e2feeda728" + integrity sha1-WvIvGMBSoACkjXuCxenC4v7tpyg= + +use@^3.1.0: + version "3.1.1" + resolved "https://registry.yarnpkg.com/use/-/use-3.1.1.tgz#d50c8cac79a19fbc20f2911f56eb973f4e10070f" + integrity sha512-cwESVXlO3url9YWlFW/TA9cshCEhtu7IKJ/p5soJ/gGpj7vbvFrAY/eIioQ6Dw23KjZhYgiIo8HOs1nQ2vr/oQ== + +uuid@^3.3.2, uuid@^3.4.0: + version "3.4.0" + resolved "https://registry.yarnpkg.com/uuid/-/uuid-3.4.0.tgz#b23e4358afa8a202fe7a100af1f5f883f02007ee" + integrity sha512-HjSDRw6gZE5JMggctHBcjVak08+KEVhSIiDzFnT9S9aegmp85S/bReBVTb4QTFaRNptJ9kuYaNhnbNEOkbKb/A== + +v8-to-istanbul@^4.1.3: + version "4.1.4" + resolved "https://registry.yarnpkg.com/v8-to-istanbul/-/v8-to-istanbul-4.1.4.tgz#b97936f21c0e2d9996d4985e5c5156e9d4e49cd6" + integrity sha512-Rw6vJHj1mbdK8edjR7+zuJrpDtKIgNdAvTSAcpYfgMIw+u2dPDntD3dgN4XQFLU2/fvFQdzj+EeSGfd/jnY5fQ== + dependencies: + "@types/istanbul-lib-coverage" "^2.0.1" + convert-source-map "^1.6.0" + source-map "^0.7.3" + +validate-npm-package-license@^3.0.1: + version "3.0.4" + resolved "https://registry.yarnpkg.com/validate-npm-package-license/-/validate-npm-package-license-3.0.4.tgz#fc91f6b9c7ba15c857f4cb2c5defeec39d4f410a" + integrity sha512-DpKm2Ui/xN7/HQKCtpZxoRWBhZ9Z0kqtygG8XCgNQ8ZlDnxuQmWhj566j8fN4Cu3/JmbhsDo7fcAJq4s9h27Ew== + dependencies: + spdx-correct "^3.0.0" + spdx-expression-parse "^3.0.0" + +verror@1.10.0: + version "1.10.0" + resolved "https://registry.yarnpkg.com/verror/-/verror-1.10.0.tgz#3a105ca17053af55d6e270c1f8288682e18da400" + integrity sha1-OhBcoXBTr1XW4nDB+CiGguGNpAA= + dependencies: + assert-plus "^1.0.0" + core-util-is "1.0.2" + extsprintf "^1.2.0" + +w3c-hr-time@^1.0.1: + version "1.0.2" + resolved "https://registry.yarnpkg.com/w3c-hr-time/-/w3c-hr-time-1.0.2.tgz#0a89cdf5cc15822df9c360543676963e0cc308cd" + integrity sha512-z8P5DvDNjKDoFIHK7q8r8lackT6l+jo/Ye3HOle7l9nICP9lf1Ci25fy9vHd0JOWewkIFzXIEig3TdKT7JQ5fQ== + dependencies: + browser-process-hrtime "^1.0.0" + +w3c-xmlserializer@^1.1.2: + version "1.1.2" + resolved "https://registry.yarnpkg.com/w3c-xmlserializer/-/w3c-xmlserializer-1.1.2.tgz#30485ca7d70a6fd052420a3d12fd90e6339ce794" + integrity sha512-p10l/ayESzrBMYWRID6xbuCKh2Fp77+sA0doRuGn4tTIMrrZVeqfpKjXHY+oDh3K4nLdPgNwMTVP6Vp4pvqbNg== + dependencies: + domexception "^1.0.1" + webidl-conversions "^4.0.2" + xml-name-validator "^3.0.0" + +walker@^1.0.7, walker@~1.0.5: + version "1.0.7" + resolved "https://registry.yarnpkg.com/walker/-/walker-1.0.7.tgz#2f7f9b8fd10d677262b18a884e28d19618e028fb" + integrity sha1-L3+bj9ENZ3JisYqITijRlhjgKPs= + dependencies: + makeerror "1.0.x" + +webidl-conversions@^4.0.2: + version "4.0.2" + resolved "https://registry.yarnpkg.com/webidl-conversions/-/webidl-conversions-4.0.2.tgz#a855980b1f0b6b359ba1d5d9fb39ae941faa63ad" + integrity sha512-YQ+BmxuTgd6UXZW3+ICGfyqRyHXVlD5GtQr5+qjiNW7bF0cqrzX500HVXPBOvgXb5YnzDd+h0zqyv61KUD7+Sg== + +whatwg-encoding@^1.0.1, whatwg-encoding@^1.0.5: + version "1.0.5" + resolved "https://registry.yarnpkg.com/whatwg-encoding/-/whatwg-encoding-1.0.5.tgz#5abacf777c32166a51d085d6b4f3e7d27113ddb0" + integrity sha512-b5lim54JOPN9HtzvK9HFXvBma/rnfFeqsic0hSpjtDbVxR3dJKLc+KB4V6GgiGOvl7CY/KNh8rxSo9DKQrnUEw== + dependencies: + iconv-lite "0.4.24" + +whatwg-mimetype@^2.2.0, whatwg-mimetype@^2.3.0: + version "2.3.0" + resolved "https://registry.yarnpkg.com/whatwg-mimetype/-/whatwg-mimetype-2.3.0.tgz#3d4b1e0312d2079879f826aff18dbeeca5960fbf" + integrity sha512-M4yMwr6mAnQz76TbJm914+gPpB/nCwvZbJU28cUD6dR004SAxDLOOSUaB1JDRqLtaOV/vi0IC5lEAGFgrjGv/g== + +whatwg-url@^7.0.0: + version "7.1.0" + resolved "https://registry.yarnpkg.com/whatwg-url/-/whatwg-url-7.1.0.tgz#c2c492f1eca612988efd3d2266be1b9fc6170d06" + integrity sha512-WUu7Rg1DroM7oQvGWfOiAK21n74Gg+T4elXEQYkOhtyLeWiJFoOGLXPKI/9gzIie9CtwVLm8wtw6YJdKyxSjeg== + dependencies: + lodash.sortby "^4.7.0" + tr46 "^1.0.1" + webidl-conversions "^4.0.2" + +which-module@^2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/which-module/-/which-module-2.0.0.tgz#d9ef07dce77b9902b8a3a8fa4b31c3e3f7e6e87a" + integrity sha1-2e8H3Od7mQK4o6j6SzHD4/fm6Ho= + +which@^1.2.9, which@^1.3.1: + version "1.3.1" + resolved "https://registry.yarnpkg.com/which/-/which-1.3.1.tgz#a45043d54f5805316da8d62f9f50918d3da70b0a" + integrity sha512-HxJdYWq1MTIQbJ3nw0cqssHoTNU267KlrDuGZ1WYlxDStUtKUhOaJmh112/TZmHxxUfuJqPXSOm7tDyas0OSIQ== + dependencies: + isexe "^2.0.0" + +which@^2.0.1, which@^2.0.2: + version "2.0.2" + resolved "https://registry.yarnpkg.com/which/-/which-2.0.2.tgz#7c6a8dd0a636a0327e10b59c9286eee93f3f51b1" + integrity sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA== + dependencies: + isexe "^2.0.0" + +word-wrap@~1.2.3: + version "1.2.3" + resolved "https://registry.yarnpkg.com/word-wrap/-/word-wrap-1.2.3.tgz#610636f6b1f703891bd34771ccb17fb93b47079c" + integrity sha512-Hz/mrNwitNRh/HUAtM/VT/5VH+ygD6DV7mYKZAtHOrbs8U7lvPS6xf7EJKMF0uW1KJCl0H701g3ZGus+muE5vQ== + +wrap-ansi@^6.2.0: + version "6.2.0" + resolved "https://registry.yarnpkg.com/wrap-ansi/-/wrap-ansi-6.2.0.tgz#e9393ba07102e6c91a3b221478f0257cd2856e53" + integrity sha512-r6lPcBGxZXlIcymEu7InxDMhdW0KDxpLgoFLcguasxCaJ/SOIZwINatK9KY/tf+ZrlywOKU0UDj3ATXUBfxJXA== + dependencies: + ansi-styles "^4.0.0" + string-width "^4.1.0" + strip-ansi "^6.0.0" + +wrappy@1: + version "1.0.2" + resolved "https://registry.yarnpkg.com/wrappy/-/wrappy-1.0.2.tgz#b5243d8f3ec1aa35f1364605bc0d1036e30ab69f" + integrity sha1-tSQ9jz7BqjXxNkYFvA0QNuMKtp8= + +write-file-atomic@^3.0.0: + version "3.0.3" + resolved "https://registry.yarnpkg.com/write-file-atomic/-/write-file-atomic-3.0.3.tgz#56bd5c5a5c70481cd19c571bd39ab965a5de56e8" + integrity sha512-AvHcyZ5JnSfq3ioSyjrBkH9yW4m7Ayk8/9My/DD9onKeu/94fwrMocemO2QAJFAlnnDN+ZDS+ZjAR5ua1/PV/Q== + dependencies: + imurmurhash "^0.1.4" + is-typedarray "^1.0.0" + signal-exit "^3.0.2" + typedarray-to-buffer "^3.1.5" + +ws@^7.0.0, ws@^7.4.6: + version "7.5.3" + resolved "https://registry.yarnpkg.com/ws/-/ws-7.5.3.tgz#160835b63c7d97bfab418fc1b8a9fced2ac01a74" + integrity sha512-kQ/dHIzuLrS6Je9+uv81ueZomEwH0qVYstcAQ4/Z93K8zeko9gtAbttJWzoC5ukqXY1PpoouV3+VSOqEAFt5wg== + +xml-name-validator@^3.0.0: + version "3.0.0" + resolved "https://registry.yarnpkg.com/xml-name-validator/-/xml-name-validator-3.0.0.tgz#6ae73e06de4d8c6e47f9fb181f78d648ad457c6a" + integrity sha512-A5CUptxDsvxKJEU3yO6DuWBSJz/qizqzJKOMIfUJHETbBw/sFaDxgd6fxm1ewUaM0jZ444Fc5vC5ROYurg/4Pw== + +xmlchars@^2.1.1: + version "2.2.0" + resolved "https://registry.yarnpkg.com/xmlchars/-/xmlchars-2.2.0.tgz#060fe1bcb7f9c76fe2a17db86a9bc3ab894210cb" + integrity sha512-JZnDKK8B0RCDw84FNdDAIpZK+JuJw+s7Lz8nksI7SIuU3UXJJslUthsi+uWBUYOwPFwW7W7PRLRfUKpxjtjFCw== + +y18n@^4.0.0: + version "4.0.3" + resolved "https://registry.yarnpkg.com/y18n/-/y18n-4.0.3.tgz#b5f259c82cd6e336921efd7bfd8bf560de9eeedf" + integrity sha512-JKhqTOwSrqNA1NY5lSztJ1GrBiUodLMmIZuLiDaMRJ+itFd+ABVE8XBjOvIWL+rSqNDC74LCSFmlb/U4UZ4hJQ== + +yallist@^2.1.2: + version "2.1.2" + resolved "https://registry.yarnpkg.com/yallist/-/yallist-2.1.2.tgz#1c11f9218f076089a47dd512f93c6699a6a81d52" + integrity sha1-HBH5IY8HYImkfdUS+TxmmaaoHVI= + +yallist@^4.0.0: + version "4.0.0" + resolved "https://registry.yarnpkg.com/yallist/-/yallist-4.0.0.tgz#9bb92790d9c0effec63be73519e11a35019a3a72" + integrity sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A== + +yargs-parser@18.x, yargs-parser@^18.1.2, yargs-parser@^18.1.3: + version "18.1.3" + resolved "https://registry.yarnpkg.com/yargs-parser/-/yargs-parser-18.1.3.tgz#be68c4975c6b2abf469236b0c870362fab09a7b0" + integrity sha512-o50j0JeToy/4K6OZcaQmW6lyXXKhq7csREXcDwk2omFPJEwUNOVtJKvmDr9EI1fAJZUyZcRF7kxGBWmRXudrCQ== + dependencies: + camelcase "^5.0.0" + decamelize "^1.2.0" + +yargs@^15.3.1: + version "15.4.1" + resolved "https://registry.yarnpkg.com/yargs/-/yargs-15.4.1.tgz#0d87a16de01aee9d8bec2bfbf74f67851730f4f8" + integrity sha512-aePbxDmcYW++PaqBsJ+HYUFwCdv4LVvdnhBy78E57PIor8/OVvhMrADFFEDh8DHDFRv/O9i3lPhsENjO7QX0+A== + dependencies: + cliui "^6.0.0" + decamelize "^1.2.0" + find-up "^4.1.0" + get-caller-file "^2.0.1" + require-directory "^2.1.1" + require-main-filename "^2.0.0" + set-blocking "^2.0.0" + string-width "^4.2.0" + which-module "^2.0.0" + y18n "^4.0.0" + yargs-parser "^18.1.2" + +yauzl@^2.10.0: + version "2.10.0" + resolved "https://registry.yarnpkg.com/yauzl/-/yauzl-2.10.0.tgz#c7eb17c93e112cb1086fa6d8e51fb0667b79a5f9" + integrity sha1-x+sXyT4RLLEIb6bY5R+wZnt5pfk= + dependencies: + buffer-crc32 "~0.2.3" + fd-slicer "~1.1.0" + +yazl@^2.5.1: + version "2.5.1" + resolved "https://registry.yarnpkg.com/yazl/-/yazl-2.5.1.tgz#a3d65d3dd659a5b0937850e8609f22fffa2b5c35" + integrity sha512-phENi2PLiHnHb6QBVot+dJnaAZ0xosj7p3fWl+znIjBDlnMI2PsZCJZ306BPTFOaHf5qdDEI8x5qFrSOBN5vrw== + dependencies: + buffer-crc32 "~0.2.3"